Skip to content

Week 45 · 2–8 November 2026 ​

The week's theme is a generated app that is a real one.

Most of what landed was found the same way: by building an app from a one-line brief, over and over, and then signing into it. That turns out to be an unusually honest test, because it exercises the parts of the platform a hand-written demo quietly works around. Five builds of a CRM queued an invitation that nothing delivered. Five builds of a to-do app deployed a worker whose owner could sign in and then create nothing. Two of them let a sales rep read a deal that was not theirs. None of those were defects in the generated code; each was a gap in the platform underneath it, and each is closed here.

The largest of them is identity. An operation could not see who the issuer said the caller was, so a vertical that shared by email took the address as input and guarded it in host code — and leaving the guard out broke nothing a project could see. ctx.verifiedEmail is now that address, a join taking email no longer loads at all, and a deployed worker joins a person and gives them their own record the first time they arrive. The to-do reference can invite an address that has not joined yet, which is the flow every generated app copies.

Beside that, @substrat-run/elements is published: web components on Web Awesome's free core, with an entity table that reads with a query — sort, views, filters, search, paging and the whole query in the URL. The dashboard and the console are now drawn with them, which is the dogfooding that keeps them honest.

And one quieter thing worth your attention: every error code the platform answers with now has a page at the URI its problem document names, so a refusal you have never seen before is one click from an explanation.

The address the issuer verified, not the one the caller typed ​

A vertical that shares by email has to know who is asking. Until this week it could not: an operation saw only its input, so the caller's address arrived as a field the caller filled in, and the only thing standing between that and a lie was host code the vertical wrote itself.

ctx.verifiedEmail is the address the identity provider verified for this person, or null. Only getScope can supply it, through a parameter no other door has, so a door that forgets to pass it gets null and fails closed rather than falling back to something plausible. On the hosted adapter it crosses the RPC into the Durable Object. verifiedEmailOf(subject) in @substrat-run/vertical-auth is what a door hands over; it reuses the existing identity read without the break-glass path, and answers null for a delegated token, because a delegated token is not a person claiming an address.

The field alone would not have been enough. A project can be handed ctx.verifiedEmail and go on reading input.email, and the kernel cannot judge a vertical's own tables to notice. So the rule is enforced one level up: an operation named join or sign-up that takes an email input no longer loads. It is an assertion in defineOperations, which means the model gate, substrat push and every test get it from the same place, before anything runs.

The limits are worth stating. The refusal looks at the operation's name: customer/register taking an email is staff recording somebody else, and only the name distinguishes the two, so the same mistake under another name still gets through. That is why the scaffold template, the model skill and the to-do reference all changed too — the pattern has to be the one you copy. Connection, capability and peer doors cannot receive an address by construction, since only getScope passes that parameter. And none of this protects a vertical that is already deployed; it starts holding when you upgrade.

One behaviour change to know about: an unverified address no longer gets a person joined, only signed in. Be clear about where that refusal lives, though, because it is yours to write. The platform hands the handler null and the hosted door skips its automatic join; what actually refuses is the handler, which the to-do reference does in one line (permission_denied, "joining needs a verified email address") — because a caller holding the permission can invoke an exposed join directly, over REST, /api/invoke or MCP. A handler that requires a verified address has to check for null itself before it writes a membership.

A hosted app joins a person the first time they arrive ​

A deployed app's owner could sign in and then do nothing. This was invisible locally, which is why it survived: the dev server runs the vertical's join on sign-in, and the seed gives each person the owner shape on their own record. Hosted, the platform seats the owner in the owner role at provision and that is all. So the owner reached their first screen, asked to create something, and was told to join first — and had they joined by hand, they would not have seen what they made, because records inherit through the person's own entity and no shape had been given.

workerDoor({ join }) closes it. The vertical names its join — join: (scope, who) => scope.invoke('todo/join', { displayName: who.display }) — and the first time a person reaches a scope the door runs it, then gives them the shapes the vertical declares on their own record. It happens in /api/me or before any other call, so scripts and MCP are covered too, not just the browser.

