@voltro/runtime 0.64.0 → 0.66.0

package/dist/index.d.ts

@@ -11,7 +11,7 @@ import { ConnectionCredential } from '@voltro/protocol';
 import { ConnectionInfo } from '@voltro/protocol';
 import { ConnectionInfoMiddleware } from '@voltro/protocol';
 import { ConnectionKind } from '@voltro/protocol';
-import { ConnectionState } from '@voltro/protocol';
+import { ConnectionState as ConnectionState_2 } from '@voltro/protocol';
 import { ConstraintFacts } from '@voltro/database';
 import { ConstraintKind } from '@voltro/database';
 import { ConstraintViolation } from '@voltro/protocol';
@@ -57,6 +57,8 @@ import { listRetentions } from '@voltro/database';
 import { Metric } from 'effect';
 import { MetricBoundaries } from 'effect';
 import { MetricReader } from '@opentelemetry/sdk-metrics';
+import { MutationIdempotencyScope } from '@voltro/protocol';
+import { NoRowFound } from '@voltro/protocol';
 import { PendingApproval } from '@voltro/protocol';
 import { PluginHttpRoute } from '@voltro/protocol';
 import { PluginRefOrphanPolicy } from '@voltro/database';
@@ -71,6 +73,7 @@ import { RetentionSource } from '@voltro/database';
 import { RetentionSpec } from '@voltro/database';
 import { retentionTtlMsFromEnv } from '@voltro/database';
 import { Row } from '@voltro/database';
+import { RowKey } from '@voltro/database';
 import { RowPatch } from '@voltro/protocol';
 import { Rpc } from '@effect/rpc';
 import { RpcGroup } from '@effect/rpc';
@@ -102,6 +105,7 @@ import { TenantRowNotFound } from '@voltro/protocol';
 import { TenantScopeViolation } from '@voltro/protocol';
 import { Tracer } from 'effect';
 import { Unauthenticated } from '@voltro/protocol';
+import { UpsertOptions } from '@voltro/database';
 import { ValidationError } from '@voltro/protocol';
 import { ValidationErrors } from '@voltro/protocol';
 import { VersionConflict } from '@voltro/database';
