Skip to content

Week 44 · 26 October – 1 November 2026 ​

The week's theme is seeing what your app did, and reaching what it needs.

The larger half is observability, and it arrived as one arc rather than a feature. The dashboard's Logs page now answers "which requests did my app answer, and what happened inside them" — a histogram you can brush, facets for level, operation, who asked, which route answered and which entity types were touched, free text that also matches a request id, a line count per request, and an opened line that links to the history of every record that request touched. Beside it, substrat dev records the same kind of trace locally, and a failed control-plane call finally tells you the request id to quote.

The other half is reach. A vertical can now define its own connector and ship it with substrat push, with no change to this repository. A single scope can own and bind its own connection instead of inheriting the tenant's. And mail sent to an address on the platform's receiving subdomain lands through an operation the vertical declares, attachments and all.

Underneath both, two things that had been failing quietly now work: a release is built on the platform from a persisted revision rather than from whatever the client uploaded, and a scope that keeps taking writes can finally be copied — previews of busy apps used to refuse after three attempts.

Logs: every request your app answered, and what it touched ​

Logs had a shape and almost no data behind it. It now has both.

Requests mode is laid out as its design draws it: the histogram is its own card, the facet sidebar sits beside the stream rather than below the fold, and each version that went live inside the window is a dashed line labelled with its version and time. Hovering a bar gives you its time range and per-level counts. Brushing it zooms, and Reset zoom appears beside the caption while you are zoomed in. A Live toggle slides the window forward every 15 seconds, keeps the last answer on screen while the next one loads, and pauses while the tab is hidden.

What you can now filter and search on:

  • Level, with a histogram of its own over the Lines view, and Operation and Who — request lines and your own ctx.log lines counted together.
  • Path — the route that answered, bounded to your app's own route table rather than raw paths, so request ids cannot explode the facet. A malformed route is refused rather than guessed at.
  • Entity — the entity types a request touched.
  • Problem code, which now reads "None in this window" instead of disappearing. It is the facet people come looking for, so its absence should be visible.
  • Free text, in Requests mode as well as Lines, matching the request id at either grain and reaching ctx.log lines and ids older than the newest page. While a search is running, the counts say plainly that they are unavailable rather than showing a number that ignores the search.

A request now carries three new facts. Its line count — how many ctx.log lines were written under its id — sits on the invocation line, so you can see which request was noisy without opening it. The mode tabs carry the counts their modes already answered, so you do not have to click a tab to learn whether it holds anything. And an opened line links each record the request touched to that record's own history, so a request and the rows it changed are one click apart.

The lifecycle moves an operation made are on the line too. assertTransition now takes the operation's context as an optional last argument and notes each legal move through the new ctx.noteTransition. Both scope hosts keep the notes in the invocation's signals — ctx.atomic restores them — and report them after the commit as transitions: at most eight entities, each from the first state it left to the last it reached. Read null as not recorded rather than as "this operation moved nothing": a call that moved nothing and a module that does not hand assertTransition its context cannot be told apart, and a route that is not an operation, an asynchronous line and an older scope host all read null too. An empty list is the narrower fact — every noted entity came back to where it started. The workorder and booking engines pass their context, so a vertical composing them gets the moves for free.

The CLI: Windows, request ids, local traces, entitlements ​

A builder ran @substrat-run/cli on Windows — Node 24, a project path with a space and a non-ASCII letter, a short 8.3 temp directory — and found that push could not build a Worker at all and login only worked with workarounds. All three bugs were fixed at the source, each with a test that fails without the fix, and a windows-latest CI job now keeps the CLI covered.

  • push runs your project's own wrangler, as node <wrangler bin> with no shell, the same on every OS. A project without wrangler is refused with the command to add it, rather than having npx silently download the newest one. The build's PATH starts with the project's node_modules/.bin, so a build.command like vite build still finds the project's own vite when the CLI is installed globally.
  • login works without a terminal. Nothing is asked when there is no TTY: the plane is --cp, else the stored one, else the public one. A new --workspace <slug|id> picks the default. Ctrl+C at any prompt exits 130 instead of reading as "no answer" — before, a push asked whether to pin its workspace went on to upload.
  • substrat doctor [--fix] is new: it checks Node 22+, the project's wrangler, and on Windows the long-path setting, which a nested node_modules needs. npm create substrat offers the same once.

