@earendil-works/chord 1.2.0 → 1.3.0

package/dist/wire.d.ts

@@ -1,135 +1,216 @@
-import type { Description } from "./contract.ts";
-import type { WireOp } from "./delta/index.ts";
-import { ChordError, type ChordErrorCode } from "./errors.ts";
-import type { Principal } from "./types.ts";
-export interface RootRef {
-    readonly rootId: string;
-    readonly epoch: number;
-}
-export interface WireError {
-    readonly code: ChordErrorCode;
-    readonly message: string;
-    readonly reason?: string;
-}
-export interface WireReloadOptions {
-    readonly remove?: readonly string[];
-    readonly gateDeadline?: number;
-    readonly retireDeadline?: number;
-}
+import { type Static, type TSchema, Type } from "typebox";
+import { ChordError } from "./errors.ts";
+/**
+ * The link protocol version, announced in `hello`. Peers of different versions do not talk: the side that notices
+ * closes the link with reason `protocol-version <its version>`, so the other side learns it too
+ * (`LinkOptions.onProtocolMismatch`).
+ */
+export declare const PROTOCOL_VERSION = 4;
+declare const RootRefSchema: Type.TObject<{
+    rootId: Type.TString;
+    codeVersion: Type.TInteger;
+}>;
+export type RootRef = Static<typeof RootRefSchema>;
+declare const WireErrorSchema: Type.TObject<{
+    code: Type.TEnum<["aborted", "contract_mismatch", "forbidden", "gone", "invalid", "not_in_variant", "not_ready", "released", "superseded", "unavailable", "upgrade_conflict", "upgrade_required"]>;
+    message: Type.TString;
+    reason: Type.TOptional<Type.TString>;
+}>;
+export type WireError = Static<typeof WireErrorSchema>;
+declare const WireReloadOptionsSchema: Type.TObject<{
+    remove: Type.TOptional<Type.TImmutable<Type.TArray<Type.TString>>>;
+    gateDeadline: Type.TOptional<Type.TNumber>;
+    retireDeadline: Type.TOptional<Type.TNumber>;
+}>;
+export type WireReloadOptions = Static<typeof WireReloadOptionsSchema>;
 /** A child's prepared reload, sent with its vote (same fields as `ReloadReport`, without children). */