@@ -1025,6 +1029,10 @@ export declare interface AppContext {
      */
     readonly storeForTenant: (tenantId: string) => FluentStore;
     readonly request: RuntimeContext;
+    /** Ephemeral server-owned state of this RPC connection. Absent for internal
+     * calls; mutation writes commit with the operation and disconnect clears it.
+     * It grants no authority until the app explicitly records its own decision. */
+    readonly connectionState?: ConnectionState;
     /** Typed authorization slice — the caller's effective scopes. Use
      *  `ctx.access.has(scope)` / `yield* ctx.access.require(scope)` instead of
      *  reaching into `ctx.request.subject.scopes`. Always present. */
@@ -1649,7 +1657,7 @@ export declare const bindMutation: <Input, Output, E = never>(execute: (input: I
  * schema keeps exactly the old behaviour rather than collapsing errors it
  * cannot classify.
  */
-declaredError?: Schema.Schema.All) => Effect.Effect<Output, E, SubjectService | ConnectionInfo>;
+declaredError?: Schema.Schema.All, idempotencyScope?: MutationIdempotencyScope) => Effect.Effect<Output, E, SubjectService | ConnectionInfo>;
 
 /**
  * Bind a non-reactive server→client stream (A3). The executor builds a
@@ -2295,7 +2303,7 @@ export declare interface ConnectionsFacade {
     tryGet(connectionId: string): Promise<ResolvedConnection | null>;
     /** Every declared connection with the caller's status — the same projection
      *  `__voltro.connections.list` serves, for server-side rendering. */
-    list(): Promise<ReadonlyArray<ConnectionState>>;
+    list(): Promise<ReadonlyArray<ConnectionState_2>>;
 }
 
 export declare interface ConnectionsFacadeDeps {
@@ -2304,6 +2312,19 @@ export declare interface ConnectionsFacadeDeps {
     readonly subject: Subject;
 }
 
+/** Server-local application state for ONE RPC connection. Not authentication,
+ * a presence roster or durable storage. Mutation writes become visible only
+ * after commit; reads always see committed state, including in the writer.
+ * Values must be structured-cloneable and are copied on write and read so a
+ * mutable alias cannot bypass the transaction boundary.
+ * Disconnect clears everything and a reconnect starts empty. */
+export declare interface ConnectionState {
+    readonly get: (key: string) => unknown;
+    readonly has: (key: string) => boolean;
+    readonly set: (key: string, value: unknown) => void;
+    readonly delete: (key: string) => void;
+}
+
 /** Test-only — number of streams currently registered for a client. */
 export declare const _connectionStreamCount: (clientId: number) => number;
 
@@ -3644,7 +3665,7 @@ export declare interface EffectStoreOps {
     readonly query: <R = Row>(descriptor: QueryDescriptor<R>) => Effect.Effect<ReadonlyArray<R>, StoreError>;
     readonly insert: (table: string, row: Row) => Effect.Effect<Row, StoreError>;
     readonly insertMany: (table: string, rows: ReadonlyArray<Row>) => Effect.Effect<ReadonlyArray<Row>, StoreError>;
-    readonly patchJson: (table: string, primaryKey: string, path: string, value: unknown) => Effect.Effect<Row | null, StoreError>;
+    readonly patchJson: (table: string, primaryKey: string, path: string, value: unknown, additionalPatch?: Readonly<Record<string, unknown>>) => Effect.Effect<Row | null, StoreError>;
     readonly update: (table: string, primaryKey: string, patch: Readonly<Record<string, unknown>>) => Effect.Effect<Row | null, StoreError>;
     readonly updateMany: (table: string, patch: Readonly<Record<string, unknown>>, options: {
         readonly where: Predicate;
@@ -3653,13 +3674,31 @@ export declare interface EffectStoreOps {
     readonly deleteMany: (table: string, options: {
         readonly where: Predicate;
     }) => Effect.Effect<number, StoreError>;
-    readonly upsert: (table: string, row: Row, options: {
-        readonly conflictColumns: ReadonlyArray<string>;
-        readonly update?: ReadonlyArray<string> | ((existing: Row) => Readonly<Record<string, unknown>>);
-    }) => Effect.Effect<Row, StoreError>;
+    readonly upsert: (table: string, row: Row, options: UpsertOptions) => Effect.Effect<Row, StoreError>;
     readonly insertIgnore: (table: string, row: Row, options: {
         readonly conflictColumns: ReadonlyArray<string>;
     }) => Effect.Effect<Row, StoreError>;
+    /**
+     * The single-row reads, on the typed channel — the same three `ctx.store`
+     * offers, taking a builder or a descriptor.
+     *
+     * Their absence made two doctor rules mutually unsatisfiable: `row-not-found`
+     * says reach for `.maybeOne(builder)`, `store-effect-lift` says reach for
+     * `yield* EffectStore`, and `EffectStoreOps` had no `.maybeOne`. An app
+     * following both got `Property 'maybeOne' does not exist on type
+     * 'EffectStoreOps'`. Nothing was hard about it: the object this service
+     * closes over has always been the full `FluentStore` — only the declared type
+     * was narrower, and every call site was already casting to say so.
+     *
+     * `one` fails with `NoRowFound` on its own channel rather than collapsing
+     * into `StoreOperationFailed`, for the reason the catch boundary gives about
+     * `TenantRowNotFound`: stringifying a deliberate, catchable refusal is how it
+     * stops being one. There is no `onMissing` here — `Effect.catchTag` says the
+     * same thing and keeps the failure channel exact.
+     */
+    readonly one: <R = Row>(query: QueryLike<R>) => Effect.Effect<R, StoreError | NoRowFound>;
+    readonly maybeOne: <R = Row>(query: QueryLike<R>) => Effect.Effect<R | null, StoreError>;
+    readonly first: <R = Row>(query: QueryLike<R>) => Effect.Effect<R | null, StoreError>;
     /** Bypass soft-delete. See `MutationStore.hardDelete`. */
     readonly hardDelete: (table: string, primaryKey: string) => Effect.Effect<boolean, StoreError>;
     /** Run one Effect program atomically against the transaction-scoped store.
@@ -4804,11 +4843,11 @@ export declare interface FluentStore extends Omit<MutationStore, 'update' | 'del
     /** Fluent predicate update: `update('notes').where('id', id).set({...})`. */
     update(table: string): UpdateBuilder;
     /** Keyed update by primary key — returns the post-image. */
-    update(table: string, primaryKey: string, patch: Readonly<Record<string, unknown>>): Promise<Row_7 | null>;
+    update(table: string, primaryKey: RowKey, patch: Readonly<Record<string, unknown>>): Promise<Row_7 | null>;
     /** Fluent predicate delete: `delete('notes').where('id', id).soft()`. */
     delete(table: string): DeleteBuilder;
     /** Keyed delete by primary key. */
-    delete(table: string, primaryKey: string): Promise<boolean>;
+    delete(table: string, primaryKey: RowKey): Promise<boolean>;
     /**
      * Build an update patch from `input`, keeping ONLY the listed `keys` whose
      * value the caller actually PROVIDED (`!== undefined`). Collapses the
@@ -4933,6 +4972,10 @@ export declare const getResourcePolicy: (resourceType: string) => ResourcePolicy
 /** The registered row filter, or `undefined`. */
 export declare const getRowFilter: () => RowFilter<never> | undefined;
 
+/** Read the live server-owned connection for an opaque runtime clientId.
+ * Missing for internal invocations and after transport teardown. */
+export declare const getRpcConnection: (clientId: number) => RpcConnection | undefined;
+
 /**
  * Read the currently-registered process-wide handle (`undefined` when none
  * is registered — the state in which `runAsSystem` refuses).
@@ -5117,19 +5160,16 @@ export declare class InMemoryDataStore implements DataStore {
     query(descriptor: QueryDescriptor): Promise<ReadonlyArray<Row>>;
     insert(table: string, row: Row): Promise<Row>;
     insertMany(table: string, rows: ReadonlyArray<Row>): Promise<ReadonlyArray<Row>>;
-    patchJson(table: string, primaryKey: string, path: string, value: unknown): Promise<Row | null>;
-    update(table: string, primaryKey: string, patch: Readonly<Record<string, unknown>>): Promise<Row | null>;
-    delete(table: string, primaryKey: string): Promise<boolean>;
+    patchJson(table: string, primaryKey: RowKey, path: string, value: unknown, additionalPatch?: Readonly<Record<string, unknown>>): Promise<Row | null>;
+    update(table: string, primaryKey: RowKey, patch: Readonly<Record<string, unknown>>): Promise<Row | null>;
+    delete(table: string, primaryKey: RowKey): Promise<boolean>;
     updateMany(table: string, patch: Readonly<Record<string, unknown>>, options: {
         where: Predicate;
     }): Promise<number>;
     deleteMany(table: string, options: {
         where: Predicate;
     }): Promise<number>;
-    upsert(table: string, row: Row, options: {
-        conflictColumns: ReadonlyArray<string>;
-        update?: ReadonlyArray<string> | ((existing: Row) => Readonly<Record<string, unknown>>);
-    }): Promise<Row>;
+    upsert(table: string, row: Row, options: UpsertOptions): Promise<Row>;
     insertIgnore(table: string, row: Row, options: {
         conflictColumns: ReadonlyArray<string>;
     }): Promise<Row>;
@@ -5561,7 +5601,7 @@ export declare class LinearScanMatcher implements Matcher {
 }
 
 /** Every connection the app declares, projected for ONE subject. */
-export declare const listConnectionStates: (store: VaultStore, registry: ConnectionRegistry, subjectId: string) => Promise<ReadonlyArray<ConnectionState>>;
+export declare const listConnectionStates: (store: VaultStore, registry: ConnectionRegistry, subjectId: string) => Promise<ReadonlyArray<ConnectionState_2>>;
 
 export declare const listResourcePolicies: () => ReadonlyArray<ResourcePolicy>;
 
@@ -5795,6 +5835,12 @@ export declare const makeConnectionResolver: (deps: {
 
 export declare const makeConnectionsFacade: (deps: ConnectionsFacadeDeps) => ConnectionsFacade;
 
+/** Host seam shared by dev/serve and testing. Pass the mutation lifecycle's
+ * existing afterCommit collector; rolled-back/retried bodies must discard it.
+ * Outside a transaction writes are immediate. Values are server-owned; do not
+ * put a client payload here as an authority claim. */
+export declare const makeConnectionState: (connection: RpcConnection, afterCommit?: (work: () => Promise<unknown>) => void) => ConnectionState;
+
 /**
  * Factory the CLI binds into the plugin bind-ctx: closes over the
  * process-wide coordinator + replicaId so a plugin calls the ergonomic
@@ -5841,7 +5887,7 @@ export declare const makeDisconnectConnectionExecutor: (deps: ConnectionBuiltinD
  * dev.ts (CLI) and any standalone test setup uses this to wire up the
  * tag before running the user's Effect.
  */
-export declare const makeEffectStoreLayer: (store: MutationStore) => Layer.Layer<EffectStore>;
+export declare const makeEffectStoreLayer: (store: FluentStore) => Layer.Layer<EffectStore>;
 
 export declare const makeEventPublisher: (ctx: EventPublishContext) => EventPublisher;
 
@@ -5869,7 +5915,7 @@ export declare const makeIdleGate: (graceMs: number, now?: () => number) => Idle
 export declare const makeLazyWorkflowFacade: (resolve: () => WorkflowsAppContext | undefined) => WorkflowsAppContext;
 
 /** `__voltro.connections.list` — every declared connection, for the caller. */
-export declare const makeListConnectionsExecutor: (deps: ConnectionBuiltinDeps) => (_input: Record<string, never>, ctx: ConnectionExecutorCtx) => Promise<ReadonlyArray<ConnectionState>>;
+export declare const makeListConnectionsExecutor: (deps: ConnectionBuiltinDeps) => (_input: Record<string, never>, ctx: ConnectionExecutorCtx) => Promise<ReadonlyArray<ConnectionState_2>>;
 
 /**
  * Build the replay codec from a mutation's `descriptor.output` Schema (call it at
@@ -6467,7 +6513,7 @@ export declare interface MutationRunnerDeps {
 export declare interface MutationStore extends DataStore {
     /** Bypass auto-soft-delete. Hard-removes the row regardless of
      *  whether the table has `softDelete()` applied. */
-    hardDelete(table: string, primaryKey: string): Promise<boolean>;
+    hardDelete(table: string, primaryKey: RowKey): Promise<boolean>;
 }
 
 export declare type NegotiatedEncoding = 'br' | 'gzip';
@@ -6477,6 +6523,25 @@ export declare type NegotiatedEncoding = 'br' | 'gzip';
  *  (a client sending both accepts both). */
 export declare const negotiateEncoding: (acceptEncoding: string | undefined) => NegotiatedEncoding | undefined;
 
+/**
+ * A fresh trace id for work that has NO incoming span to continue — a webhook
+ * delivery, a schedule firing, a devtools invoke, a REST or gRPC entry point.
+ *
+ * 128 random bits as 32 lowercase hex, the shape `TRACEPARENT_RE` above accepts
+ * and the shape a collector, a log pipeline or `voltro traces` can join on.
+ *
+ * The reason this exists as ONE function: every entry point that minted its own
+ * had drifted somewhere different, and three of the shapes were not ids at all.
+ * `incoming:<webhookId>`, `reaction:<workflow>` and the literal
+ * `'webhooks:trigger'` are CONSTANTS — they were the caller's `source` label
+ * copied into the id field, so every delivery a process ever handled shared one
+ * trace and the waterfall merged unrelated work. `public-`/`grpc-`/`rest-` plus
+ * eight base36 characters carried ~41 bits, which collides long before a busy
+ * day is over. The entry-point kind is not lost by fixing this: it lives in the
+ * `source` field beside the id, which is where it was already being written.
+ */
+export declare const newTraceId: () => string;
+
 /**
  * The backoff curve, extracted so it can be asserted directly — a schedule
  * that backs off wrongly is otherwise only visible as a latency an integration
@@ -6583,24 +6648,7 @@ export declare const normalizeIp: (raw: string) => string | undefined;
  *  never accidentally compare equal to a real one. */
 export declare const normalizeOrigin: (raw: string) => string;
 
-/**
- * `.one()` matched a number of rows other than exactly one.
- *
- * `found` distinguishes the two failure modes without a second error type:
- * `0` is "the row you required is missing", `2` is "your filter is not as
- * unique as you assumed" (the terminal probes with LIMIT 2, so `2` means
- * "at least two" — it never counts the whole set just to report a number).
- */
-export declare class NoRowFound extends NoRowFound_base {
-    get message(): string;
-}
-
-declare const NoRowFound_base: Schema.TaggedErrorClass<NoRowFound, "NoRowFound", {
-    readonly _tag: Schema.tag<"NoRowFound">;
-} & {
-    table: typeof Schema.String;
-    found: typeof Schema.Number;
-}>;
+export { NoRowFound }
 
 /** What `.one()` hands an `onMissing` factory — the two facts `NoRowFound` carries. */
 export declare interface NoRowFoundInfo {
@@ -7084,7 +7132,7 @@ export declare interface PreviewStore {
 /** Project a stored row into the wire shape. Deliberately total over the
  *  columns the descriptor declares — and deliberately silent about the token
  *  columns, which have no wire representation at all. */
-export declare const projectConnectionState: (definition: ConnectionDefinition, row: AnyRow_2 | undefined) => ConnectionState;
+export declare const projectConnectionState: (definition: ConnectionDefinition, row: AnyRow_2 | undefined) => ConnectionState_2;
 
 /** Exact-match property filter. Values are AND'd. */
 export declare type PropertyFilter = Readonly<Record<string, string | number | boolean | null>>;
@@ -7641,6 +7689,17 @@ export declare interface RebacSubject {
 
 export declare const recordCoalesced: (label: string, collapsed: number) => void;
 
+/**
+ * The verified expiry of the credential a connection authenticated with, in
+ * unix SECONDS — recorded by the auth chain, read by `ConnectionInfo`.
+ *
+ * It lives here rather than being re-derived from headers because those are two
+ * different facts once more than one auth shape exists. The header derivation
+ * read the `voltro:session` cookie and nothing else, so an app on Bearer JWTs
+ * had no bound at all while the docs said every realtime primitive had one.
+ * The strategy that verified the token is the only place the expiry is known,
+ * and this is how it reaches the consumer without a second derivation.
+ */
 export declare const recordCredentialExpiry: (clientId: number, exp: number | undefined) => void;
 
 /** What the framework emit-seams (servePipeline / rpcServer / plugin wrappers)
@@ -7930,6 +7989,8 @@ export declare interface RegistryTableLike {
          * Distinct from `defaultValue` (literal landed in DDL).
          */
         readonly defaultFactory?: () => unknown;
+        /** Application-side value used when an UPDATE omits this column. */
+        readonly onUpdate?: 'now' | (() => unknown);
         /**
          * Computed field — re-evaluated on INSERT (AFTER defaults) and on
          * UPDATE (against the merged post-update row); the return value
@@ -7964,6 +8025,13 @@ export declare interface RegistryTableLike {
         readonly name: string;
         readonly fields: ReadonlyArray<string>;
     }>;
+    /**
+     * The columns of an EXPLICIT primary key (`.primaryKey([...])`). Absent or
+     * empty for the ordinary table whose `id()` column carries the key. The
+     * registry surfaces it so the keyed store forms can refuse a table they have
+     * no single string to address — see `SchemaInfo.declaredPrimaryKey`.
+     */
+    readonly appliedPrimaryKey?: ReadonlyArray<string>;
     /**
      * Optional `effect/Schema` the framework decodes a row against
      * BEFORE every INSERT. Set via `table().validate(schema)`. The
@@ -8113,7 +8181,7 @@ export declare class ReplicatedDataStore implements DataStore {
     private routeWaitMode;
     insert(table: string, row: Row): Promise<Row>;
     insertMany(table: string, rows: ReadonlyArray<Row>): Promise<ReadonlyArray<Row>>;
-    patchJson(table: string, primaryKey: string, path: string, value: unknown): Promise<Row | null>;
+    patchJson(table: string, primaryKey: string, path: string, value: unknown, additionalPatch?: Readonly<Record<string, unknown>>): Promise<Row | null>;
     update(table: string, primaryKey: string, patch: Readonly<Record<string, unknown>>): Promise<Row | null>;
     delete(table: string, primaryKey: string): Promise<boolean>;
     updateMany(table: string, patch: Readonly<Record<string, unknown>>, options: {
@@ -8122,10 +8190,7 @@ export declare class ReplicatedDataStore implements DataStore {
     deleteMany(table: string, options: {
         where: Predicate;
     }): Promise<number>;
-    upsert(table: string, row: Row, options: {
-        conflictColumns: ReadonlyArray<string>;
-        update?: ReadonlyArray<string> | ((existing: Row) => Readonly<Record<string, unknown>>);
-    }): Promise<Row>;
+    upsert(table: string, row: Row, options: UpsertOptions): Promise<Row>;
     insertIgnore(table: string, row: Row, options: {
         conflictColumns: ReadonlyArray<string>;
     }): Promise<Row>;
@@ -8928,6 +8993,15 @@ export declare interface RowHistoryEntry {
     readonly traceId?: string | null;
 }
 
+/** Server-owned lifetime, not a user identity or a client-supplied claim.
+ * WebSockets retain it across calls; HTTP retains it only within one request.
+ * Reconnects and server restarts receive a new id. */
+export declare interface RpcConnection {
+    readonly id: string;
+    readonly transport: 'websocket' | 'http';
+    readonly signal: AbortSignal;
+}
+
 export declare interface RpcServerOptions<Rpcs extends Rpc.Any> {
     readonly group: RpcGroup.RpcGroup<Rpcs>;
     readonly handlersLayer: Layer.Layer<Rpc.ToHandler<Rpcs>>;
@@ -9205,14 +9279,15 @@ export declare interface RuntimeContext {
      *  build the outbound `traceparent` header for cross-api hops. */
     readonly spanId?: string;
     /**
-     * Per-connection identifier the rpc transport assigns to a
-     * WebSocket connection. Stable for the lifetime of that connection.
-     * Used by re-auth handlers (`auth.signin`) to write into the
-     * per-connection subject override map so subsequent calls on the
-     * same connection see the new subject. `undefined` for non-rpc
-     * call paths (workflows, smoke tests, internal invocations).
+     * Opaque process-wide identifier, distinct across RPC transports/listeners.
+     * Stable within a WebSocket or one HTTP request; never persist this number.
+     * Re-auth handlers use it to bind a credential, not a resolved subject.
+     * Undefined for non-RPC call paths (workflows, internal invocations).
      */
     readonly clientId?: number;
+    /** Server-owned transport identity and close signal. Not authentication;
+     * session membership remains an application's explicit access decision. */
+    readonly connection?: RpcConnection;
 }
 
 /**
@@ -9630,6 +9705,8 @@ export declare interface SchemaInfo {
      * on every UPDATE against the merged post-update row.
      */
     readonly computedFields: ReadonlyMap<string, (row: Readonly<Record<string, unknown>>) => unknown>;
+    /** Optional for custom registries; absent means no automatic update columns. */
+    readonly onUpdateFields?: ReadonlyMap<string, 'now' | (() => unknown)>;
     /** The column marked `.version()`, when the table declares one. */
     readonly versionColumn?: string;
     /**
@@ -9666,11 +9743,24 @@ export declare interface SchemaInfo {
     readonly validatePatchSchema?: Schema.Schema.Any;
     /**
      * Resolved id-scheme for the table's primary-key column. `undefined`
-     * for tables that have no `id`-typed column (rare; framework tables
-     * always have one). MutationStore reads this to decide whether to
-     * auto-generate a string id or omit the column for the DB to allocate.
+     * for tables that have no `id`-typed column — a natural or composite
+     * primary key, see `declaredPrimaryKey`. MutationStore reads this to decide
+     * whether to auto-generate a string id or omit the column for the DB to
+     * allocate.
      */
     readonly idScheme?: IdScheme;
+    /**
+     * The columns of an EXPLICIT primary key (`.primaryKey(['userId','orgId'])`,
+     * or one column for a shared key). Empty for the ordinary table whose `id()`
+     * column carries the key.
+     *
+     * Read by the keyed store forms — `update(table, pk, patch)` and
+     * `delete(table, pk)` address a row by a single string, which such a table
+     * has nothing to match against. Before this was carried here they answered
+     * `null` / `false`: the SAME values that mean "no such row", so a caller
+     * could not tell a missing row from a call that can never find one.
+     */
+    readonly declaredPrimaryKey: ReadonlyArray<string>;
 }
 
 /**
@@ -9709,6 +9799,11 @@ export declare interface SchemaRegistry {
      * hook in `./storeMiddleware.ts`.
      */
     idScheme(table: string): IdScheme | undefined;
+    /**
+     * The columns of the table's EXPLICIT primary key, or an empty array when
+     * its `id()` column carries the key. See {@link SchemaInfo.declaredPrimaryKey}.
+     */
+    declaredPrimaryKey(table: string): ReadonlyArray<string>;
     /**
      * Per-column app-side default factories for a table. Empty map if
      * none. Read by MutationStore.stampedForInsert to fill missing
@@ -9894,6 +9989,8 @@ export declare type SerializedGuard = {
     readonly action: string;
     readonly resourceType: string;
     readonly resource: string | null;
+} | {
+    readonly kind: 'authenticated';
 };
 
 /**
@@ -11064,7 +11161,7 @@ export declare type TupleSource = (req: {
 export declare const TX_READ_VERSIONS_KEY: unique symbol;
 
 /**
- * Drop everything this connection accumulated. Called by the WS-close finalizer
+ * Drop everything this connection accumulated. Called by the transport finalizer
  * and by explicit sign-out flows. Idempotent.
  */
 export declare const unbindConnection: (clientId: number) => void;