A failed control-plane call now carries the request id the plane stamped.ControlPlaneError.requestId holds it; substrat push, promote, preview and the CLI's control-plane reads print it as a final request id: line when they fail — substrat hostnames still prints the bare error — and the control plane stamps one on every /api/* response and problem body. When something fails and you need an operator to look, the reference is now in front of you instead of in a log you cannot read.

substrat dev records local request traces. It runs your project's existing dev script — stdout, stderr, exit code and Ctrl-C passed through — and installs the trace sink the host already declares. Each completed request prints a compact line with its id, operation, principal, outcome, problem code and permission decision, and the newest 256 requests are kept as per-request files under .data/substrat-traces/, bounded to 8 MiB. SQL parameter values and request and response bodies are deliberately not stored. Traced children now enable Node source maps, so a captured stack points at your authored TypeScript. The measured cost is about 1.5 ms per request at the median; --no-trace runs the script unchanged.

substrat entitlements list | grant <key> | revoke <key> manages a workspace's entitlement keys from the command line. grant takes --plan, --expires and --quota, and both writes print the resulting key list. A key containing a slash travels as one encoded path segment. The plane's rules are untouched and its refusal is printed as it stands.

A vertical can ship its own connector ​

A connector used to be first-party by definition: to reach a provider the platform did not already speak to, you needed a registration in this repository. Now a vertical can define its own and ship it with substrat push, and nothing here changes.

A vertical-defined provider is named <namespace>.<name> — acme.docbox, say. First-party slugs never contain a dot, so the two cannot collide.

The platform keeps everything it holds for a first-party connector: the sealed credential, the bindings, the connector's state, the sweep schedule, the intent drain and the probe routes. What changes is where the provider code runs. For a dotted provider the call is dispatched into your own worker, with your version's outbound policy bounding it, on two internal routes the router is admitted to — a replay-free probe that touches no scope, and a scoped call signed with tenant and scope.

Your connector is handed a ConnectionContext for one connection: the secret, a deadline-bound fetch whose uses are recorded, and key/value state. On a scoped call it also gets land/invoke as the connection principal, plus attachments. It never gets HostAdmin, a ScopeHost, or a tenant argument. State travels in and out with each call and is applied only when the call succeeds, so a cursor never moves past work that did not land. One sweep call is sent per bound scope, to that scope's own deployment, because a tenant's scopes can be running different versions.

The standing grants come from the serving version's declaration, never from the caller — ignored on the relay and on the dashboard door alike — and they are lifted into the permission registry, so widening them moves the permission digest and is reviewed like any other permission change. A vertical with no connectors has a byte-identical registry.

Two things to know before you reach for it. Your deployment holds the plaintext credential, including one a tenant types into the dashboard — that is new, and the design says so. And the decision behind this, D-64, is still proposed: shipping it privately works today, and sharing it as an npm package works by construction, but the listed tier, where another vertical binds your connector, is designed and not built.

A scope can hold its own connection ​

A connection belonged to the tenant. For a vertical whose spaces each connect one folder of a file source, that is the wrong grain — each space needs its own account, bound to itself, and revocable by itself. There was no door for it.

A module manifest's connection landing can now declare bind: 'on-request'. The connector pass then grants and binds nothing for it, leaving the binding to the scope. Leaving bind out keeps today's behaviour, and the permission digest of a vertical that declares no on-request landing does not move.