Your join has to be idempotent, and this is the one thing to get right when you wire it. "First time" is remembered per isolate, so a new isolate or two first requests at once can run it again for the same person — and the shapes are granted only after the join returns, so a join that throws because the person is already there means they never get them, on that request or any later one. Return the row you already wrote rather than failing, as the to-do reference does. Each isolate remembers who has arrived, so it costs nothing after the first request. A join that is refused is logged and tried again on that person's next request rather than being swallowed.

The grant half is grantSelfShapesLocal, and it is given once: a new kernel helper writes nothing where a marker row already exists, live or tombstoned. Without that, granting on every sign-in would quietly undo a revoke, because bringing a shape back is exactly what the grant does.

A gate holds the wiring, because every local gate passes without it — the dev server joins people itself, so a worker that forgets looks fine until it is deployed. A model declaring a */join or */sign-up whose src/worker.ts does not name it in workerDoor now fails.

Two things are deliberately not here. Member invitations are not in the door: it seats the owner, so a second person does not arrive through the door the way the owner does. That is not the same as being locked out — a worker that wants them mounts mountInviteRoutes from @substrat-run/vertical-auth behind its own admin gate, which is what the template points you at. Putting them in the door is the next step. And this is the hosted door only — the dev server keeps granting through its seed.

Alongside it, the scaffold template's worker ships auth at all, which it did not: every /api call answered 401 once deployed. The wiring existed, but each deployed demo carried it by hand, so it moved into one door and a worker now supplies only its bindings, routing and settings. In the same spirit, mountSession (@substrat-run/vertical-auth/session-route) is the /api/me three deployed workers had each written separately — resolve the subject, map it to a principal, report the login's place, and answer needs-setup or 401 when it bound nobody. Two of the three had named the principal differently, so a shared header component could read only one of them.

Invite someone who has not arrived yet ​

Sharing in the to-do reference only worked with somebody already in the scope, which is a strange thing for a sharing feature to require. It now takes an address.

If the address has already joined, the share happens immediately and no mail is sent. Otherwise the invitation is recorded and the email queued in the same transaction. When that person joins, a consumer of the join event turns open invitations into shares — and it has to be a consumer, not a handler: ctx.grant delegates, and the person arriving holds nothing on the list, so they cannot grant themselves in. The app lists open invitations marked "invited", and the owner can withdraw one. The vertical declares substrat.sendsEmail, because a hosted send is refused without the grant that declaration requests.

This matters beyond the demo, because the to-do reference is what a generated app copies for sharing. The builder's skills had been teaching that a share names someone who has already joined; that stopped being true here, and they were corrected.

On the dev path, a queued invitation used to go nowhere at all. The platform's drain sends it when hosted, and a dev server has no platform behind it, so the row simply stayed pending — five of five generated CRM builds did this. devMailOutbox(host, { dataDir, actor }) on the SQLite adapter is the local stand-in, in the hosted shape: each queued send is written to <dataDir>/outbox as a .eml file, one log line names the file, and the intent is settled with the same event the platform's handler writes. Other intents are left alone. The template's src/server.ts wires it, and a gate refuses a project that queues mail and writes it nowhere.

One known limit: an invitation to a binned list waits. If its address joins while the list is in the bin and the list is later restored, nothing fires again. Inviting that address a second time does share the list at once — but it does not tidy up behind itself, because the handler shares and returns without touching the invitation row. Only the join consumer or an explicit withdrawal deletes one, so the owner has to cancel the stale invitation separately or it sits there marked "invited" against someone who already has access.

A derived list stays inside the parent it checked ​

This one is a permission bug, and it is worth reading even if you do not have the shape it affects.

A derived list read narrowed to a parent checks the parent id from one input field — dealId, say — and then pages using filters keyed by column. If the operation also took an optional field over the same link column — deal_id — that second field replaced the parent's filter after the check had already passed. So GET /deals/D2/history?deal_id=D1 checked your access to D2 and returned D1's history. Two generated CRM builds wrote exactly that, and a sales rep could read deals that were not theirs.

The fix is in two parts. The platform now keeps a derived list inside the parent it checked, whatever else the input says. And defineOperations refuses the shape at module load: an operation whose permission is { entity, idFrom } and whose input takes a second field spelling the same id — a field equal to idFrom, or to <entity>Id, ignoring case, _ and - — does not load.