-export interface WireReloadReport {
-    readonly epoch: number;
-    readonly previous: number;
-    readonly changed: readonly string[];
-    readonly removed: readonly string[];
-    readonly prepared: readonly string[];
-    readonly gated: readonly string[];
-}
-export type Frame = {
-    readonly t: "hello";
-    readonly name: string;
-    readonly kind: "host" | "client";
-    readonly epoch: number;
-} | {
-    readonly t: "hold";
-    readonly id: number;
-    /** Target host name. */
-    readonly at: string;
-    /** The consumer's contract token; the provider checks that it covers it. */
-    readonly token: Description;
-    readonly input: unknown;
+declare const WireReloadReportSchema: Type.TObject<{
+    codeVersion: Type.TInteger;
+    previous: Type.TInteger;
+    changed: Type.TImmutable<Type.TArray<Type.TString>>;
+    removed: Type.TImmutable<Type.TArray<Type.TString>>;
+    prepared: Type.TImmutable<Type.TArray<Type.TString>>;
+    gated: Type.TImmutable<Type.TArray<Type.TString>>;
+}>;
+export type WireReloadReport = Static<typeof WireReloadReportSchema>;
+declare const FrameSchema: Type.TUnion<[Type.TObject<{
+    t: Type.TLiteral<"hello">;
+    /** The link protocol version (`PROTOCOL_VERSION`; absent: 1). Peers of another version close the link. */
+    protocol: Type.TOptional<Type.TInteger>;
+    name: Type.TString;
+    kind: Type.TUnion<[Type.TLiteral<"host">, Type.TLiteral<"client">]>;
+    codeVersion: Type.TInteger;
+    /** The sender acknowledges what it receives (`ack`). Flow control applies only when both hellos say so. */
+    acks: Type.TOptional<Type.TBoolean>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"ack">;
+    n: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"hold">;
+    id: Type.TInteger;
+    /**
+     * Target host name, resolved by the consumer from the token's `host` and `input`. Relays route on it after
+     * checking it against both; the target refuses an input its own contract places elsewhere.
+     */
+    at: Type.TString;
+    /** The consumer's contract token; the provider checks that it covers it. Remote tokens carry `host`. */
+    token: Type.TObject<{
+        name: Type.TString;
+        scope: Type.TUnion<[Type.TLiteral<"remote">, Type.TLiteral<"local">]>;
+        version: Type.TInteger;
+        input: Type.TUnsafe<TSchema>;
+        host: Type.TOptional<Type.TUnion<[Type.TObject<{
+            name: Type.TString;
+        }>, Type.TObject<{
+            prefix: Type.TString;
+            key: Type.TString;
+        }>]>>;
+        variants: Type.TRecord<"^.*$", Type.TRecord<"^.*$", Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"method">;
+            args: Type.TOptional<Type.TUnsafe<TSchema>>;
+            result: Type.TOptional<Type.TUnsafe<TSchema>>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"state">;
+            schema: Type.TUnsafe<TSchema>;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"opaque">;
+            id: Type.TString;
+        }>]>>>;
+    }>;
+    /** Normalized with the consumer's contract. */
+    input: Type.TUnknown;
     /** A forwarded principal. Honored only on frames from the parent link. */
-    readonly principal?: Principal;
-    /** Set by a relay when the hold originates from a client (browser): not a reload participant. */
-    readonly client?: boolean;
-} | {
-    readonly t: "release";
-    readonly id: number;
-} | {
-    readonly t: "shape";
-    readonly id: number;
-    readonly kind?: string;
-    readonly members: readonly string[];
-    readonly contract: string;
-    readonly epoch: number;
-} | {
-    readonly t: "gone";
-    readonly id: number;
-    readonly error: WireError;
-} | {
-    readonly t: "call";
-    readonly id: number;
-    readonly hold: number;
-    readonly member: string;
-    readonly args: unknown;
+    principal: Type.TOptional<Type.TUnknown>;
+    /**
+     * The client connection the hold comes from: an opaque id the server assigned to it, forwarded by relays. Honored
+     * only on frames from the parent link; present means the hold is a client's (not a reload participant).
+     */
+    origin: Type.TOptional<Type.TString>;
+    /** False: no state for this hold until `sub` (a method-only binding). */
+    state: Type.TOptional<Type.TLiteral<false>>;
+    /** The consumer already has values (a re-hold after a link loss): its unit is not urgent. */
+    again: Type.TOptional<Type.TLiteral<true>>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"release">;
+    id: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"shape">;
+    id: Type.TInteger;
+    variant: Type.TOptional<Type.TString>;
+    members: Type.TImmutable<Type.TArray<Type.TString>>;
+    contract: Type.TString;
+    /** The state members whose snapshots follow this frame; the consumer applies the shape once they are here. */
+    state: Type.TImmutable<Type.TArray<Type.TString>>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"gone">;
+    id: Type.TInteger;
+    error: Type.TObject<{
+        code: Type.TEnum<["aborted", "contract_mismatch", "forbidden", "gone", "invalid", "not_in_variant", "not_ready", "released", "superseded", "unavailable", "upgrade_conflict", "upgrade_required"]>;
+        message: Type.TString;
+        reason: Type.TOptional<Type.TString>;
+    }>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"call">;
+    id: Type.TInteger;
+    hold: Type.TInteger;
+    member: Type.TString;
+    args: Type.TOptional<Type.TUnknown>;
     /** Absent: the receiving host starts a root (browsers never carry roots). */
-    readonly root?: RootRef;
-} | {
-    readonly t: "result";
-    readonly id: number;
-    readonly value?: unknown;
-    readonly error?: WireError;
-} | {
-    readonly t: "cancel";
-    readonly id: number;
-} | {
-    readonly t: "sub";
-    readonly id: number;
-    readonly hold: number;
-    readonly member: string;
-} | {
-    readonly t: "unsub";
-    readonly id: number;
-} | {
-    readonly t: "state";
-    readonly id: number;
-    readonly snap?: unknown;
-    readonly reset?: unknown;
-    /** Encoded with the subscription's delta encoder. */
-    readonly ops?: readonly WireOp[];
-    readonly error?: WireError;
-} | {
-    readonly t: "ping";
-    readonly n: number;
-} | {
-    readonly t: "pong";
-    readonly n: number;
-} | {
-    readonly t: "bye";
-    readonly reason?: string;
-}
-/** The root ended at its origin: its leases on records end (sent on every link the root's calls used). */
- | {
-    readonly t: "root_end";
-    readonly rootId: string;
-} | {
-    readonly t: "invalidate";
-    readonly pattern: Readonly<Record<string, unknown>>;
-} | {
-    readonly t: "prepare";
-    readonly reload: number;
-    readonly epoch: number;
-    readonly plugins: readonly string[];
-    readonly options: WireReloadOptions;
-} | {
-    readonly t: "vote";
-    readonly reload: number;
-    readonly error?: WireError;
-    readonly report?: WireReloadReport;
-} | {
-    readonly t: "commit";
-    readonly reload: number;
-}
-/** The parent dropped `epoch`: roots of it may still come from there no longer. */
- | {
-    readonly t: "retire";
-    readonly epoch: number;
-} | {
-    readonly t: "abort";
-    readonly reload: number;
-};
+    root: Type.TOptional<Type.TObject<{
+        rootId: Type.TString;
+        codeVersion: Type.TInteger;
+    }>>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"result">;
+    id: Type.TInteger;
+    value: Type.TOptional<Type.TUnknown>;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TEnum<["aborted", "contract_mismatch", "forbidden", "gone", "invalid", "not_in_variant", "not_ready", "released", "superseded", "unavailable", "upgrade_conflict", "upgrade_required"]>;
+        message: Type.TString;
+        reason: Type.TOptional<Type.TString>;
+    }>>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"cancel">;
+    id: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"sub">;
+    hold: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"unsub">;
+    hold: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"resync">;
+    hold: Type.TInteger;
+    m: Type.TString;
+}>, Type.TObject<{
+    t: Type.TLiteral<"state">;
+    hold: Type.TInteger;
+    m: Type.TString;
+    /** `snap`/`reset` without `value`: the value is `undefined`. */
+    as: Type.TUnion<[Type.TLiteral<"snap">, Type.TLiteral<"reset">, Type.TLiteral<"ops">, Type.TLiteral<"error">]>;
+    value: Type.TOptional<Type.TUnknown>;
+    /** Encoded with the stream's delta encoder; the decoder validates each op. */
+    ops: Type.TOptional<Type.TImmutable<Type.TArray<Type.TImmutable<Type.TArray<Type.TUnknown>>>>>;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TEnum<["aborted", "contract_mismatch", "forbidden", "gone", "invalid", "not_in_variant", "not_ready", "released", "superseded", "unavailable", "upgrade_conflict", "upgrade_required"]>;
+        message: Type.TString;
+        reason: Type.TOptional<Type.TString>;
+    }>>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"ping">;
+    n: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"pong">;
+    n: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"bye">;
+    reason: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"root_end">;
+    rootId: Type.TString;
+}>, Type.TObject<{
+    t: Type.TLiteral<"invalidate">;
+    pattern: Type.TRecord<"^.*$", Type.TUnknown>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"prepare">;
+    reload: Type.TInteger;
+    codeVersion: Type.TInteger;
+    plugins: Type.TImmutable<Type.TArray<Type.TString>>;
+    options: Type.TObject<{
+        remove: Type.TOptional<Type.TImmutable<Type.TArray<Type.TString>>>;
+        gateDeadline: Type.TOptional<Type.TNumber>;
+        retireDeadline: Type.TOptional<Type.TNumber>;
+    }>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"vote">;
+    reload: Type.TInteger;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TEnum<["aborted", "contract_mismatch", "forbidden", "gone", "invalid", "not_in_variant", "not_ready", "released", "superseded", "unavailable", "upgrade_conflict", "upgrade_required"]>;
+        message: Type.TString;
+        reason: Type.TOptional<Type.TString>;
+    }>>;
+    report: Type.TOptional<Type.TObject<{
+        codeVersion: Type.TInteger;
+        previous: Type.TInteger;
+        changed: Type.TImmutable<Type.TArray<Type.TString>>;
+        removed: Type.TImmutable<Type.TArray<Type.TString>>;
+        prepared: Type.TImmutable<Type.TArray<Type.TString>>;
+        gated: Type.TImmutable<Type.TArray<Type.TString>>;
+    }>>;
+}>, Type.TObject<{
+    t: Type.TLiteral<"commit">;
+    reload: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"retire">;
+    codeVersion: Type.TInteger;
+}>, Type.TObject<{
+    t: Type.TLiteral<"abort">;
+    reload: Type.TInteger;
+}>]>;
+export type Frame = Static<typeof FrameSchema>;
+/** A frame that passes validation; anything else is a protocol violation. */
+export declare const isFrame: (value: unknown) => value is Frame;
 export declare function toWireError(error: unknown): WireError;
 export declare const fromWireError: (error: WireError) => ChordError;