With that in place, a scope does three things through the platform relay, each admitted only for a caller established as the scope it names:

  • Own a connection, keyed apart from the tenant's and every other scope's. The upsert takes owner: 'scope'; the default stays tenant, and every in-repo first-party connector stays tenant-owned.
  • Bind it to itself, with its own options. The operation and the key come from the version the scope is running, never from the request body. The declared options fill only what the binding does not hold yet, so a rebind keeps the scope's own choices. A refused bind leaves nothing behind: the landing key is taken back, whoever granted it, so a retry starts clean.
  • Unbind. The key the binding itself recorded is taken back first, then the binding is dropped. Standing grants survive, so binding again resumes. What the scope already landed stays.

@substrat-run/vertical-host gains the client half — upsertConnection, bindConnection, unbindConnection — so this is called from your worker's request path, and a scope can read its own bindings' sweep status, counting only its own sweeps.

Mail arrives into an operation you declare ​

The platform can receive mail. A scope gets an address on the platform's receiving subdomain, <app>-<random>@in.substrat.run, and each message sent to it lands through the operation its vertical declares, with the attachment bytes stored as files on the entity that operation answers.

You opt in by declaring it: connections: [{ provider: 'mail-in', operation, permission }]. That row joins the permission registry, so it appears in PERMISSIONS.md and in the permission digest, and when an address is requested the operation and key are read off the manifest the scope runs — not taken from whoever asked. Each address is its own connection, holding the declared key on its one scope, so rotating and revoking an address reuse what connections already do.

What is refused at SMTP time, with nothing stored: an address that is unknown, revoked, at the wrong domain or not in the shape the platform mints — all answered identically, so a bounce reveals nothing about which addresses ever existed; a message over 25 MiB, checked before the body is read; and a sender that is not on the address's allowlist, or is on it but unproven. Proof means DMARC on From: (or an aligned DKIM signature), or SPF on the envelope sender, and only the topmost Authentication-Results from the trusted authserv-id is read — a sender can write any result it likes into its own headers.

After accept it is durable. The raw message goes to object storage before the SMTP answer and is recorded once per Message-ID, so a redelivery is accepted and stored once. Delivery runs immediately and again from the connector sweep as the retry floor: the message's headers and text body are invoked as one change, then each attachment's bytes are uploaded and invoked as another, with progress saved after every step so a retry resumes and never lands a file twice. After eight attempts the message is dead-lettered and its raw copy kept. Once delivered, the platform deletes its own copy.

mailInAddress() in @substrat-run/vertical-host is the harness helper your worker calls to get, request, rotate or revoke the address. The dashboard card and the routes in front of it are the next slice.

Every release is built on the platform, from a revision ​

The builder and the CLI had different source and build paths — Git bundles in object storage on one side, client-built module uploads on the other. Both are gone. GitHub and Cloudflare Artifacts are now the shared repository, and the platform builds every release from a persisted revision.

substrat push and preview create submit a source snapshot. The platform installs and builds it in a fresh container as an unprivileged user, with a frozen lockfile, temporary repository credentials, and provenance recorded for both the source and the toolchain. Promotion and rollback reuse the immutable release output rather than rebuilding. A snapshot leaves out the tests and changelogs of a monorepo's dependency packages, and a submit refused because the builder is busy is now retried with backoff for about eight minutes instead of failing at once.

The deploy endpoint accepts source JSON only, so this needs a current CLI. Existing builder studio projects have no migration path, deliberately.

A busy scope can be copied at last ​

A paged scope copy was consistent only while the source's write revision stayed where the first page read it. A scope that keeps taking writes — through its own traffic, its sweeps, its schedules — moves that revision on every attempt, so after three tries the copy was refused with "retry when it is quieter". A busy scope needing more than one page never copied at all, which is why preview jobs on active apps failed intermittently.

The copy now catches up instead of waiting for quiet. The first page opens a capture on the source in the same turn it reads: a log of changed rows, written by triggers on every dumped table, keyed so that one set of triggers serves overlapping copies. Once every page is staged, the copy reads change batches and stages each one after the pages until a batch comes back final — read in the same turn the log ran empty, so its revision is the moment the copy is true at. A capture is invisible from the outside: it moves no write revision, appears in no dump, leaves your own triggers and tables untouched, and expires by itself if the copy that opened it stops.