Read that rule precisely, because it is narrower than "one id per operation" and deliberately so. It refuses the spellings of the checked id, which is how the duplicate actually arrives and covers every input a derived page could map onto the parent's link column. It does not refuse a second id under a different name: a bare id is the child row's id in the nested-route shape (/lists/{listId}/items/{id}), and targetDealId on a merge names a second entity on purpose. Both pass, because a rule that refuses correct code gets routed around — and both are still the handler's to check. If your handler reads an entity id that is not the one idFrom names, check the caller on it too; nothing above does that for you.

While in there, defineOperations also learned to report every declaration problem at once. Its six checks ran in sequence and each threw at the first operation it refused, so a model with three problems reported one. An agent building a vertical spent an entire turn on that: it fixed an unpaged list read, met a required PATCH body field, fixed that, and met an authored it had itself added while fixing the first.

Elements: web components, published, with a table that reads with a query ​

@substrat-run/elements was a private prototype that exported TypeScript source, so only a workspace member with a bundler could use it. It is now published, Apache-2.0, built to dist with types and theme CSS beside it.

The elements are Lit over Web Awesome's free core, styled entirely through its --wa-* tokens, which is what makes them themeable without a fork. They are framework-free on purpose: a vertical's screens need not be React.

  • <sub-entity-table> reads with a query rather than drawing one fixed page. source.read(query) drives sortable headers, views, equality filters, a search mode scoped to the views it covers, and Previous / Next paging with a page-size picker. Row actions and bulk selection behave as before; a refused action keeps its rows, and a stale view is re-read.
  • The query goes in the URL. queryToParams / queryFromParams write it and read it back against an allow-list spec, so an unknown value in a link falls back to the table's default instead of producing a broken screen. The page cursor is opaque, so it stays out of the URL.
  • Cells are typed by kind, drawn by Lit with render, or mounted as a light-DOM element so React or Vue can own them. Styling is --sub-table-* tokens, ::part()s and density="compact".
  • A column picker, opt-in. People can show, hide and reorder columns by dragging, or with Move up / Move down buttons that keep focus and announce the move. layout-key remembers the layout in the browser; sub-layout-change and the layout property let a vertical store it per account instead. The first column is always shown and always first.
  • <sub-user-menu> and <sub-avatar>. Web Awesome has no account menu, so this is one: the avatar, a menu with the vertical's own slotted items, then "Switch user" and "Sign out", which it owns because it knows the auth routes. Every built-in part is a slot with a default, and the sign-out and switch-user events are cancelable. Signed out it draws "Sign in"; before the first read, an empty circle. Both share one session read.

Each element has its own subpath, and you should use it. An element registers itself and imports its Web Awesome components as a side effect, so a bundler cannot shake one out of the package root: importing SubAvatar from the root shipped the entity table too, at 84 KB gzipped against 27 KB for the avatar alone. The root export stays, for apps that register no Web Awesome at all.

A generated client's paged reads now take limit, order and sort, with sort typed to the read's sortable columns — which is what lets the table drive a real API rather than sorting a page it already has.

The docs have an Elements section now, and its first sentence is the point: Substrat has no opinion about your UI. The elements take the hard parts of a business app's screens, whichever framework you picked.

The platform's own consoles are drawn with them ​

Both platform consoles moved onto Web Awesome and the elements this week — every control and table in the admin console, and every control and table in the customer dashboard. The shared wrappers live in packages/ui rather than being copied into each app, and packages/ui's elements-theme.css maps Web Awesome's tokens onto the platform's own, light and dark, so the elements look like the apps around them.

This is not cosmetic housekeeping. These two apps are the largest consumers of the entity table, and a sort, a filter or a column picker that is wrong is wrong on a screen somebody uses daily.

Every error code has a page at the URI it names ​

A problem document carries a type URI. Those URIs now resolve.

One page per code in the closed taxonomy is emitted to /errors/<code>, served at exactly the URI each problem document points at, with an index at /errors/. The facts — codes, statuses, titles, wire members and the example bodies — are read from the contracts package, so they cannot drift from what the platform actually answers; the prose is keyed by code in the emitter, which refuses to run on a code it has no prose for, prose for a code that no longer exists, a wire member with no description, or a moved base URI. CI re-emits with --check.

