Skip to content

Week 40 · 28 September – 4 October 2026 ​

Three rules the platform used to ask you to remember, it now keeps itself. Your app's request log no longer depends on your having mounted the middleware — the uploader wraps your entry point and writes the line. Your declared schedules no longer depend on your having exported a sweeper, bound it as a store and called two hooks from your platform hooks — the uploader supplies the sweeper. Each of these was a rule that failed silently when you forgot it, in a way that looked exactly like no traffic and no scheduled work. Alongside them, background work joins the log it was always missing from: a consumer delivery, each of its retries, a dead letter and a schedule run each write one line you can click.

Attachments become searchable: the kernel extracts and indexes the text inside a file and answers a search on it, authorizing before it matches. And the rule for a copy of a scope — a fork, a preview, a snapshot, one scope's backup restored onto another — is written down and enforced on both adapters: a copy keeps the source's history and none of its power.

Two published behaviours change. A paged read declaring a descending order is now actually served descending, and an email address identifies someone only when their issuer said it was verified. Details in "Two changes to notice" below.

The platform writes your request log for you ​

Everything in your app's Lines, Requests and Patterns views comes from one log line per request. That line existed only if your worker mounted invocationLog as the first registration on its Hono app. A lint rule and a push warning made forgetting it loud, but not impossible — and an app deployed without the mount read as having no traffic at all, which is the most misleading possible answer.

The uploader now puts its own entry module in front of your bundle and makes it the worker's main module. That entry wraps your default export and re-exports everything else you ship — your Durable Object classes, your entrypoints — untouched. The line gets written whether you mounted anything or not.

Mounting it yourself is still correct and still supported. One request writes one line either way: the stamp lives in a registry both the platform's copy and your own kernel read, so your middleware steps aside when the request is already stamped, and your operation route's record still lands on that one line. A bundle built against a kernel old enough to write the line without the shared stamp is left alone rather than wrapped, since wrapping it would log every request twice.

The entry carries no runtime dependency — it validates ids with a pattern instead of pulling in the schema package, which took it from 753 KB to roughly 7 KB, and every byte there is added to every upload you make.

This one takes effect on the platform's side: your app is wrapped on its next upload, which is any push, promote or backout. You do not have to change code to get it.

Two reads got better underneath it. The Lines tab showed every request twice — the runtime's own invocation record and the stamped line, which are genuinely two events and will stay two — and now folds them into one row, carrying the runtime's CPU time, wall time and outcome onto the stamped row, so a request the runtime cut short still reads that way. And the aggregate log reads are scoped to your app's script with each closed span counted once.

Background work writes a log line too ​

A request wrote a line. Work that never arrived as a request wrote nothing: a consumer delivery, each retry, a dead letter, a schedule run. A consumer that failed every attempt showed up as a dead-letter count with no row to open.

Now each unit of async work writes one line, in the same grammar as a request's, with a kind of consumer or schedule added. A request's line still carries no kind, and readers treat a missing one as a request, so every line you have already keeps its meaning.

A consumer's line names the consumer, the event type, the event id, the attempt number and the outcome: delivered at info, retrying and dead-lettered at error when your handler threw, and at warning when the event never reached your handler — an undecodable event, a schema version your consumer does not take, an event the producer withheld. A copy's delivery reads inert, at warning, so it never looks like success. A schedule's line names the schedule, when it was due and how late it ran, and a schedule that is not due or is switched off writes nothing.

Lines carry ids, names and codes only — no payload, no error text, and no entity ids. A handler's error can quote the event it failed on, and an entity id is your data (an email address is a valid one), so a run's line keeps its event count and declared event types instead. The error's kernel code travels as the problem code; the message stays on the delivery journal row the event id names.

ctx.log joins it. A unit that runs in a call's tail logs under that call's id, so a request's drill-down shows the consumers it set off. A unit outside any call — a sweep's retry, an import, a seed — gets an id minted for it, and its handler's own log lines carry that id.

