Week 41 · 5–11 October 2026
The week's theme is declaration over code. Four things you used to write by hand are now one line in your model, and the platform writes the rest: an entity that can be archived or binned, a create operation, the stamps that say who last touched a row, and the moves in and out of the bin. Each of them was a place where a hand-written handler could be subtly wrong — a binned row that still answered a GET, a create that forgot a stamp — and the fix is not a lint rule but the absence of the handler.
Beside them, three pieces of the permission system grew the ability to change their mind after the fact. A declared entity-grant shape now reaches the people who already hold it when you add a key, and can retire a key from them when you drop one; a binding invite ties the person who claims it to their own record rather than delegating the inviter's rights; and a page that filters row by row no longer leaks the position of a row the caller cannot see.
Mail becomes a first-class platform intent — written in your operation's transaction, sent after it commits, with the outcome coming back as an event — and the first engine built on it arrives. Two changes are breaking: a module's handlers are now bound to their declaration by a type, and a create your model describes completely must say who writes it. Both are in "Five changes to notice" below, each with its migration.
Archive and trash, each in one declared line
An entity can now be archived — hidden from active views, kept, still readable — or trashed, a delete that can be undone. You opt in with one line per verb in your model:
list: { …, archive: { permission: 'list:archive' }, trash: { permission: 'list:trash' } }and the platform derives everything else, the way it already derives your search and list indexes: two columns on your table, ctx.archive / unarchive / ctx.trash / restore that re-check the declared key on that row, refuse a wrong-state move and emit the event, an active-by-default ctx.page and ctx.search, a ctx.pageTrashed that checks the trash key on every row, and partial list indexes so an active walk never steps over your archive.
The two keys are deliberately separate. Archiving a record and binning it are different decisions with different audiences, and a role that may tidy is not automatically a role that may delete. Restore returns an entity to the state it was trashed from, so an archived record comes back archived and never silently becomes active.
The bin is held by the host, not by your handlers. An operation addressed by permission: { entity, idFrom } is refused on a binned entity before its guards and handler run, unless it declares trashed: 'admits' or 'purges'. The order of that refusal matters: the declared key is checked first, so a caller who does not hold it meets the same permission_denied an active record gives, and only a key holder learns the record is in the bin. ctx.link refuses a binned parent, and ctx.relink a binned destination.
The purge is declared too. trash: { permission, purgeAfterDays } derives a schedule that runs your own trashed: 'purges' operation as the module's system principal — hourly, bounded per pass, one entity per transaction with the cutoff re-checked inside it. Keys the system principal holds only for purging are withheld from every other call. Previews never purge, a scope's kill switch stops it, and the events stay. A purge pass now walks the whole due bin once per cadence window rather than restarting at the head, so one entity that keeps failing to purge can no longer starve everything behind it. And trash: { …, purgeEarly: false } declares a floor: the kernel refuses that purge operation, for every caller, on an entity that is not in the bin or was binned less than the horizon ago. The default keeps the purge the permanent delete a person empties the bin with.
Two integrity details worth knowing, because they protect you from your own SQL. ctx.sql refuses a write naming any _substrat_* column, as it already refused _substrat_* tables — judged by position, so a positional INSERT, any REPLACE, and a _substrat_trashed_at = NULL hidden inside a CASE … END are all refused. Under that, derived triggers mean a row can never be born archived or binned, and the state columns move only when the kernel's own authorization row for that entity exists. And an authored migration that rebuilds a table no longer strips what the kernel derived onto it: a create-copy-rename used to drop the guard triggers, the derived list indexes and the search-index triggers, with nothing putting them back. Every migration now checks, inside its own transaction, that the columns the journal says were added are still there, and the pass puts back the triggers and indexes each table is owed, or the scope fails closed naming it.
Finally, a held ETag survives a move. A kernel state move — archive, unarchive, trash, restore — keeps the entity's version, so a concurrency token a client is holding is still valid after the record goes to the bin and comes back. The Todo demo's app has the whole thing on screen: archive, bin, restore, and the bin itself.
The model writes your create, and your moves
An operation whose handler the model already describes completely must now say who writes it: derive: '<shape>' and no handler, or authored: '<what the derived one would get wrong here>'. This release adds create to the derivable shapes, plus the five archive and trash operations.
A derived create is a POST that emits about the new row by its id, answers the entity's own fields, and fills every column from exactly one thing your model names — a minted ULID for the key, the parent's id for a link column, an input field of the same type and snake_case name, a declared stamp, or the column's own default. It checks the declared key first, answers not_found for a parent that does not exist, links the row so the parent's grants reach it, and on an entity with a natural key answers the row already holding it with no write and no event.
Stamps are the declaration that makes that safe. EntityDef.stamps names the columns filled from the call rather than from input — createdAt from ctx.now(), createdBy from the calling principal — and a derived update refuses a body field that would write one. The updated pair goes further, because a declaration like that is only worth having if nothing can make it false: the host now holds the updated pair on every row an operation, a consumer or an imported-event handler emits about. After your handler, inside its transaction, each such row must carry that call's ctx.now() and principal, or the call fails and rolls back. It reads what the call emitted from the outbox since a mark taken before it, so a scope with no entity declaring the pair reads nothing.
One behaviour change rides along: a derived page whose check is narrowed to a parent now answers not_found for a parent that does not exist, where it answered an empty page. The check still comes first, so a caller without the key is still permission_denied.
A PATCH declaration is also held to being a patch: a declared input that would make it a replacement — a field with a default, or a nested shape that fills one in — is refused, inspected through every Zod wrapper and failing closed on a shape it cannot read.
A grant shape reaches the people who already hold it
A vertical's bootstrap entity-grant shape — the keys a person gets on their own record, their own order, their own employee row — was minted key by key at the moment the person was linked. So a key a later release added to that shape reached only the people linked after it, and everybody already in the scope silently kept the old set. There was no mechanism that could ever fix them.
The shape is now given with grantEntityShape, which leaves a holder marker beside the keys, and every provision, reconcile and listed promote tops each holder up to the declared shape in bounded, resumable passes. It is top-up only, and never over a tombstone: a key deliberately revoked from one person stays revoked. Someone who was ctx.granted part of a shape by hand is not a holder and is left alone. People granted before markers existed are backfilled once per scope and type, reading a bounded keyset window per pass and resuming from a cursor, so a large scope's first reconcile does not have to fit in one pass.
Dropping a key is the other half, and it is explicit: a shape can retire a key, which takes it from the existing holders. The promote diff and PERMISSIONS.md both say who loses a retired key and who keeps a dropped one — because those are different things, and a key dropped from a shape without being retired leaves its holders holding it forever.
For this to be a real boundary, a shape's keys now have exactly one way in. A direct grant of a shape's key on a parent of another type used to be accepted, and the permission walk carried it down onto every record of the shape's type beneath it. The walk now probes such a record but will not climb past it for a protected key, for entity grants and act capabilities alike, so the shape's own grant on the record is the only route. Grants already on the spine are covered from the next check.
ctx.revoke also stops being ambiguous. A revoke used to delete the tuple, so a key taken back from a person and a key never held were the same absent row. A revoke now writes a tombstone, and a re-grant is explicit about clearing it.
An invite can bind someone to their own record
A member invite and a customer invite look alike and are not the same thing. A member invite is delegation: the person who invites hands over some of what they hold, so it must be bounded by what they hold. A customer invite is not delegation at all: it ties the person who claims it to their own record, and the rights that record confers come from your reviewed permission registry, never from the link.
Both now exist as capabilities on the spine rather than as a vertical's own table.
A member invite is a become capability minted by the member who invites — single use, revocable, no expiry — under a bound: the minter must hold, at the scope, every permission the target holds there, and every entity-narrowed grant the target holds must be one the minter could exercise on that entity. A binding invite adds bind: { permission } to an entity-grant shape; claiming it sets the holder column on that record, grants the shape and emits, all in one transaction, and the bind is judged at mint and again before the use is taken. Unbinding exists, and erasure captures bound records before the module half and releases them after the hooks.
Because a binding shape is now load-bearing, a push that would strand people is refused: a version that drops or retires a key a binding invite bound somebody to is refused at promote, at bind and on a serving reference, rather than quietly leaving those people without the rights they were bound for.
Two smaller things in the same area. An operations-narrowed capability can be opted into attachment reads, separately from everything else it may do — a record from a host that predates the field reads as no opt-in, so nothing is granted by omission. And an operator's capability revoke now reaches the deployment serving the scope: a leaked link share that showed in the console but could not be stopped there is now stoppable, crossing an internal route with the operator named as its revoker, and a deployment built before the route answers "redeploy" rather than "not found".
Members, managed from the dashboard
An installed vertical's members can now be listed, invited, moved between roles and removed from the dashboard's app Settings → Members, down one sanctioned path: dashboard → control plane, tenant-pinned and audited → the vertical's platform-gated internal members surface, which runs the kernel's bounded scope-role verbs. Every change is bounded by what the signed-in person holds in the vertical's own scope, asked inside the scope task that writes. The owner of record and principals holding non-member roles are refused rather than removed, and a removal withdraws the invite, takes every role and unbinds every login, in that order. The hook is opt-in; a vertical that does not mount it answers 501.
Invites and removals effected out of band go through a membership executor, bounded by authority, where a removal wins over a concurrent acceptance and the first acceptance decides who joins — an acceptance written in someone else's name joins nobody. An org join is bounded by membership too: the executor joins the org only when the inviter is a live member of it.
Send email from inside an operation
requestEmail(ctx, { to, subject, html, text, … }) sends mail as part of the operation. The send is a platform intent written in the operation's own transaction, which gives you the property that is hard to get any other way:
- if the operation throws, nothing is sent;
- once it commits, the send happens;
- the outcome comes back as an event your module can consume —
email.sentwith the provider's message id,email.refusedfor a refusal that will not be retried, oremail.dead-letteredafter ten transient failures in a row.
A throttled mailbox is waited out rather than hammered: a handler may defer, with no attempt counted inside the window, honouring Retry-After when given and otherwise backing off from 30 seconds to 30 minutes. Within one pass, a sender that answered 429 is not tried again. The outcome event's payload carries no address and no provider prose; the full refusal stays on the intent row, where erasure can reach it. Passing subjectId marks the row as direct personal data, so erasing that subject tombstones it and cancels a pending send, with no new erasure code.
Mail can go through the tenant's own mailbox. A send may name a from, and a proven caller's message then goes through the tenant's live connection whose MailSender covers that address. An address no connection covers is refused by name and never quietly sent as the platform, and two connections claiming one address are refused rather than chosen between. The first such connector is Microsoft 365: app-only Graph, signing in with a client secret or with a keypair the platform generates per connection, the private key sealed with the credential and the certificate downloaded by the tenant. Its probe reads the SharePoint site, and "the certificate is not on the app registration yet" is reported as inconclusive so the connection can be saved before the tenant uploads it.
This is for transactional mail, not bulk: the platform-intent backpressure bound applies. Two honest limits: a send the provider accepted whose settle is then lost is sent again on the next pass, and the message body stays in the intent journal after it is sent unless a subject erasure removes it.
A notifications engine
The first engine built on that intent. A vertical calls notify(ctx, { topic, description, dedupeKey, recipients, vars, about, template, required? }) inside its own transaction — usually from its own consumer of a domain event — and for each recipient the engine applies mutes (unless the notification is required), looks up the address, renders the template, writes the send, and records a delivery unique per dedupe key, topic, principal and channel. A missing template variable throws and rolls back the caller, which is the right failure: a half-rendered notification is worse than none.
It is composed by call, so you wrap it in your transaction and extend it by composition. Topics are recorded on first use, and that record is what the preferences list and a mute must name, so a mute can never name a topic that does not exist. Addresses live on an erasable recipient row and the send carries the recipient as its subject, so erasure cancels a held notification.
Findings: an inbox for what your app keeps getting wrong
Your app's logs tell you what happened. They do not tell you what keeps happening. Observability › Findings is the new room for that: one tenant-scoped inbox of things worth your attention, each with a lifecycle rather than a timestamp.
Findings are detected on write, with no cron and no scan. A tenant's ops failure opens a recurring finding on the issue's fingerprint, a failed schedule run an invariant one, and a stale freshness verdict a drift one. Each carries a severity, when it was first and last seen, the codes seen, an evidence reference, and — for one that comes back — the version it regressed under. You can acknowledge, resolve and reopen, and write suppress rules with a scope and an expiry of at most 90 days; every mutation is audited. Retention resolves a quiet open finding as stale, audited, and never deletes it.
The reads are the tenant's own: counts, versions and scope, with no evidence text and no fleet count. The list pages by cursor through the kernel, the control plane and the dashboard alike, and the inbox says when a list was cut at the plane's limit rather than showing counts it cannot stand behind.
Findings are also the first routes on a declared, team-scoped dashboard route set. Every dashboard handler used to take its team from a cookie that every browser tab shares, so a tab showing one team could read and write another team's data after a second tab switched. Routes now name their team in their path and answer for that team — a team the caller is not in is a 404, never a silent fall back to their own. The declaration is the same shape an operation uses, with the compile-time check that every {var} in a path names an input field, and the mount resolves the context first, so a caller with no session is refused before their input is read.
Two things feeding it got more honest. Every control-plane 5xx is now recorded as an ops failure however it was answered, so the reference the CLI prints always finds something in the console — recording used to live only in the error handler, and two dozen routes answer their own errors. And the fleet rollup no longer calls an app failing because of one failed schedule run inside a 24-hour window: a sweep unit counts as failing only while its newest firing failed, which is what the app's own schedules panel already said.
Rate limiting at the router
The router now counts every resolved request before it dispatches, in two buckets: one keyed on the credential (a hashed bearer token, else a hashed session cookie, else the client address) and one on the client address alone. Every key begins with the tenant and scope, so one tenant never draws on another's budget.
Over budget, the answer is a 429 problem document with code rate_limited, plus Retry-After, RateLimit and RateLimit-Policy headers — and rate_limited joins the documented error codes, so every emitted OpenAPI document now lists the 429 on its operations. A limiter that throws fails open with a structured log line: losing the limiter should not lose the request. A node host with no router in front mounts the same check as middleware.
A page hands out no hidden row's position
A walk that checks permission row by row used to mint its cursor from the last row it read. So a caller refused every row on a page still got a cursor — and that cursor was the hidden row's id and sort value, which is a position you were not meant to learn.
Such a walk now fills from batches whose rows were all visible, mints the cursor only from the last visible row, and answers no cursor at the end. One call is bounded by a scan budget; a page that stops short answers the rows it has and no cursor whether it reached the end or the budget, so the shape of the answer never reveals which. For the sparse case where that bound would end a walk early, a sealed continuation carries the hidden position in a token the caller cannot read, capped and expiring, pruned by the purge sweep, with the residual disclosure written down rather than hand-waved.
The shop demo's portal order list is the worked example of why this matters for cost as well as confidentiality: it used to read every order in the scope and check each one before cutting a page, so one portal request cost one permission check per order the shop had ever taken. It now pages over the entity and walks visibly — a page costs the checks it takes to fill it, and the cursor is only ever one of the caller's own orders.
Your migrations are held to the SQL that ran
A scope's migration journal recorded that version 7 of your module had been applied. It did not record what version 7 said. So editing a shipped migration — which the rules forbid and nothing enforced on an already-migrated scope — left every existing scope on the old SQL and every new one on the new, with no signal anywhere.
The journal now stores a digest of the exact SQL. An authored migration already applied with a different digest fails the scope closed at wake, naming the module, the version and both digests. Rows from before the column are accepted and never backfilled, and kernel-derived DDL is held to its declaration rather than its digest, since the kernel re-derives it.
Erasure reaches your own tables
Subject erasure redacted the spine and destroyed the subject's key, but never touched a vertical's own tables — a documented limit, and a large one. An entity now declares whose rows it holds beside its erasable fields: erasure: { subjects } to blank them, mode: 'delete' to remove the row, or a custom mode reached by your module's onSubjectErased(ctx, { subjectId }) hook. The hook is synchronous and its ctx.sql reaches your module's own model tables only, reads included. A module is refused at registration without an erasure block, or for a custom entity with no hook. Both adapters run the module half in one transaction with the spine redaction, so an erasure is still all or nothing.
The reference desk completes its own erasure on the back of it, and a gap worth naming is now held by a test: an import's replayed delivery rows must be erased together with the live ones, so an erasure that reaches one copy and not the other goes red with a message naming the fix.
Attachment search reads PDFs
Last week's attachment text extraction learns PDFs, and the extractor it ships is a single forward scan written for hostile input. Old uploads are reached by a one-shot backfill that runs as a kernel job, and a host can now set its own extraction bounds rather than taking the defaults.
The memory budget is the interesting part. A page's content was joined once per content reference, so 96 references to a one-megabyte stream held about 100 MB of buffers before any budget looked — the inflate budget counted bytes produced, not bytes retained. There is now a retained-memory bound beside it: an allocation that grows with the input is taken before it is made and given back when it is freed, and past the bound the read ends truncated, exactly as the text budget ends it. Its tests are decided by an injectable clock rather than the wall clock, so an abort's promptness is counted as work charged after the abort instead of measured by sleeping.
Live reads, narrowed and bounded
A live subscription can be narrowed to one root within an entity, and checkedWithin(entity, permission) gates that feed on the subscriber's own check on the root rather than on each row — asked at the handshake and again on every pass that has something beneath the root to announce. A withdrawn grant, or a root moved out of a grant's reach, closes the socket before anything is sent. The handshake's refusal is a 403.
Two bounds come with it. subscribe takes expiresAt, the instant the caller's credential ends: the scope refuses a handshake past it and closes the socket on its first pass past it, before sending anything. And one principal may hold 8 live sockets on a scope; the next is closed with a code a client should read as "poll". An expired socket never counts against the limit.
The reference desk is the adopter on both ends. Its visitor widget and its customer portal conversation view are now pushed to over a root the customer is checked on, each falling back to polling where a push cannot reach, and signing out ends every feed the page holds.
Five changes to notice
1. A module's handlers are bound to its declared operations by a type.ModuleRegistration.operations is now one value holding the handlers and the three maps derived from their declaration, and only the binder produces it. Migrate in two lines: replace operationInputs: operationInputsOf(ops), operations: { … } satisfies OperationImpl<…> — and any operationConcurrency or operationIdempotencyOptOuts line — with ...operationsFor(ops)({ … }) from @substrat-run/kernel. A module with no declared surface wraps its map as ...undeclaredOperations('why it has none', { … }), and code reading a registration's handlers reads registration.operations?.handlers.
Why a type rather than a lint: the old shape had a registration pair its handlers with another declaration's maps, or forget a map entirely, and nine modules — both reference demos and the scaffold among them — parsed nothing while every gate stayed green. A missing, extra or mistyped handler is now a compile error at that entry, a handler whose type was erased by a cast is refused too, and both adapters refuse an unbound value at registration. The casts no type can see are boundary-lint R11, with the usual reviewable allow block; R2 now also refuses module code importing a test seam.
2. A create your model describes completely must say who writes it. After upgrading, defineOperations refuses at module load a create that matches the derivable shape and declares neither derive: 'create' nor authored: '<reason>', and the error names the operation and both remedies. The same rule now covers the five archive and trash shapes: an operation that matches one exactly must declare it. An entity that declares trash or archive cannot pair a natural key with a derived create — the replay would answer a row the kernel hides — so that create is written by hand.
3. A module with a trashable entity must hand the host its operation targets (operationTargets: operationTargetsOf(ops)) or it does not register. That is what lets the host refuse an entity-addressed operation on a binned record before your handler runs. An operation whose check is resolved inside the handler still has to ask ctx.entityState itself, and lint:model warns about each one — including the general form of the gap: a scope-wide key plus an id input whose entity is named only by a concurrency declaration.
4. The kernel no longer exports what was never yours. The host-side code deprecated two releases ago now lives in its new homes — the request-log middleware and the routed-node reader in @substrat-run/vertical-host, the connector-call recorder in @substrat-run/adapter-cloudflare, the delivery-failure classifier in @substrat-run/control-plane-api, the signed connect state in @substrat-run/control-plane-api, and the live-socket close codes in @substrat-run/contracts with the socket cap in the Cloudflare adapter. The same pass removed 133 index exports that nothing outside the kernel imported — SQL fragments, batch sizes, budgets, decode helpers — each of which was published surface the additive-only rule had to freeze forever. Nine were dead code and are deleted. If you import one of these names, import it from the package that now owns it; it is the same function.
5. ctx.platformRequests returns an entry type, and ctx.sql refuses ATTACH/DETACH. A journal row whose id, kind, status, attempts or time does not decode now comes back as an UndecodablePlatformRequest beside the other rows — the five identity columns as stored, as text, plus the decode error — where one bad row used to make the whole read throw, in the drain's queue, the history and your own read alike. Separately, ctx.sql now refuses ATTACH and DETACH for every module: an attached database is a second place a protected name could resolve. Nothing in the repo used them.
Typed refusals, finished
The long conversion from matching error sentences to declaring error codes is done. Every refusal the control plane still matched by message now declares its code where it is thrown, on both adapters, and a refusal raised inside a Durable Object travels as data so its code survives the hop — the attachment verbs are the last set converted. The pattern table is deleted, which means an untyped throw is now always a generic 500 rather than an accidental 404. The dashboard reads the code rather than the sentence, and the remaining sentence-matching in the vertical host is deprecated for one release: each match still keeps its status and logs once per sentence, naming the code that would have decided it.
The reference support desk
ticket0 gained the parts a real desk needs and a demo usually skips. Business hours: structured opening hours, an SLA clock that runs in business time rather than wall time, and breaching-soon computed on that clock, with an editor in Settings. Saved replies: personal and shared, in desk-wide folders, with usage counted in the transaction that writes the message — so a preview, an insert or a refused send counts nothing — and a new key for curating the shared library, so the assistant roles no longer rewrite it. Saved replies go to a 30-day bin of their own, and the folder create is now derived rather than hand-written. Public messages hang once under a per-conversation thread rather than once per widget session, which is what makes a conversation merge cost messages plus sessions instead of their product.
For hosted operators
- Suspension now holds background work. A suspended tenant's schedules, executor retries and job runs are deferred rather than run, on both adapters, and the tenant lifecycle is re-checked at the system door. A vertical whose deployment does no work a request did not start can declare
substrat.lifecycle: "router", which says the router's refusal of a held scope's requests is the whole hold — carried in the deploy manifest and stored in the install spec, so those scopes are left out of every lifecycle delivery, the heal and the tenant-record ask instead of answering 501 and writing an ops failure per pass. - Job runs are claimed before they run. Two drives on one scope could both pick a due run and both invoke its handler. A drive now claims each run with one compare-and-set that holds only while the run is running and due, writing the pass's lease in the same statement; a leased run is simply not due.
causedByis per call. Both hosts set a host-widecausedByaround an executor's awaited handler, so any admin call served in that window — a staff call included — was stamped with that event. Attribution is now a view rather than a field, and an executor attributes from the admin it is handed, so the event flows by construction rather than by remembering to pass it.- Every per-version scope copy is in a ledger, with erasure and reap fenced against a stranded one, and historic copies backfilled into it. A copy of a scope — a fork, a snapshot, a preview — consumes no other vertical's events and never honours the source's impersonation session.
- Peer calls bind to the tenant's chosen instance, resolved through an explicit binding in the directory and cleared when a tenant is reaped. The peer kill switch is recorded, re-asserted and held through a point-in-time rewind, tenant-held peers can be switched, and a switch turns OFF on a deployment from before the fence.
- The egress worker proves which vertical is calling the relay. The platform check established that a platform script was calling, not which one, so the tenant and scope in a relay body were the caller's claim. The caller is now held against the request object the gateway hands the worker, and a proven caller naming any scope but its own is refused on the email, connection, connect-url and connect-link relays.
- A vertical can mint shareable connect links — a revocable, single-use row the platform holds in the directory, for the case the fifteen-minute in-browser connect flow cannot serve: the person who must approve at the provider is a client company's own administrator, opening a mailed link days later with no account anywhere. Mint, revoke, consume and restore are admin-logged, and the row is single-use under racing consumes.
- Audited changes never drop their outcome row silently. Owner hand-over, dashboard member management, the kill switches and the replay lever all write their outcome through one helper: a row that cannot be written is logged as unrecorded rather than swallowed, and a watermark no longer moves ahead of an outcome that then throws.
- Restore and snapshot always name the tenant, so no load leaves a scope the tenant record does not know about.
- The push route refuses to supply a platform sweeper to a bundle that registers no scope host — on an older vertical host, or one that never mounts the platform surface, a supplied sweeper would never arm and never log.
- Pulse gains a third series: declared lifecycle moves per bucket, counted from the outbox in one aggregate statement over a window of at most seven days, with no new index and no migration. Per-tenant storage joins the meters as a stored daily gauge, and the app page shows sampled returned-field counts beside field coverage.
- The console offers the notifications engine's SKU, and a bureau's Fortnox fleet is manageable from the dashboard: every connected company listed, each addressable for verify, activity and disconnect, and a way to connect another.
- A login's place is reported from two more deployed verticals.
Also landed
- The Callout demo is removed. It was the reference every skill read, on a shape nothing else uses any more; the Todo demo (the shape) and the reference desk (the deployed half) replaced it. Its catalogue row is blocked and unlisted rather than deleted, so existing scopes keep serving.
- Joining the Todo demo records only the session's own verified address. The join route stored whatever address the request body carried, and sharing grants access to the member found at that address. It now checks that the address is the session's own and that the issuer asserted it verified.
- The auth server gains invited account setup with BankID or a password plus SMS, and can import users from another issuer with their bcrypt hashes intact — proven by signing in as an imported user.
- The shared Dialog is a real modal dialog: role, accessible name, Escape, focus in and trapped and returned, with the Tab wrap skipping what a browser skips.
- A spike places scopes across processes — placement by rendezvous hash, a fenced lease, a router that fails over, and a kill-mid-write test that is red before the fence and green after it.
- Two RFCs: a revision of the disclosure register with a recommendation, and VAT carriage in the invoicing engine, proposed.
- The builder studio can run a build turn as two lanes, API then UI, with disjoint write guards (opt-in).
- An installed vertical receives its per-install configuration through an internal configure route, with per-site auth isolation held by tests and the delivered client secret carried by no answer of the worker.
- Tooling: the repo moves to vitest 5, the Cloudflare vitest plugin and vite 8;
pnpm test:affectedtests what the working tree changed plus its dependents, with the release PR still running everything; the Cloudflare adapter's suite is split across two shards; workerd suites get a precise unhandled-rejection filter, a floating-promise lint and real rejection assertions; and CI's scoping now selects a suite that reads another package's files off disk, which is the gap behind a red main. - Dependencies: an override pinned past an advisory is now also checked for being stale — a newer release on its line out for more than 30 days — with an accept list for a consciously held version, and
honoandbetter-sqlite3move to the catalog with a one-version assertion. A publish-date comparison that sorted ISO strings now sorts instants. Plus the minor-and-patch group across 21 updates and two advisory pins. - Upkeep: a changeset names a package by its real name, a control-plane test no longer depends on request order, a review's three findings are folded in, and the reference desk's OpenAPI document is re-emitted twice after two operations changed under it.
Released
| Package | Span |
|---|---|
@substrat-run/contracts | 0.137.0 → 0.144.0 |
@substrat-run/kernel | 0.137.0 → 0.144.0 |
@substrat-run/adapter-sqlite | 0.137.0 → 0.144.0 |
@substrat-run/adapter-cloudflare | 0.137.0 → 0.144.0 |
@substrat-run/vertical-host | 0.137.0 → 0.144.0 |
@substrat-run/control-plane-api | 0.137.0 → 0.144.0 |
@substrat-run/contract-tests | 0.137.0 → 0.144.0 |
@substrat-run/control-plane-client | 0.1.2 → 0.1.9 |
@substrat-run/attachment-extractors | 0.1.3 → 0.2.5 |
@substrat-run/vertical-auth | 0.19.0 → 0.23.0 |
@substrat-run/oidc-rp | 0.10.0 → 0.11.0 |
@substrat-run/cli | 0.40.1 → 0.41.4 |
@substrat-run/model-emit | 0.9.32 → 0.10.0 |
@substrat-run/model-view | 0.2.41 → 0.2.48 |
@substrat-run/model-providers | 0.5.27 → 0.5.34 |
@substrat-run/dev-issuer | 0.2.19 → 0.2.26 |
@substrat-run/boundary-lint | 0.6.2 → 0.7.0 |
@substrat-run/engine-workorder | 0.12.21 → 0.12.28 |
@substrat-run/engine-protocol | 0.13.22 → 0.13.29 |
@substrat-run/engine-invoicing | 0.11.21 → 0.11.28 |
@substrat-run/engine-booking | 0.8.21 → 0.8.28 |
@substrat-run/engine-invites | 0.9.14 → 0.9.21 |
@substrat-run/engine-absence | 0.6.21 → 0.6.28 |
@substrat-run/engine-metering | 0.6.21 → 0.6.28 |
@substrat-run/connector-scrive | 0.14.43 → 0.14.50 |
@substrat-run/connector-fortnox | 0.4.39 → 0.4.46 |
@substrat-run/connector-planima | 0.2.34 → 0.2.41 |
create-substrat | 0.10.14 → 0.11.4 |
boundary-lint's minor is R11 and the widened R2; model-emit's is the declared route sets; oidc-rp's is the live-read narrowing and session expiry. The four vertical-auth minors and create-substrat's are the binder migration and the derive rules reaching the scaffold. In 0.x semver a minor is where a breaking change goes, so the fixed group's 0.144.0 carries every "change to notice" above.