@earendil-works/chord 1.3.0 → 1.5.0

package/dist/wire.d.ts

@@ -1,4 +1,4 @@
-import { type Static, type TSchema, Type } from "typebox";
+import { type Schema, type Static } from "@earendil-works/pi-schema";
 import { ChordError } from "./errors.ts";
 /**
  * The link protocol version, announced in `hello`. Peers of different versions do not talk: the side that notices
@@ -6,207 +6,188 @@ import { ChordError } from "./errors.ts";
  * (`LinkOptions.onProtocolMismatch`).
  */
 export declare const PROTOCOL_VERSION = 4;
-declare const RootRefSchema: Type.TObject<{
-    rootId: Type.TString;
-    codeVersion: Type.TInteger;
+declare const RootRefSchema: Schema<{
+    rootId: string;
+    codeVersion: number;
 }>;
 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>;
+declare const WireErrorSchema: Schema<{
+    code: "aborted" | "contract_mismatch" | "forbidden" | "gone" | "invalid" | "not_in_variant" | "not_ready" | "released" | "superseded" | "unavailable" | "upgrade_conflict" | "upgrade_required";
+    message: string;
+    reason?: string | undefined;
 }>;
 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>;
+declare const WireReloadOptionsSchema: Schema<{
+    remove?: readonly string[] | undefined;
+    gateDeadline?: number | undefined;
+    retireDeadline?: number | undefined;
 }>;
 export type WireReloadOptions = Static<typeof WireReloadOptionsSchema>;
 /** A child's prepared reload, sent with its vote (same fields as `ReloadReport`, without children). */
-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>>;
+declare const WireReloadReportSchema: Schema<{
+    codeVersion: number;
+    previous: number;
+    changed: readonly string[];
+    removed: readonly string[];
+    prepared: readonly string[];
+    gated: readonly string[];
 }>;
 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. */
-    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). */
-    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;
-}>]>;
+declare const FrameSchema: Schema<{
+    t: "hello";
+    protocol?: number | undefined;
+    name: string;
+    kind: "client" | "host";
+    codeVersion: number;
+    acks?: boolean | undefined;
+} | {
+    t: "ack";
+    n: number;
+} | {
+    t: "hold";
+    id: number;
+    at: string;
+    token: {
+        name: string;
+        scope: "local" | "remote";
+        version: number;
+        input: Schema;
+        host?: {
+            name: string;
+        } | {
+            prefix: string;
+            key: string;
+        } | undefined;
+        variants: Record<string, Record<string, {
+            kind: "method";
+            args?: Schema | undefined;
+            result?: Schema | undefined;
+        } | {
+            kind: "state";
+            schema: Schema;
+        } | {
+            kind: "opaque";
+            id: string;
+        }>>;
+    };
+    input: unknown;
+    principal?: unknown;
+    origin?: string | undefined;
+    state?: false | undefined;
+    again?: true | undefined;
+} | {
+    t: "release";
+    id: number;
+} | {
+    t: "shape";
+    id: number;
+    variant?: string | undefined;
+    members: readonly string[];
+    contract: string;
+    state: readonly string[];
+} | {
+    t: "gone";
+    id: number;
+    error: {
+        code: "aborted" | "contract_mismatch" | "forbidden" | "gone" | "invalid" | "not_in_variant" | "not_ready" | "released" | "superseded" | "unavailable" | "upgrade_conflict" | "upgrade_required";
+        message: string;
+        reason?: string | undefined;
+    };
+} | {
+    t: "call";
+    id: number;
+    hold: number;
+    member: string;
+    args?: unknown;
+    root?: {
+        rootId: string;
+        codeVersion: number;
+    } | undefined;
+} | {
+    t: "result";
+    id: number;
+    value?: unknown;
+    error?: {
+        code: "aborted" | "contract_mismatch" | "forbidden" | "gone" | "invalid" | "not_in_variant" | "not_ready" | "released" | "superseded" | "unavailable" | "upgrade_conflict" | "upgrade_required";
+        message: string;
+        reason?: string | undefined;
+    } | undefined;
+} | {
+    t: "cancel";
+    id: number;
+} | {
+    t: "sub";
+    hold: number;
+} | {
+    t: "unsub";
+    hold: number;
+} | {
+    t: "resync";
+    hold: number;
+    m: string;
+} | {
+    t: "state";
+    hold: number;
+    m: string;
+    as: "error" | "ops" | "reset" | "snap";
+    value?: unknown;
+    ops?: readonly (readonly unknown[])[] | undefined;
+    error?: {
+        code: "aborted" | "contract_mismatch" | "forbidden" | "gone" | "invalid" | "not_in_variant" | "not_ready" | "released" | "superseded" | "unavailable" | "upgrade_conflict" | "upgrade_required";
+        message: string;
+        reason?: string | undefined;
+    } | undefined;
+} | {
+    t: "ping";
+    n: number;
+} | {
+    t: "pong";
+    n: number;
+} | {
+    t: "bye";
+    reason?: string | undefined;
+} | {
+    t: "root_end";
+    rootId: string;
+} | {
+    t: "invalidate";
+    pattern: Record<string, unknown>;
+} | {
+    t: "prepare";
+    reload: number;
+    codeVersion: number;
+    plugins: readonly string[];
+    options: {
+        remove?: readonly string[] | undefined;
+        gateDeadline?: number | undefined;
+        retireDeadline?: number | undefined;
+    };
+} | {
+    t: "vote";
+    reload: number;
+    error?: {
+        code: "aborted" | "contract_mismatch" | "forbidden" | "gone" | "invalid" | "not_in_variant" | "not_ready" | "released" | "superseded" | "unavailable" | "upgrade_conflict" | "upgrade_required";
+        message: string;
+        reason?: string | undefined;
+    } | undefined;
+    report?: {
+        codeVersion: number;
+        previous: number;
+        changed: readonly string[];
+        removed: readonly string[];
+        prepared: readonly string[];
+        gated: readonly string[];
+    } | undefined;
+} | {
+    t: "commit";
+    reload: number;
+} | {
+    t: "retire";
+    codeVersion: number;
+} | {
+    t: "abort";
+    reload: number;
+}>;
 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;