Beside it, a repo-wide refusal gate: a response built with a literal status of 400 or more has to serve application/problem+json in that same call. Files that cannot are listed one by one with an exact count, either because another specification owns the body — OAuth, JSON-RPC, the store wire, a page meant for a person — or because the site has not been converted yet. The count only shrinks.

The conversions themselves covered most of what was left: every /internal relay route in the control plane, the connector callbacks and the relay gateway; the egress worker's own outbound and peer refusals; the social relay's discovery, JWKS, userinfo, platform surface and catch-all; and the dev issuer's /userinfo. Each relay error class now carries the code its status implies, read through one shared mapping that covers only statuses the catalog answers with — 413, 422, 501 and 502 stay about:blank rather than being given a code they do not have. Statuses and sentences are unchanged throughout, and error stays beside detail.

Two fixes in that work are worth singling out. An uncaught throw is now a problem document too, so a route that fails unexpectedly answers internal with no detail instead of a text 500. And the handler that turns a throw into a document reads it only when it is a typed platform error: anything else, a schema-validation error included, is a 500 with no detail. A validation error there is the server failing to parse its own data, and it had been read by shape as a client's 400.

A team can read its own events, across every app it has ​

The event lake has been readable by staff for a while. A team can now read its own events through the dashboard — across every app it owns, including apps it has since removed, which is the question no single app's history can answer.

The read is windowed: since is required, and the span from it is at most 31 days. The window is what bounds the query, not the tenant filter — the lake is one table for every tenant and the sink cannot partition it, so a tenant filter narrows the answer but not what gets scanned. Only a time window narrows that, through the table's file statistics. Staff reads stay unwindowed, because an audit question must not quietly lose older history. A read outside the rule is refused before the engine is asked at all.

One detail for anyone writing a paged walk: with until absent the window is measured to the platform's clock, not yours, so ask for slightly under 31 days or pin until for the length of the walk.

It is owners and admins only, and the reasoning is written down: a member already browses each app's own history in the Data tab, while this read reaches across the whole team at once. The key is dashboard:read-event-lake, and existing teams pick it up through role reconciliation.

The route answers 501 until the lake engine is configured, and there is no screen yet — a panel that could only say "not available" would be dead weight. What is live is the contract and the permission.

Separately, the event drain now prunes drained outbox rows after 90 days, so a scope's outbox is not an unbounded ledger of everything that ever happened in it.

A CSV export a spreadsheet opens as data ​

A generated CRM built a contact export, five times out of five, whose cells were RFC 4180 quoted and nothing else. Which is correct CSV — and a contact named =HYPERLINK("http://example.net","x") still ran as a formula in the spreadsheet that opened the file. Quoting does not stop that. A leading apostrophe does.

csvTable is the helper, and it does both halves: proper quoting and the prefix that keeps a cell beginning =, +, -, @, tab or carriage return from being evaluated. Boundary-lint R13 backs it up, so hand-rolling a CSV join in module code is refused rather than reviewed.

If you export CSV today, this is the one item on this page to act on.

Billing shows what your apps used, by day ​

The Billing page gained a daily usage chart and a summary strip. The metered-usage read answers one row per closed UTC day, and the page draws requests and model tokens stacked by app with stored bytes as a team total. A day with no reading is hatched and null rather than drawn as a zero, because those are different facts.

Three plumbing fixes sit behind it. A hosted model-usage line is now filed under the scope's vertical: a host labelled its line with its package name while the directory knows a scope by its slug, so the comparison failed every hosted line terminally and nothing reached the ledger. A builder turn now counts against the team it ran for, instead of being metered in the studio's own scope where the team's usage page would never see it. And successful hosted build time is metered per tenant and vertical, one row per build keyed on the build id so a repeated report counts once — queue time and failed builds are deliberately out.

The page also stopped naming each app by its registry id, which read like a scope path, in favour of the name the catalogue gives it. Entitlements moved to Settings, where they belong.

A scope of any size moves a page at a time ​