Where a capture cannot be opened — a table with a unique index on an expression, which no row trigger can key — the copy falls back to today's quiet-moment path rather than failing, and the same happens when either end predates the new verbs. A capture lost mid-way, or a catch-up that never finishes, starts the copy again and counts an attempt. Every path that gives a copy up now ends its capture and discards its stage through one helper, so a cancelled, superseded or faulted job leaves nothing behind.

Self-hosted copies are unaffected: the pure adapter has no paged copy and always reads at a quiet moment.

The dashboard's whole surface is declared ​

The long migration of the dashboard onto declared, team-scoped routes finished this week. Every read and write of an app — environment, previews, members, owner claim and auth settings, integrations, lifecycle (update, bind, rewind, restore), peers and edges, the data browser, diagnostics, GitHub import, connect links, the install catalog, team-wide reads, observability — now takes its team from the path rather than from a shared cookie, so two browser tabs can read two different teams at once. A path naming a team you are not a member of answers 404 before anything else happens.

Three consequences you can see:

  • openapi.json is emitted from the declared routes and held by lint:api --check, so the dashboard's own surface is now documented the same way a vertical's is.
  • The browser app reads its types from the generated client — deployments, members, app rows, install steps, traffic series, audit entries, schedules, the process map, domains, hostnames, observability views. The last hand-written call() is deleted.
  • The three routes outside the team path are declared too — the invite preview, the public catalog and the support identity read — in a third route table mounted with a context that resolves no caller at all. One answer changed: /api/support/identity now checks the session first, so a caller without one gets 401 even on a deployment with no support desk configured.

Along the way, defineRoutes grew two things any declared surface can use: a route may name responseHeaders, and its generated client method then answers { body, headers }; and a GET input field declared as an array is read from every repeat of its query key.

BankID, presented through the sign-in relay ​

BankID's RP API needs a client certificate, and a hosted vertical cannot present one: Workers fetch has no client-certificate option, node:tls ignores key and cert, certificate bindings are fixed at deploy time, and a dispatched script has no raw socket. So BankID could be switched on in the auth server's console and would never appear among an app's sign-in methods.

The platform's sign-in relay now has a route that opens a raw socket and runs rustls, compiled to WebAssembly, over it, presenting the certificate the install sends with the call. Only BankID's two hosts are reachable, nothing is stored, and request and response bodies are never logged — a failure names the stage it reached (tls.config, tcp.open, tls.handshake, http.response) and its timings. The install authenticates with the relay client it already holds for social sign-in, under the same per-install kill switch and rate limit.

The auth server uses the relay whenever it has no certificate binding of its own. Saving a certificate tests it, a Test connection button shows where a call stopped, and BankID is offered to apps only once a test has passed — so a half-configured install does not advertise a method that cannot work. The WebAssembly module is built in a digest-pinned container, checked in, and a CI job rebuilds it and fails on a single byte of drift.

Billing shows what you have used ​

The Billing page shows a team's real entitlements, and beside them its metered usage — with no prices, which is the standing decision for this platform: meter, don't bill. Owners and admins see sampled scope database bytes, estimated daily router requests, and recorded model calls with provider-reported tokens.

The care is in how each figure describes itself. Every number names its coverage, whether it is an estimate, how fresh it is, how long it is retained, and whether it is a partial lower bound. Empty, unavailable, truncated, loading, read-failed and "you are not an owner" stay six distinct states, and absent data is never shown as zero: a model call with no provider-reported usage adds to the call count and never adds zero tokens, and when none of them report, the page says "Tokens not reported" rather than nothing. An exact figure is shown only when every signal says it is exact; anything else is a labelled lower bound.

The read is bounded — indexed paths, narrow projections, row caps per query, a five-second budget that stops starting new reads — and no price, margin, person or scope field from the staff records can reach the page.

Ask reads everything you can read ​

