dsh-plugin-guide 0.3.41 → 0.4.0

package/references/official-docs/docs/subsystems/ssh.zh.md

@@ -1,146 +0,0 @@
-# SSH
-
-[English](ssh.md) | 中文
-
-[SSH 提供方家族](../../packages/ssh/README.zh.md) 通过部署方持有的 OpenSSH 连接提供一个远端文件系统／进程环境。Harness、模型传输及 Session 存储留在主机。该家族实现既有文件系统、子进程及沙箱 API，不引入 SSH 专用模型工具。
-
-## 执行坐标
-
-文件系统身份、可执行文件查找、进程 cwd、沙箱工作区根目录及语言服务器文件 URL 都指向 SSH 主机。提供方在文件实际存在的位置规范化路径，保留文件系统对 `symlink/..` 的解释。策略解析器保留执行环境中的绝对路径写法，不尝试在 Harness 主机上解析远端路径。
-
-`processPath()` 提供配套子进程提供方可用的路径。SSH 的 `processPathFromHostPath()` 仍不可用；安装远端产物不意味着任意主机路径可移植。因此 [`NodePtcRuntime`](../../packages/ptc-runtime/ptc-runtime-node/README.zh.md) 使用验证后的远端启动配置：已安装的脚本引导程序，或 [helper 可执行文件内嵌的 worker](../../packages/ssh/ssh-helper-runtime/README.zh.md)。
-
-## 传输与信任
-
-管理 RPC 使用辅助进程的 SSH exec 流。普通 stdin、stdout、stderr、终端输出及可选 fd 7 控制流使用分别认证的转发 Unix 套接字。每条转发流拥有独立 SSH 通道窗口；暂停的程序输出不与控制或管理消息共用窗口。所有通道仍共享连接带宽及传输失败。
-
-部署认证、已安装产物验证及逐流 TLS 认证属于 [`dsh-ssh`](../../packages/ssh/ssh/README.zh.md)。辅助进程使用远端机器上的可信本地提供方执行文件系统与进程请求。SSH 是传输方式；文件效果限制由所选远端沙箱提供方执行。
-
-## 进程生命周期与取消
-
-进程先预留，再连接流，且启动最多接受一次。`done` 报告直接结果，`waitForExit` 观察远端托管进程范围。终端操作保留共享异步 API。准备阶段取消、已启动进程终止及提供方释放都通过辅助进程释放各自资源。
-
-管理截止时限约束单次 RPC 观察，不替代 Bash 或 PTC 运行时消费方选择的执行截止时限。远端等待可以持续挂起，同时其他请求继续推进。SSH 丢失会使待处理操作失效；辅助进程 EOF、信号及租期到期会启动远端清理。客户端如实报告未确认结果，绝不通过重连重放可能已执行的操作。
-
-## 组合范围
-
-headless 通过已挂载的文件系统提供方记录和检查 Session cwd。因此远端 FS、Bash、终端、LSP 及 PTC 消费方可以共享这些坐标。假定可访问主机文件系统的 Web 工作区视图需要单独集成；仅替换提供方并不会使这些视图支持远端。
-
-替代方案与验证责任见[决策记录](../../.agents/notes/implemented/architecture/2026-09-11-posix-ssh-runtime.zh.md)。
-
-## 连接 API
-
-```ts type-equiv
-/** Installed helper invocation; script deployments may also install a PTC bootstrap. */
-type HelperLaunch = {
-  /** Run the installed script with a separately installed Node executable. */
-  kind: 'node-script'
-  /** Absolute remote Node executable. */
-  node: string
-  /** Absolute remote PTC bootstrap; requires bootstrapHash. */
-  bootstrapPath?: string
-  /** Lowercase SHA-256 of bootstrapPath; requires that path. */
-  bootstrapHash?: string
-} | {
-  /** Run the helper executable with its embedded Node and PTC worker. */
-  kind: 'executable'
-}
-```
-
-```ts type-equiv
-/** Deployment-owned SSH identity and installed helper; no model argument selects these values. */
-interface Config {
-  /** OpenSSH host alias, including its existing user, key and known-host configuration. */
-  host: string
-  /** Explicit script or self-contained executable invocation. */
-  launch: HelperLaunch
-  /** Absolute path to the installed, bundled helper entry. */
-  helper: string
-  /** SHA-256 of that bundled helper; mismatches refuse the connection. */
-  helperHash: string
-  /** Absolute remote default workspace. */
-  workspace: string
-  /** Connection and administrative-request deadline, at most 2,147,483,647 milliseconds. */
-  requestTimeoutMs?: number
-  /** Maximum JSON payload bytes per helper request or response. */
-  maxFrameBytes?: number
-  /** Maximum ordinary requests; heartbeat and bounded resource cleanup have reserved capacity. */
-  maxPending?: number
-  /** Remote helper lease; loss of heartbeats starts remote managed cleanup. */
-  leaseMs?: number
-}
-```
-
-```ts public-api
-/** One non-reconnecting SSH session; loss invalidates all active operations. */
-declare class SshConnection extends Service {
-  static Config: schema<Config>;
-  /** Verified remote helper coordinates; callers must await this before launch. */
-  readonly ready: Promise<Hello>;
-  constructor(ctx: Context, config: Config);
-  /** Hold plugin readiness until the remote identity and helper digest are verified. */
-  async [Service.init](): Promise<void>;
-  /** Verified remote PTC launch configuration; script deployments require a verified bootstrap. */
-  get ptcLaunch(): { kind: 'embedded'; executable: string } | { kind: 'node-script'; executable: string; bootstrapPath: string };
-  /**
-     * Send a helper operation; cancellation never replays an ambiguous mutation.
-     * @param method - the private helper operation.
-     * @param params - JSON request fields validated by the helper.
-     * @param result - response validation before returning provider-visible data.
-     * @param signal - cancellation, which does not undo completed remote effects.
-     * @param wait - allow a process observation to outlast the administrative deadline.
-     * @returns the validated remote result.
-     */
-  async request<T>(method: string, params: unknown, result: z.ZodType<T>, signal?: AbortSignal, wait: boolean = false): Promise<T>;
-  /**
-     * Forward one authenticated stream through an independent SSH channel.
-     * @param endpoint - private coordinates issued by this connection's helper.
-     * @param signal - cancellation of allocation and the resulting socket.
-     * @returns a paused socket; attach a consumer before resuming it.
-     */
-  async connectStream(endpoint: SshStreamEndpoint, signal?: AbortSignal): Promise<Socket>;
-  /** Tear down the helper's remote managed ranges before releasing the SSH master when reachable. */
-  dispose(): Promise<void>;
-}
-```
-
-<!-- BEGIN GENERATED cordis-surface (gen-cordis-catalog.ts) — do not edit between markers -->
-
-<a id="cordis-surface"></a>
-
-## Cordis API
-
-Generated from source by `scripts/gen-cordis-catalog.ts` (verified fresh by `pnpm run verify-cordis-catalog` in doc-sync; regenerate with `pnpm run gen-cordis-catalog`) — the language sides differ only in locale-specific paired document paths. Signature blocks use a `ts cordis-catalog` fence and keep the original source JSDoc; dispatch modes are defined in the [primer](../cordis-primer.zh.md#dispatch-modes), and the framework-inherited `ctx` API lives in [cordis-api/inherited.md](../cordis-api/inherited.md).
-
-<a id="ctxssh--sshconnection"></a>
-
-### `ctx.ssh` — `SshConnection`
-
-One non-reconnecting SSH session; loss invalidates all active operations.
-
-```ts cordis-catalog
-/**
- * Send a helper operation; cancellation never replays an ambiguous mutation.
- * @param method - the private helper operation.
- * @param params - JSON request fields validated by the helper.
- * @param result - response validation before returning provider-visible data.
- * @param signal - cancellation, which does not undo completed remote effects.
- * @param wait - allow a process observation to outlast the administrative deadline.
- * @returns the validated remote result.
- */
-async request<T>(method: string, params: unknown, result: z.ZodType<T>, signal?: AbortSignal, wait: boolean = false): Promise<T>
-
-/**
- * Forward one authenticated stream through an independent SSH channel.
- * @param endpoint - private coordinates issued by this connection's helper.
- * @param signal - cancellation of allocation and the resulting socket.
- * @returns a paused socket; attach a consumer before resuming it.
- */
-async connectStream(endpoint: SshStreamEndpoint, signal?: AbortSignal): Promise<Socket>
-
-/** Tear down the helper's remote managed ranges before releasing the SSH master when reachable. */
-dispose(): Promise<void>
-```
-
-Source: [`packages/ssh/ssh/src/index.ts`](../../packages/ssh/ssh/src/index.ts)
-<!-- END GENERATED cordis-surface -->

package/references/official-docs/docs/subsystems/storage.i18n.yaml

@@ -1,25 +0,0 @@
-# Bilingual-pair consistency record for storage.md (docs/i18n/README.md): per heading
-# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
-# After editing either side, bring the other along and re-record with:
-#   pnpm run verify-translation-pairing --write docs/subsystems/storage.md
-/storage:
-  en: ca316310c10348c3
-  zh: 066885a031d283cc
-/storage/the-hub-ctx-storage:
-  en: b11e06e7c0e0fd13
-  zh: 4585f26ff416cb41
-/storage/the-backend-contract:
-  en: 2316787902c6a94e
-  zh: e3bda06e1c33acac
-/storage/declaring-a-domain:
-  en: 775cce941500f01f
-  zh: 78acbc67f48574cb
-/storage/the-open-domain:
-  en: 2468b5df66c49b51
-  zh: 1587f460e9769db2
-/storage/the-domain-facility-ctx-storagedomain:
-  en: deed74fcd4506ef4
-  zh: 8e3e6e5d2dc2e989
-/storage/the-change-event-domain-changed:
-  en: 2488ccd675624561
-  zh: 6db32b6c7715e428

package/references/official-docs/docs/subsystems/storage.md

@@ -1,259 +0,0 @@
-# Storage
-
-English | [中文](storage.zh.md)
-
-The storage subsystem persists everything that is not a session event log (session logs have their own seam — [persistence.md](persistence.md)). It is one optional capability, not part of the agent-loop spine, split as a [capability seam](../../.agents/notes/implemented/architecture/2026-06-13-capability-seams.md): the hub and Service Definition ([dsh-storage](../../packages/storage/storage), `ctx.storage`), the Service Providers ([dsh-storage-json](../../packages/storage/storage-json), registered as `json`, and [dsh-storage-sqlite](../../packages/storage/storage-sqlite), registered as `sqlite`), and the Consumer data form ([dsh-storage-domain](../../packages/storage/storage-domain), `ctx.storageDomain`, also reachable as `ctx.storage.domain`) — the backend contract's only Consumer and the typed API everything else uses. The hub performs no IO itself: backends own media, data forms own semantics, and product packages never touch backends directly. Design record: [domain KV storage Agent Note](../../.agents/notes/proposed/architecture/2026-07-24-domain-kv-storage-and-workspace.md).
-
-Source: [`packages/storage/storage/src/backend.ts`](../../packages/storage/storage/src/backend.ts) · [`packages/storage/storage-domain/src/spec.ts`](../../packages/storage/storage-domain/src/spec.ts) · [`packages/storage/storage-domain/src/events.ts`](../../packages/storage/storage-domain/src/events.ts)
-
-## The hub: `ctx.storage`
-
-`Storage` ([signatures](#ctxstorage--storage)) is a meeting point, not a store. `ctx.storage.backend` is a name → backend table: multiple backends stay mounted side by side, and which backend serves which consumer is that consumer's configuration (the domain layer's route table), never a hub-global choice. `register(name, backend)` returns the disposer; duplicate names and unknown lookups throw `StorageError`. Disposal only unregisters the name — the owning plugin closes the backend after unregistering. Each backend plugin also publishes a lifecycle-only service key (`storageBackendServiceKey(name)`), which form providers inject so their activation cannot race backend registration.
-
-Data forms mount on the hub under a merge-extensible key map:
-
-```ts type-equiv
-/**
- * Data forms mountable on the hub, keyed by form name. Form owners extend
- * this map via declaration merging (the domain layer merges
- * `domain: DomainFacility`) and mount the facility in their `apply`.
- */
-interface StorageForms {}
-```
-
-`mount(form, facility)` is an effect whose disposer unmounts; a second mount of the same key throws `duplicate-mount`. `form(form)` resolves a mounted facility and throws `form-not-mounted` until the owning plugin loads — assemblies order plugins accordingly rather than silently deferring. The domain layer merges `domain: DomainFacility`, so `ctx.storage.domain` and `ctx.storageDomain` are the same object.
-
-## The backend contract
-
-```ts type-equiv
-/**
- * One registered backend. A backend owns exactly one medium and shares its
- * lifecycle across all facets; facets are optional members — a backend that
- * cannot serve a data kind simply omits it, and resolution fails loud instead.
- */
-interface StorageBackend {
-  /** Key-value operations; absent when this backend cannot serve them. */
-  readonly kv?: KvFacet
-
-  /**
-   * Drain in-flight writes across all open units and release the medium.
-   * Idempotent; concurrent and repeated calls resolve once teardown finishes.
-   * @returns resolution after the medium is released.
-   */
-  close(): Promise<void>
-}
-```
-
-A backend owns one medium (a file-tree root, a database file) and exposes optional operation groups; `kv` is the only shipped group. `KvFacet.open(descriptor)` opens one named unit — `KvUnitDescriptor` carries the name, current format version, optional compatible record versions, table names, and whether a global singleton slot exists — and returns a `KvUnit` with `loadAll`, `putRecord`, `deleteRecord`, `setGlobal`, and `close`. Unit and table names must match `UNIT_NAME_RE` (safe as a file name and as a SQL identifier segment); record keys are arbitrary strings that never reach file paths. A unit does not serialize concurrent writes — ordering belongs to the caller — but each single call is atomic on the medium and durable once resolved. A `single` medium stamped with a different version rejects `version-mismatch`; a `per-record` document stamped outside the accepted set reads as absent. A medium that cannot be parsed as the unit rejects `malformed-medium`. [`backend.ts`](../../packages/storage/storage/src/backend.ts) is the normative clause-by-clause contract, and the shared conformance suite in [`tests/contract.ts`](../../packages/storage/storage/tests/contract.ts) checks every clause against each backend. The [json backend](../../packages/storage/storage-json/README.md) republishes one whole human-readable file per unit atomically; the [sqlite backend](../../packages/storage/storage-sqlite/README.md) stores one document per row in one database for frequently updated data.
-
-## Declaring a domain
-
-A domain is declared once by its owning package as a spec object — the single source of the domain's identity, layout, and record schemas (zod, so `z.infer` keeps consumer types un-duplicated):
-
-```ts type-equiv
-/** Static declaration of one domain: identity, version, and record layout. */
-interface DomainSpec {
-  /** Domain name; must match `UNIT_NAME_RE` (doubles as the backend unit name). */
-  readonly name: string
-  /** Current domain format version; reads enforce it according to the selected layout. */
-  readonly version: number
-  /**
-   * Medium layout for the backend unit: `single` (the default) stores the
-   * whole unit as one document; `per-record` stores each record as its own
-   * document, for units whose records are large, sparse, or individually
-   * disposable — the projection cache — and scopes version checks per record
-   * (an unaccepted record document is discarded, never migrated).
-   */
-  readonly layout?: 'single' | 'per-record'
-  /**
-   * Older domain versions whose stored records the current record schemas
-   * also accept (the declaring owner vouches for that, typically by
-   * declaring the fields older records lack as optional). `per-record` backends
-   * read documents stamped with a listed version instead of discarding them,
-   * and accept a legacy whole-unit file so stamped for the one-time
-   * bootstrap; writes always stamp {@link version}.
-   */
-  readonly compatibleVersions?: readonly number[]
-  /**
-   * What `open` does with a stored table record that fails its zod schema.
-   * Absent (the default), the whole open rejects with `invalid-record` —
-   * right for authoritative data. `'backup-and-skip'` is for domains whose
-   * records are disposable derived data: the backend moves the record's
-   * document aside (`KvUnit.backupRecord`), the failure is logged with
-   * its cause, and the open continues with the record absent. A backend
-   * without `backupRecord` (no per-record document to move) falls back
-   * to the rejecting default. The global slot always rejects.
-   */
-  readonly invalidRecords?: 'backup-and-skip'
-  /** Optional global singleton slot. */
-  readonly global?: DomainGlobalSpec<unknown>
-  /** Table declarations keyed by table name; each name must match `UNIT_NAME_RE`. */
-  readonly tables: Record<string, DomainTableSpec>
-}
-```
-
-`defineDomain(spec)` pins the spec's literal types and fails loud at the owner's module load, before any medium is touched: a domain or table name outside `UNIT_NAME_RE`, a version that is not a non-negative integer, or a global schema that accepts `null` all throw (`null` is the medium's "never written" sentinel, so a stored nullable global could not round-trip). `domainTable<K, V>(schema)` declares one table with a phantom compile-time key type (typically a [branded id](core.md#branded-ids)); `descriptorOf(spec)` projects the backend-facing unit descriptor.
-
-## The open domain
-
-```ts type-equiv
-/** One open domain, typed by its spec. */
-interface Domain<S extends DomainSpec> {
-  /** Domain name from the spec. */
-  readonly name: string
-  /** Global singleton handle; a spec without `global` has no usable handle (`never`). */
-  readonly global: DomainGlobalHandleOf<S>
-  /**
-   * Resolve one declared table handle. Handles are stable — repeated calls
-   * return the same instance.
-   * @param name - Declared table name.
-   * @returns the typed table handle.
-   */
-  table<N extends keyof S['tables'] & string>(name: N): KvTable<TableKeyOf<S, N>, TableValueOf<S, N>>
-
-  /**
-   * Close this domain: reject new writes immediately, drain already-queued
-   * writes (their events still emit), release the backend unit, then free
-   * the domain name for a later open. Idempotent — repeated calls share one
-   * teardown. The consumer owns this call (typically as its own `ctx.effect`
-   * disposer); the facility closes any domain left open when it unmounts.
-   * @returns resolution after the unit is released.
-   */
-  close(): Promise<void>
-}
-```
-
-Reads are synchronous from authoritative in-memory state: `KvTable` exposes `get`/`entries`/`keys`/`size` (snapshot iterators that stay stable while queued writes land), and the global handle's `get()` serves the spec's `initial` until the first `set` materializes the slot on the medium. Every write — `put`, `delete`, `update`, `global.set` — queues on one per-domain chain and reaches backend durability first, then mutates memory, then emits `domain/changed`; a rejected backend write leaves memory untouched, so reads never diverge from the medium. `update(key, fn)` is an atomic read-modify-write at its chain slot (a missing key rejects `missing-key`); `delete` of an absent key resolves `false` with no write and no event. Returned records are the stored objects themselves, not copies — replace via `put`/`update`, never mutate in place.
-
-## The domain facility: `ctx.storageDomain`
-
-`DomainFacility` ([signatures](#ctxstoragedomain--domainfacility)) opens declared domains over routed backends. Routing is the domain plugin's configuration, never the hub's: `backend` names the required default route and `routes` overrides it per domain name. `open(spec)` runs a strict sequence, each step failing the whole call: it rejects a name already open or still closing (`already-open`), resolves the route (`backend-not-found`), requires the backend's `kv` facet (`facet-unsupported`), opens the unit (backend `version-mismatch`/`malformed-medium` pass through), and validates every stored record and global against the spec's zod schemas (`invalid-record` with the offending table and key). The caller owns the returned handle and releases it with `Domain.close()`; domains still open when the plugin unmounts are closed by the facility, and a closed domain's name frees for reopening only after teardown fully completes. `get(name)` is an untyped diagnostic lookup onto the package-private `DomainImpl` runtime behind every typed handle; `closeAll()` is the unmount path.
-
-## The change event: `domain/changed`
-
-Every durable write emits one event strictly after the backend acknowledged durability, in the domain's write-chain order ([event entry](#domainchanged--emit)):
-
-```ts type-equiv
-/** Shared location fields of one durable domain change. */
-interface DomainChangedBase {
-  /** Owning domain name. */
-  readonly domain: string
-  /** Table name; `''` for a global-singleton write. */
-  readonly table: string
-  /** Record key; `''` for a global-singleton write. */
-  readonly key: string
-}
-```
-
-```ts type-equiv
-/** One durable domain change; a closed union — switch on `operation`. */
-type DomainChanged = DomainChangedPut | DomainChangedDeleted
-```
-
-`put` (inserts, overwrites, and global writes) carries the new snapshot in `value` — never the old value; a diffing consumer keeps its own previous snapshot. `deleted` is a tombstone with no value. The event is a notification, not a transaction participant: the commit point has passed at emission, so a synchronously throwing listener is contained with a logged warning rather than rejecting the already-durable write, and emitted values equal the in-memory state at emission. The event is in-process only; cross-process change push is a recorded limitation ([package README](../../packages/storage/storage-domain/README.md)).
-
-<!-- BEGIN GENERATED cordis-surface (gen-cordis-catalog.ts) — do not edit between markers -->
-
-<a id="cordis-surface"></a>
-
-## Cordis API
-
-Generated from source by `scripts/gen-cordis-catalog.ts` (verified fresh by `pnpm run verify-cordis-catalog` in doc-sync; regenerate with `pnpm run gen-cordis-catalog`) — the language sides differ only in locale-specific paired document paths. Signature blocks use a `ts cordis-catalog` fence and keep the original source JSDoc; dispatch modes are defined in the [primer](../cordis-primer.md#dispatch-modes), and the framework-inherited `ctx` API lives in [cordis-api/inherited.md](../cordis-api/inherited.md).
-
-<a id="ctxstorage--storage"></a>
-
-### `ctx.storage` — `Storage`
-
-The storage hub service. Backends register under `backend`; data forms mount under their `StorageForms` key and are reached as `ctx.storage.<form>`.
-
-```ts cordis-catalog
-/**
- * Mount a data-form facility on the hub. Mounting is an effect: the
- * returned disposer unmounts the form.
- * @param form - Form key declared in {@link StorageForms}.
- * @param facility - The facility instance to expose.
- * @returns the disposer that unmounts the form.
- */
-mount<K extends keyof StorageForms>(form: K, facility: StorageForms[K]): () => void
-
-/**
- * Resolve a mounted data form.
- * @param form - Form key declared in {@link StorageForms}.
- * @returns the mounted facility.
- */
-form<K extends keyof StorageForms>(form: K): StorageForms[K]
-```
-
-Source: [`packages/storage/storage/src/index.ts`](../../packages/storage/storage/src/index.ts)
-
-<a id="ctxstoragedomain--domainfacility"></a>
-
-### `ctx.storageDomain` — `DomainFacility`
-
-The mounted domain facility. Opens declared domains over routed backends; one facility instance owns the open-domain table and enforces single-open per domain name.
-
-```ts cordis-catalog
-/**
- * Open one declared domain. Steps, each failing the whole call: reject a
- * name that is already open (`already-open`); resolve the backend route
- * (`backend-not-found` passes through from the hub); require its `kv` facet
- * (`facet-unsupported`); open the unit projected from the spec (backend
- * `version-mismatch`/`malformed-medium` pass through); load and validate
- * every stored record against the spec's zod schemas (`invalid-record`
- * with the offending table and key — unless the spec declares
- * `invalidRecords: 'backup-and-skip'` and the unit can move documents aside, in
- * which case the failing record is backed up, logged, and skipped);
- * construct the domain.
- *
- * Lifecycle: the CALLER owns the returned handle and closes it via
- * `Domain.close()` (typically as its own `ctx.effect` disposer) — the
- * facility does not tie the domain to any consumer fiber. Domains still
- * open when the facility unmounts are closed by the plugin disposer.
- * @param spec - The domain declaration, typically from `defineDomain`.
- * @returns the opened domain handle, typed by the spec.
- */
-async open<S extends DomainSpec>(spec: S): Promise<Domain<S>>
-
-/**
- * Look up an open domain by name, untyped. Diagnostic surface; typed
- * consumers hold the handle returned by {@link open}.
- * @param name - Domain name.
- * @returns the open domain runtime, or `undefined` when not open.
- */
-get(name: string): DomainImpl | undefined
-
-/**
- * Close every domain still open on this facility. The unmount path for
- * consumers that never called `Domain.close()` themselves; closing is
- * idempotent, so double-closing an already-closed domain is harmless.
- * @returns resolution after every unit is released.
- */
-async closeAll(): Promise<void>
-```
-
-Source: [`packages/storage/storage-domain/src/index.ts`](../../packages/storage/storage-domain/src/index.ts)
-
-<a id="domain-events"></a>
-
-### `domain/*` events
-
-<a id="domainchanged--emit"></a>
-
-#### `domain/changed` — emit
-
-A domain record or the global singleton changed, emitted once per write strictly after the backend acknowledged durability. Events of one domain arrive in its write-chain order.
-
-```ts cordis-catalog
-/**
- * A domain record or the global singleton changed, emitted once per write
- * strictly after the backend acknowledged durability. Events of one
- * domain arrive in its write-chain order.
- * @param change - domain, table (`''` for global), key (`''` for global),
- * operation discriminant, and on `put` the new snapshot.
- * @mode emit
- */
-'domain/changed'(change: DomainChanged): void
-```
-
-Source: [`packages/storage/storage-domain/src/events.ts`](../../packages/storage/storage-domain/src/events.ts)
-<!-- END GENERATED cordis-surface -->