Backup, restore, snapshot and copy all used to hold a whole scope in memory, which means they worked until a scope got big and then stopped working. Each of them now moves a page at a time:

  • A scope backup is stored and restored a page at a time, so a scope past what one Durable Object call can do can be backed up and reaped at all.
  • A kept copy of any size is restored forward a page at a time.
  • A restore now puts back a module table's own indexes and guard triggers, which it had been dropping — a restored scope was subtly slower and less protected than the one it came from.
  • The directory's own backup is paged too, and that one was actively broken: the dump had outgrown the control plane's isolate, so since early September every scheduled backup reset the directory instead of storing a copy, and because nothing was stored the next sweep tried again — roughly one reset per quarter-hourly pass, failing whatever was in flight. A failed copy is now waited out instead of retried immediately.

The store contract moved the same way. The reserved substrat.export and substrat.import operations give way to export-page, stage-page, commit-stage, discard-stage and selfcheck. A chain is one moment, a commit is the only step that changes the object, and a registration declares its page size. The contract is written for any driver, and both the runner suite and the rollout canary hold a driver to it.

Four changes to notice ​

  1. A join or sign-up operation taking an email input no longer loads.defineOperations refuses it, so the model gate, substrat push and your tests all report it. Migration: drop the field and read ctx.verifiedEmail, refusing when it is null. A vertical on its current pins is not stopped, so a hotfix is not blocked; it starts holding when you upgrade, in the same release that gives you the field. demos/todo's todo/join lost its email, which is a major bump for that package.
  2. An entity-narrowed operation cannot take its id twice. An operation whose permission is { entity, idFrom } and whose input also takes a field spelling the same id — equal to idFrom, or to <entity>Id, ignoring case, _ and - — is refused at module load. Migration: drop the duplicate and keep the field idFrom names — that is where the id comes from, which is often a path parameter but need not be one, since an operation may declare no http at all. A second entity of the same kind on purpose is named for its role (targetDealId) and checked in the handler. This is the shape behind the cross-parent read described above, so if your model has it, you have the bug.
  3. Import an element from its own subpath — on 0.5.0 or later. @substrat-run/elements has a subpath per module. Mind the version: 0.4.0, where the table below ends, exports only the root, ./controls, ./jsx and ./themes/*, so switching imports on it fails to resolve. The per-element subpaths arrive in 0.5.0. Migration: none required — the root export still works — but importing from it ships every element, so take 0.5.0 and switch for the bundle size. The package is 0.x, and a minor may still change an element's attributes or slots.
  4. A hosted door names the vertical's join. workerDoor({ join }) is how a deployed worker joins a person on arrival, and a model declaring a */join or */sign-up whose worker does not name it fails its gate. Migration: pass join in workerDoor. The door's host argument now needs grantSelfShapesLocal, which every caller already satisfies, and the fixed release group moves both packages together.

Smaller, but easy to trip over: a new project now pins packageManager, because a project without one installed with whatever pnpm was on the machine — and pnpm 11 refuses such a project outright, exiting on a native build script, writing a placeholder into the workspace file, and holding back any release younger than its minimum age, which every fresh platform release is.