Ask had three hand-written tools. It now has about 35: every declared GET route of the dashboard becomes a tool, called through the route's own handler, as you, with the route's own input schema. Because each handler checks its own permission, the assistant has exactly your access — no more and no less — and a read the dashboard adds later becomes a tool automatically. Apps, activity, hostnames, members and invites, audit logs, domains, observability and its patterns, deployments and previews, findings and suppress rules are all reachable, plus a finding's redacted evidence and an app's process map. Published application concepts are queryable too.

It is read-only by construction — only GET routes are exposed, and a test pins the offered tool list to them, so letting a write into the filter fails that test. Free text is redacted and bounded before it reaches the model: keys, tokens, URL credentials, and any email addresses or phone numbers inside text. A field that is exactly one address — a member, an inviter, an actor — is kept, because that is the team's own roster. Long lists are halved until they fit the protocol's bound and marked truncated, and the model is told to say when a list may be longer. A refused permission answers { refused } and any other 4xx answers { error }, so the model can correct itself instead of the turn failing.

Six changes to notice ​

  1. substrat push submits source; the platform builds it. The deploy endpoint accepts source JSON only. Migration: update @substrat-run/cli. Existing builder studio projects have no migration path.
  2. push requires your project's own wrangler, and Node 22+. A project without wrangler is refused with the command to add it, where npx used to download one silently. Migration: add wrangler as a dev dependency — the scaffold now declares it, with @cloudflare/workers-types 5. Run substrat doctor.
  3. A vertical declares only entitlement keys inside its own namespace. Your bare slug, the nine published engine keys, and — if you are a tenant-provisioner manager — plan SKUs that are not another registered vertical's slug. The platform-granted keys (dashboard, builder) are declarable by nobody. A push declaring anything else is refused with a 422 before it uploads. Migration: none if you gate on your own slug. Published versions keep loading; only what an install or grant derives from a declaration narrows. npm create substrat now gates the scaffold on the project name instead of a fixed bikeshop.
  4. A generated client answers a non-JSON failure with ApiError. An HTML error page from a proxy used to throw a SyntaxError. Migration: none, but a catch that matched on SyntaxError should match ApiError's status instead.
  5. A sibling scope's owner is signed in at provision. provision-sibling carries parentScopeId and binds the new scope's owner seat to the login the parent binds to that owner, instead of opening a 15-minute window in which whichever login arrived first became the owner. Migration: pass b.parentScopeId from your onProvision hook. Without a bound login the seat waits for a claim link, and no first sign-in can take it.
  6. A store driver's registration is { driver, isolationBasis }.storeDriverRelease and its type are gone from @substrat-run/contracts, and a registration still carrying a release pin is refused when parsed. Migration: none outside the platform — the registry is empty, and no vertical read these.