It is bounded, so a dead-letter storm cannot drown the view: one drain pass writes at most 100 unit lines, then one summary line that keeps the per-kind, per-outcome counts rather than folding everything into a total, logged at the worst level it withheld.

On the reading side, kind is a facet. The Requests view gets a Kind filter, async rows show their outcome as the result rather than "threw", and the request slide-over lists the consumer lines that logged under the same id as marks on the request. Async rows read like consumer executor:notify ← ticket.created (attempt 2) → retrying (12 ms).

Unlike the request line above, this one ships with your adapter: you get it after you upgrade and push, not on a platform deploy.

Your schedules run on a sweeper the platform supplies ​

A vertical that declared manifest.schedules had to export defineScopeSweeperDO, bind it as a store, and call noteScope and forgetScope from its platform hooks. Forget any of it and your schedules never fired on a hosted deploy, and nothing told you.

The uploader now supplies the sweeper. When your version declares schedules and your worker exports none, it adds the platform's sweeper module, re-exports its class, declares it in the migration it already derives, and binds it. The class is named SweeperDO bound as SWEEPER — the names the template and both demos used by hand — so a vertical dropping its own sweeper keeps the same namespace on its serving script: the same singleton, the same roster, the same armed alarm, and an empty migration delta.

The pass runs on your host, not a host rebuilt from your modules. That matters: your host carries your host options too, such as service principals and declared connectors, and a rebuilt one would drain a declared connector's events as though none were declared.

Three things about how the decision is made are worth knowing:

  • It is the push's decision, made once and recorded. Promote, re-serve and rollback read the record and never re-decide, so a version that was accepted cannot later be refused. A version stored without the record keeps exactly what it had.
  • It reads your declaration, not your bundle's bytes. If you export your own sweeper it is kept and nothing is added — and the push is refused if no binding names it. The platform's names bound to something else is also a refusal, never an overwrite.
  • It fails loudly against an older control plane. Every control-plane response now advertises the feature, and substrat push checks for it before uploading a version that leaves the sweeper to the platform. --allow-unswept-schedules warns and proceeds.

The gate changed meaning with it. It no longer refuses a vertical with no sweeper; it refuses only wiring that would still leave schedules unrun — your own sweeper that nothing binds, the platform's names bound to something else, or a @substrat-run/vertical-host too old to register the host the supplied sweeper runs on. substrat push judges by the same rule.

The platform supplies a sweeper for schedules only. If you rely on executor retries or resumable jobs and declare no schedule, you keep your own. The in-repo deployed verticals and the scaffold template deliberately keep theirs until the release carrying this is live, and the supplied path is proven in workerd on a fixture vertical run exactly as the uploader ships it.

Two smaller fixes land beside it. A schedule contributed by an engine you composed now runs on your install without requiring the engine's own SKU — previously a vertical whose only schedule came from an engine could have it silently skipped. And a scope's kill switch now holds a rewound module off for job runs as well as for requests, so switching scheduled work off stays off through a reconcile, a re-grant, a promote or a point-in-time rewind. The switch also wins over tenant-level system authority: a system actor holding a tenant-wide grant no longer runs work in a scope whose switch is off, which is the only reading of an off switch that means anything.

You can search inside your attachments ​

The kernel now extracts the text from an uploaded attachment, indexes it in the scope, and answers ScopeAttachments.search(term, { limit }).

Extraction happens as a scope job, never on the upload path, so an extraction failure cannot fail an upload. The upload writes the attachment row, a pending text row and a job run in its own transaction; the job later reads the record, picks an extractor for the type, checks the recorded size before fetching a byte, verifies the bytes' hash, runs the extractor, and records the outcome. readAttachmentText(ctx, id) tells you where it got to: pending, indexed, empty, unsupported or failed, each with a reason.