For hosted operators ​

  • The hosted review runner can read a review. A per-review Durable Object runs the reader half on an alarm: the streamed, capped diff of the stored archives, one guarded model call, a strict parse, the assembler's drop rule, and a single create-only result in which "gates not run" is a first-class answer rather than a silence. Usage is filed under a platform sentinel scope, and metering never fails a review. The runner's rules are emitted from the checklist and the procedure, so the thing it enforces and the thing a human reads are one source. Several rounds of hardening followed: a finding must point at a line the change actually adds or alters; both archives are held to the receipt's digests; every untrusted string is fenced under a per-run nonce; findings are parsed one at a time, masked then cut, with control characters stripped in the store and the CLI; duplicates and findings on items claimed clean are dropped; and the call aborts at its deadline with one HTTP attempt apiece. The redaction reader itself took most of that work — a quoted or backticked name followed by an operator was being matched whole, so what it held was never scanned. substrat review <id> prints the result in the checklist's report shape, and --wait polls until the reader half has run.
  • A push is gated on the migrations in its own bundle. A defineScopeDO class exposes the migrations it registers, and the control plane evaluates the pushed bundle in a loader isolate — empty env, no outbound, a CPU cap — to read them. A push whose declared migrations differ from the bundle's, or whose worker entry cannot be evaluated at all, is refused before upload.
  • Store-driver releases got their rollout machinery. A new reserved substrat.selfcheck builds a driver's whole runtime and answers the catalogue it serves; the canary imports a fixture carried in the release and covered by its digest, expects it exported back unchanged, then runs selfcheck over that data and refuses a catalogue other than the one the approval records. A push keeps its driver hold until its version is published, so a rollout cannot land in the gap. A push judges its scope stores against the registry, and push --check now does the same with the slug it had been omitting. substrat store-driver publish is upload, approval wait and rollout in one command. D-67, D-68, D-69 and K-59 are ratified, and the graph driver is registered for the platform's own modelling vertical as D-67's narrow first use — every other vertical declaring a graph store is still refused at deploy.
  • A deletion fences a store object instead of wiping it. Every path that deletes a scope's stores sends substrat.fence. The store entry answers it ahead of any driver, in both the TypeScript and Python entries: it writes a tombstone, waits out the calls already inside the driver, hands the driver a plain wipe, and writes the tombstone again. From then on the object answers 410 to every caller call, whenever it was signed. A store object also admits each envelope once now, spending the nonce in synchronous storage after the envelope verified and the object's id matched its signed name, and before the driver is reached.
  • Credential headers are kept out of the runtime's logs. The runtime records each request's headers, and the platform credential's header is not one the provider redacts. Pushed verticals upload with invocation logs off, as do the control plane, egress and relay, and log reads drop the header from records already written.
  • A CP-less door refuses a scope whose tenant is not recorded. A scope holding neither a provision receipt nor role rows has nothing to hold a tenant-and-scope pair against; it used to be admitted with a warning. Every door now refuses it, the same way it refuses a foreign pair, and provision, reconcile, restore, snapshot and lifecycle delivery record the tenant without passing the door. A CP-less host also reads its connection grants without a control plane now — the unconditional directory read threw there, which meant no declared landing on a hosted vertical was ever granted.
  • Deleting an app actually deletes it. Delete used to archive the scope and unbind its hostnames and nothing else: the bytes stayed until a retention reap no deployment has enabled, and snapshots or test environments pinned "until deleted" outlived the app. The dialog had been promising deletion in 30 days, which nothing performed. It now wipes the scope and every copy of it.
  • Access log rows name the person a delegated read was made for. When the dashboard reads a team's data it uses the team's credential, which carries the signed-in person — and the access log's one writer ignored that, so the row named only the platform service actor. A nullable column on both adapters now holds it, with no backfill, so an older row reads as "not recorded" rather than as nobody. Staff reads stay attributed to the staff member.
  • Request logs say what a request changed. The invocation line carries each lifecycle move as <entityType>:<state> — sorted, distinct, never an id — the router writes it as its own blob, both cube sources group by it, and the dashboard lists a Process state facet. A request's Result row reads ticket: open → resolved, with +N for further moves.
  • Bind links are a third capability mode, beside act and become. A holder of the binding's key on a record mints one for a named member who is already in the scope, and it binds that member when their own session presents it — single use, with an optional expiry, on the spine as its own minted event. An unbind of the record, or the erasure of the member it names, revokes it in the same transaction, because a link must not outlive the binding it was made for.
  • Also: an operation may declare impersonation: 'refused' and be refused under any impersonation session; a deployment can ask for an immediate poll of its scope's bindings and is told what each one did; the control plane's directory inventory is counted read-only with a logged shared unlink, as phase 0 of the dashboard's directory retirement; and the Data tab loads again when a search index outlived its content table.

