Week 42 · 12–18 October 2026
The week's theme is fencing a thing before it holds anything. A new kind of storage arrives — a store the platform runs on your behalf, reached through a binding you declare — and almost none of the week's work on it is the storage itself. It is the object name the platform refuses to let you choose, the signature on every call, the erasure that reaches it, the dump that carries it, the reap that wipes it first, the gauge that measures it, and the release pin that says which version of a store's code your scope is talking to. Nothing is registered yet, so no store holds a byte of anybody's data. That is the point of doing all of it now.
Beside it, the same instinct applied to something that does already hold your data: a migration can no longer quietly lose it. Authored SQL that drops a populated table, forgets a column in a rebuild, or narrows a value's type is now refused — in the kernel, on both adapters, before it commits — unless the migration declares the loss and says why. The same check runs at substrat push, so an external vertical is told at push time rather than at promote. And the promote screen now shows you what each pending migration has declared, bound to the acknowledgement you give it.
The third strand is being able to find out what happened. Every response now carries a request id, the same id that ties together the invocation line, every event, every log line and now every outbound call the request made. The dashboard will take an id and show you the request, the calls it made, and the requests related to it.
And a quieter fourth: three judgements an agent makes confidently and gets wrong are now computed instead. The semver bump comes out of the artifact diff. The design gate renders the concept delta and refuses an approval for a delta that has since changed. The review checklist names, per item, the gate that already refuses it, so a reviewer reports a gate rather than re-deriving a rule.
Two things need action from you this week: a hand-built IN (?, ?, …) is now a lint error, and a destructive migration needs a declaration. Both are in "Six changes to notice" below, each with what to write instead.
A platform-run store, declared before it holds anything
A store is an object the platform runs for one scope of one vertical. You declare it, you never construct it, and you never choose where it lives:
// substrat.runtimeNeeds in your package.json
scopeStores: [{ binding: 'GRAPH', driver: 'graph' }]Your code reaches it with getScopeStore('GRAPH'). It is deliberately not a field on getScope, because a store is not part of a scope's data — it is a separate thing your scope is connected to.
What the platform keeps for itself is the part a caller could otherwise abuse:
- The object name. The host builds it from facts it asserts itself — the tenant, the vertical, the scope, the binding. A caller that chooses its own name can write another caller's object, which is exactly what the evidence behind this design demonstrated on a shared script.
- The script. There is one store script per driver per vertical, not one fleet-wide, so a driver's code cannot see across verticals at all.
- The signature. Every call carries an Ed25519 envelope, signed per audience, and the store script holds public keys only. The envelope is checked before the driver's own class runs, so a driver never sees an unverified call. An object is bound to its name by its id, so holding a binding without holding the key gets you nothing.
A binding already used by an own store, a per-tenant store, a blob store or a static binding is refused, and ATTACHMENTS can never be a store. A driver with no registration is refused by the push and again by the deploy's sandbox contract. Today the registry is empty, so a declaration parses and is then refused — on purpose.
A driver must also answer every reserved operation before it can be registered, which is how the lifecycle below is guaranteed rather than hoped for.
The lifecycle lands before the data does
A store that the platform runs is a store the platform has to be able to erase, export, wipe, meter and upgrade. All of that landed this week, while there is still nothing in any of them:
- Subject erasure reaches stores. An erasure request fans out to every store a scope is connected to. Erasure is also fenced against a concurrent bind, so a store cannot be attached to a scope mid-erasure and miss the sweep.
- A scope dump carries its stores, and a reap wipes them first — before the scope's own data, so a failed reap never leaves orphaned store objects behind a deleted scope. A scope is unrouted before its stores are wiped, so no request can arrive at a half-wiped store.
- A scope pull keeps its stores, and the driver and the release pin are checked before any write.
- The storage gauge samples stores, so they appear in the same number your storage bill is built from.
- Store calls are named on the invocation line, so a slow store shows up in the same place a slow outbound call does.
- A dropped binding is still reachable from every version a vertical ever declared, which is what makes erasure complete rather than best-effort.
Releases are versioned and pinned the way a connector's are: a driver's release is stored, canaried, rolled out and rolled back by a person, pinned by hash and commit. A rollout past 300 verticals pages through a walk ledger rather than trying to do it in one pass, and the platform rebuilds every store script when a key list or an entry changes, so a rotated key reaches every script without anyone pushing.
Upload planning is separated from upload: you can plan a store upload and see what it would do without moving its objects.
A tenant-level store, decided
The per-scope store above cannot be the whole answer, because the first intended consumer is a tenant-wide data layer over a tenant's verticals — several verticals of one tenant reaching the same store. A store keyed per (tenant, vertical, scope, binding) is by construction not that.
So the shape is now decided. A driver declares its grain, 'scope' or 'tenant'. A tenant-grain driver backs named instances: only a tenant admin creates one, its jurisdiction is fixed at creation, and a tenant admin explicitly connects an installation scope's binding to an instance behind its own permission key. Partitions are keyed (instance, scope, binding), and the router builds the object name from facts it asserts itself — the vertical never chooses it.
Two properties are worth knowing before you design against it:
- Reads across partitions are opt-in and narrow. A connection reads no other partition until a tenant admin enables reads for it, and then only the producer's declared shareable read operations, and only non-personal shapes — permanently, because subject ids are per scope, so an erasure can never reach a reader's copy.
- A disconnect keeps the partition. Reconnecting the same pair revives it, and existing grants keep naming it. Deleting an instance that still has live connections is refused.
Strict tenant isolation is the invariant throughout: one store script per (driver, tenant), never wider. Inside a tenant, separation between partitions is held by review — and a stricter split, a script per partition, is required before any driver written outside this repository can be registered at tenant grain.
A migration cannot quietly lose data
This is the week's one change that can turn a deploy of yours red, and it is meant to.
The model planner has always refused a destructive diff when it generates a migration. Nothing judged what authored SQL does to rows that already exist. A hand-written DROP TABLE, a DROP COLUMN, a DELETE, or a create-copy-rename rebuild that forgot a column ran unchecked against a populated scope.
Now one check in the kernel runs inside every authored migration's transaction, on the hosted adapter and on SQLite alike. It measures; it does not parse. Syntax decides only whether to measure at all: a migration made purely of CREATE … and ALTER TABLE … ADD … costs nothing. Anything else counts every module table before the first statement and after the last — rows, and each column's values per storage class. Counting every table rather than the named ones is what makes a trigger or foreign-key cascade visible.
It refuses, for a table that held rows: the table gone or holding fewer rows; a column that held values gone or holding fewer; or a column's values changing storage class, which is a narrowing retype ('1.50' → 1). Renames are followed, and a rebuild is judged by the name it ends up under.
"Data" means rows that exist in that table in that scope. There is no go-live flag — an empty table may be dropped or reshaped freely, which is what keeps a dev scope free.
A loss you intend is declared on the migration, beside the SQL and outside its digest:
{
version: '0003-drop-legacy-notes',
statements: ['DROP TABLE notes'],
discards: { notes: 'superseded by entries; exported before this release' },
}moves: { source: target } is the other declaration, table-to-table or table.column-to-table.column, and it is verified: the target must gain, per storage class, what its sources held, and a table moved whole must bring each column that held values into a target column of the same name unless that column is itself moved or discarded by name. So a lossy "move" is still refused. discards requires a reason, and an empty one is refused. A declaration naming a table or column the scope does not hold is refused as an authoring error.
The refusal names the table, the column, the before and after counts, and the exact line to add:
migration @x/y@0002 would lose data this scope holds, so it was not applied:
table notes held 2 row(s) and is gone. If this is intended, declare it on the
migration — discards: { 'notes': '<why this data may go>' } — or, where the data
moved, moves: { '<source>': '<where it went>' }.If a scope applies it after a promote, the migration rolls back inside its own transaction, no journal row is written, and that scope fails closed exactly as any failed migration does. Migrations are applied lazily, per scope, as each one wakes — promote moves the version pointer, it does not run them — so this is a scope at a time, not an all-or-nothing step. Your data is intact. Recovery is to promote the previous version back — the migration never ran, so the old code still fits the schema — or to push a version that fixes or declares it.
substrat push now replays your migrations through the same fence, using your vertical's own pinned kernel, so an external vertical hears about this at push rather than at promote. Verticals in this repository are caught by a CI gate first, which replays every authored migration against a scope where every table holds a row and every column a value.
Two things the counting deliberately cannot see, stated so you don't assume otherwise: values rewritten in place at the same count and storage class, and rows replaced by as many other rows. A faithful widening (5 → 5.0) is reported as a retype, because a count cannot tell it from 5 → 0.05; declare that one.
Promote shows you what a migration will do
The human checkpoint on migrations gets the information it was missing. The promote review now shows each pending migration's declared moves and discards, with its reason — so the person acknowledging a promote is reading the declarations, not just a list of version numbers.
The acknowledgement is now bound to the review it answers, on both the promote path and scope rebind --ack-migrations: an acknowledgement is for a specific set of pending migrations, and a different set needs a new one.
Underneath that, a version's migration digest is now derived on the server from the migrations stored for it, and at apply time the scope checks that its pending migrations are the ones stored for that version. An edit to shipped SQL between push and apply stops being something you find out about by having a scope fail closed.
Single-use upload links, so bytes never ride a tool call
An operation can now mint a short-lived, single-use URL that lets a caller with no session — an agent's shell, a curl — upload one file to one entity:
const link = await ctx.attachments.mintUploadUrl({
entity: ref,
filename: 'scan.pdf',
ttlSeconds: 300,
});
return { url: `${PUBLIC_ORIGIN}${link.path}`, expiresAt: link.expiresAt };The result is { id, secret, path, expiresAt, maxBytes, filename }. path is /api/attachment-uploads/<entityType>/<entityId>/<secret>, and the origin in front of it is yours — so what you hand the caller is a URL you assembled:
curl --upload-file scan.pdf "$url"You opt in per attachment target, and the opt-in is the policy: attachmentTargets[].uploadLinks: { maxBytes, contentTypes? }. It renders in PERMISSIONS.md under Upload links, so widening it shows up in review.
The guarantees worth knowing:
- Minting checks the target's write permission as the caller, and redemption re-checks it as the minter. A minter who loses the permission between mint and upload gets a refused upload.
- Only the secret's SHA-256 is stored. A copy of a scope starts with no links.
- The link is spent in the same transaction as the attachment row, so every refusal leaves it unspent — and a lost reply is retryable with an
Idempotency-Keywithout weakening single use. - Answers are the ones you would expect: 201, 404 for an unknown secret or a path naming another target, 410 for used, expired or revoked, 413, 415, 403.
- The default TTL is ten minutes and the cap is an hour.
revokeUploadLinkanduploadLinks(a list, never the secret) sit beside the mint.
Two limits are documented rather than solved: the secret is in the URL path so that curl --upload-file works unaided — the invocation log redacts that segment, but a runtime log of full URLs can still hold an unused link until it expires — and your own entity locks run at mint, not at redemption, which is the reason to keep the TTL short. There is no virus scanning.
Attachment bytes nothing points at are swept
Attachments gain a garbage collector. The kernel can sweep attachment bytes no row points at — never a committed row's — and the control plane runs it: off by default, and dry run before delete, with the dry-run licence held in the scope's own storage rather than in the caller's request, so a sweep cannot be talked into deleting by whoever calls it.
A related fix: attachment bytes are now preserved when an upload commits but post-upload processing fails.
Every response carries a request id
Every response a stamped request gets now carries x-substrat-request-id, and every problem document gains an optional requestId member. It is the same id that was already on the invocation line, on every event, and on every ctx.log line — nothing new is minted. It is now handed out.
HTTP/1.1 403 Forbidden
content-type: application/problem+json
x-substrat-request-id: 01K7Z2M8QH9W3V4P5R6S7T8U9VInside an operation you can read it: ctx.requestId. In an operation it is the request's id, or null on an in-process call that passed none. In a consumer it is the delivery's id — the originating request's when the event is delivered inside that call, and otherwise an id minted for the delivery, never null. In a schedule run it is the run's id.
The header is opaque: the ULID and nothing else, no tenant, no scope. If your vertical configures its own CORS, list the exposed-headers constant (REQUEST_ID_EXPOSED_HEADERS) or a cross-origin browser will not be able to read it on a 2xx — failures are covered either way, since the body carries it.
Hosted verticals get the header and the envelope member with the next control-plane deploy, with no re-push. ctx.requestId reaches you when you upgrade your kernel and adapter and push.
A request has a timeline
With an id to search by, the rest follows. The dashboard will find a request by id, show the requests related to it, and put the id on a failure so the person reporting it has something to quote. Outbound calls are on the request timeline — host, path, status, timing, and platform refusals — and the egress hop marks a platform refusal with its own header and logs it, so "the call never left" and "the call failed" stop looking the same.
Peer calls carry their parent on the invocation line, purges run under the run's id, and install, retry and resume failures carry a request id too.
Underneath, a request trace now has a declared shape and a sink a host records it through, with hooks on both the SQLite adapter and the vertical host — and local servers stamp every request and serve the HTTP half of a trace, so what you see in development is the shape you will see hosted.
A list of any length is one SQL parameter
A Durable Object refuses a statement binding more than 100 parameters. So this passes every test with a small fixture and fails on the first hosted call whose list outgrew it:
// ✗ fine with 4 ids, a refused statement with 120
`WHERE id IN (${ids.map(() => '?').join(', ')})`inList from @substrat-run/contracts makes the list one parameter — a JSON array read back with SQLite's own json_each, which runs identically on both adapters:
import { inList } from '@substrat-run/contracts';
const list = inList(ids);
await ctx.sql`SELECT id, title FROM notes WHERE id IN ${list.sql}`.all(list.params);IN stays visible in your SQL. An empty list matches nothing, where a hand-built IN () is a syntax error. NaN, Infinity, null and bigint throw rather than silently becoming null inside the JSON. Pass values in the column's own type: a numeric column will convert a numeric string, but a TEXT column never matches a number.
The old form is now boundary-lint R12 in module code, so it cannot reach a deploy unreviewed. A genuinely fixed, short list opts out with a boundary-lint-allow R12 … boundary-lint-end R12 block. The node adapter's own parameter refusal now names inList, after the Durable Object's words.
An assistant engine: the record of a chat
A new private engine records a conversation between a person and an assistant. It never talks to a model — a host runs the loop and writes each result through the engine, which is what makes the record the authority rather than a transcript beside one.
What it guarantees is the interesting part:
- An append-only, numbered record.
(thread, seq)rows, never updated or removed;seqis the cursor a client resumes from. - One writer, inside a turn the user opened. A run takes a single-writer lease, and a run replaced while still running cannot write. A run can no longer write to a resting thread and lock its owner out.
- A gated tool runs once, with what the user actually saw. An approval request is bound to a digest over the tagged tuple — version, approver, thread, step, call, operation, expiry, nonce, input. Answering recomputes it with the answering principal and version; claiming recomputes it with the operation, version and input about to run. Both are conditional writes, so two concurrent answers or two concurrent claims produce exactly one winner.
- Two keys, deliberately split. What the user did is written under
assistant:useas the owner. What the assistant did is written underassistant:run. If a person held the run key they could append events to their own thread that the record then attributes to the assistant.
assistant:run is a system principal's key only, and that is now mechanical: lint:permissions refuses a role or entity-grant shape that holds it, and a role may now be declared system-held — the one shape that may carry a reserved key.
Nothing composes the engine yet: no model, no loop, no screens.
The dashboard's routes become declared and team-scoped
The dashboard's API is migrating from cookie-scoped routes to a declared surface mounted under /api/teams/:teamId. This week covered Apps (read and lifecycle: install, remove, retry, resume), Domains (team domains and app hostnames), Members and invites, and Deployments and previews.
Two properties come from the move itself. A path naming any team but the caller's exact one is a 404, and the cookie is never read — so a session pinned to one team cannot be used to read another by URL. And a declared output answers exactly its schema, which is how internal columns the cookie routes leaked (an app's deleted_at, an install step's app_scope_id) are simply not on the new ones.
Each route group is one implementation behind two doors, so the old and new paths cannot drift while the migration is in flight.
A peer is found by the name you declared
A tenant-pinned vertical is now resolved by its bare declared name. If you declare a peer as invoicing, that is what resolves, whether or not the tenant's installation of it is pinned to a particular version — and the peer panel finds a pinned caller's grants under that same bare name, instead of showing you nothing.
The other half: peers hold only what the running declaration names. A peer you narrow or remove loses its keys at promote, rather than keeping a grant from a declaration that is no longer deployed. An ownerless reconcile now reaches older installs too, so a version's peer, schedule and connection grants are applied to scopes that installed before the declaration changed.
Refusals are problem documents wherever the control plane answers
The error model's long tail: a refusal the control plane decided itself — unknown scope, forbidden, "not configured on this control plane" — used to answer plain application/json, while only a throw went through the problem renderer. Whether you got the contract depended on how the failure happened to be raised. All 231 of those sites now answer application/problem+json, as do the vertical host's /internal and live-read refusals.
Statuses are unchanged at every site, the error sentence is unchanged at every site, and every extra member a route carried is kept verbatim. The one visible change is the content type. No published client gates on it — they read the body with res.json() and then .error, which still says the same thing — but if you deep-compare a whole error body you will now see type, title, status, detail and often code beside it.
Two witnesses keep it true rather than merely done: a runtime tripwire that logs control-plane.non-problem-refusal with the route pattern (never a tenant or scope id, never the body) and fails any test that reaches a non-problem refusal, and a source scan that refuses a hand-rolled error response whether a test reaches it or not. The second exists because 109 of 267 refusal sites were reached by no test at all.
Documents in a Teams channel folder
The Microsoft 365 connector can now read and write files in one Teams channel's folder. Writes are event-dispatched: you emit microsoft365.channel-files-requested naming attachments on an entity, and the bytes are read through the delivery's own authority rather than handed over in the event. Reads are a delta sync that lands each change through your own operation, keyed by a stable item id, so your handler upserts rather than guessing.
Everything about it is addressed relative to the bound folder's id, so a write can only land underneath it, and a path grammar runs before any call to refuse the usual escapes — .., backslashes, percent-encoding, non-NFC text, and characters whose normalized form is a separator. Out-of-folder metadata seen during a sync lives in memory for one pass and is never stored, logged, landed or put in an error.
The delete rule is strict on purpose: an item is deleted only on an answer about that item, never inferred from a deleted parent or from a full pass's silence. An item the connector cannot place is kept, counted, and retried — never deleted because it could not be read. If the bound folder is deleted or moved out, the binding refuses syncs and writes until it is bound again, and never falls back to the drive root.
Certificate rotation now happens before the certificate lapses, with no gap in mail.
One tenant's events, out of the lake
A staff-only control-plane route reads one tenant's events from the Tier-2 lake. Three independent layers hold the tenant scoping: the input schema has no tenant field and is strict, so there is nothing to say; the gateway writes the SQL itself with a fixed shape and a fixed column list, with the tenant predicate first in every WHERE; and the answer is checked, so a row naming another tenant fails the whole read with no rows. It returns envelopes only — no payloads, no subject ids — because erasure does not reach the lake yet.
It ships off: the engine is built only when all three of its settings are present, and one of them is deliberately absent from the deployed configuration, so every deployment currently answers 501. Nothing in it has been run against the real lake yet.
The design gate shows you the delta
substrat plan prints the concept delta a design gate should show: entities added, changed and removed with the model diagrammed before and after; lifecycle states and each transition added, removed or retargeted with the operation that triggers it; the permission table before and after with each change flagged for the checkpoint; and the spec-version impact.
Approval is a separate step, run only after a person says yes:
substrat plan --approve <digest> --by <name> --why <reason>The digest is over the delta as it was shown. If the model changed after you read it, --approve refuses and writes nothing — so the approval on record is always for the delta the person actually read. It also refuses an empty delta, a missing --by or --why, and a document whose decisions log it cannot find.
One limit is stated rather than papered over: "who may trigger" a transition is shown as the operation, not the permission key, because no artifact records which key each operation checks. That gap is now being closed from the other end — PERMISSIONS.md gains an Operations section naming the key each operation checks.
spec/concept.md also gains generated sections — the model, the lifecycles and the permissions, emitted from model.json and checked in CI — so the document a design gate reads cannot drift from the model it describes.
Your bump is computed, not guessed
Choosing a semver bump is a judgement made with confidence and got wrong, and a breaking change marked patch looks exactly like a green release. A vertical already checks in every fact the judgement needs, so the bump is now computed from the diff of model.json, openapi.json and PERMISSIONS.md against the merge-base:
substrat changeset # writes a changeset with the computed bump
substrat changeset --check # refuses one that declares lessRemoved or narrowed anything — an operation, field, entity, state, transition, response, enum value, parent edge, an input that became required or tighter, an output that may now be omitted — is major. Additions are minor. Any permission change is at least minor and is flagged for the human checkpoint, narrowing and widening alike. Documentation-only changes are patch. And anything the classifier cannot rank is major, because an unknown shape must never lower a bump.
In CI, a changeset that names a vertical and declares less than the computed bump is red. A vertical whose artifacts changed and that no changeset names is a warning carrying the computed bump, not a failure — most such changes are a platform-wide regeneration, which releases the platform rather than the vertical. A reviewed exception lives in the changeset itself as a bump-override comment with a reason, parsed strictly and printed in CI.
A review checklist that names its gate
There is now one rule set for reviewing Substrat code: nine items — scope isolation, permission checks, generated files, migrations, personal data, lifecycles, events and time and ids, secrets, tests — each with a severity, what to look for, and the mechanical gate that already refuses it. A reviewer reports the gate rather than re-deriving the rule, and the checklist's own gate holds that promise: every command an item names must be a real script that CI actually runs with those arguments, and items no script decides are marked as judgement.
It runs locally as a review skill against your merge-base, reads the diff against each item, and reports file:line findings. It never edits and never acknowledges a checkpoint.
The hosted runner behind it is designed and decided but not built — deliberately without a model key in this repository, because a hosted review belongs behind the platform, enabled per customer and metered there, and independent of where a customer's git lives.
Six changes to notice
- A hand-built
IN (?, ?, …)is a lint error. boundary-lint R12 refuses it in module code. Replace it withinListas shown above; a fixed, short list opts out with a reviewedboundary-lint-allow R12block. Migration: the two module-code sites in this repository were converted; runnode tools/boundary-lint.mjsto find yours. - A destructive authored migration needs a declaration. Dropping a populated table or column, deleting rows, or narrowing a value's type is refused unless the migration carries
movesordiscards. Migration: add the declaration the refusal message prints. Nothing is needed for additive migrations, and nothing for a scope whose table is empty. - The control plane's refusals are
application/problem+json. Statuses and theerrorsentence are unchanged, and every extra member is kept. Migration: none, unless you deep-compare a whole error body. - A store's
kindis now adriver— in the code, the routes, the CLI and the directory. Nothing is registered yet, so this costs nothing today, but the word in the declaration above isdriver. assistant:runcannot be held by a role.lint:permissionsrefuses a role or entity-grant shape carrying it. A role that legitimately needs a reserved key declares itself system-held.substrat push --checkwarns when your code names a host thatsubstrat.outbounddoes not declare — a warning today, and the thing that would otherwise fail as a platform refusal at runtime.
For hosted operators
- Store driver releases are stored, canaried, rolled out and rolled back by a person, pinned by hash and commit. A rollout past 300 verticals pages through a walk ledger.
- Envelope keys have a full set of commands — generate, doctor, rotate — an inventory gate, and a runbook. A key list or entry change rebuilds every store script.
- The orphan-attachment sweep is off by default and dry-runs before it deletes; its licence lives in the scope's own storage.
- A promote acknowledgement is bound to the review it answers, and so is
scope rebind --ack-migrations. - The console gains search and paging on Tenants, Domains and Verticals, and hides reaped tenants.
control-plane.non-problem-refusalin the control plane's logs names any surface still answering a refusal in the old shape. It should never fire.- The lake query route answers 501 until its bucket setting is present. It has not been exercised against the real lake; a human smoke test is documented before it is turned on.
Also landed
- Capability expiry transitions now happen on the hosted path, with no clock seam — so an expiry is a transition the Durable Object makes, rather than something only the SQLite adapter could be held to.
- The auth server gains identifier-first sign-in with email-domain routes per application, machine-to-machine (
client_credentials) client registration, a user-import preview that counts new people whose address arrives unverified, and a sign-in page whose methods stay visible and whose SMS step refuses an expired sign-in. - The relying-party half gains a second sign-in issuer reached by
?idp=alt, presents the client secret as HTTP Basic where an issuer wants it, and no longer fails federated logout withInvalid post_logout_redirect_uriwhen areturnTois supplied. - MCP sends tool results once and compact, and takes a
fieldsargument on reads. Separately, a host admits a delegated token only by opt-in, capped by its scope. - Connections gain audited scope binding for two accounting and planning connectors, and the Fortnox consent round now also asks for the supplier-invoice scope.
vertical-authcounts the pending hash-only invites per scope, which is the number an invite-cleanup decision needs.- The binding-shape gate now judges a shape a scope actually bound rather than only the registry's bind, and judges a drop from the retirement-finished record rather than the bare receipt.
- The console's views read one contract: a query-first data source with capabilities each source declares, a local source over the working tree, a trace reader, and a suite every source passes.
- The kernel's platform sweep is split into four files — schedule state, scope identity, install receipts and the export-break gate — with no behaviour change.
- Two RFCs are proposed: a cross-scope read, declared and host-run and checked per scope; and a connector shape for sources that bear files rather than records.
- Tooling:
lint:testsnow refuses a bare RegExp as atoMatchObjectvalue, which asserts nothing at all (writeexpect.stringMatching(…)instead); the repo's tools are rooted on a real path so a Windows checkout scans the tree; and a test that asserted on digits a random id can contain was fixed. - Docs: the ebook and the published site are refreshed with the recent platform changes, and store erasure, backup, metering and logging are documented.
- Dependencies: the minor-and-patch group across eight updates.
- Upkeep: last week's changelog entry, and a review's follow-up findings on the store declaration folded in.
Released
| Package | Span |
|---|---|
@substrat-run/contracts | 0.145.0 → 0.150.0 |
@substrat-run/kernel | 0.145.0 → 0.150.0 |
@substrat-run/adapter-sqlite | 0.145.0 → 0.150.0 |
@substrat-run/adapter-cloudflare | 0.145.0 → 0.150.0 |
@substrat-run/vertical-host | 0.145.0 → 0.150.0 |
@substrat-run/control-plane-api | 0.145.0 → 0.150.0 |
@substrat-run/contract-tests | 0.145.0 → 0.150.0 |
@substrat-run/control-plane-client | 0.1.10 → 0.3.1 |
@substrat-run/attachment-extractors | 0.2.6 → 0.2.11 |
@substrat-run/vertical-auth | 0.24.0 → 0.24.5 |
@substrat-run/oidc-rp | 0.11.1 → 0.13.0 |
@substrat-run/cli | 0.41.5 → 0.46.0 |
@substrat-run/model-emit | 0.10.1 → 0.10.6 |
@substrat-run/model-view | 0.2.49 → 0.3.0 |
@substrat-run/model-providers | 0.5.35 → 0.5.40 |
@substrat-run/dev-issuer | 0.2.27 → 0.2.32 |
@substrat-run/boundary-lint | 0.7.1 → 0.8.0 |
@substrat-run/engine-workorder | 0.12.29 → 0.12.34 |
@substrat-run/engine-protocol | 0.13.30 → 0.13.35 |
@substrat-run/engine-invoicing | 0.11.29 → 0.11.34 |
@substrat-run/engine-booking | 0.8.29 → 0.8.34 |
@substrat-run/engine-invites | 0.9.22 → 0.9.27 |
@substrat-run/engine-absence | 0.6.29 → 0.6.34 |
@substrat-run/engine-metering | 0.6.29 → 0.6.34 |
@substrat-run/connector-scrive | 0.14.51 → 0.14.56 |
@substrat-run/connector-fortnox | 0.4.47 → 0.4.52 |
@substrat-run/connector-planima | 0.2.42 → 0.2.47 |
create-substrat | 0.11.5 → 0.12.0 |
boundary-lint's minor is R12. model-view's is the exported concept diagram renderers that substrat plan draws with. oidc-rp's two minors are the second sign-in issuer and HTTP Basic client authentication. control-plane-client's are the store lifecycle and the connection binding's folder. The five cli minors are plan, changeset, the migration fence at push, connection bind --folder and the outbound warning. In 0.x semver a minor is where a breaking change goes, so the fixed group's 0.150.0 carries every "change to notice" above.