package/dist/wire.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA,OAAO,EAYN,KAAK,MAAM,EACX,KAAK,MAAM,EAIX,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAqB,UAAU,EAAE,MAAM,aAAa,CAAC;AAe5D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAUlC,QAAA,MAAM,aAAa;;;EAA2D,CAAC;AAC/E,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyGf,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AAE/C,6EAA6E;AAC7E,eAAO,MAAM,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,KAAkC,CAAC;AAEtF,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAOrD;AAED,eAAO,MAAM,aAAa,UAAW,SAAS,KAAG,UACyD,CAAC"}

package/dist/wire.js

@@ -1,5 +1,4 @@
-import { Type } from "typebox";
-import { Value } from "typebox/value";
+import { arr, bool, compile, int, lit, map, num, obj, oneOf, opt, str, union, unknown, } from "@earendil-works/pi-schema";
 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
@@ -20,46 +19,48 @@ import { CHORD_ERROR_CODES, ChordError } from "./errors.js";
  * (`LinkOptions.onProtocolMismatch`).
  */
 export const PROTOCOL_VERSION = 4;
-const Id = Type.Integer({ minimum: 1 });
-const Name = Type.String({ minLength: 1 });
-const Reload = Type.Integer({ minimum: 1 });
-/** 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 Id = int({ minimum: 1 });
+const Name = str({ minLength: 1 });
+const Reload = int({ minimum: 1 });
+/** Arrays a sender may pass as readonly: the same schema, a readonly type. */
+const List = (item) => arr(item);
+/** An object that admits fields it does not name (a newer peer's), as every frame does. */
+const Open = (properties) => obj(properties, { open: true });
+const RootRefSchema = Open({ rootId: Name, codeVersion: int({ minimum: 1 }) });
+const WireErrorSchema = Open({
+    code: oneOf(CHORD_ERROR_CODES),
+    message: str(),
+    reason: opt(str()),
 });
-const WireReloadOptionsSchema = Type.Object({
-    remove: Type.Optional(List(Type.String())),
-    gateDeadline: Type.Optional(Type.Number()),
-    retireDeadline: Type.Optional(Type.Number()),
+const WireReloadOptionsSchema = Open({
+    remove: opt(List(str())),
+    gateDeadline: opt(num()),
+    retireDeadline: opt(num()),
 });
 /** 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 WireReloadReportSchema = Open({
+    codeVersion: int(),
+    previous: int(),
+    changed: List(str()),
+    removed: List(str()),
+    prepared: List(str()),
+    gated: List(str()),
 });
-const FrameSchema = Type.Union([
-    Type.Object({
-        t: Type.Literal("hello"),
+const FrameSchema = union([
+    Open({
+        t: lit("hello"),
         /** The link protocol version (`PROTOCOL_VERSION`; absent: 1). Peers of another version close the link. */
-        protocol: Type.Optional(Type.Integer({ minimum: 1 })),
+        protocol: opt(int({ minimum: 1 })),
         name: Name,
-        kind: Type.Union([Type.Literal("host"), Type.Literal("client")]),
-        codeVersion: Type.Integer({ minimum: 0 }),
+        kind: union([lit("host"), lit("client")]),
+        codeVersion: int({ minimum: 0 }),
         /** The sender acknowledges what it receives (`ack`). Flow control applies only when both hellos say so. */
-        acks: Type.Optional(Type.Boolean()),
+        acks: opt(bool()),
     }),
     /** 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"),
+    Open({ t: lit("ack"), n: int({ minimum: 1 }) }),
+    Open({
+        t: lit("hold"),
         id: Id,
         /**
          * Target host name, resolved by the consumer from the token's `host` and `input`. Relays route on it after
@@ -69,90 +70,90 @@ const FrameSchema = Type.Union([
         /** 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(),
+        input: unknown(),
         /** A forwarded principal. Honored only on frames from the parent link. */
