Week 46 · 9–15 November 2026
The week's theme is an app made of other apps.
Three changes that each read as a feature are really one shape. A second app can now take its people from the first one instead of managing its own — sign-in, roles, who may see which record — and the first app can then call it as the signed-in person, so the second runs under that person's own permissions instead of trusting the caller's word about who they are. A deployed app can hold its sample world and seat its own cast inside a clean-room preview, so a preview has a real login for the first time. And the team identity server grew the two surfaces an app needs to take part in somebody else's identity estate: a SCIM server to be provisioned into, and a read-only Management API subset to be asked about.
The other half of the week is smaller and more overdue. An invited person could not get into a deployed app at all. Generated apps have been mailing "sign in with this address to claim your account" for weeks, and nothing on the platform honoured it — the worker's door bound only the provisioned owner, so an invitee who signed in was answered 401 before any join could run. Files are now served by a deployed worker as the signed-in person, streamed and seekable, with a link form for the places a session cookie does not ride. And a WooCommerce store lands its products and orders in a provider-neutral commerce shape.
An invited person can get in
A member invite is already filed in the tenant's identity directory under the scope it was written for, with the address it names, and every request arrives naming its scope. So the door can answer the question from that one directory, with no index and no search. For a signed-in subject bound to nobody in the scope, it now finds the open invite matching the address the issuer verified, exchanges that invite's link by its id, and binds the subject to the invited principal. The person then arrives as anyone does: your join runs, then the self shapes. No secret is involved, so the mail carries none.
The exchange makes every judgement the secret's exchange makes — expiry, withdrawal, the single use, and the invited principal's holdings unchanged since the mint — and lands on the spine as capability.exercised. It only exchanges a plain become that a principal minted, which is exactly a member invite's shape: an owner-claim link, a binding invite, a bind link and an act share all answer null, with their use untaken.
Two routes come with it, mounted by workerDoor({ invites: { roles, send, cancel } }):
POST /api/member-invites { email, roleKey }. The invited principal is minted and given its role, bounded by the inviter's own, with a link that expires in 14 days. Yoursendthen runs as the inviter — it checks who may invite, records what your screens list, and queues the mail. Only then is the invite recorded where the door looks, so nothing can admit anyone by an invite your app refused. A refusal fromsendtakes the role and the link back.POST /api/member-invites/:principal/withdraw. The platform's half goes first — the roles, then the link, then the row — so no later failure can leave an invite that still admits. Anyone admitted in between is unbound. Yourcancelupdates your own record after.
The path is /api/member-invites rather than /api/invitations so it never shadows an invitation route you declared yourself.
A link that names an address is now accepted only from a session whose issuer verified that address. The check runs before the scope is asked, so a forwarded link opens nothing and its single use stays for the person it named. Addresses are compared as NFC with ASCII-only lowercasing — a full Unicode lowercase merges characters no normalisation equates. See the changes to notice below: this refuses more than the old accept did, and deliberately.
The local dev server admits an invited person the same way, and a generated project's own invite screens are wired to these routes.
A second app can take its people from the first
One app owns the people. A second app owns none — no owner claim, no invitations. It signs people in at the shared issuer and asks the first app who each login is.
- The contract is
identity.person@1. In: the login (issuer, subject, verified address). Out: a person id, a status and role keys, or nobody. No name and no address. - The door is
admitPerson. It asks by peer call, uses the answered id as the principal, seats the mapped roles, and keeps the answer for 300 seconds by default.ctx.checkis unchanged and still makes no network call; the call happens at the door, when an answer is missing or past its time. - It fails closed. An expired answer with a master that does not answer admits nobody —
503, not a guess. - The revocation bound is a number. A block or a role change reaches the second app within 300 seconds by default, and
people.ttlSecondson the door moves that bound either way — nothing caps it, so a longer TTL buys cheaper reads and a slower revocation. No event delivery is involved, so no paused or skipped edge can lose a block.
The reference pair is Todo and Notes: Notes keeps notes on Todo's items, asks Todo before every read and write whether this person may see the item, and has no screens of its own — Todo's app draws what the plugin adds, for whoever the plugin lets in. Switched off, Todo looks exactly as it does without it. The design record, with the decisions taken and the questions still open, is docs/rfc/dependent-people.md; the walkthrough is on the Notes page in the docs.
…and then calls it as the signed-in person
Taking the people is half of it. Until this week the second app could only be called as the first app, which meant trusting its word about who the person was and stamping the first app's name on every event. Now the call runs as the person.
The mechanism is the RFC 8693 delegated token, in a new one-step form:
- The first app keeps a live token for the person. Opting in means asking for
offline_accessat sign-in and keeping the refresh token server-side, per session, deleted at sign-out. - It exchanges that token at the issuer over a new
peerchannel: it presents the person's token and names the second app's client as the audience, and gets back a token living at most five minutes whose subject is the person, whose audience is the plugin, and whose actor is itself. A banned person is refused. - It calls over the peer transport with
onBehalf: { token }— the local broker, or egress → router → the internal invoke. - The second app verifies the token itself, resolves the person through the person contract exactly as it does at sign-in, and runs the operation as them.
- The token's scope is a ceiling the kernel enforces on every check — on both adapters, covering
ctx.check, entity checks, grant-scoped reads,canAssign, guards and derived handlers. The call can do at most what the person holds and what was delegated, and idempotency recordings are keyed per delegation.
The second app opts in by declaring it, in its manifest:
delegations: [{ actor: 'todo', permissions: ['note:read', 'note:write'], channels: ['peer'] }]The declaration travels with the push in the permission registry, so it shows up in PERMISSIONS.md and in a promote's permission diff — the human checkpoint reads it like any other widening. A grant with no channels stays MCP-only, so no existing delegation gains the peer channel by accident.
What the spine records. A delegated call's events and denials now carry delegation: { actor } beside the person who is still the entry's actor, read through readHistory, readScopeHistory and a denial read. Read null as nobody acted for anyone — which covers every consumer- and schedule-emitted event and every row written before the column — and an absent field as an older kernel answered. Only the actor is stored, not the delegated scope: that can run to kilobytes per row and says nothing the manifest and the event's own authorization chain do not.
The delegated MCP endpoint passes the same kernel ceiling now, which closes the per-tool limit that RFC left open, and the peer door's checks got a stage of their own so a refused peer call reads the same to every caller. Refresh rows whose session expired without a sign-out are swept.
The revocation bound, as built: a ban at the issuer stops the next exchange; a block at the first app stops the second within the person contract's TTL — 300 seconds unless the door widened it; signing out of the first app deletes its refresh row. Signing out at the issuer alone does not stop it, the same as the first app's own session, and a cached delegated token stays usable for its remaining five minutes at most.
Files: served as the person who may read them
A route on a deployed worker had the caller's stub but not their id, so it could not serve or remove a file as them. The workaround — an operation that returns ctx.principal — is gone.
door.attachments(c) returns the signed-in person's ScopeAttachments, minted from the session the same way door.scope(c) mints the stub. It answers 401 for nobody, and the person "arrives" first, as with scope.
workerDoor({ attachments: true }) mounts two routes, both run as that person:
| Route | Answer |
|---|---|
GET /api/attachments/:attachmentId | 200 with the file streamed, 206 for one byte range, 416 for a range with no byte in the file, 404 for an id the person cannot read |
DELETE /api/attachments/:attachmentId | 204, or 404 |
There is one answer to a file request now, and the link-share download uses it too, so that streams and seeks as well. It never holds the file whole, answers one Range and ignores several (which RFC 9110 allows), uses the file's SHA-256 as its ETag, honours If-Range, and is hardened before anything can fail: nosniff, a sandbox CSP, no-store, no-referrer, and always Content-Disposition: attachment. A media or image element ignores the disposition, so <audio src> plays while a navigation saves the file instead of rendering it. A range is read by the store as a slice — R2 passes the range, the SQLite file store seeks, and a store without slices serves the whole file and says so by carrying no range in the answer.
One integrity trade-off, stated. A whole read is still checked against the record's size and SHA-256 as the bytes pass. A ranged read is held to the recorded size but not to the digest, because a digest needs every byte; asking for bytes=0-, which is what a media element sends first, goes through the fully verified path.
A download link is the read-side counterpart of an upload link: a URL that lets whoever holds it read one file, with no session, until it expires. Use it where a cookie does not ride — an <audio> element on another origin, a file an MCP tool returns, a link in a mail.
const link = await ctx.attachments.mintDownloadUrl({ attachmentId, ttlSeconds: 3600 });
// → { id, secret, path: '/api/attachment-downloads/<attachmentId>/<secret>', expiresAt }It reads as the minter, now: the secret resolves to the principal who minted it, and the file's readPermission is asked as them on every read, so there is no second gate to keep in step. Losing the key ends every link that principal minted; getting it back revives them. A read spends nothing — a media element reads one file in many ranged requests, so single use would break playback — and what bounds the bearer is its life (15 minutes by default, one day at most) and revokeDownloadLink. Only the secret's SHA-256 is stored, the table is left out of a scope copy so a fork or preview never honours the source's links, and both the request log and every problem document strip the secret out.
A preview you can sign in to
A clean-room preview had no login, so every studio Run of every project answered "no identity provider configured". That is fixed from both ends.
The app's end. A deployed app can seat its own sample world in a clean-room preview and seat its personas so they can sign in. seatWorldWith is seatWorld with the directory, the role, the grant and the invoke passed in, which is what a deployed vertical needs because it has no admin directory of its own; the local seed is unchanged. A persona's principal is derived from the scope and its subject, because every push binds a new script with an empty identity directory while the scope's data is carried — without that, a persona would lose everything it built on the last push. Two internal routes supply the world and the personas, and both refuse any scope that is not a clean room, whatever the request says. A persona marked invited: true is offered and never seated: they get in by a member invite naming their address, locally and in a preview alike. The scaffold template now keeps its sample world in src/world.ts and names it in src/worker.ts.
The platform's end is a real OpenID Connect provider on the control plane, one issuer per preview, so a token minted for one preview names an issuer no other trusts. It serves discovery, a JWKS, a picker and a code exchange. The picker answers only a person signed in to Substrat who is on the preview's team, and offers the personas that preview's deployment reports. The signing key is generated inside a Durable Object and never leaves it — it is not the social relay's key, which vouches for verified identities. The preview is its own client, and its secret is an HMAC of the preview's id under a key held in that same object, so every push delivers the same secret and a late-finishing older push cannot break a newer one's login. A code is single-use, lasts two minutes and is bound to its PKCE challenge, and each persona sign-in is logged with the person who made it. A version that declares no world reads as unseeded rather than failing the create.
And on production data. The studio has a Sample data / Production data picker beside Run. Production data is greyed out, with the reason in the studio's own words, when the app is not installed yet, is installed several times, or you are not its owner. The fork is made as the signed-in person rather than as the builder, and the plane judges that person in the app's own scope before copying anything: they must be the owner of record, or hold every role the owner holds there, with the roster read from the deployment that holds the scope. A team role confers nothing — "admin" is not a platform concept, because every app names its own roles — and a deployment that cannot answer refuses the fork. A new fork-check read answers the same decision without forking.
Two limits worth knowing: someone whose access to the app came from an invite has their own principal there rather than the one their team login maps to, so the plane cannot see their role from the studio and fails closed; and a team that has installed the app several times has to pick the install in the dashboard.
The team identity server: provisioned into, and asked about
Two surfaces, both opt-in at two levels — the scope must be in the issuer's MACHINE_SCOPES ceiling and held by a machine client — and both re-checked on every request, so disabling the client or removing the scope ends access at once rather than when the token expires.
A SCIM 2.0 server at /scim/v2, so an identity master creates the people it owns before their first sign-in and gets back each person's subject. Discovery; POST, GET, PATCH and DELETE on /Users; a single eq filter on userName, emails.value, externalId or id; and /Bulk with failOnErrors and bulkId: references. A BankID personal number goes in a write-only extension that is returned never — it becomes the account row BankID sign-in looks up, so the first sign-in lands on that same subject with open sign-up off, and it appears in no response, error message, log line or sign-in row. An address set over SCIM is stored unverified, because it is a claim. active: false blocks the account and ends its sessions and stored tokens; active: true lifts only a block SCIM set. A client may change or delete only accounts it provisioned — every other account is read-only to it, administrators included. And ?dryRun=true runs any write, or a whole Bulk, inside a transaction that is then rolled back, answering exactly what the real run would: a conflict between operation 1 and operation 2 of one batch shows up in the dry run too.
An Auth0 Management API subset, so an operator's own app can read who uses what: Auth0's token endpoint, users-by-email and users/{id} in Auth0's user shape and error body, and one extension marked as one — users/{id}/x-client-activity, when each application last got a token for the person, which Auth0 keeps no record of. Every other /api/v2 method or path is a 501 naming what was asked for, and an unknown query parameter is Auth0's 400. Nothing is silently ignored.
Both pages list every deviation from the specification they implement, one table row each — demos/auth-server/SCIM.md against RFC 7643/7644 and MANAGEMENT-API.md against Auth0 — because the differences are the part an integrator needs. An attribute this SCIM server does not store is refused rather than dropped, so an Entra ID or Okta mapping has to be trimmed to fit, and a BankID identity's personal number and placeholder address are never returned from either surface.
And one machine client per app. An app declares the issuer scopes it needs in its package.json:
"substrat": { "issuerScopes": ["read:users", "users:provision"] }substrat push carries it in the manifest. A sign-in scope, a scope with a comma or a space, a duplicate, or more than 32 scopes is refused before upload, with the error naming the field. Two platform-gated routes at the issuer then register, converge or remove the app's client: declared scopes inside the ceiling are granted and the rest are answered by name as withheld, so widening the ceiling later grants what was withheld without a new secret. A rotation keeps the client's id. An operator's own decisions survive it — an ensure never re-enables a client an operator disabled, and the ceiling bounds this client like any other. Nothing registers a client at install yet; that half is next.
BankID now proves an address
BankID asserts a person, not an address, so a first BankID sign-in used to create a placeholder account. Someone who already had an email account ended up as a second user with no access, and nothing could join the two.
Now the first sign-in parks the verified identity server-side and asks for an address, then proves it with an emailed one-time code:
| The address | Result |
|---|---|
| Is free | A verified account with BankID linked |
| Belongs to an account with no BankID | BankID is linked to that account |
| Belongs to an admin, an SMS-factor account, an unverified account, or one with another BankID | Refused — sign in and connect BankID from your account page |
It is a panel toggle, Require a verified email, on by default, and the personal number never reaches the browser. Existing placeholder accounts take the same step and merge when the address is taken: one subject retires, an app's binding is kept on whichever side holds it, and two bound accounts are refused with the apps named. An administrator can also merge two accounts by hand from a user's Identities tab, in one transaction, picking the survivor — so the refusals there cover only loss. An emailed code can join BankID to an admin account the same way.
Sign-in in two languages, themed, and logged
The sign-in screens are light by default and speak Swedish and English. An issuer has a theme, a theme file can reword the screens and limit which languages it offers, and a theme can be raw. The BankID screen's "open on this device" link is a full-width button.
The sign-in log records every way in, and keeps 30 days. Beside it, a longer-lived pair of records — a person's last sign-in and login count, and when each application last got a token for them — backs the Management API read above and is kept for as long as the person exists. An account merge folds the retired account's activity into the survivor, and an existing install fills both once at boot from the log and live sessions.
Two long-standing sign-in annoyances are also gone. There is now one rule for skipping the login screen — a single-upstream client goes straight there, and a domain route rules it out — and the logout confirmation is skipped only for a GET naming a client, with upstream sign-ins started only for navigations. Every log line names the version that wrote it, and Settings shows it.
Elements: a table people work in, a board, an assistant
@substrat-run/elements grew the three components a screen actually needs, and every one of them now runs live on the docs reference page.
<sub-entity-table> can back a list people work in, like a file manager. The table reports each gesture and draws the state; your screen decides what the gesture means. Everything is opt-in, and a table that sets none of it behaves exactly as before.
| Part | What you get |
|---|---|
| Selection | shift-ranges, cmd/ctrl-click, select-all, Escape, and a selection that survives a page turn |
| Opening and keyboard | row open, roving focus, load-on-scroll, icons and menus on row actions |
| Right-click and drag | context menu and drag start, both cancelable, with drop rules, a count preview and long-press on touch |
| Nested rows | lazy children, per-row reload, treegrid roles |
A changed sort, filter, search or page size keeps only the selected rows the new read still returns; a changed view clears the selection. With row-open set, a single click waits 300 ms so a double-click reports only the open.
<sub-kanban> is cards in columns, one column per state, moved by drag or by keyboard, built against how five well-known boards handle it. The card lifts out tilted and sways with the pointer's speed, a gap opens where it will land, and the board and column auto-scroll near their edges. canDrop is your lifecycle's own transitions: columns a held card cannot move to are dimmed, and the one under it says why. A column limit shows "2 / 3" and warns at and over it, and in strict mode refuses the card that would take it over. Every keyboard step is announced — space picks a card up, arrows move it past columns that refuse it, Escape cancels — which none of the boards it was modelled on documents, and one of them has an open bug about. A move fires a cancelable event first, marks the card busy while it saves, and puts it back if the save rejects. prefers-reduced-motion turns off the tilt, the sliding and the settle. The pure half ships as a DOM-free model.
<sub-assistant> draws a conversation over AssistantModel, loading no Web Awesome component of its own, and the dashboard's Ask is drawn through it. An assistant source can say what it is and where it lives. A re-read keeps appended batches, and more() waits for it.
The docs reference runs all of them on in-memory data, with a theme picker that follows the site's light and dark mode and a log of the events each one fires, and every demo has a one-line text version in llms.txt.
A WooCommerce store, in a shape a second platform can fill
Connect a WooCommerce store from the dashboard with its URL and a read-only REST API key, and its products and orders land in your app every quarter of an hour. Read-only and poll-only for now.
What they land in is a provider-neutral commerce shape, checked against a second store platform before it was frozen, so another connector can land the same records into the same operation. The rules your app can rely on whatever the platform: every product has at least one variant (a product sold without variants gets one whose id is the product's); an order line names the variant it sold by that same id, or null; money is a decimal string with a currency, refused rather than rounded; and listed, paidAt and cancelled are what to branch on, with the provider's own status there for display only. What is deliberately left out is written in the shape's own header: deletes, stock, fulfilment and refunds, a customer register, and write requests.
The connector does a few things worth knowing about. It sends the key as Basic auth over HTTPS and never in a URL, though WooCommerce accepts it that way. It walks by keyset rather than page number — oldest change first, from a per-resource cursor, restarting each request from the cursor with a one-second overlap, so it is correct whether the store's modified_after includes its boundary or not. It reads at most ten pages per resource per pass, so a large store's first sync spreads over several passes and shows catching up meanwhile. A record it cannot map faithfully is refused, naming the record and the field, keeping everything landed before it. The store URL is judged before it is called — HTTPS only, default port, no credentials, query or fragment, no IP literal in any spelling, no localhost or private-network suffix. And the probe reads the unauthenticated index first and then an authenticated call, so it tells "no WooCommerce store here" from "key refused" from "the key's user is not a manager", and names the store by the URL WordPress reports for itself.
Two behaviours are called out rather than hidden: a variation edited on its own is not seen until its product is next saved, because WooCommerce bumps the variation's modified date and not the parent's; and a host that strips the Authorization header will read as "key invalid", with the usual workaround being the key in the query string, which this connector refuses. The docs page tells the merchant how to pass the header through instead.
The studio: open to every team, and a chat is a branch
The builder studio is open to every team. Membership in any team is now enough; the separate builder entitlement is no longer read. An account with no team still gets a 403, and it now says so — that the account has no team yet, and how to get one — rather than that the studio was not enabled.
A chat is a branch. The studio used to keep one conversation per project and commit every green turn straight to the project's base branch, which is what Build release builds and what a connected repository's deploy workflow watches. A turn could reach production with no person in between. Now "+ New chat" starts a fresh conversation on its own branch from the base's tip, earlier chats stay listed to resume, and each has its own history, snapshot and phase. Turns and editor saves push only to the chat's branch; uncommitted work in the chat you leave is parked and restored when you reopen it.
The base moves only by a merge. For a studio-hosted project that is "Merge into main": a fast-forward when the base has not moved, otherwise a merge that moves the base only if the gates pass and nothing conflicts — a conflict names its files, a red gate shows its report, and either way both branches stay where they were. For a project connected to a GitHub repository it is a link to the compare page: the studio never writes a connected repository's base. Run previews the chat's commit; Build release builds the base's and refuses when nothing has been merged there yet. Existing projects need no migration — the current conversation becomes the first chat.
Around that, a long list of studio repairs: a busy project's 409 names what holds it and the preview's Run waits for it; the preview pane signs you in inside the frame and its notes stop looking like errors; the studio offers no sign-in its frame would drop and says why; the build phase has a 100-step ceiling per pass; a turn never commits node_modules, so a build turn's save reaches the repository; the chat drops tool-result rows instead of printing them as JSON and its tool-call groups keep their height in a long conversation; a project's files list without the NUL bytes the container's exec drops; the model gate never exits the sandbox's shell and runs the migrations emitter from the container's own toolchain; and a power stays with the role the answers give it, with an invite offered only at a role the inviter covers.
The command line can read a promote without promoting
If your app deploys from CI on merge, its promote is refused in a workflow log — and nothing in the command line could read that review without promoting.
substrat promote [slug] --review-onlyreads it without promoting: the permission diff, the migration diff, the apps it breaks, the acknowledgements a promote needs, and the exact command line to run. It follows the dashboard dialog's rules, so a first promotion asks nothing, a missing registry or missing SQL is "cannot compare" and asks, and promoting what already serves asks nothing.substrat status [slug]shows what production serves, the promote waiting and what it needs, recent versions with their admission, live previews, and recent failures.substrat changeslists open pull requests or workspace branches with their check results, failure details and previews.substrat review uploadstarts a code review of your own app, andreview <id>andreview listread them back. Availability is a staff-grantedreviewentitlement on the workspace — no app can declare it and no workspace can grant it to itself. Without it you still read your workspace's earlier reviews but start no new ones, and a CI push token cannot start one at all. Per workspace: at most 5 in progress and 50 kept in the 30-day window, one upload at a time. A review's model usage is metered to the workspace that asked for it.
The Claude Code plugin's approvals pane does all of this now instead of waiting for the agent's own call to be refused: it shows what promote is waiting and what it needs, with Acknowledge and promote running exactly the line it just showed you, lists your open changes, and starts a code review from a committed branch.
Six changes to notice
- An entitlement refusal no longer lists the other keys your tenant holds. The
detailis nowoperation not entitled: <operation> — tenant does not hold '<key>', and the; holds: A, B, Clist is gone. The code is stillnot_foundand the problem document is otherwise unchanged. Those keys are the SKU names of your tenant's other apps and engines, any signed-in member could trigger the refusal, and apps tend to printdetailon screen. The required-versus-held diagnosis moved to a server-sidewarnline keyed by the request id, so quoting the request id from the response lets an operator find it. If you parsed that list, stop. - Accepting an invite refuses more. An outstanding invite that names an address now needs a session whose issuer verified that same address. That rules out an issuer that sends no
email_verified, and someone invited at one address who signs in with another. The remedy is an invite that names no address. This is deliberate: without it, anyone could sign up unverified and use a forwarded link. - A member invite's link expires after 14 days, the dashboard's member invites included.
mintMemberInvite({ expiresAt: null })keeps one open until withdrawn, which is what the support-desk demo passes — whether a desk's invites should expire is the desk's own decision. - A dashboard fork of production data is judged as the signed-in person. A team admin who is not the app's owner, or who does not hold every role the owner holds in that app, now gets a 403 where they used to get a copy. A credential that names nobody — a CI push token, the command line, staff — keeps its old rule, since it can already push code onto the production scope itself.
- The Scrive connector registers three event types instead of one. It answers a voided or withdrawn request set as well as a requested one, cancelling the document at Scrive and settling the ledger row as
withdrawn. Adopters get this by upgrading and pushing again. A document every party had already signed before the cancel landed goes to needs-attention rather than being swallowed, and a fresh request set after a cancel is sent rather than dropped. - The Fortnox supplier-invoice write-back has a measured limit now. Driven against a real sandbox: in a company that requires attest before booking, the payment block cannot be released after booking — booking refuses an invoice nobody has attested, and once attested, only the OCR, invoice number and due date may change. An approved invoice therefore ends up booked, still blocked from payment, with no board comment, and with a failed receipt, and every repeat retries the refused release. The behaviour is unchanged and the finding is written down in full in the connector's measurements file, with the three candidate designs named. A booked invoice also lands with a null voucher, because the voucher is not in the field the landing reads.
For hosted operators
- The control plane gains a Durable Object class for the per-preview persona issuer, so deploy the control plane before the builder. A project's previews offer personas once that project has been pushed with a host carrying the seeded preview work and names its world in its worker; an existing project needs
src/world.tsandworkerDoor({ world: WORLD }). A control plane without the issuer answers 503 before creating anything. - Issuer-only config keys are moving behind a claim.
/configureis on the tenant-credential allowlist and accepted any key, so any holder of a tenant credential could write a delegation grant, a place registration, an MCP resource, a client redirect, or an app'ssubstrat:auth— the keys that decide which issuer an app trusts. The staff-only tenant-token mint now takes anissuerConfigclaim, verification refuses any other value so a malformed claim fails closed, and the dashboard's mint sends it while the builder's does not./configurerefuses those prefixes from a tenant principal without the claim, with a 403 naming the prefix and never the value, and refuses the whole batch so nothing is half-applied. It is behindCONFIGURE_REQUIRE_ISSUER_CLAIM, which starts off: deploy the plane, then the dashboard, then turn the switch on once no old dashboard isolate can still be serving — the dashboard re-mints only after a 401, so turning it on early fails deliveries until the old isolates recycle. Once it is on, a 403 there means an old token is still in use.substrat:social-relayis refused from every tenant credential whatever the switch says, since its only writer hands it to the vertical directly. - The lifecycle heal backs off. A scope whose deployment could never accept a delivery used to file an ops-failure row every 15 minutes without limit — one production issue had reached 52 000 occurrences. The directory now keeps one row per failing scope: the first failure still retries on the next pass, each repeat doubles the wait up to one attempt a day, and a waiting scope is left out of the passes with fixed limits so it no longer takes a slot. A row is filed only for news — the first failure against a receipt and deployment, or a different error from the last — and a landed delivery, a differently wanted receipt, or a changed serving ref or version clears it and tries again at once. A transition's own delivery never waits.
scripts/env-provisionstands up a whole environment from one token-minting token.- The router's kick drains the scope the intent went into and the named one, never a preview's, and a vertical's connectors poll on request. Dispatch and bind take the connector state lease, and connector state got a compare-and-set.
- A connector's sweep rows say why a binding did not land, in the connector's own words.
- The persona picker's form POST carries its Origin.
Also landed
- Mail landing is sturdier. A delivery claims its message before working on it, and the original message uploads streamed. An answer can keep the original (
raw: true);raw: truewith no entity fails rather than silently dropping it, and a non-booleanrawkeeps the entity instead of being read as a request for the original. - Fortnox reads a supplier-invoice flag the provider sends as a string, which it had been reading as a boolean.
- The hosted review runner reviews the revision a build was made from, an accepted amendment to its RFC, and a ledger line still unwritten when a job ends is retried rather than lost.
- The builder's quality harness got a comparison battery and the real checks in the repository, one tester serving both batteries, no more testers spawning themselves, every file name hashed, the interactive shell dropped, and a model passed to the CRM builder. Its scenario phase asserts the refusals behind a cross-tenant handle rather than that a scope lookup rejects, and its CRM builder archives only what its own run wrote and refuses a missing lane count. A glob in a string opens no comment, and the model gate emits the tables.
- Two CLI test files got cheaper: the store-driver limit test walks small caps instead of 5 000 files, and the login test runs the workspace choice in-process and the command line itself twice.
- Docs: the assistant pages reach the platform model host; a push submits source for a platform build rather than a local bundle; the control-plane page describes paged scope-store backups and the CP-less tenant-record gate; the platform page was re-read against the control plane and the router; identity covers admin account merge, the BankID email-linking limits and the auth server's machine-scope ceiling; the console guide covers builder turns; the dashboard's Billing page and the usage reads behind it; events leaving the scope after retention rather than at shipping; the scaffold supplying auth through
workerDoor; the CLI reference covering store-driver publish; and the Todo reference covering list search and pending invitations. - Upkeep: last week's changelog entry, and three corrections to it from a full review.
Released
| Package | Span |
|---|---|
@substrat-run/contracts | 0.189.0 → 0.198.0 |
@substrat-run/kernel | 0.189.0 → 0.198.0 |
@substrat-run/adapter-sqlite | 0.189.0 → 0.198.0 |
@substrat-run/adapter-cloudflare | 0.189.0 → 0.198.0 |
@substrat-run/vertical-host | 0.189.0 → 0.198.0 |
@substrat-run/control-plane-api | 0.189.0 → 0.198.0 |
@substrat-run/contract-tests | 0.189.0 → 0.198.0 |
@substrat-run/cli | 0.58.3 → 0.60.0 |
@substrat-run/control-plane-client | 0.6.11 → 0.8.0 |
@substrat-run/vertical-auth | 0.32.2 → 0.36.0 |
@substrat-run/oidc-rp | 0.14.0 |
@substrat-run/dev-issuer | 0.4.2 → 0.9.0 |
@substrat-run/elements | 0.6.0 → 0.8.5 |
@substrat-run/model-emit | 0.12.7 → 0.12.19 |
@substrat-run/model-view | 0.6.37 → 0.6.49 |
@substrat-run/model-providers | 0.5.79 → 0.5.88 |
@substrat-run/attachment-extractors | 0.2.50 → 0.2.59 |
@substrat-run/boundary-lint | 0.9.0 → 0.9.1 |
@substrat-run/engine-workorder | 0.13.14 → 0.13.23 |
@substrat-run/engine-protocol | 0.13.74 → 0.13.83 |
@substrat-run/engine-invoicing | 0.11.73 → 0.11.82 |
@substrat-run/engine-booking | 0.9.14 → 0.9.23 |
@substrat-run/engine-invites | 0.9.66 → 0.9.75 |
@substrat-run/engine-absence | 0.6.73 → 0.6.82 |
@substrat-run/engine-metering | 0.6.73 → 0.6.82 |
@substrat-run/engine-notifications | 0.3.34 → 0.3.43 |
@substrat-run/engine-assistant | 0.1.41 → 0.1.50 |
@substrat-run/connector-scrive | 0.14.95 → 0.15.0 |
@substrat-run/connector-fortnox | 0.7.12 → 0.7.22 |
@substrat-run/connector-planima | 0.2.86 → 0.2.95 |
create-substrat | 0.15.1 → 0.18.2 |
In 0.x semver a minor is where a breaking change goes, so the fixed group's 0.198.0 carries the entitlement-refusal text, the spine's new delegation column and the attachment and invite surfaces above. vertical-auth's four minors are the person contract and its door, admission by verified address, the delegated token half, and the peer-door stage. dev-issuer moved five minors across refresh tokens and the peer exchange, the dev people door, and the dev delegation harness. cli's two are the machine-client declaration carried in a push, and the promote --review-only / status / changes / review commands; control-plane-client's two are the promote-impact and ops-failure reads, and the builder review routes. elements' two minors are the entity table's row gestures and the kanban board. connector-scrive's minor is the void and withdraw handling. create-substrat's three carry the sample world moving to src/world.ts, the attachment routes, and the member-invite routes. @substrat-run/oidc-rp published one version in the week, carrying the peer-token refusal.