-/** A frame that passes structural validation; anything else is a protocol violation. */
-export declare const isFrame: (value: unknown) => value is Frame;
+export {};
 //# sourceMappingURL=wire.d.ts.map

package/dist/wire.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAQ5C,MAAM,WAAW,OAAO;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,uGAAuG;AACvG,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,MAAM,MAAM,KAAK,GACd;IAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxG;IACA,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wBAAwB;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,iGAAiG;IACjG,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CACzB,GACD;IAAE,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC9C;IACA,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACtB,GACD;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACtE;IACA,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACvB,GACD;IAAE,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GACnG;IAAE,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1F;IAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC5C;IACA,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,qDAAqD;IACrD,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC1B,GACD;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;AACjD,0GAA0G;GACxG;IAAE,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,GACjF;IACA,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACnC,GACD;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAAE,GAC/G;IAAE,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACnD,mFAAmF;GACjF;IAAE,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAOrD;AAED,eAAO,MAAM,aAAa,UAAW,SAAS,KAAG,UACyD,CAAC;AAwG3G,wFAAwF;AACxF,eAAO,MAAM,OAAO,UAAW,OAAO,KAAG,KAAK,IAAI,KAAwC,CAAC"}
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAqB,UAAU,EAAE,MAAM,aAAa,CAAC;AAe5D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAQlC,QAAA,MAAM,aAAa;;;EAA2E,CAAC;AAC/F,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAEnD,QAAA,MAAM,eAAe;;;;EAInB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAEvD,QAAA,MAAM,uBAAuB;;;;EAI3B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEvE,uGAAuG;AACvG,QAAA,MAAM,sBAAsB;;;;;;;EAO1B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAErE,QAAA,MAAM,WAAW;;IAGf,0GAA0G;;;;;IAK1G,2GAA2G;;;;;;;;IAQ3G;;;OAGG;;IAEH,wGAAwG;;;;;;;;;;;;;;;;;;;;;;;;IAExG,+CAA+C;;IAE/C,0EAA0E;;IAE1E;;;OAGG;;IAEH,yEAAyE;;IAEzE,6FAA6F;;;;;;;;;;;IAU7F,8GAA8G;;;;;;;;;;;;;;;;IAU9G,6EAA6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoB7E,gEAAgE;;;IAGhE,8EAA8E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4B9E,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AAE/C,6EAA6E;AAC7E,eAAO,MAAM,OAAO,UAAW,OAAO,KAAG,KAAK,IAAI,KAAwC,CAAC;AAE3F,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAOrD;AAED,eAAO,MAAM,aAAa,UAAW,SAAS,KAAG,UACyD,CAAC"}