The split between what the kernel does and what parses a file format is a deliberate one. The kernel owns the table, the index, the job, the enforcement and the search; the parsers live in a new published package, @substrat-run/attachment-extractors (text, HTML, DOCX, XLSX, PPTX), and a host passes them in. The kernel and both adapters never import it, and a lint refuses the edge in source and in shipped type declarations alike. The default is no extractors, which is a valid configuration: every type records unsupported with its reason rather than failing.

Whatever an extractor returns, the kernel enforces the bounds after the fact, so no extractor can bypass them: a 32 MiB input ceiling applied first and on its own (never a Math.min, which a NaN would switch off), a 30-second budget, a 512 KiB output cap cut on a code-point boundary and recorded as truncated, a throw recorded without its message since the message may quote the file, and a result that is not the declared shape recorded as failed. The OOXML reader budgets 16 MiB of inflated bytes across all parts, counted on what the inflater actually produces rather than on what an entry's header claims. Every bundled parser is a single forward scan — the regexes they replaced went quadratic on hostile input.

The search authorizes before it matches. Each declared target type is checked once at the scope, so a caller holding a role or a scope grant pays one check per type. For every other type, the owners that actually have indexed text are checked one by one, which only a narrowed caller pays for, and past 2 000 owners the search is refused with a stable reason, never truncated — so the answer never depends on what you cannot see. The readable set goes into the SQL before ORDER BY … LIMIT, so truncation only ever happens over rows you may read.

What the results deliberately do not carry: no count, no "more" marker, no snippet, and no relevance score. Results are newest-first instead of ranked, because FTS5's scoring weighs a term by how many documents in the whole index contain it — a score would let a caller infer how often a term appears in files they cannot open. Contract tests pin that a caller gets byte-identical pages to the ones they get in a scope where the hidden files never existed.

The text never leaves the scope. It is excluded from every dump, backup and snapshot — a dump carries an attachment's metadata and never its bytes, so text derived from those bytes stays where the bytes are — and the lake streams the outbox only. Removing an attachment takes its text and index entries with it, by any delete path. A restore drops text whose attachment did not come back and re-queues extraction for every attachment without it; in a fork, where the objects stay under the source scope's key, each attachment re-extracts to a legible failed: the bytes are missing from the blob store rather than sitting pending forever.

This is a first cut and says so. PDF is not extracted and nothing is OCR'd. Spreadsheet numeric cells are not indexed. There is no automatic backfill for attachments uploaded before this, and no HTTP route — the verb is on ScopeAttachments and you wire your own. A hosted vertical extracts only if its scope sweeper has runJobs on; without it every upload stays pending, which is visible rather than silent. The extractors are now wired into every host that serves attachment targets, and a hosted vertical's attachments reach its own tenant's bucket with nothing for you to configure.

A copy of a scope keeps the source's history and none of its power ​

A dump loaded into a different scope id is a copy: a fork, a snapshot, a preview, or one scope's backup restored onto another. A dump loaded back into the scope it came from is a return: a backup restore, a carry onto a new version, adopt, rebind. That distinction now lives in one place that both adapters call, so the two hosts cannot disagree about it — and an unknown source counts as a copy.

On a copy:

  • Capability rows load empty. A share link that was live against the source never opens the copy. The owner still reads what they owned, and the source keeps accepting the link.
  • Everything the source had queued is settled, not dropped. Pending platform intents settle failed, attributed to the platform, with the reason "not carried: copied from scope X before it ran". Executor retries become terminal with that reason. A job run copied mid-walk settles failed at its cursor, with its step ledger intact. A journal row saying why nothing happened is better than a gap where a row should be.
  • Events nobody had reached yet cannot be settled row by row — an executor is registered on the coordinator, so the loader cannot know who still owes a delivery. Instead the copy records the highest event id it brought in, and consumer dispatch, executor dispatch and the lake drain all carry that mark, so only events above it become work. The same mark keeps a copy from shipping the source's events to the lake a second time.

A return changes none of this. The copy's own events flow normally even when the source's clock ran ahead, because both loaders now re-seed the event-id floor from the loaded outbox.