Also landed ​

  • The builder studio builds a to-do app correctly and repeatably, and it is measured. Most of the defects in a generated app came from the studio's own skills and setup rather than from the model: skills that had gone stale and contradicted each other, project files that did not match a scaffold's, an install gate that judged the enclosing lockfile. On the measured arm the build scores 89 of 100 in eight runs of nine and 84 in the ninth, with no repairs and no red gates, against a baseline of 79–84 with a repair in every run. The graded runs and the rubric are in the repository, so the measurement can be repeated rather than recalled. A second, much larger fixture — a team CRM with two companies that must never see each other's data, three roles, deals private by owner and visible to the team's manager, a locked won-or-lost deal and an uneditable history — is where most of this week's platform gaps came from.
  • Golden fixtures, staged runs and gates that refuse what builds got wrong. A run can start from reviewed files at any stage, run beside others in its own lane, and build against unreleased packages, and the scorer stopped crediting what only looks right. The golden to-do fixture is at version 3, joined by the verified address and deployable for real. The new gates each caught real builds that passed every other one: an app calling /api/invoke that nothing mounts, a package.json script running a file the project lacks, runtimeNeeds parsed as push parses it rather than as it looks, an invitation nobody receives, a row nobody can open, a dev server that joins nobody, and a hand-written migrations file that nothing checks against the model — a generated project now emits its migrations from its model with a journal, as the reference does.
  • The studio is steadier under a model that misbehaves. A silent stream is abandoned and retried, with timeouts to a step's first output and between outputs; a rate limit backs off far enough to matter (about two and a half minutes over five tries, against one); an unreadable 200 is retried; a host that refuses a second system message gets one; and the model picker lists the provider it opens on instead of showing an empty row. A hosted build shows its work as it is written and survives a lost container, saving the working tree after each pass and every 30 seconds within one. An interrupted build keeps what stopped it on a staff-readable row under the request id the caller was shown. A release crosses into the sandbox in reads that fit one RPC — a whole-release JSON read failed every build of a large vertical, because the reply limit is 32 MiB and one character outside Latin-1 doubles a string.
  • The studio's record and its screens. Every turn is kept in an assistant thread per project, where before a failed, stopped or unwatched turn left nothing but an unattributed log line. One summary row per turn, studio-wide, answers "which turns this week ended with a red gate, and on what" without scanning every thread, and the admin console has an Operations → Builder turns page over all of them. A turn also records what it takes to compare it with another: the model that actually ran rather than auto, the prompt version, cached tokens, steps, time and tool failures. Hosted Run deploys the project to a preview slot — always clean-room, since a fork would put the tenant's live data in front of anyone holding the builder entitlement. Next-step buttons replaced having to guess the phrase that advances the ladder, the stepper lists all five phases rather than three, a project can be removed from the menu, a build with no lockfile is refused before upload, and the portal starter opens a row, reloads the table an action changed, and keeps a row's actions in the row.
  • Connectors. A new Bolagsverket connector: organisation-number validation, a per-tenant connection, probes and a door, with a review round tightening how a company's status is read — the whole procedure list is read and the most severe named procedure wins, and the probe fails a client lacking the read scope and says so. The Fortnox invoice binding lands each invoice's file, reads as far back as it declares, and writes decisions back; a ledger binding can land the year's SIE4 file itself in place of monthly sums, keeping opening and closing balances and vouchers, and options.years says how much history to hold. Microsoft 365 sends attachments over the inline limit as a draft with upload sessions, so a message above roughly 2.5 MB is no longer refused, and the channel folder got a live QA run and a runbook.
  • The team auth server. An app's hostnames reach its client, so sign-in and sign-out work on every hostname it has. A first BankID sign-in no longer builds a placeholder address out of the personal number — that column is what the email claim, the console and every export read; new accounts get a random placeholder, existing ones are rewritten at boot, and a placeholder is never released as a claim or marked verified. Machine scopes can be set from the console like the signup flag, judged before they are stored. It has its own glyph now, so its tab differs from the dashboard's, and reloading its console no longer flashes black.
  • Docs. A guide for building a platform on Substrat — one vertical, each customer a tenant, parts sold per customer, and customers later writing their own additions, with the "would a different product need this unchanged" test for what belongs in the platform. The dashboard's directory retirement is now a phased plan with rollback and its four settled decisions recorded. D-67's revisit names all three isolation conditions, D-70 is proposed, measured over three runs on a real dispatch namespace, and its last unmeasured row — the billed cost — is filled in at $0 inside the plan's allowance. Two spikes carry the evidence: a supervisor loading a driver's inert modules through the Worker Loader into an isolate per object, and store facets. The assistant element's home is settled as the elements package.
  • Releases and upkeep. Release tags go out in one push, after a provider refused them one at a time on two separate days and failed the publish step after a good publish, skipping every production deploy; a version npm has not listed yet is waited out. The assistant engine is enabled for public publication. A changelog entry that had been growing two spaces per release — a lazy continuation under an indented code block, re-indented by the formatter on every pass, past 400 leading spaces — was stopped. The dashboard's error readers follow the generated client's errors and the dead hand-written error class is gone; a comment that called the team cookie the team a request acts on now calls it the last team used; the store-driver repository check stopped listing the assistant engine as private; and the npm minor-and-patch group took 20 updates.
  • CI and tests. The ticket0 deploy workflow was overwritten by a one-click setup run for another demo and had not deployed since; it is back, and that demo has its own workflow. Every job has a timeout, and the WebAssembly toolchain image is cached rather than rebuilt against an archive that had been answering 503 on 7 of 12 main runs. Four time-racy tests stopped racing the clock: an expiry is moved into the past in the stored row rather than waited out, a copy-job case says when a step stops throwing or a hold runs out, and a trace-axis test asserts a bound no stall can reach.
  • Upkeep: last week's changelog entry.