For hosted operators ​

  • A store-driver release now runs on a person's approval, not on a pin in this repository's source. Staff approve a release for a driver by its uploaded bytes; the approval can be revoked, and the driver's registration must still carry an isolation basis that admits it. Every reader moved in one change, so no control-plane version reads both pins and approvals, and a rollback below the switch fails closed. Each request reads the approvals once, under the hold it already took, and a failed read refuses with 503 rather than counting as approved or being cached. A release being left is judged by its recorded facts, which are fixed at first approval, so a revoked release can still be rolled off. The approve route itself refuses an approval whose source references fall outside the basis, because readers alone would let such a row hold the slot a corrected approval needs. substrat store-driver approve | revoke | status is the staff command line, and the upload line points at the approval. One hazard for the runbook: a directory outage now also stops pushes of store-declaring verticals.
  • A staff upload of a source archive creates an immutable review record. Phase 0 of the hosted review runner: deterministic archive paths, a refusal for an archive with no source files, intake held behind a single approved bucket, per-actor upload bounds, and archives compared against committed blobs.
  • Promote is stricter in three ways. The unbound permission acknowledgement is retired — a console promote now needs a review bound to it, and refuses when the review cannot load. An auto-admitted version is refused as the production channel of a listed vertical. And a control-plane-full restore lands with the directory's permission state as it stands.
  • More admin writes commit with their audit row. The remaining HostAdmin directory writes, the hostname and entitlement writes, and scope-node permission writes — which now record an intent row before the scope change and an outcome row after it, so a change that failed halfway is legible rather than absent.
  • Platform intents are bounded to the manager's own tenants.provision-tenant and set-entitlements act only there. Wire signing gained the nonce store for calls pinned to a scope. A proven relay caller may act for a sibling scope its own install serves, and no further.
  • Two dashboard doors tightened: restoring an app from a file needs a team owner or admin, and rewinding an app is gated on the provisioning permission.
  • Connector sweeps say what became of them. A failed row names the outcome in staff's own words, Planima polls on a provider cadence rather than every pass, and a Fortnox binding declares whether it lands ledger or supplier-invoice data — the ledger sweep reports a supplier-invoice binding as unsupported instead of syncing it.
  • Smaller operational fixes: setTenantStatus refuses a tenant already reaped; the pre-upload serving read is held inside its compare-and-set; a build service that drops the connection answers 502 with a plain sentence; a publish retries once on a transparency-log conflict; a model setting is picked from a generated catalog of priced models, with every billed tier shown; a declared env setting can opt in to carrying into a preview, and preview scope settings are cleared through the delete hook; a finding's code links to the requests behind it; and the sampled-field zero tail is surfaced rather than implied.

Also landed ​

  • The auth server's console moved onto the dashboard's shell, in the shape a mainstream identity console has. BankID's page explains itself better: what BankID answered to a connection test, that the test-certificate hint is for the test environment only, and plainly when the key does not match the certificate. BankID appears among sign-in providers. A failed provider callback is explained in the sign-in log. The GitHub email resend and SMS send cooldowns hold for a minute from the send rather than to the next calendar minute; GitHub fetches no longer use redirect error, and the email check never holds the redirect. An invite's email address is verified after a GitHub sign-in.
  • Microsoft 365 mail is verified as data, with a send test from the door, the picker fed the real sender list rather than a truncated display field.
  • Scrive discards the draft when a dispatch fails after the document was created, so a half-sent document is not left behind.
  • The assistant engine takes spreadsheet attachments in a conversation, with inconsistent spreadsheet archives and XML refused rather than parsed.
  • The builder studio is steadier. A waiting build no longer holds the submitted snapshot in memory, and neither does a running source build; builds queue per vertical instead of being refused; a snapshot over 32 MiB is written to the sandbox in parts; a turn reopens a project whose branch was never pushed; the model gate's tsc runs from the hosted container's toolchain and compiles under the project's own tsconfig once one exists; model artifacts are validated on every gate run; a model-emit result the model cannot fix no longer reddens a turn or asks for repair; and a source build's error is logged so its cause is readable.
  • Dashboard polish: a vertical's Bound scopes fold away unless there is something to do; observability handlers read their arguments from the parsed input; Ask reads tighter (published outputs, usable cursors, honest cuts); and the portal's inert controls and fixture panels are gone, with the remaining gaps against the UI brief closed and long team slugs kept readable.
  • Smaller CLI and scaffold fixes: trace prune races are tolerated during writes, an HTML error page reads as its title and code, the scaffold installs on pnpm 10, 11 and 12, and the corrected scaffolder shipped as 0.13.1.
  • The kernel's scope host was split by concern with no surface change, and its retained move-out helpers are recorded.
  • Tests and tooling: vitest timeouts are centralized and the pure dashboard tests run in Node; the workerd contract file and ticket0's business-time sweep are split across shards and the shard weights refreshed from recent main runs; the cases that ran near their timeout are fixed; shared rewind-hold, event-version and handler-binding suites moved into the test kit with no case lost; fail-closed route cases are table-driven; cap and page tests plant their rows instead of filling them through RPCs; the rewind hold's snapshot age is a host option so those tests settle in 450 ms; vertical-egress boots workerd in beforeAll; the data-loss replay's timing is deterministic; migration-desk and health-index fixtures got cheaper; a preview repair fixture does one insert; dashboard-web declares the workspace packages its type imports reach; and the lockfile reader skips YAML block scalars so the audit can run on bump PRs. The repo also wrote down its rules for lean, fast tests.
  • CI: the deploy and preview jobs that submit a build share one queue, the ticket0 deploy workflow runs when the CLI it builds changes, and it waits for the deployed source protocol before releasing to production.
  • Refusals: the dashboard's connect-probe and export-break refusals and the dev issuer's /dev/token refusal are problem documents now, and the error model's stale open items — the control plane's request id and the dev issuer — are closed.
  • Docs: ten pages re-read against the code and corrected, getting-started re-read against the CLI and scaffold, the rule that a PR carries a changeset for each published package it changes, the dashboard team-in-path status, D-65 accepted, an RFC for connectors that live outside this repo, a proposal for online copy catch-up, a cross-store audit pattern, the dashboard's control-plane retirement, process-map target and latency decisions, the ticket0 scope and extension-slot decisions, allowance and booking turnaround use cases, a reality check of which portal screens are real, roadmap entries for the parked ideas and experiments, the tracking issues whose work is done closed, and the changeset steps dropped from the PR preview guidance.
  • Dependencies: the npm minor-and-patch group across 21 updates, the workers-types catalog aligned with the scaffold, a stale vite lockfile reference repaired, and release bookkeeping.
  • Upkeep: last week's changelog entry.