Two decisions here are worth a reader's attention. Capabilities are dropped rather than loaded as revoked, because the copy never minted those links and a revocation recorded there would be audit noise about something that never happened in it. And provenance on a caller-supplied restore is a claim: "a copy carries none of this" holds for every platform copy, but a staff restore of a file presented as the target's own backup is treated as a return and keeps what the file carries. That grants nothing a restore could not already write, and the docs say so rather than promising "never".

Previews and forks also stop acting outward: they cause no outbound side effects. A carry now binds compare-and-set and wipes the copy it leaves behind, scope bindings are guarded with an expected version, and a copy's data classification is its own fact rather than being inferred from the copied-events mark. An operator can read a scope's capabilities directly.

A copy is not yet inert: it stops re-running the source's work, and work it creates itself still flows.

A restore builds every table from the DDL it ships with ​

The other half of trusting a restore is that the schema it lands in is the one your code expects, not whatever the dump happened to carry. A directory restore now builds every table — and its spine — from its own DDL, and refuses a table it does not build rather than improvising one. Restore, fork and preview re-point exactly the dump's source scope and no other, collisions are re-pointed by rank, kernel namespaces are refused as declared entity types, and dumps and restores match the sqlite_ prefix literally instead of treating it as a pattern.

The spine itself gained its first triggers this week, which meant the gate comparing the two adapters' independently-built spines had to start comparing triggers too — it compared columns, indexes and foreign keys before, which was safe only while the spine had none.

Two changes to notice ​

A paged read declaring a descending order is now served descending. An operation declaring paged: { order: 'desc' } was served ascending whenever the caller named no order — the route forwarded order only when it was on the request, and the fallback was asc. The OpenAPI document was the only thing reading the declaration, so it promised desc while the endpoint served asc. The default now lives in the parse every invocation already goes through, on every path in: HTTP, MCP, an in-process invoke, a seed, a schedule, both adapters. An explicit order still wins, and an undeclared order stays absent so a handler-composed read's own fallback still decides.

Visibly: ticket0/list-conversations, list-block-rules and list-signups, shop/orders, invoicing/list and workorder/list are now newest-first by default.

Honouring that default meant cursors had to say which walk they belong to. A ctx.page cursor used to be the bare position value|id, and nothing checked where it was replayed — a descending cursor replayed under ascending turned created_at < ? into created_at > ? over the same value, and the "next" page was rows you had already read. Cursors are now an opaque versioned envelope naming their order and sort, every field validated on the way back, and a cursor whose walk disagrees with the effective one is refused with a reason that says to restart paging. A descending walk in flight at deploy restarts once. Cursors minted before this release are recognised by their exact old shape and continue in the ascending default-sort walk they could have come from; one whose id is not a ULID restarts too. A restart is cheap; a silent replay is not. Handler-composed sortKey cursors are untouched.

An email address identifies someone only when the issuer asserted email_verified: true. This was an opt-in that no deployment had switched on; it is now the default with no configuration, and an absent claim is refused like a false one. Every place an address decides access goes through one decision now — the control plane's staff roster, the builder studio's staff check (which was address-keyed with no gate at all), and the dashboard's invite accept, owner-row heal, support identity and new-team owner row.

Signing in is not gated: a session with an unverified address is still a valid session, it just cannot be anyone by address. A refusal says which problem it is — "sign in again" when there is no claim, "verify your address" when the issuer said false — and the console and CLI both show that sentence instead of a bare 401. Sessions minted before the claim was carried are refused until the person signs in again, which reaches at most a week of them. A CLI user runs substrat login again. OIDC_ALLOW_UNVERIFIED_EMAIL="true" is the only way off, it is deployment-wide, and while it is on each isolate announces itself once and every admitted address is logged by sub — never by address.

Everything in the scope since a watermark ​