-        principal: Type.Optional(Type.Unknown()),
+        principal: opt(unknown()),
         /**
          * 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),
+        origin: opt(Name),
         /** False: no state for this hold until `sub` (a method-only binding). */
-        state: Type.Optional(Type.Literal(false)),
+        state: opt(lit(false)),
         /** The consumer already has values (a re-hold after a link loss): its unit is not urgent. */
-        again: Type.Optional(Type.Literal(true)),
+        again: opt(lit(true)),
     }),
-    Type.Object({ t: Type.Literal("release"), id: Id }),
-    Type.Object({
-        t: Type.Literal("shape"),
+    Open({ t: lit("release"), id: Id }),
+    Open({
+        t: lit("shape"),
         id: Id,
-        variant: Type.Optional(Type.String()),
-        members: List(Type.String()),
-        contract: Type.String(),
+        variant: opt(str()),
+        members: List(str()),
+        contract: str(),
         /** 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: WireErrorSchema }),
-    Type.Object({
-        t: Type.Literal("call"),
+    Open({ t: lit("gone"), id: Id, error: WireErrorSchema }),
+    Open({
+        t: lit("call"),
         id: Id,
         hold: Id,
         member: Name,
-        args: Type.Optional(Type.Unknown()),
+        args: opt(unknown()),
         /** Absent: the receiving host starts a root (browsers never carry roots). */
-        root: Type.Optional(RootRefSchema),
+        root: opt(RootRefSchema),
     }),
-    Type.Object({
-        t: Type.Literal("result"),
+    Open({
+        t: lit("result"),
         id: Id,
-        value: Type.Optional(Type.Unknown()),
-        error: Type.Optional(WireErrorSchema),
+        value: opt(unknown()),
+        error: opt(WireErrorSchema),
     }),
-    Type.Object({ t: Type.Literal("cancel"), id: Id }),
+    Open({ t: lit("cancel"), id: Id }),
     /** Starts the state of a hold opened with `state: false` (answered with a unit). */
-    Type.Object({ t: Type.Literal("sub"), hold: Id }),
+    Open({ t: lit("sub"), hold: Id }),
     /** Stops the state of a hold. */
-    Type.Object({ t: Type.Literal("unsub"), hold: Id }),
+    Open({ t: lit("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"),
+    Open({ t: lit("resync"), hold: Id, m: Name }),
+    Open({
+        t: lit("state"),
         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()),
+        as: union([lit("snap"), lit("reset"), lit("ops"), lit("error")]),
+        value: opt(unknown()),
         /** Encoded with the stream's delta encoder; the decoder validates each op. */
-        ops: Type.Optional(List(List(Type.Unknown()))),
-        error: Type.Optional(WireErrorSchema),
+        ops: opt(List(List(unknown()))),
+        error: opt(WireErrorSchema),
     }),
-    Type.Object({ t: Type.Literal("ping"), n: Type.Integer() }),
-    Type.Object({ t: Type.Literal("pong"), n: Type.Integer() }),
+    Open({ t: lit("ping"), n: int() }),
+    Open({ t: lit("pong"), n: int() }),
     /** 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()) }),
+    Open({ t: lit("bye"), reason: opt(str()) }),
     /** 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"),
+    Open({ t: lit("root_end"), rootId: Name }),
+    Open({ t: lit("invalidate"), pattern: map(unknown()) }),
+    Open({
+        t: lit("prepare"),
         reload: Reload,
-        codeVersion: Type.Integer({ minimum: 1 }),
-        plugins: List(Type.String()),
+        codeVersion: int({ minimum: 1 }),
+        plugins: List(str()),
         options: WireReloadOptionsSchema,
     }),
-    Type.Object({
-        t: Type.Literal("vote"),
+    Open({
+        t: lit("vote"),
         reload: Reload,
-        error: Type.Optional(WireErrorSchema),
-        report: Type.Optional(WireReloadReportSchema),
+        error: opt(WireErrorSchema),
+        report: opt(WireReloadReportSchema),
     }),
-    Type.Object({ t: Type.Literal("commit"), reload: Reload }),
+    Open({ t: lit("commit"), reload: Reload }),
     /** 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 }),
+    Open({ t: lit("retire"), codeVersion: int({ minimum: 1 }) }),
+    Open({ t: lit("abort"), reload: Reload }),
 ]);
 /** A frame that passes validation; anything else is a protocol violation. */
-export const isFrame = (value) => Value.Check(FrameSchema, value);
+export const isFrame = compile(FrameSchema).check;
 export function toWireError(error) {
     if (error instanceof ChordError) {
         return error.reason === undefined