package/dist/wire.js

@@ -1,112 +1,165 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { ChordError } from "./errors.js";
-export function toWireError(error) {
-    if (error instanceof ChordError) {
-        return error.reason === undefined
-            ? { code: error.code, message: error.message }
-            : { code: error.code, message: error.message, reason: error.reason };
-    }
-    return { code: "unavailable", message: error instanceof Error ? error.message : String(error) };
-}
-export const fromWireError = (error) => new ChordError(error.code, error.message.replace(/^[a-z_]+(\/[a-z_]+)?: /, ""), { reason: error.reason });
-// ─── validation ──────────────────────────────────────────────────────────────
+import { DescriptionSchema } from "./contract.js";
+import { CHORD_ERROR_CODES, ChordError } from "./errors.js";
+// JSON frames between two hosts (or a host and a client). Ids are chosen by the side that creates the hold, call or
+// subscription; every frame type has one direction, so ids never collide:
+//   consumer → provider: hold, release, call, cancel, sub, unsub, resync
+//   provider → consumer: shape, gone, result, state
+// State is addressed by (hold id, member): a hold implies the state of its variant, sent as units (a shape followed by
+// a snapshot of each member the consumer lacks; see Connection).
+//   both: hello, ping, pong, bye, root_end, ack; parent → child: invalidate, prepare, commit, abort, retire;
+//   child → parent: vote
+//
+// Each frame is declared once, as the schema every received frame is checked against (`isFrame`); the types are derived
+// from it. Payloads (hold inputs, call args, results, snapshots) stay `unknown`: they are validated where they are
+// used, against the contract. State ops are checked op by op by the delta decoder.
+/**
+ * The link protocol version, announced in `hello`. Peers of different versions do not talk: the side that notices
+ * closes the link with reason `protocol-version <its version>`, so the other side learns it too
+ * (`LinkOptions.onProtocolMismatch`).
+ */
+export const PROTOCOL_VERSION = 4;
 const Id = Type.Integer({ minimum: 1 });
 const Name = Type.String({ minLength: 1 });