readTimeline and readHistory were the only sanctioned spine reads, and both are per-entity. Anything wanting "everything since N" — a projection, an activity feed, an offline mirror — had to hand-roll a SELECT against the outbox, which gets the four nullables wrong (a shredded payload, a consumer-emitted event's operation, a row predating authorization recording, a version that lives only on the column) and has to get the watermark right on top of that.

readScopeTimeline(ctx, page?) and readScopeHistory(ctx, page?) do that walk: every event in the scope since a watermark, each entry carrying the entity it was about, decoded exactly as the per-entity reads decode it, with an optional entityType filter. The watermark is the event id and the cursor is exclusive — so a page boundary falling inside one operation's burst, where every event shares the same ctx.now(), drops nothing.

One thing to get right: keep the last applied id, not nextCursor. nextCursor is null once you are caught up, and a mirror that stored it would restart from zero.

Like readTimeline, these reads check no permission — you check first, as always. In front of a scope-wide walk that check must itself be scope-wide: a permission checked with no entity, whose holder may see every event. A caller entitled to only some entities can still use the walk and filter after it, paging by the last row examined rather than the last row returned. A walk that visits only the events a caller may read is deliberately left for later: it is the same question two other features have to answer, and it should be designed once.

The record of what did not happen ​

Your app's history has always recorded what happened. This week it starts recording what was refused.

Refused lifecycle transitions are recorded and drawn on the process map, and readable row by row through HostAdmin.listRefusals. A guard that refuses a transition is recorded beside the refusal, so the row says what stopped it rather than only that something did.

Refused permission checks reach the dashboard's Audit page, narrowed to one app: who was refused which permission on which operation, with a "while staff acted as them" note when it happened under impersonation, and a link that opens the refused request. An Outcome filter switches between All, Allowed and Refused. Merging two logs that page differently — the audit log by cursor, the denial log by time — would normally show an older action above a newer refusal and fill the gap in later, so the list shows only rows newer than the newest point where either log still has more, and "load older" reads whichever log is holding the list back. If the refusals read fails, the actions still show and the page says the refusals are missing rather than implying there are none.

The dashboard learns to navigate itself ​

Processes › State machines is the new signature screen: your declared lifecycle drawn as a state machine with what actually moved through it. Edge thickness scales with moves; a declared pair nobody took is dashed, but only when the replay was complete, because a partial replay cannot prove a zero; a move your model does not declare is drawn in warning colour. Each state shows how many instances are in it now, median and p90 time in state, and the instances stuck longest — each of which opens its event history in place. Selecting a pair lists the operations that caused it with actor kinds (person, consumer, connector, link, another app) and links to those operations in Logs. A compare-to-previous-period toggle adds per-transition change, and a funnel shows the share of starts that reached each state. The layout is computed rather than hand-placed, so any declared machine draws well and draws the same way every time: the busiest route is the spine on the centre line, steps are straight, skips arc above, returns arc below, and count labels are de-collided busiest-first.

Three more rooms: a ⌘K overlay that jumps anywhere, opens a pasted id and reaches support; an instance timeline showing one record's lifecycle to scale with what moved it; and a request slide-over that opens one request from anywhere it is mentioned. Pulse gains per-bucket p95 trend and tenant connector calls, and Failing badges open their error details. The Requests histogram and facets now read the router's own datapoints.

Which declared fields your API actually returns ​

A new per-response walk compares each response against the field names your operation declared as its output, and records them as present, empty (the field was carried as null — an always-null column does not read as "returned") or absent. It is off by default, armed only by a platform-reserved binding you cannot set from your own config, and arming it is the platform's decision.

It is built to be unobservable when off and cheap when on: it costs O(declared fields) rather than O(response), never enumerates the response's own keys, reads own enumerable descriptors so an inherited getter or a Proxy's get never runs, walks before the response is built, stops at an output schema that pipes or transforms, and cannot fail a request. Unarmed, a result that counts every access to it is never touched.

Only field names are recorded, and only names your declaration supplies: a value is compared against undefined and nothing else — never copied, measured or stringified — and a response key your declaration does not name is never recorded, because a key can be data. That is still not nothing: the report comes from one response, on a line that also carries the tenant and a path that can name a record, so any store built from it must aggregate per operation and field and keep no per-request buckets. The MCP door is walked too, and the router arms the walk per request with one tenant-scoped tally reading it.

Handing over an owner, and getting back in ​

owner_of_record is the row a lockout repair re-seats from, and it was first-write-wins with nothing able to move it — so after an owner hand-over done by hand, a later lockout brought back the original owner. There is now a hand-over verb that moves it, staff or platform-token only, ordered so every partial failure fails closed: move the record and open a marker, seat the new owner, revoke the old owner's scope-level owner role, close the marker. There is never a moment with zero owners or two records. A resend of an open hand-over finishes it; a repeat after the close changes nothing; a stale or abandoned pair is never replayed; and a hand-over wedged by removing its target can be cleared by staff explicitly, which a healthy one refuses. Every outcome is audited, paired by operation id. A re-provision, a reconcile and a lockout repair now all re-seat whoever the record names.

Beside it: a human lockout is repaired while service roles stay live, audit rows name the person a service acted for, and the tenant allowlist names routes.

Owner claim links are now capabilities — authority carried by a secret that the permission checker itself enforces — with a 15-minute expiry, a single use, and a re-mint that revokes the previous link. The redeem route is one shared mount the demo workers use instead of four copies of it. Expiry, revocation and single use are judged atomically in the scope's own storage, and the exchange lands on the spine. Links minted before this deploy keep working until they expire rather than being migrated, which cannot be done: the directory holds only the old token's hash, and a capability is exchanged by its own prefixed secret. An old link therefore lives at most fifteen minutes past the deploy.

Invite routes now apply their canAssign bound on create and on revoke, all of a principal's subjects can be unbound at once, and platform sessions stay host-only.

Erasure reaches the spine's free text ​

An erasure can now erase the spine's own free-text columns, by link or by subject id, and an external job's output by its declared subject. A scope-table page bound that SQLite would misread is refused rather than quietly returning the wrong page.

One Apache-2.0 client for the control plane ​

The CLI is Apache-2.0 and installs into a builder's tooling, so it cannot carry an AGPL dependency — but it talked to the control plane through code that lived beside the server. There is now one typed HTTP client, @substrat-run/control-plane-client, Apache-2.0 and published, holding the one transport the CLI, the console and a vertical's connect seam share: credentials, problem documents, and one error type. The CLI, the console and the dashboard's tenant-narrowed authority all call through it now, and a lint refuses an AGPL dependency in it or in the CLI.

The release machinery around it got the fix it needed. control-plane-client@0.1.0 had reached npm with an unresolvable workspace:^ specifier, which made npx @substrat-run/cli fail to install for everyone — and no packed manifest could have seen it, because pnpm publish -r skips a version npm already has. The gate now also reads what npm actually serves for each current version, a guard refuses any publisher but pnpm, and the broken version was republished.

The reference support desk ​

ticket0 gained the automation half of a real desk: auto-tag, auto-close, no-reply notification, last-fired tracking and off-boarding. Also CCs — outbound CC, portal-visible CCs, and forwarding as a third message visibility — a suspended queue with bulk discard and model-free spam classification, and service levels due soon surfaced in the inbox. An exact address keeps the contact that always had it, a conversation merge drops the losing follows, off-boarding revokes followed conversations, and the desk reads that still scanned are indexed.

For hosted operators ​

  • A vertical that runs without the control plane in its request path now holds its own work correctly when a scope is suspended: platform intents wait, lifecycle deliveries order by revision, and connector doors hold. Every scope door holds the (tenant, scope) pair to that scope's own record, and the tenant-record walk rotates on the ask, so failed asks cannot starve it.
  • A redirect is never followed past a vertical's declared outbound surface.
  • Preview create reaps a provisioning row only once its create is over and answers 409 while one is in flight; legacy preview serving pins are repaired on scope bind, with a one-time fleet repair for the rest.
  • A truncated or unreadable answer leaves a switch's position reading unknown, never "Nothing was switched" — a position nobody could read must not render as a fact.
  • Scope migrations record their duration and how many rows they changed.
  • substrat push includes SQL migrations in its promotion digest, a restore preserves scope backup provenance, and preview create retries a transient 502, 503 or 504 and says so.
  • Executor consumer ids are distinguished from module ids.
  • The delete-scope hook is passed its tenant.
  • planMigration refuses an enum whose CHECK changed, rather than emitting a migration that would not apply.
  • The dependency audit now fails on an advisory of any severity against a version pinned in overrides:, where the rest of the tree keeps the critical-only gate — a pin there has no updater, since Dependabot reads neither overrides nor the catalog.

Also landed ​

  • Links: ctx.link now refuses a cycle, sharing the live-edge walk that ctx.relink uses; ctx.relink itself moves an entity to another parent, and access follows the move.
  • Scrive: signatures are attributed by the provider's own party id, with whatever cannot be attributed surfaced rather than guessed; legacy parties are pinned by position only when the names agree; and a document is titled by the name of the paper rather than by its template key and version.
  • The errors registry: the owner, auto-admission, not-admitted and the last two coordinator-only refusals each carry their own code, so a caller can tell them apart.
  • Scaffolding: a new project gets test:ui and a tests launch entry, as does every demo, and publishing the scaffold now pins what a release moves.
  • Host-side exports are moving out of the kernel; this week's step is forward-only.
  • The architecture sketches are gated against the types they mirror, the K-43 split is written down, and the Substrat skill inventory names the absence and metering engines.
  • The landing page gets a hero explainer and a console tour.
  • Upkeep: the Cloudflare adapter's tests get a directory per counting harness and scopes that read it, the publish-guard producer test runs against a fixture and a stub registry, a builder-generator test mock is fixed for a new ai release, the auth-server deploy stops promoting to prod, a root catalog lockfile mismatch is avoided, and the minor-and-patch dependency group moved by eleven updates.

Released ​

PackageSpan
@substrat-run/contracts0.126.0 → 0.136.0
@substrat-run/kernel0.126.0 → 0.136.0
@substrat-run/adapter-sqlite0.126.0 → 0.136.0
@substrat-run/adapter-cloudflare0.126.0 → 0.136.0
@substrat-run/vertical-host0.126.0 → 0.136.0
@substrat-run/control-plane-api0.126.0 → 0.136.0
@substrat-run/contract-tests0.126.0 → 0.136.0
@substrat-run/control-plane-client0.1.0 → 0.1.1
@substrat-run/attachment-extractors0.1.0 → 0.1.2
@substrat-run/vertical-auth0.15.8 → 0.18.5
@substrat-run/cli0.36.4 → 0.40.0
@substrat-run/model-emit0.9.19 → 0.9.31
@substrat-run/model-view0.2.28 → 0.2.40
@substrat-run/model-providers0.5.16 → 0.5.26
@substrat-run/dev-issuer0.2.8 → 0.2.18
@substrat-run/boundary-lint0.6.0 → 0.6.1
@substrat-run/engine-workorder0.12.10 → 0.12.20
@substrat-run/engine-protocol0.13.10 → 0.13.21
@substrat-run/engine-invoicing0.11.10 → 0.11.20
@substrat-run/engine-booking0.8.10 → 0.8.20
@substrat-run/engine-invites0.9.3 → 0.9.13
@substrat-run/engine-absence0.6.10 → 0.6.20
@substrat-run/engine-metering0.6.10 → 0.6.20
@substrat-run/connector-scrive0.14.31 → 0.14.42
@substrat-run/connector-fortnox0.4.28 → 0.4.38
@substrat-run/connector-planima0.2.23 → 0.2.33
create-substrat0.10.1 → 0.10.13

@substrat-run/attachment-extractors is the week's new package: the file-format parsers behind the kernel's attachment extractor seam. The CLI's four minors are the sweeper handshake, the schedule check, the control-plane client and the promotion digest.