Released ​

PackageSpan
@substrat-run/contracts0.175.0 → 0.188.0
@substrat-run/kernel0.175.0 → 0.188.0
@substrat-run/adapter-sqlite0.175.0 → 0.188.0
@substrat-run/adapter-cloudflare0.175.0 → 0.188.0
@substrat-run/vertical-host0.175.0 → 0.188.0
@substrat-run/control-plane-api0.175.0 → 0.188.0
@substrat-run/contract-tests0.175.0 → 0.188.0
@substrat-run/cli0.55.3 → 0.58.2
@substrat-run/control-plane-client0.5.3 → 0.6.10
@substrat-run/vertical-auth0.29.3 → 0.32.1
@substrat-run/elements0.3.0 → 0.4.0
@substrat-run/model-emit0.11.5 → 0.12.6
@substrat-run/model-view0.6.23 → 0.6.36
@substrat-run/model-providers0.5.65 → 0.5.78
@substrat-run/attachment-extractors0.2.36 → 0.2.49
@substrat-run/dev-issuer0.2.57 → 0.4.1
@substrat-run/engine-workorder0.13.0 → 0.13.13
@substrat-run/engine-protocol0.13.60 → 0.13.73
@substrat-run/engine-invoicing0.11.59 → 0.11.72
@substrat-run/engine-booking0.9.0 → 0.9.13
@substrat-run/engine-invites0.9.52 → 0.9.65
@substrat-run/engine-absence0.6.59 → 0.6.72
@substrat-run/engine-metering0.6.59 → 0.6.72
@substrat-run/engine-notifications0.3.20 → 0.3.33
@substrat-run/engine-assistant0.1.28 → 0.1.40
@substrat-run/connector-scrive0.14.81 → 0.14.94
@substrat-run/connector-fortnox0.5.8 → 0.7.11
@substrat-run/connector-planima0.2.72 → 0.2.85
create-substrat0.13.14 → 0.15.0

@substrat-run/elements is the week's new arrival — published mid-week and released several times after, which is what a package being built and dogfooded at the same time looks like. vertical-auth's three minors are mountSession, the verified address a door hands over, and bind links — a third capability mode beside act and become, which binds a member already in a scope to a record when their own session presents the link, is single use, and is revoked by an unbind of the record or the erasure of the member it names. cli's three are the store-driver publish command, the push gates that judge a scope store against the control plane's registry, and substrat review <id>, which prints a hosted review in the checklist's report shape and will wait for the reader half to run. model-emit's minor is the paged limit, order and sort a generated client now takes. dev-issuer's two carry its problem-document refusal and the verified address on a dev caller. connector-fortnox's two are the invoice binding's write-back and the SIE ledger form. create-substrat's two are the template's deployed auth and the hosted join. In 0.x semver a minor is where a breaking change goes, so the fixed group's 0.188.0 carries every "change to notice" above.