Released ​

PackageSpan
@substrat-run/contracts0.163.0 → 0.174.0
@substrat-run/kernel0.163.0 → 0.174.0
@substrat-run/adapter-sqlite0.163.0 → 0.174.0
@substrat-run/adapter-cloudflare0.163.0 → 0.174.0
@substrat-run/vertical-host0.163.0 → 0.174.0
@substrat-run/control-plane-api0.163.0 → 0.174.0
@substrat-run/contract-tests0.163.0 → 0.174.0
@substrat-run/cli0.49.7 → 0.55.2
@substrat-run/control-plane-client0.3.14 → 0.5.2
@substrat-run/vertical-auth0.28.3 → 0.29.2
@substrat-run/model-emit0.10.19 → 0.11.4
@substrat-run/model-view0.6.10 → 0.6.22
@substrat-run/model-providers0.5.53 → 0.5.64
@substrat-run/attachment-extractors0.2.24 → 0.2.35
@substrat-run/boundary-lint0.8.1 → 0.8.2
@substrat-run/dev-issuer0.2.45 → 0.2.56
@substrat-run/engine-workorder0.12.47 → 0.12.58
@substrat-run/engine-protocol0.13.48 → 0.13.59
@substrat-run/engine-invoicing0.11.47 → 0.11.58
@substrat-run/engine-booking0.8.47 → 0.8.58
@substrat-run/engine-invites0.9.40 → 0.9.51
@substrat-run/engine-absence0.6.47 → 0.6.58
@substrat-run/engine-metering0.6.47 → 0.6.58
@substrat-run/engine-notifications0.3.8 → 0.3.19
@substrat-run/connector-scrive0.14.69 → 0.14.80
@substrat-run/connector-fortnox0.4.65 → 0.5.7
@substrat-run/connector-planima0.2.60 → 0.2.71
create-substrat0.12.13 → 0.13.13

cli's six minors are, in order: Windows plus local dev traces plus vertical-defined connectors; a published versioned concept description; platform-built releases from source; the on-request connection landing and a leaner source snapshot; the request id on a failed call; and substrat entitlements. control-plane-client's two are the request id and the entitlement commands. model-emit's minor is responseHeaders, repeated query fields and ApiError for a non-JSON failure. vertical-auth's is the sibling scope's owner seat. connector-fortnox's is the binding kind and supplier-invoice ingest. create-substrat's is the Windows work and the entitlement namespace. In 0.x semver a minor is where a breaking change goes, so the fixed group's 0.174.0 carries every "change to notice" above.