Attributed workflows and qualified package artifacts

All 106 @playstack/* packages are prepared as 0.1.0-beta.5, including the CLI and their exact internal dependency and peer requirements. Artifact, integration and Skills manifests advance with the same train. This is a new version for changes made after the published beta 4 release; existing beta 4 artifacts remain immutable.

Gesture-bound extension permissions

Extension requests native permissions directly from the calling gesture without an asynchronous inspection first. Ordinary denial returns false; browser failures remain errors. Narrow inspection, removal and added/removed subscriptions own their snapshots and support disposable listeners. Packed ESM/CommonJS and an isolated Chromium MV3 fixture cover the helpers; visible consent dialogs and application-specific permission journeys remain separate gates.

Extension messaging upgrade notes

Extension messaging has two breaking changes. RuntimeMessageApi.onMessage now requires removeListener: real chrome.runtime and browser.runtime already provide it, but custom or fake runtime objects, such as test doubles, must implement it. registerMessageHandlers now returns an idempotent unsubscribe function. Request envelopes carry kind: 'request', and handlers ignore envelopes without it, so a beta 4 client's requests are not answered by beta 5 handlers. Upgrade every context of one extension together; a single extension bundle already does. A central authorize sender policy can refuse a sender before the payload is parsed; the client then rejects with the new extension/sender_denied error code.

Explicit dependency build decisions

The CLI planner exposes explicit pnpm build decisions before package copying or installation. Known Scarf telemetry and optional MessagePack acceleration default to denied; existing reviewed boolean choices remain authoritative. Selected Argon2 requires approval. Unresolved YAML placeholders, conflicting policies and nested workspaces selecting another policy fail before mutation. Dry-run output includes the decisions and their reasons. Unknown dependency scripts still need review, and package-manager side effects remain nontransactional.

Validation adoption now separates native Nest requirements from optional DTO/OpenAPI composition. Portable and web-only plans stay framework-free; --api selects /nest/pipe, while --api --adapter=openapi explicitly selects the complete bridge and its Swagger/nestjs-zod peers. Existing application dependencies are retained. Dependency-range errors identify the manifest to review and explain declaration alignment without accepting an installed version as proof that a broader range is supported.

Transaction-bound Staff verification

Auth adds a focused existing-session verifier with explicit user/IP policy and native User → StaffPrincipal → StaffSession locks. Caller work can join current identity verification without constructing MFA, issuance or impersonation dependencies. Canonical schema admission, action authority and final application qualification remain host-owned; this does not add transaction-bound Staff mutation APIs.

Exact email-change notice sources

Auth completion notices carry the native changeId for both new-inbox/reversal and dual-inbox approval policies. Transactional and ordinary after-commit delivery can bind exact source identity directly, without reconstructing it from events. Proof, authorization and notification recovery semantics stay separate; no schema change is needed.

Installed documentation

Package READMEs use hosted references for cross-package and repository-only guidance. The publication-file gate checks linked local assets against actual package contents and public documentation routes/headings against authored source, including Markdown representations. Maintainer scripts are labeled as checkout-only tools. Reviewed handoff guidance separates distinct prereleases and immutable archive evidence from same-version local Yalc iteration.

Failure-only MFA with joined login effects

MFA adds verifyCodeChallengeWithEffect so trusted host pending-login consumption, transactional session issuance and required evidence can share successful factor consumption's original failure-budget transaction. Negative attempts still commit their counters as data. The callback receives a verified user/method fact without a portable proof; both proof and host result remain private until acknowledged commit. Final policy and TOTP freshness checks follow callback waits. Host login policy, budget composition and complete application qualification remain explicit responsibilities.

Price-free product trials

Billing adds a trial-only factory and catalog without payment-provider, customer or price configuration. The narrow persistence port reuses the existing create-once trial record, deadline extension and monotonic cancellation, sharing the full Billing lifecycle engine. Caller transactions join trial state, required evidence, local grants and product effects. Product eligibility and paid-conversion policy remain explicit application responsibilities; this does not change full Billing's existing conversion behavior.

Full Billing also offers an explicit transaction-bound conversion decision over accepted provider facts, separate from paid access/grants. Pending-payment evidence and genuine period starts survive current/history projections and authoritative rereads. Unknown stays unknown; missing new facts clear stale evidence. Schema and adapter adoption move together, with existing rows left NULL. Product access and refund policies remain application-owned.

Subscription commands now expose bounded unresolved-command discovery by account and provider instance. The existing unique barrier supplies one minimal authorized summary, including unresolved pending payment, without scanning closed history or exposing requests/receipts. Final authorization covers both matching and null results. Inspection never submits, expires or retires work.

Explicit terminal request redaction now removes full command dispatch/source material after settled outcomes and the original replay window. A closed record retains permanent keys, commitments, compact acknowledgment proofs and factual receipts. Uncertainty and unresolved payment refuse cleanup. Required retention authority/evidence share the transaction; matching late acknowledgments cannot restore requests, replay work, release newer barriers or advance generations. The existing JSON journal needs no schema migration. Host retention policy and factual-evidence retention remain explicit application responsibilities.

Explicit Render purge client

The new Render client submits one bounded cache-purge request for an explicit service without a Next, Redis or queue dependency. It preserves known acceptance, safe error classification and rate-limit metadata; HTTP 202 does not attest complete edge freshness. Optional durable coordination now retains change generations, storage-owned lease fences and shared quota deadlines through worker restarts and lost acknowledgments. Native Redis and existing ioredis/BullMQ connections are supported without bundling a queue SDK. Coordination now distinguishes retryable storage unavailability from permanent integrity refusal, and inspection includes other services' shared-quota leases. The separate Render Next adapter now applies an explicit public Pages Router policy to final HTML/data responses, refuses private and unsupported variants, and owns optional production-server startup/drain. It preserves browser cache policy and recognizes HTTP-200 data redirects without buffering arbitrary responses. Exact Next 15.5.28 and 16.4.2 production fixtures now qualify both gzip and identity public HTML/data; compressed private responses and redirects retain no-store. Native compression remains enabled, and the peer ranges include the qualified Next 15 baseline. Real Render edge staging remains a separate activation gate.

Native Nest validation pipe

Validation adds @playstack/validation/nest/pipe for native Nest validation without loading the optional DTO/Swagger adapter. The existing /nest path reexports the same pipe class and retains its helpers. Both entry points preserve async parsing, validation-error responses and unexpected-refinement handling.

Conservative webhook submission

Webhooks adds an explicit quarantine-uncertain delivery policy alongside default leased retry. A durable one-use marker must commit before dispatch; uncertain submissions remain blocked across lease expiry, worker restart and operator retention. Authorized recovery can resolve the FIFO barrier without granting replay. Adopt the updated outbound schema and persistence contract together, and qualify a non-retrying transport.

Append-only Audit writers

Audit supports PostgreSQL application writers with SELECT/INSERT-only authority on audit history. A protected append head tracks the current chain separately from maintenance-owned retention checkpoints. Concurrent first writes, queued deduplication and required evidence still share the transaction and roll back with the application operation.

Native persistence now requires an explicit trusted permanent schema. Apply the published @playstack/audit/postgres-protection.sql resource in a reviewed owner-run migration, and grant application, verifier and maintenance roles their separate privileges. The installer refuses populated history rather than inventing a trusted head. Existing populated deployments need a reviewed activation plan; copying the Prisma fragment alone is insufficient. Custom adapters must implement the protected-head and snapshot contracts together. This remains a tamper-evident chain with trusted installation and maintenance, not an external anchoring service.

Native passkey challenge consistency

MFA now applies SimpleWebAuthn's exact challenge encoding consistently during registration and authentication verification. Stored challenges retain their opaque-string contract; exact challenge, origin, RP and single-use checks remain intact. Real signed-ceremony fixtures qualify SimpleWebAuthn 13.3.2 and 13.3.3 across ESM/CommonJS and frozen reinstall, including binding refusals, replay/expiry and caller/prepared rollback. Browser/device and application database acceptance remain deployment gates.

Billing attribution and private mail diagnostics

Billing carries OperationContext through webhook preparation and application, reconciliation, import, trial commands and nested entitlement effects. All 15 registered Billing events can retain actor, account scope, correlation, causation and trace metadata through required audit and durable delivery. Prepared operations own detached metadata; mismatched resolved-account scope refuses. Authorization identity remains separate from staff or system attribution. Hosts supply trusted provider-system context after signature verification, never from untrusted webhook JSON.

Subscription commands reauthorize after lock waits and required evidence before admission returns; denial rolls the claim/reservation and audit back together. Real provider acknowledgments remain durable even if disclosure is denied. The optional admitSubscriptionSource hook lets a host check its current mapping under the transaction before a historical subscription can replace the current one or clear its grants. Ignored webhooks retain verified deduplication receipts; without the hook, the existing chronological replacement policy remains.

Mail keeps the native Resend transport quiet in development, test and production. Raw error bodies are discarded and only fixed, allowlisted diagnostics escape; console and environment globals are not changed. Request-local cancellation, deadlines and uncertain outcomes remain. Hosts that inject their own transport still own that transport's logging policy. The native Resend factory now fixes its email destination, refuses redirects, bounds success receipts to 64 KiB and explicitly encodes attachments as base64. Known HTTP rejections survive failed or stalled body cleanup; unknown submissions remain non-retryable. Packed consumers qualify both supported-minimum Resend 6.24.0 and selected 6.32.1 without changing application SDK versions.

Customer and Portal request ownership

Billing captures customer-creation/adoption inputs and Portal account, actor and return URL before awaited work. Caller mutation cannot retarget the account-derived provider key, local mapping, redirect or final authority check. A revoked actor cannot switch the input to another allowed account to disclose the original URL.

The separate opt-in Customer bootstrap service now adds a permanent target journal and qualified single-POST Stripe transport. Fresh admission/evidence commits before I/O; crashes, unknown outcomes and lost acknowledgements cannot grant a resend, including with new keys or after provider-window expiry. Receipts survive actor revocation; current authority gates mapping installation/disclosure. Explicit reviewed provider-GET reconciliation recovers matching outcomes without another POST. The journal stores no request/email, and adds an optional schema/scaffold. Unconfigured Customer calls retain their existing boundary. Portal has a separate opt-in profile below; retain safeguards for paths not yet qualified. A denied disclosure never rolls back provider work.

Durable Portal operations

Billing adds opt-in per-operation admission, permanent no-replay receipts and encrypted local Portal URL recovery. Fresh host intent and required evidence commit before one guarded Stripe POST. IDs survive actor revocation, encryption failure and local closure; disclosure rechecks current mapping/authority under operation locks and the original local deadline. Inspection and evidence expose neither bearer URLs nor ciphertext. Closure cannot be reopened by late acknowledgements or encryption. Optional schema/scaffold and deployment wiring are explicit; existing unconfigured Portal calls remain supported.

Stripe has no session retrieval/status/expiry API in this profile. Unknown or ID-only outcomes remain unavailable without resubmission. Local disclosure deadlines and cleanup do not revoke provider sessions or prove their actual expiry. Fresh keys require deliberate host-approved new sessions, never automatic retry rotation.

Pending-payment plan-change commands

Billing adds an explicit pending_if_incomplete profile for immediate, same-interval classic card/Link changes. A discriminated receipt separates applied and pending updates without retaining client secrets or hosted invoice URLs. Pending acknowledgments keep the account/provider barrier across restart and expiry, and duplicate submissions never issue another POST.

resolvePendingPayment requires exact invoice/revision and a separate trusted evidence gate, joining caller work when supplied and reauthorizing after required Audit/outbox effects. It preserves the first acknowledgment/resolution and leaves paid grants with verified subscription projection. Custom adapters update the published resolution contract/scaffold; existing JSON data needs reviewed adoption before cutover to the required plan-receipt discriminator. No new columns or automatic backfill are introduced. SCA UI, scheduling, interval changes, refund policy and live Stripe qualification remain separate.

Joined subscription and entitlement reads

Billing exposes caller-transaction current, distinct-subscription and history reads alongside its existing trial read. Entitlements adds joined single/bulk decisions, snapshots and all-grants checks. Each uses the original physical handle, including uncommitted caller changes, without opening a nested transaction or contacting a provider. Entitlements custom adapters update the required live-handle guard and transaction-aware list contract with its scaffold/hash. No schema change, authority lease or new snapshot-isolation guarantee is introduced.

Existing-token admission and atomic account switching

Auth admits an existing opaque or JWT credential through verifyInTransaction, using the caller's exact handle and a locked current session. Access, idle, absolute and configured device checks remain in force across admission waits. JWT admission preserves signed expiry/bindings and requires the exact backing credential even when ordinary verification omits revalidation. A late refusal must escape the caller transaction so activity and protected host writes roll back together.

Custom Auth persistence must update its transaction guard, joined hash lookup and locked-read capabilities with the published scaffold. No schema migration is required. Resolution by session ID is not credential proof; account-membership authorization and later host waits remain the host's responsibility.

Accounts joins active-user and destination membership checks with native session replacement on one physical transaction. The original credential must match captured discovery IDs before writes. Signing, required evidence and caller failures preserve the original pair, and replacement retains the original access/idle/absolute and signed JWT deadlines through waits. Custom session strategies must implement the strong joined capability; an independently committed switch is insufficient. Expose new tokens after outer commit. Final membership authorization follows required handlers and precedes original-deadline checks, covering authority changes inside the same transaction. No Accounts schema or persistence-port migration is introduced.

Trusted withdrawal in caller transactions

Audiences joins authenticated workflow withdrawal to the caller's physical transaction without a temporary preferences token or deployment-operator grant. The host authorizes the exact list/contact before mutation and after required suppression, events and remote-intent writes. Failure rolls those effects back with caller work; acceptance is exposed after commit. Contact and consent history remain, and remote processing keeps its existing policy. No token issuer, verifier, provider call or public route is added.

Custom Audience persistence must update the published transaction guard and scaffold contract. Native joined mutations require ReadCommitted; no schema migration is introduced.

Durable remote audience outcomes

Audiences adds opt-in registered remote commands, retained provider-target barriers and accepted-receipt recovery. Original admission and queue handoff share a transaction without minting tokens. A worker claims before submission; only trusted proof of no mutation permits retry. Partial or unknown outcomes quarantine, while accepted retries finish local projection without a second provider call. Changed endpoints/configuration cannot activate a different contact. Prisma 7 dispatch requires the qualified fence.

The Resend adapter owns the resolved segment/endpoint plan and provides a quiet bounded client with fixed diagnostics in every environment. Injected clients retain their own transport responsibilities. Activate the optional journal schema, registering queue and stable keyed target identity together. Missing evidence and unconfigured pending workers refuse; old uncertain work is not automatically backfilled or replayed. Permanent unknown barriers have no automatic timeout/reset. This does not claim provider erasure or application activation.

Local-contact erasure across remote-linked audiences

Audiences supports explicit target: 'local-contact' erasure across the complete local contact scope, including remote-linked lists. The receipt preserves that target; list authority and provider data remain unchanged. Native tombstones, suppression and exact remote command markers survive local cleanup without becoming provider acknowledgments.

Inspect and erase can join caller transactions. Required pre-lock host admission establishes GLOBAL/SUBJECT authority before native locks, and final operator authorization follows required cleanup/evidence. Custom lifecycle adapters update the guard and explicit-target contracts; this adds no DDL. Hosts must preserve and qualify keyed complaint, uncertain-command and cross-ID enrollment fences. Provider work already in flight cannot be recalled; drainage and durable remote outcome handling remain separate gates.

Exact OAuth issuer identifiers

Browser-bound Auth OAuth login now preserves exact HTTPS issuer identifiers in configuration, state commitments and encrypted attempt persistence. Slashless root issuers work without adding a slash; slashed and path-based identifiers remain distinct. Callback issuer mismatch still refuses before consumption, and endpoint/redirect canonical validation is unchanged. No schema or nonce API change is required.

Already-exchanged OAuth grants

Connections separates provider identity verification/encryption from transaction-bound credential admission. A mandatory expected provider account binds the prepared token set; a trusted host callback authorizes its current owner before locks and after required evidence. Missing rows use create-only persistence, and reauthorization preserves a confirmed latest refresh token only for the same OAuth identity.

Bounded, service-instance preparations support storage retries after known rollback without exchanging or identifying again. They are not durable receipts or permission to replay success/unknown commits. Custom persistence must update the transaction guard and create-only scaffold contracts; native mutation requires ReadCommitted and owner-before-provider-key lock ordering. The admission seam itself adds no schema or Auth/browser credential surface; current version, binding and reservation contracts require reviewed schema adoption. Product linking policy and uncertain rotating-refresh recovery remain separate qualification requirements.

Guarded automatic refresh

When refresh is due, Connections now requires a provider's explicit rotatingRefreshTokens: false. Rotating or unclassified refresh refuses with fixed, nonretryable refresh_requires_reauthorization before secret decryption, provider I/O or state/evidence writes. Existing access tokens outside the refresh lead window remain usable. GitHub/X declare rotation; generic OAuth2/LinkedIn currently leave it unclassified. Do not relabel providers to bypass this guard.

This closes the unsafe automatic submission path: a database rollback cannot undo a provider's consumed rotating credential. No schema/journal is added. Durable rotating submission, encrypted outcome recovery, uncertainty quarantine and generation/authority fencing remain separate work; direct protocol methods still require caller-owned qualification.

Versioned connection writes

Connections adds a required row revision and conditional, update-only save. Creation starts at 1; every accepted write returns the next authoritative version and preserves immutable ownership/provider/creation bindings. Stale or missing records cannot be restored through UPSERT. Verification success, denial and identity mismatch are fenced to the revision observed before provider I/O, so older responses cannot overwrite or revoke a newer grant at the same clock time.

Custom adapters and all three schema variants need the current revision contract, scaffold and hashes. Existing data requires reviewed schema adoption; no automatic backfill or old-format reader is added. Row versions do not replace permanent deletion/recreation barriers or durable provider-outcome records, and automatic rotating refresh remains refused.

Permanent Connection identities

All three scope fragments add ConnectionIdReservation, retained independently of live rows and owner cascades. Creation reserves a never-reusable ID in the original transaction; saves require its witness. Physical deletion cannot reset an old ID to revision 1 through native ports. Known rollback removes provisional state; direct adapter calls preserve owner-before-reservation lock ordering.

Review schema and custom-adapter adoption before activation, retaining actual historical ID evidence where available. There is no automatic backfill or ID recycling. This closes same-ID resurrection, not cross-ID provider-target uncertainty, and rotating/unclassified refresh remains refused.

Immutable provider credential bindings

Connections requires an immutable credentialBinding on every stored record and a corresponding provider method deriving a lowercase SHA-256 commitment from its actual client/server/resource configuration. Native request generation and binding share an owned configuration snapshot; logical aliases and dedicated client-secret rotation do not change that identity. Signed OAuth state, prepared grants and trusted already-exchanged expectedCredentialBinding inputs preserve it across flow boundaries. Configuration mismatch refuses credential use before decryption or credential-bearing I/O, including callback exchange under changed settings.

The three schema variants, custom-adapter contract and scaffold/hashes move together. There is no default, old-format fallback, automatic historical backfill or current-revision rebind. Generic OAuth2 requires a trusted HTTPS resource declaration; it does not attest application callback behavior. This bounded guard adds no cross-ID physical-target ownership, durable target-key hasher pinning, dispatch journal or retained uncertainty recovery. Rotating/unclassified refresh remains refused; publication and adopter cutover remain owner-managed.

Native refresh request inspection

Connections' native drivers expose optional frozen client/token-endpoint request facts without I/O or credentials. These help qualified server integrations inspect real driver configuration; they are not canonical issuer/alias authority or a refresh-target key. The exact credential commitment remains a separate configuration guard: resource/parameter changes must not create a new target partition. Legitimate links across accounts remain supported. No schema, retained target ownership or rotating-refresh dispatch is enabled by this batch.

Explicit GitHub.com authority and key activation

Connections adds optional authority/key persistence and a native 32-byte HMAC key factory. Explicit maintenance activation pins the actual key and opaque native GitHub.com client mapping; read-only target derivation can join caller transactions. Changed actual keys, unactivated clients and lookalike/custom-endpoint providers refuse. Runtime roles need SELECT only; activation additionally needs INSERT. Optional schema and adapter artifacts preserve explicit selection and role/retention boundaries. Existing credential schemas and writer behavior are unchanged.

This is activation and derivation, not retained target ownership or a dispatch fence. Verified identity, transport qualification and authorization remain required; automatic rotating refresh stays disabled. The explicit managed workflow below adds the remaining coordination and recovery contracts.

Retained Connections credential-configuration mapping

Explicit GitHub.com activation now retains exact credential-configuration to request/client mappings, derived through private native constructor state. Read-only assertCredentialBinding checks that mapping and pinned key without provider I/O; public provider overrides cannot substitute another commitment. Missing or conflicting mappings refuse. Existing target hashes stay unchanged.

The optional authority schema, custom-adapter contract and artifact hashes move together. Runtime roles retain SELECT-only access; maintenance additionally needs INSERT. No implicit schema adoption, old-format fallback or backfill is supplied. This is configuration evidence, not a record/epoch guard or refresh-dispatch proof; automatic rotating refresh remains disabled.

Qualified Connections credential writes

Connections separates credential replacement from ordinary status/metadata saves. Native creation and replaceCredentials require opaque service-issued admission bound to the full record, expected revision and original transaction; independent adapter instances reject forged, changed or cross-transaction invocations. Ordinary save cannot rewrite tokens, scopes, expiry or provenance, or reactivate a nonactive record. Revoked/insufficient records cannot bypass that boundary through expired status either; expired may still resolve valid tokens. Reauthorization and supported nonrotating refresh retain their service paths, including access-only refresh preservation.

The custom persistence port, scaffold/hash, public read-only admission inspector and conformance runner move together. No public mint or legacy-call fallback is supplied. The mandatory ordinary policy below adds retained schema; durable target enforcement belongs to the explicit managed profile below. A local admission alone does not authorize provider dispatch. Automatic rotating refresh stays refused.

Mandatory ordinary Connections credential policy

The selected Connection scope schema now includes retained configuration/grant policy. Explicit maintenance activates manual and OAuth independently; runtime only reads the exact profile before credential use, and every native writer requires the policy without an opt-out. Native GitHub retains its private refresh-blocked profile despite public configuration overrides. Explicitly nonrotating providers keep ordinary refresh support.

Adopt the required schema and reviewed policies before enabling writers. Custom adapters add the policy assertion and separate maintenance contract. No automatic registration/backfill, target-key requirement for ordinary grants, rotating dispatch or credential-epoch guarantee is introduced. Publication and application schema deployment remain separate.

Native GitHub client policy across configurations

Connections now pins an immutable ordinary-or-managed selection for a recognized native GitHub refresh client, independently of exact API/resource configuration. A custom-API GitHub or generic native OAuth2 configuration cannot ordinary-activate the same client after managed enrollment; the reverse transition also refuses. Private constructor capture survives negative subclass classification and ignores public inspection overrides. Conflicting Basic-auth body client IDs refuse at the recognized standard GitHub token endpoint.

The base schema gains a required client-policy table and nullable exact-policy mapping. Runtime uses SELECT; maintenance uses SELECT/INSERT with one ordered activation unit. Custom adapters and application-owned schema adoption must move together. Ordinary clients still need no HMAC key or optional authority tables. No automatic promotion/backfill or rotating refresh permission is added.

Single-admission prepared Connections grants

A prepared OAuth grant can now commit one native credential admission. Its private random identity is retained in a permanent receipt, atomically with create or replacement. Known rollback permits retry; committed or unknown completion never grants replay, including after owner/Connection deletion. Failed CAS does not consume a receipt, and concurrent claims cannot commit two writes.

The required base schema, adapters, scaffold and conformance move together. This is not refresh-token identity or epoch tracking: independently prepared identical credentials remain supported. Ordinary code/manual/nonrotating paths keep their existing behavior; these preparations alone do not authorize rotating dispatch. Publication and application schema adoption are separate.

Managed GitHub credential identity

Explicit native GitHub enrollment activates authority/key and both managed grant policies together. Managed service aliases use captured native operations and retain private refresh-token identities plus current links. The same client/token converges across owners, aliases and reencryption; assigning it to another verified subject refuses. Existing key methods and target framing are unchanged.

Managed writes and stored-secret use require current activation/link evidence. Access-only OAuth preserves the exact current refresh identity; manual replacement detaches its pointer without deleting history. The optional schema, custom-adapter port, grants and scaffolds move together. Ordinary profiles remain key-independent. The explicit managed profile below supplies separate consumption, target and dispatch coordination.

Owner-first Connections mutation locking

Native Connections mutations now lock the selected owner strongly before provider keys and live rows. This removes row/owner inversions and late-audit owner-upgrade cycles. By-ID discovery returns current same-identity state after waits; saves retain expected-version CAS and permanent ID evidence. Memory operations recheck handle liveness after guards. The adapter scaffold describes the same contract.

The tradeoff is owner-wide serialization, including owner locks during existing nonrotating provider I/O. By-ID locking/direct save also require owner-table row-lock grants; broader host ancestor ordering remains application-owned. No schema or retained target/refresh-epoch machinery is added by owner locking itself; automatic rotating refresh stays disabled.

Managed GitHub target serialization

Enrolled native GitHub credential operations now acquire a canonical target lock between owner and provider locks, including missing-row grant admission, by-ID reads and direct saves. Source-issued lookup proofs bind the scope, alias, subject and original transaction before locks; unconfigured peers still observe retained managed links. Late target acquisition refuses across native adapter instances sharing a physical transaction. Custom adapters must implement the same ordering.

This requires no schema change and adds no rotating refresh permission. The explicit managed profile below adds durable consumption, unknown-outcome barriers and response recovery. Cross-domain ancestor ordering and application role qualification remain host-owned.

Explicit CLI inspection and template generation

CLI accepts Billing's shipped artifact manifest without vendor patches, while optional command schemas and explicit adapter scaffolding retain their selection rules. Plain info reports neutral capability metadata; explicit surfaces and adapters use the same recipe resolver as add. Database sync now honors --json with one structured compatibility and synchronization report; JSON inspection never prompts to configure a target.

Installed integration declarations now drive one tracked generation path. For example, playstack eject @playstack/mail --integration=mail --target=mail-provider --output=src/mail.provider.ts selects a named published template and an explicit application file. Mail and Cloudflare Queues templates support read-only planning, source fingerprints, conflict detection, edit-preserving repeats and tracked merge ownership. Managed targets, bases and control files cannot be claimed through demonstrated case or hardlink aliases.

Skills synchronization also round-trips the published shared references used by Chakra composition and structured data. Package skills may co-own declared reference/ files with matching hashes; overrides remain confined to their own skill folder. Conflicting receipts refuse, and local edits remain protected. Removed skill IDs or targets are left untouched; retirement within an active target still requires explicit force.

Strict server writes and unified inbox reads

Storage adds putStrict for server-owned bytes with exact SHA-256, length and explicit SSE-S3/SSE-KMS constraints. It owns and validates the complete body before provider I/O, within a default 16 MiB cap or an explicit host limit. This is a buffered single-PUT profile; unsupported providers refuse before consuming the body, with no fallback to ordinary writes.

The S3 provider requires a matching checksum-enabled HEAD observation after PUT. That observes the current object, not a version-bound receipt. A failed or mismatched observation can follow a committed write: Playstack does not delete or automatically replay it. Hosts own reconciliation and SDK retry policy; use maxAttempts: 1 when implicit transport retries are prohibited. Live AWS/KMS, multipart behavior and application object admission remain separate gates.

Notifications supports unified listInbox and countUnread reads across an explicit authorized account set, with optional personal rows. The host authorizes the recipient and every account on every call; there is no account discovery or all-account wildcard. Omitted account selection remains personal-only.

The selected view has global ordering and a cursor bound to recipient, canonical account set, personal inclusion and archive filter. A changed view rejects the old cursor. Custom adapters must explicitly advertise and qualify selection support. Cross-account mutations remain outside this read profile: individual and bulk mutations, attribution and retention retain exact-scope authority. No inbox schema migration or framework route is introduced.

Qualification and adoption

The release workflow now installs the complete production-native archive train before protected review. Initial and empty-store frozen consumers check every artifact/resource hash, Billing schema commands and export formats, Skills sync, and all five Mail/Cloudflare generation contracts. Public runtime dependencies come from the CI checkout's frozen installation; lifecycle scripts, workspace links, Yalc and registry credentials are absent from this gate.

Local source and artifact qualification does not establish live provider behavior, managed-registry availability or an adopting application's authorization and persistence. Review the Audit schema, trigger installation and role grants; update custom Billing and inbox mappings; qualify worker, retention and recovery boundaries before replacing retained safeguards. Broader subscription financial profiles, cross-account inbox mutation and live AWS/KMS qualification remain outside this train.

Publication status

Beta 5 is upcoming. October 30, 2026 is the preparation-note date, not a publication date. No protected publication run or registry availability is claimed for these changes. Deploying the site or merging the preparation does not publish packages; record successful durable workflow evidence separately.

Explicit managed GitHub refresh

Connections adds an explicit Node GitHub.com managed-refresh coordinator. Native admission permanently claims the predecessor and blocks its canonical target; only fresh commit-confirmed local admission can use one native HTTPS request. Encrypted factual responses survive actor/live-row loss, while current source, authority, receipt and expiry checks gate successor installation. Existing keys and unknown outcomes never resubmit; spent credentials stay unavailable across linked owners.

This profile requires explicit managed enrollment, the shared Clock, native storage/journal, qualified Prisma transaction evidence and transactional required callbacks. Adopt the updated optional schema and narrow column grants before activation, with reviewed retention of restricted source IDs/ciphertexts. It exposes no reset, TTL, cleanup or operator release. Automatic rotating refresh remains refused; custom providers/transports and live GitHub/application qualification remain separate.

Generation-bound account deletion finalization

Accounts adds an opt-in trusted-worker finalizer for one account and expected deletion ID. Required worker/cleanup admission, generation/deadline checks, conditional native deletion, local cascades and native Audit erasure share one owned or caller transaction. Final authority runs after required work; stale jobs, restored generations, failed cleanup/evidence and same-transaction recreation refuse and roll back together. System-worker attribution does not require the original requester to remain active.

Opting into finalization also refuses batch purge on that service before discovery, preventing accidental bypass; unconfigured services retain the explicit batch API. Custom persistence/scaffolds add the conditional deletion port. No new schema, automatic purge scheduling, remote-cleanup engine or successful-replay claim for a missing account is introduced. Product reconciliation and acknowledged provider cleanup remain prerequisites; separate databases retain separate transactions.

Explicit plan-schedule withdrawal

Billing's durable command journal now accepts withdraw-scheduled-plan-change with an expected schedule and complete native pending terms. The bounded Stripe profile releases one attached active price/quantity schedule, preserving cancellation dates under the original-key, one-POST dispatch guard. A factual release receipt survives later projection changes without inventing subscription terms or paid grants. Changed unresolved sources require reconciliation. Schedule creation, richer phase programs, combined reactivation and refund calculation remain separate capabilities or application policy.

Plan changes at the period boundary

Billing adds a separate schedule-plan-change command for an already attached active release-ending schedule. It supports qualified monthly/annual target prices at the current period boundary, preserves current terms and binds the future phase to one durable original-key request. Accepted evidence records the future schedule without granting paid target access. Schedule creation/attachment, richer financial programs and combined reactivation remain separate.

Durable schedule attachment

Billing adds attach-subscription-schedule for a qualified existing subscription. One guarded from_subscription request retains its original key, source and uncertainty barrier. Factual receipts record the returned schedule and actual ending behavior without changing plans or granting target access. Follow-on schedule commands qualify that result independently; automatic renewal is not silently treated as release-ending behavior.

Qualified renewal sources for scheduled plan changes

The existing schedule-plan-change command now admits a neutral, single-phase renew schedule after fresh source qualification. It retains the observed ending behavior in its prepared request and uses the same guarded update to set the release-ending future program. No intermediate normalization request or new public API is introduced. Unknown renewal programs refuse, and a still-renewing acknowledgment remains uncertain. Existing native request records need reviewed artifact/adoption qualification before cutover.

Withdrawing metadata-bearing scheduled changes

Schedule withdrawal now accepts bounded opaque phase/item metadata such as application plan labels. The metadata never supplies authority or enters command evidence. The existing release request can undo a qualified uncanceled pending downgrade without a redundant cancellation-toggle request. Verified provider projection still owns pending-state cleanup; phase rewriting keeps its stricter metadata requirements.

Cancellation-preserving schedule withdrawal

Billing schedule withdrawal now has an explicit cancellation: 'preserve' mode for qualified pending-plan sources with standard period-end cancellation. The native provider retains the one-POST release body and factual receipt. Verified projection then permits a separately journaled cancellation withdrawal; unknown release work still blocks progression. Provider capability and immutable intent checks preserve the default uncanceled-only profile. Product orchestration and live Stripe qualification remain separate, with no schema change.

Withdrawing native scheduled changes

The withdrawal profile now recognizes the unstarted future billing anchor emitted by native plan scheduling. A verified pending projection connects the two commands; their factual receipts never project subscription state. Current anchors, financial guards and the pending-boundary refusal remain unchanged.

Stripe Customer declaration compatibility

Billing's structural Customer results now accept the void deletion marker used by Stripe's normal Customer type. Customer creation and retrieval can be wired without application casts; deleted customers still reject at runtime. Packed ESM/CommonJS declaration checks cover Stripe 22.3.1, 22.5.0 and 22.6.2, including direct SDK results and customer bridges, while retaining qualified transport admission.

Focused account administration and lifecycle authority

Accounts adds focused administration, invitation access/issuance, ownership access/issuance and closure factories. They expose only installed operations, retain caller-transaction evidence and require transactional delivery for issued proofs. Scoped invitation management, bounded pending lists and full deletion status avoid unrelated delivery or purge requirements. Closure permanently invalidates pending proofs; restoration never reactivates them.

Native Auth closure and ownership handlers retire the appropriate account-scoped sessions and all retained refresh descendants, including expired access. Required evidence rolls back with the account mutation. The complete Accounts service retains multi-owner behavior and its ordinary delivery profile; custom adapters must implement the accompanying persistence ports. Application policy, cooperative account admission locks and provider cleanup remain host-owned.

Best-effort Audit failure reporting

Nest Audit now isolates both synchronous throws and rejected promises from onFailure, preserving the original successful response. Controller errors continue to propagate unchanged. Required mutation evidence still belongs in direct transactional Audit rather than the best-effort interceptor.

Failure-only password sign-in budgets

Auth adds an opt-in password failure limiter. Successful verification preserves the existing failure history; exhausted budgets refuse before password work. Native rolling limits support prospective checks and explicit zero cooldown, while the Prisma adapter retains subject locks through verification and failure accounting. Required host evidence can commit with the budget. Identity/session commit remains separate and rechecks current authority; pool capacity and bounded verification scopes are required. Ordinary attempt limits and other credential operations retain their behavior. MFA failure-policy integration remains separate.

Combined MFA code failure budgets

MFA adds an opt-in active-code challenge that tries TOTP and then an explicitly allowed recovery fallback before counting a failure. Successful fallback spends no quota. Native rolling budgets, factor consumption, proof signing and required evidence join the same transaction; signed proofs remain private until commit. Explicit limited/invalid/unavailable outcomes support host response mapping. Existing prepared, enrollment and passkey profiles retain their behavior.

Final subscription-reconciliation authority

Billing now repeats trusted operator and current account authorization after reconciliation journal and required evidence waits, including identical terminal retries. Late denial rolls back the decision, accepted generation and Audit/outbox changes together. Factual provider acknowledgment storage remains independent of actor authority. No new command engine or schema is introduced.

Explicit OAuth refresh-token omission policy

Already-exchanged OAuth admission can now select omittedRefreshToken: 'clear'. Preserving the latest token remains the default, and a newly supplied token always wins. Authorization sees the captured policy. Managed clearing removes only the live refresh and current credential pointer; retained history and uncertainty barriers remain. Rollback restores credentials and evidence together, with no new schema or direct persistence bypass.

Managed Node transport shutdown

The managed GitHub Node provider now exposes close(): Promise<void> to stop new network admission, cancel outstanding requests and await physical request, response and socket closure. Previously prepared requests cannot dispatch after closing. Complete HTTP observations remain available for durable receipt storage; incomplete submissions retain their no-replay barrier. Applications still join their refresh/recovery and onboarding operations before disconnecting shared database or crypto resources. No schema change or automatic replay is introduced.

Managed-refresh secret redaction

Connections retains source credential commitments instead of encrypted credential copies in permanent refresh bindings. A narrow redaction service removes encrypted response material with a monotonic marker while retaining claims, status and target barriers. Dedicated worker authorization and required evidence share a native or caller cleanup transaction. Late sealing/recovery/installation cannot restore redacted secrets; installed successors remain usable and unresolved operations remain blocked. Adopt the updated optional schema and reviewed grants and data cutover together. In-flight work, live credentials and provider cleanup remain application-owned.

Terminal cleanup also covers genuinely superseded attempts, including received responses. Native storage verifies the retained replacement witnesses before cleanup, on repeats and after required evidence. Status, credential claims and generation barriers survive; missing witnesses refuse cleanup. This refinement requires no additional schema change.

Explicit managed-refresh reconnect

Verified OAuth admission can explicitly supersede an exact unresolved managed refresh using a different, never-known refresh credential, matching native journal and required trusted authorization/evidence. Target-wide generations keep every older linked credential blocked while current grants and successors remain usable. Credential replacement, preparation consumption, supersession and generation advance commit atomically; stale outcomes cannot install afterward. Hosts must vouch for fresh exchange provenance and drain old work. Adopt the updated optional schema/constraint/hash/grants in a reviewed migration; ordinary admission and automatic rotating-refresh policy remain unchanged.

Durable per-target OAuth preparation retirement

Native managed Connections can retire earlier OAuth preparations for one canonical client/subject without retiring the complete service. A committed issuance stamp follows private grants, signed callback state and exact native admissions. Authorized inspection and exact-revision retirement share required evidence and the credential writer's physical target lock; old admissions refuse, new issuance works and unrelated subjects retain their preparations. Adopt the updated optional schema/hash and narrow counter/floor grants together. Fresh provider issuance, remote uncertainty and complete-operation drainage remain application responsibilities.

Verified webhook-response receipt seam

Webhooks adds a separate opt-in sendReceipt API with a required application verifier, bounded explicitly selected Node response fields and typed accepted facts. Exact body/destination admission stays before network submission; verification does not replace native DeliveryAttempt authority or current authorization. Missing, invalid or lost receipts return only a redacted, non-retryable unconfirmed outcome, without granting replay permission. The default void dispatcher retains its behavior. Packed HTTP/HMAC and joined PostgreSQL fixtures cover signed acceptance, immutable intent, contention, encrypted receipts, rollback and lost acknowledgments; live provider/TLS qualification remains open.

Exact token-bucket refill accounting

Rate limiting fixes duplicate refill credit on repeated evaluations at the same time. Shared, Prisma, Durable Object and Redis paths retain exact fractional progress, monotonic observation time and no excess credit after saturation. Retry deadlines include remaining fractions and backward-clock waits; Redis expiry retains that clock debt too. Group denial still spends no bucket. Adopt the required token state fields, matching Prisma fragment/hash and reviewed state cutover with the adapters. Old populated accounting is never silently reset or backfilled. Fixed and rolling windows are unchanged; application activation and package publication remain separate.

Optional BullMQ progress subscriptions

Queues adds progressEvents: false to skip the factory's dedicated QueueEvents connection when progress subscriptions are unnecessary. The default remains enabled. Worker progress writes and inspection, counts, cancellation and scheduling are unchanged; disabled subscriptions fail explicitly. Event shutdown and native producer/worker ownership remain separate.

Terminal notification admission-payload redaction

Notifications adds explicit caller-transaction cleanup for complete durable admissions. It removes logical request/payload/recipient/context fields while retaining a permanent key tombstone; future identical or changed admissions refuse and late receipt updates cannot rebuild the data. Native admission and cleanup require Read Committed. Required authorization, Audit, producer retirement/drain and separate downstream retention remain application-owned. No automatic TTL, row deletion, schema change or complete-erasure claim is added.

Expired Billing preparation retirement

Billing adds explicit authorized retirement for an expired command that never issued a submission claim. The not-submitted closed outcome removes request/source material, keeps its key permanently closed, releases its reservation and leaves accepted generation unchanged. Required Audit and final authority checks share rollback. Claimed, uncertain and payment-bearing commands remain protected; there is no new schema, automatic sweep or fabricated provider rejection.

Permanent Billing uncertainty quarantine

Billing adds explicit default-deny request cleanup for replay-expired unknown or reconciliation-required commands. Compact quarantine retains the key and a permanent account barrier. A valid late acknowledgment is stored once without restoring the request or releasing the barrier; discovery reports only receipt presence. Required Audit and final authority checks share rollback. This does not resolve payment uncertainty, lift the account fence or add a schema migration.

Retaining pending-payment acknowledgments during cleanup

Billing extends explicit permanent quarantine to acknowledged pending-payment commands. It removes request/source material while retaining the exact receipt and original reviewer evidence, without counting acceptance twice. Resolution/cleanup races preserve facts and roll back the losing operation. The account fence remains permanent; verified payment resolution is still the route for resumed commands. No invoice settlement, new schema or automatic cleanup is implied.

Abort one pending MFA enrollment

MFA adds explicit, default-deny background cleanup for one pending credential and its exact unacknowledged recovery set/hashes, without requiring an active-factor proof. Caller cleanup receipts and required Audit join the same User-first transaction; active factors and unrelated sessions are preserved. Adopt the updated MFA schema hash, origin-column migration and regenerated client, and register transactional mfa.enrollment.aborted evidence. Confirmed pending state needs reviewed native associations, never a guessed backfill. Admission fencing and bounded challenge cleanup remain separate; source preparation does not publish packages.

Bounded expired WebAuthn challenge cleanup

MFA adds explicit global maintenance for expired registration/authentication challenges, including anonymous sign-in. A package-clock cutoff and bounded skip-locked deletion preserve live ceremonies, with count-only results and required transactional evidence. Default-deny worker permission is rechecked after evidence; caller failure rolls cleanup back with host writes. No new schema/hash or factor/session change is introduced. Worker scheduling and enrollment-admission fencing remain separate.

Native MFA transaction ownership admission

MFA adds a native Prisma assertion hook before transactional relation access, including pre-policy reads and anonymous challenge writes. It captures the original handle and owns write values before awaiting admission, with fresh checks and private refusals. Applications can supply their qualified factory's public fence while keeping active-user/account policy in the normal service hook. No schema or dependency change is introduced; artifact refresh and application qualification remain separate from source availability.

Go

Playstack Pro tag
OriginsPricingBlogChangelogStatus

© 2026 Playstack. All rights reserved.

With OSS

By

Commune Software