-const Root = Type.Object({ rootId: Name, epoch: Type.Integer({ minimum: 1 }) });
-const ErrorShape = Type.Object({ code: Type.String(), message: Type.String(), reason: Type.Optional(Type.String()) });
 const Reload = Type.Integer({ minimum: 1 });
-/** Structural schema of every frame. Payloads (args, values, ops) are checked where they are used. */
+/** Arrays a sender may pass as readonly. */
+const List = (item) => Type.Immutable(Type.Array(item));
+const RootRefSchema = Type.Object({ rootId: Name, codeVersion: Type.Integer({ minimum: 1 }) });
+const WireErrorSchema = Type.Object({
+    code: Type.Enum(CHORD_ERROR_CODES),
+    message: Type.String(),
+    reason: Type.Optional(Type.String()),
+});
+const WireReloadOptionsSchema = Type.Object({
+    remove: Type.Optional(List(Type.String())),
+    gateDeadline: Type.Optional(Type.Number()),
+    retireDeadline: Type.Optional(Type.Number()),
+});
+/** A child's prepared reload, sent with its vote (same fields as `ReloadReport`, without children). */
+const WireReloadReportSchema = Type.Object({
+    codeVersion: Type.Integer(),
+    previous: Type.Integer(),
+    changed: List(Type.String()),
+    removed: List(Type.String()),
+    prepared: List(Type.String()),
+    gated: List(Type.String()),
+});
 const FrameSchema = Type.Union([
     Type.Object({
         t: Type.Literal("hello"),
+        /** The link protocol version (`PROTOCOL_VERSION`; absent: 1). Peers of another version close the link. */
+        protocol: Type.Optional(Type.Integer({ minimum: 1 })),
         name: Name,
         kind: Type.Union([Type.Literal("host"), Type.Literal("client")]),
-        epoch: Type.Integer({ minimum: 0 }),
+        codeVersion: Type.Integer({ minimum: 0 }),
+        /** The sender acknowledges what it receives (`ack`). Flow control applies only when both hellos say so. */
+        acks: Type.Optional(Type.Boolean()),
     }),
+    /** Every frame received so far except `ack` frames, counted from the link's start, once processed. */
+    Type.Object({ t: Type.Literal("ack"), n: Type.Integer({ minimum: 1 }) }),
     Type.Object({
         t: Type.Literal("hold"),
         id: Id,
+        /**
+         * Target host name, resolved by the consumer from the token's `host` and `input`. Relays route on it after
+         * checking it against both; the target refuses an input its own contract places elsewhere.
+         */
         at: Name,
-        token: Type.Object({
-            name: Name,
-            scope: Type.String(),
-            version: Type.Integer(),
-            input: Type.Unknown(),
-            variants: Type.Record(Type.String(), Type.Unknown()),
-        }),
+        /** The consumer's contract token; the provider checks that it covers it. Remote tokens carry `host`. */
+        token: DescriptionSchema,
+        /** Normalized with the consumer's contract. */
         input: Type.Unknown(),
+        /** A forwarded principal. Honored only on frames from the parent link. */
         principal: Type.Optional(Type.Unknown()),
-        client: Type.Optional(Type.Boolean()),
+        /**
+         * The client connection the hold comes from: an opaque id the server assigned to it, forwarded by relays. Honored
+         * only on frames from the parent link; present means the hold is a client's (not a reload participant).
+         */
+        origin: Type.Optional(Name),
+        /** False: no state for this hold until `sub` (a method-only binding). */
+        state: Type.Optional(Type.Literal(false)),
+        /** The consumer already has values (a re-hold after a link loss): its unit is not urgent. */
+        again: Type.Optional(Type.Literal(true)),
     }),
     Type.Object({ t: Type.Literal("release"), id: Id }),
     Type.Object({
         t: Type.Literal("shape"),
         id: Id,
-        kind: Type.Optional(Type.String()),
-        members: Type.Array(Type.String()),
+        variant: Type.Optional(Type.String()),
+        members: List(Type.String()),
         contract: Type.String(),
-        epoch: Type.Integer(),
+        /** The state members whose snapshots follow this frame; the consumer applies the shape once they are here. */
+        state: List(Name),
     }),
-    Type.Object({ t: Type.Literal("gone"), id: Id, error: ErrorShape }),
+    Type.Object({ t: Type.Literal("gone"), id: Id, error: WireErrorSchema }),
     Type.Object({
         t: Type.Literal("call"),
         id: Id,
         hold: Id,
         member: Name,
-        args: Type.Unknown(),
-        root: Type.Optional(Root),
+        args: Type.Optional(Type.Unknown()),
+        /** Absent: the receiving host starts a root (browsers never carry roots). */
+        root: Type.Optional(RootRefSchema),
     }),
     Type.Object({
         t: Type.Literal("result"),
         id: Id,
         value: Type.Optional(Type.Unknown()),
-        error: Type.Optional(ErrorShape),
+        error: Type.Optional(WireErrorSchema),
     }),
     Type.Object({ t: Type.Literal("cancel"), id: Id }),
-    Type.Object({ t: Type.Literal("sub"), id: Id, hold: Id, member: Name }),
-    Type.Object({ t: Type.Literal("unsub"), id: Id }),
+    /** Starts the state of a hold opened with `state: false` (answered with a unit). */
+    Type.Object({ t: Type.Literal("sub"), hold: Id }),
+    /** Stops the state of a hold. */
+    Type.Object({ t: Type.Literal("unsub"), hold: Id }),
+    /** Sends member `m` again as a reset (a relay that had to drop what waited for it). */
+    Type.Object({ t: Type.Literal("resync"), hold: Id, m: Name }),
     Type.Object({
         t: Type.Literal("state"),
-        id: Id,
-        snap: Type.Optional(Type.Unknown()),
-        reset: Type.Optional(Type.Unknown()),
-        ops: Type.Optional(Type.Array(Type.Array(Type.Unknown()))),
-        error: Type.Optional(ErrorShape),
+        hold: Id,
+        m: Name,
+        /** `snap`/`reset` without `value`: the value is `undefined`. */
+        as: Type.Union([Type.Literal("snap"), Type.Literal("reset"), Type.Literal("ops"), Type.Literal("error")]),
+        value: Type.Optional(Type.Unknown()),
+        /** Encoded with the stream's delta encoder; the decoder validates each op. */
+        ops: Type.Optional(List(List(Type.Unknown()))),
+        error: Type.Optional(WireErrorSchema),
     }),
     Type.Object({ t: Type.Literal("ping"), n: Type.Integer() }),
     Type.Object({ t: Type.Literal("pong"), n: Type.Integer() }),
+    /** Ends the link (consumed by the link itself). `reason: "protocol-version <n>"`: the sender speaks version n. */
     Type.Object({ t: Type.Literal("bye"), reason: Type.Optional(Type.String()) }),
+    /** The root ended at its origin: its leases on objects end (sent on every link the root's calls used). */
     Type.Object({ t: Type.Literal("root_end"), rootId: Name }),
     Type.Object({ t: Type.Literal("invalidate"), pattern: Type.Record(Type.String(), Type.Unknown()) }),
     Type.Object({
         t: Type.Literal("prepare"),
         reload: Reload,
-        epoch: Type.Integer({ minimum: 1 }),
-        plugins: Type.Array(Type.String()),
-        options: Type.Object({
-            remove: Type.Optional(Type.Array(Type.String())),
-            gateDeadline: Type.Optional(Type.Number()),
-            retireDeadline: Type.Optional(Type.Number()),
-        }),
+        codeVersion: Type.Integer({ minimum: 1 }),
+        plugins: List(Type.String()),
+        options: WireReloadOptionsSchema,
     }),
     Type.Object({
         t: Type.Literal("vote"),
         reload: Reload,
-        error: Type.Optional(ErrorShape),
-        report: Type.Optional(Type.Object({
-            epoch: Type.Integer(),
-            previous: Type.Integer(),
-            changed: Type.Array(Type.String()),
-            removed: Type.Array(Type.String()),
-            prepared: Type.Array(Type.String()),
-            gated: Type.Array(Type.String()),
-        })),
+        error: Type.Optional(WireErrorSchema),
+        report: Type.Optional(WireReloadReportSchema),
     }),
     Type.Object({ t: Type.Literal("commit"), reload: Reload }),
-    Type.Object({ t: Type.Literal("retire"), epoch: Type.Integer({ minimum: 1 }) }),
+    /** The parent dropped `codeVersion`: roots of it may still come from there no longer. */
+    Type.Object({ t: Type.Literal("retire"), codeVersion: Type.Integer({ minimum: 1 }) }),
     Type.Object({ t: Type.Literal("abort"), reload: Reload }),
 ]);
-/** A frame that passes structural validation; anything else is a protocol violation. */
+/** A frame that passes validation; anything else is a protocol violation. */
 export const isFrame = (value) => Value.Check(FrameSchema, value);
+export function toWireError(error) {
+    if (error instanceof ChordError) {
+        return error.reason === undefined
+            ? { code: error.code, message: error.message }
+            : { code: error.code, message: error.message, reason: error.reason };
+    }
+    return { code: "unavailable", message: error instanceof Error ? error.message : String(error) };
+}
+export const fromWireError = (error) => new ChordError(error.code, error.message.replace(/^[a-z_]+(\/[a-z_]+)?: /, ""), { reason: error.reason });
 //# sourceMappingURL=wire.js.map