@jarenjs/contract 0.43.1

package/dist/types/client/outcome.d.ts

@@ -0,0 +1,289 @@
+/**
+ * @file The client-side outcome (docs/CONTRACT-FORMAT.md §10): the JSON
+ * value every `invoke` resolves to — `{ ok: true, value, meta }` or
+ * `{ ok: false, kind, error, meta }` with `kind` one of `failure`
+ * (a declared operation error, or a taxonomy error the server answered),
+ * `network` (the transport failed), `contract` (the peer violated the
+ * contract: an invalid response, an undeclared code, a malformed frame —
+ * or the client refused pre-send) and `cancelled` (a local abort). Never
+ * an `Error`, a `Response` or a `Headers`: JSON only, so the value can
+ * land in app state unchanged.
+ *
+ * `assembleOutcome` is binding-neutral: it takes what a wire answered as
+ * `{ status | null, headers, text | value | error }` and the operation's
+ * prepared route, and classifies. The HTTP client feeds it a status, the
+ * response headers and the body text; an in-process or message-port
+ * binding (no statuses) feeds `status: null` with a parsed `value` or a
+ * parsed error envelope. Nothing here performs I/O.
+ *
+ * Outcome, error and meta objects are built with a fixed member order so
+ * each shape is one hidden class — and the shapes `makeMeta` and
+ * `outcomeError` build ARE the D6 shapes of every binding (03A): `error`
+ * is always `{ code, message, status, details, retryable }`, `meta` is
+ * always `{ op, attempt, trace, revision, etag, notModified }`, and no
+ * member is ever `undefined` (`isJsonValue` — the predicate the app's
+ * task effect and state honor — rejects it, and the outcome would fall
+ * back to a string). A binding that cannot carry a member carries `null`
+ * (`status`, `etag`, `trace`) or `false` (`notModified`) and says so in
+ * its `capabilities`; it never omits the member. The member lists are
+ * exported (`OUTCOME_ERROR_MEMBERS`, `OUTCOME_META_MEMBERS`) so a later
+ * binding asserts against them instead of restating them.
+ */
+export type CompiledOperation = import('../compile.js').CompiledOperation;
+export type Catalog = import('../http/wire.js').Catalog;
+export type OutcomeMeta = {
+    op: string;
+    attempt: unknown;
+    trace: string | null;
+    revision: string | null;
+    etag: string | null;
+    notModified: boolean;
+};
+export type OutcomeError = {
+    code: string;
+    message: string;
+    status: number | null;
+    details: unknown;
+    retryable: boolean;
+};
+/**
+ * @typedef {import('../compile.js').CompiledOperation} CompiledOperation
+ * @typedef {import('../http/wire.js').Catalog} Catalog
+ */
+/**
+ * The correlation members of every outcome. `op` is the operation id;
+ * `attempt` is the CALLER's attempt id (`ctx.attempt`, `null` when the
+ * caller gave none) and is never read from a response; `trace` is the
+ * SERVER's request id (`x-jaren-trace`), `null` when the wire carried
+ * none; `revision` is reserved for the contract revision; `etag` is the
+ * entity tag a success carried (`null` otherwise); `notModified` is true
+ * exactly for a 304.
+ * @typedef {Object} OutcomeMeta
+ * @property {string} op
+ * @property {unknown} attempt
+ * @property {string | null} trace
+ * @property {string | null} revision
+ * @property {string | null} etag
+ * @property {boolean} notModified
+ */
+/**
+ * The error member of a failed outcome: a stable `code` (a declared
+ * error code, a `JC2xxx` taxonomy code, or a `JC205x` client code), a
+ * rendered `message`, the HTTP `status` when the binding carries one
+ * (`null` otherwise), `details` (`null` when none — an outcome is JSON,
+ * so no member is ever `undefined`) and whether the caller may retry.
+ * @typedef {Object} OutcomeError
+ * @property {string} code
+ * @property {string} message
+ * @property {number | null} status
+ * @property {unknown} details
+ * @property {boolean} retryable
+ */
+/**
+ * The members of every outcome `error`, in order (D6). Frozen.
+ * @type {readonly ['code', 'message', 'status', 'details', 'retryable']}
+ */
+export declare const OUTCOME_ERROR_MEMBERS: readonly ['code', 'message', 'status', 'details', 'retryable'];
+/**
+ * The members of every outcome `meta`, in order (D6). Frozen.
+ * @type {readonly ['op', 'attempt', 'trace', 'revision', 'etag', 'notModified']}
+ */
+export declare const OUTCOME_META_MEMBERS: readonly ['op', 'attempt', 'trace', 'revision', 'etag', 'notModified'];
+export type OkOutcome = {
+    ok: true;
+    value: unknown;
+    meta: OutcomeMeta;
+};
+export type FailedOutcome = {
+    ok: false;
+    kind: 'failure' | 'network' | 'contract' | 'cancelled';
+    error: OutcomeError;
+    meta: OutcomeMeta;
+};
+export type Outcome = OkOutcome | FailedOutcome;
+/**
+ * @typedef {{ ok: true, value: unknown, meta: OutcomeMeta }} OkOutcome
+ * @typedef {{ ok: false, kind: 'failure' | 'network' | 'contract' | 'cancelled', error: OutcomeError, meta: OutcomeMeta }} FailedOutcome
+ * @typedef {OkOutcome | FailedOutcome} Outcome
+ */
+/**
+ * The client-side taxonomy as data: code → `{ msgid, retryable }`. The
+ * normative table is docs/CONTRACT-FORMAT.md §10; a test holds the two
+ * equal, and equal to `CONTRACT_CODES` and the English catalog.
+ * `retryable` of `JC2055` is decided per response (5xx and 429 are
+ * retryable); the row carries the default.
+ */
+export declare const CLIENT_ERRORS: Readonly<{
+    JC2050: Readonly<{
+        msgid: "contract/client-invalid-input";
+        retryable: false;
+    }>;
+    JC2051: Readonly<{
+        msgid: "contract/network";
+        retryable: true;
+    }>;
+    JC2052: Readonly<{
+        msgid: "contract/cancelled";
+        retryable: false;
+    }>;
+    JC2053: Readonly<{
+        msgid: "contract/invalid-response";
+        retryable: false;
+    }>;
+    JC2054: Readonly<{
+        msgid: "contract/key-storage-failed";
+        retryable: false;
+    }>;
+    JC2055: Readonly<{
+        msgid: "contract/undeclared-response";
+        retryable: false;
+    }>;
+    JC2056: Readonly<{
+        msgid: "contract/not-a-contract";
+        retryable: false;
+    }>;
+    JC2057: Readonly<{
+        msgid: "contract/incompatible";
+        retryable: false;
+    }>;
+    JC2058: Readonly<{
+        msgid: "contract/host-failed";
+        retryable: false;
+    }>;
+}>;
+export type OutcomeRoute = {
+    id: string;
+    validateOutput: (value: unknown) => any;
+    errors: Readonly<Record<string, import('../compile.js').CompiledErrorDecl>>;
+    retryOn: ReadonlySet<string>;
+    details: 'none' | 'paths' | 'full';
+};
+/**
+ * What the outcome assembler reads per operation, decided once.
+ * @typedef {Object} OutcomeRoute
+ * @property {string} id
+ * @property {(value: unknown) => any} validateOutput
+ * @property {Readonly<Record<string, import('../compile.js').CompiledErrorDecl>>} errors
+ * @property {ReadonlySet<string>} retryOn
+ * @property {'none' | 'paths' | 'full'} details
+ */
+/**
+ * Prepare an operation for the assembler.
+ * @param {CompiledOperation} op
+ * @returns {OutcomeRoute}
+ */
+export declare function prepareOutcomeRoute(op: CompiledOperation): OutcomeRoute;
+/**
+ * A meta object in its fixed member order.
+ * @param {string} op
+ * @param {unknown} attempt
+ * @param {string | null} trace
+ * @returns {OutcomeMeta}
+ */
+export declare function makeMeta(op: string, attempt: unknown, trace: string | null): OutcomeMeta;
+/**
+ * @param {unknown} value
+ * @param {OutcomeMeta} meta
+ * @returns {OkOutcome}
+ */
+export declare function okOutcome(value: unknown, meta: OutcomeMeta): OkOutcome;
+/**
+ * @param {'failure' | 'network' | 'contract' | 'cancelled'} kind
+ * @param {OutcomeError} error
+ * @param {OutcomeMeta} meta
+ * @returns {FailedOutcome}
+ */
+export declare function failedOutcome(kind: 'failure' | 'network' | 'contract' | 'cancelled', error: OutcomeError, meta: OutcomeMeta): FailedOutcome;
+/**
+ * An error object in its fixed member order.
+ * @param {string} code
+ * @param {string} message
+ * @param {number | null} status
+ * @param {unknown} details
+ * @param {boolean} retryable
+ * @returns {OutcomeError}
+ */
+export declare function outcomeError(code: string, message: string, status: number | null, details: unknown, retryable: boolean): OutcomeError;
+/**
+ * A client-originated error (`JC205x`): message from the catalog, the
+ * row's `retryable` unless overridden.
+ * @param {Catalog | null} catalog
+ * @param {keyof typeof CLIENT_ERRORS} code
+ * @param {Record<string, unknown>} params
+ * @param {number | null} status
+ * @param {unknown} details
+ * @param {boolean} [retryable]
+ * @returns {OutcomeError}
+ */
+export declare function clientError(catalog: Catalog | null, code: keyof typeof CLIENT_ERRORS, params: Record<string, unknown>, status: number | null, details: unknown, retryable?: boolean): OutcomeError;
+/**
+ * True for a value shaped like an outcome: a plain object with a
+ * boolean `ok`, a `meta` carrying every D6 meta member, and, when
+ * failed, a `kind` and an `error` carrying every D6 error member with a
+ * string `code` — no member `undefined`. Reads guardedly, so a hostile
+ * value classifies as "not an outcome".
+ * @param {unknown} value
+ * @returns {value is Outcome}
+ */
+export declare function isOutcome(value: unknown): value is Outcome;
+export type WireMessage = {
+    status: number | null;
+    headers: Readonly<Record<string, string>> | null;
+    text?: string | null;
+    value?: unknown;
+    error?: unknown;
+};
+/**
+ * What a wire answered, as the assembler reads it. Exactly one of `text`,
+ * `value` or `error` carries the body: `text` is the raw body of an HTTP
+ * response (parsed here; `''`/`null` is an empty body), `value` a
+ * success value already decoded by a JSON-framed binding, `error` an
+ * error envelope (`{ code, message?, details?, retryable? }`) already
+ * decoded by such a binding. `status` is the HTTP status or `null` on a
+ * binding that carries none; `headers` holds `etag` when the binding
+ * carries entity tags.
+ * @typedef {Object} WireMessage
+ * @property {number | null} status
+ * @property {Readonly<Record<string, string>> | null} headers
+ * @property {string | null} [text]
+ * @property {unknown} [value]
+ * @property {unknown} [error]
+ */
+/**
+ * Assemble the outcome of one response. TOTAL: every shape the peer can
+ * answer classifies; nothing throws.
+ *
+ * - a 2xx (or `status: null` with a `value`): an empty body is `null`;
+ *   otherwise the text is parsed (`JC2053` when not JSON) and the value
+ *   validated against the output schema (`JC2053` with details by
+ *   `policy.errors.details`) → `{ ok: true, value, meta }` with `meta.etag`
+ *   from the header;
+ * - a 304 → `{ ok: true, value: null, meta }` with `notModified: true`
+ *   and the `etag`;
+ * - any other status: the body is parsed as JSON; a string `code` that
+ *   the operation declares, or a `JC2xxx` taxonomy code, is `kind:
+ *   "failure"` with `{ code, message, status, details?, retryable }` —
+ *   the body's `message` when it is a string, else rendered; `retryable`
+ *   the body's boolean, else whether `policy.retry.on` names the code;
+ *   anything else (a non-JSON body, no string code, an unknown code) is
+ *   `kind: "contract"` `JC2055` with the status kept and `retryable`
+ *   for 5xx/429.
+ *
+ * @param {OutcomeRoute} route
+ * @param {WireMessage} message
+ * @param {OutcomeMeta} meta - mutated: `etag`/`notModified` are set here
+ * @param {Catalog | null} catalog
+ * @returns {Outcome}
+ */
+export declare function assembleOutcome(route: OutcomeRoute, message: WireMessage, meta: OutcomeMeta, catalog: Catalog | null): Outcome;
+/**
+ * The outcome a handler projects a THROWN host value into when it must
+ * settle with an outcome (the app effect): `kind: "contract"` `JC2058`,
+ * the message from the catalog, nothing of the thrown value (its text
+ * may carry anything).
+ * @param {string} op
+ * @param {unknown} attempt
+ * @param {Catalog | null} catalog
+ * @returns {Outcome}
+ */
+export declare function hostFailureOutcome(op: string, attempt: unknown, catalog: Catalog | null): Outcome;

package/dist/types/compat.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Version compatibility — the one implementation of the
+ * negotiation rule (docs/CONTRACT-FORMAT.md §10.4, §13.1): two ends
+ * speak when they declare the same `version`, or when either end's
+ * `compat` list names the other's `version`. The client's `negotiate()`
+ * and any server that wants to refuse an incompatible peer both call
+ * this; `diffContracts` is the complementary question (WHAT changed),
+ * this is the declared answer (do the authors CLAIM the ends speak).
+ */
+export type VersionedContract = {
+    version?: string | null;
+    compat?: readonly string[] | null;
+};
+/**
+ * Why two ends are compatible, or `null` when they are not:
+ * `'same-version'` (equal `version`s — two unversioned contracts included),
+ * `'server-accepts'` (the server's `compat` names the client's version),
+ * `'client-accepts'` (the client's `compat` names the server's version).
+ * Checked in that order, so the strongest claim wins the reason.
+ * @param {VersionedContract} client
+ * @param {VersionedContract} server
+ * @returns {'same-version' | 'server-accepts' | 'client-accepts' | null}
+ */
+export declare function compatReason(client: VersionedContract, server: VersionedContract): 'same-version' | 'server-accepts' | 'client-accepts' | null;
+/**
+ * Whether a client contract and a server contract declare themselves
+ * compatible — the negotiation rule as a predicate. Takes compiled
+ * contracts, raw documents or well-known descriptions alike (it reads
+ * only `version` and `compat`).
+ * @param {VersionedContract} clientContract
+ * @param {VersionedContract} serverContract
+ * @returns {boolean}
+ * @example
+ * isCompatible({ version: '5', compat: ['4'] }, { version: '4' }); // true — the client accepts 4
+ */
+export declare function isCompatible(clientContract: VersionedContract, serverContract: VersionedContract): boolean;

package/dist/types/compile.d.ts

@@ -0,0 +1,196 @@
+/**
+ * @file `compileContract`: a `$contract` document (docs/CONTRACT-FORMAT.md
+ * §2) becomes a frozen `Contract` — per-operation validators, transport
+ * normalizers, the materialized HTTP binding with every default resolved,
+ * and one path matcher over the operation table.
+ *
+ * Two stages, like every compiler in the suite: everything is decided
+ * here, once; nothing that runs per request allocates or re-reads the
+ * document. The document is TRUSTED input but is still read totally: it
+ * is first snapshotted through guarded access into plain JSON (a
+ * throwing accessor, a non-JSON member or a cycle is `JC0001` at the
+ * member), then validated rule by rule against a CLOSED vocabulary
+ * (`JC0013` — a silently ignored `policy` member is a behavior bug), and
+ * only then compiled. Every refusal is a `ContractCompileError` with the
+ * `docPath` of the member at fault.
+ *
+ * `$ref` resolution rides the validator: the document is registered under
+ * a synthetic id and each operation schema is compiled as a `$ref` into
+ * it, so `#/$defs/Product` means the contract's own `$defs` and an
+ * absolute `$id` means one of `options.schemas`. Unresolved is `JC0007`
+ * at compile — never at request time.
+ */
+import { JarenValidator } from '@jarenjs/validate';
+export type RefScope = {
+    /**
+     * - the snapshotted document
+     */
+    src: any;
+    anchors: Map<string, object>;
+    validator: JarenValidator<any>;
+};
+export type CompiledValidate = (value: unknown) => any;
+export type InputTransport = {
+    normalize: (value: any) => any;
+    members: {
+        path: readonly string[];
+        query: readonly string[];
+        header: readonly string[];
+        repeated: readonly string[];
+    };
+    schemas: Readonly<Record<string, any>>;
+    required: readonly string[];
+};
+export type CompiledInput = {
+    /**
+     * - the declared input schema (frozen source)
+     */
+    schema: any;
+    /**
+     * - the object schema `schema` resolves to: itself,
+     * or the end of its `$ref` chain (inside the document or a registered
+     * schema) — whose `properties` are the operation's members; frozen
+     */
+    effective: any;
+    validate: CompiledValidate;
+    /**
+     * - `null` when no member travels as a string
+     */
+    transport: InputTransport | null;
+};
+export type CompiledOutput = {
+    schema: any;
+    validate: CompiledValidate;
+};
+export type CompiledErrorDecl = {
+    status: number;
+    /**
+     * - `null` when undeclared
+     */
+    schema: any;
+    validate: CompiledValidate | null;
+};
+export type CompiledPolicy = {
+    task: 'switch' | 'exhaust' | 'concat' | 'parallel';
+    idempotency: 'none' | 'optional' | 'required';
+    /**
+     * - `input:<json-pointer>` or null
+     */
+    revision: string | null;
+    cache: 'none' | 'revision';
+    limits: {
+        maxBodyBytes: number;
+    };
+    errors: {
+        details: 'none' | 'paths' | 'full';
+    };
+    retry: {
+        max: number;
+        on: readonly string[];
+    } | null;
+    /**
+     *   - the stream policy of a subscribe operation, defaults materialized; `null` on every other kind
+     */
+    stream: {
+        resume: 'snapshot' | 'replay';
+        heartbeatMs: number;
+        maxPatchBytes: number | null;
+    } | null;
+    /**
+     * - who may see the operation: `server`
+     * keeps it out of the public projection and every projection built on it
+     */
+    audience: 'public' | 'server';
+};
+export type CompiledHttp = {
+    method: string;
+    path: string;
+    template: import('./path.js').ParsedPathTemplate;
+    variables: readonly string[];
+    in: Readonly<Record<string, 'path' | 'query' | 'header' | 'body'>>;
+    body: string | null;
+    status: number;
+    media: string;
+    opaque: boolean;
+};
+export type CompiledOperation = {
+    id: string;
+    kind: 'read' | 'command' | 'subscribe';
+    doc: string | null;
+    input: CompiledInput | null;
+    output: CompiledOutput;
+    errors: Readonly<Record<string, CompiledErrorDecl>>;
+    policy: CompiledPolicy;
+    http: CompiledHttp;
+};
+export type Contract = {
+    /**
+     * - the source document, deep-frozen
+     */
+    doc: any;
+    id: string | null;
+    version: string | null;
+    compat: readonly string[];
+    operations: Readonly<Record<string, CompiledOperation>>;
+    /**
+     * - operation ids in document order
+     */
+    ids: readonly string[];
+    match: (method: string, path: string) => {
+        op: CompiledOperation;
+        params: Readonly<Record<string, string>>;
+    } | null;
+    /**
+     * - the methods under which
+     * this path shape reaches an operation, sorted (`[]` for none) — what a
+     * 405 answers in `Allow`; the path only, query split off, like `match`
+     */
+    allowed: (path: string) => string[];
+    /**
+     * - a pure-JSON summary (docs/CONTRACT-FORMAT.md §3)
+     */
+    describe: () => any;
+    /**
+     * - the SHA-256 (lowercase hex)
+     * over the RFC 8785 canonical bytes of the public projection, memoized —
+     * computed at most once per compiled contract (docs/CONTRACT-FORMAT.md §14)
+     */
+    revision: () => Promise<string>;
+    /**
+     * - frozen view of the document's `$defs` (`{}` when absent)
+     */
+    $defs: any;
+};
+export type CompileContractOptions = {
+    /**
+     * - the validator every schema
+     * compiles through; default `new JarenValidator({ collectErrors: true, skipErrors: false })`
+     */
+    validator?: JarenValidator<any>;
+    /**
+     * - schemas registered by `$id` before compile, so
+     * an absolute `$ref` resolves
+     */
+    schemas?: Record<string, any>[];
+};
+/**
+ * Compile a `$contract` document (docs/CONTRACT-FORMAT.md) into a frozen
+ * `Contract`: every operation's `input`/`output`/error validators, its
+ * transport normalizer, its resolved policy and materialized HTTP
+ * binding, and one `match(method, path)` over the whole table.
+ * Synchronous; total for a hostile document; no I/O.
+ *
+ * @param {unknown} doc - the contract document
+ * @param {CompileContractOptions} [options]
+ * @returns {Contract}
+ * @throws {ContractCompileError} when the document violates the format (`JC0001–JC0017`)
+ * @example
+ * const contract = compileContract({
+ *   $contract: '0.1',
+ *   operations: {
+ *     'catalog.load': { kind: 'read', output: true, http: { method: 'GET', path: '/api/catalog' } },
+ *   },
+ * });
+ * contract.match('GET', '/api/catalog').op.id; // 'catalog.load'
+ */
+export declare function compileContract(doc: unknown, options?: CompileContractOptions): Contract;

package/dist/types/describe.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @file `describe()`: a compiled contract as pure JSON — the resolved
+ * binding and policy of every operation, with each defaulted value
+ * marked in `inferred` so a projection can tell what the author
+ * declared from what the compiler filled in. Stable member order, no
+ * functions, no schemas (those stay on the compiled operations); this is
+ * what a CLI prints and what a golden test compares. `revision` is read
+ * synchronously from the memo (`peekRevision`), so it is `null` until
+ * someone awaited `contract.revision()` — the well-known responder does
+ * exactly that before it renders this document.
+ */
+export type OperationDescription = {
+    id: string;
+    kind: 'read' | 'command';
+    method: string;
+    /**
+     * - the canonical `{name}` template
+     */
+    path: string;
+    status: number;
+    media: string;
+    opaque: boolean;
+    /**
+     * - member → location
+     */
+    in: Readonly<Record<string, string>>;
+    /**
+     * - the whole-body member, or null
+     */
+    body: string | null;
+    task: string;
+    idempotency: string;
+    cache: string;
+    /**
+     * - the resolved stream policy; present exactly on subscribe operations
+     */
+    stream?: {
+        resume: string;
+        heartbeatMs: number;
+        maxPatchBytes: number | null;
+    };
+    /**
+     *   which of the above the compiler defaulted: `http` when the whole
+     *   binding is the canonical `POST /<id>`, `in` listing the members whose
+     *   location was not declared
+     */
+    inferred: {
+        http: boolean;
+        status: boolean;
+        media: boolean;
+        in: readonly string[];
+        task: boolean;
+        idempotency: boolean;
+        cache: boolean;
+    };
+};
+export type ContractDescription = {
+    $contract: '0.1';
+    id: string | null;
+    version: string | null;
+    compat: readonly string[];
+    /**
+     * - the contract revision (64 lowercase
+     * hex; docs/CONTRACT-FORMAT.md §14) when `contract.revision()` has
+     * settled, `null` before — `describe()` stays synchronous and never
+     * computes it
+     */
+    revision: string | null;
+    /**
+     * - document order
+     */
+    operations: OperationDescription[];
+};
+/**
+ * The description of one operation.
+ * @typedef {Object} OperationDescription
+ * @property {string} id
+ * @property {'read' | 'command'} kind
+ * @property {string} method
+ * @property {string} path - the canonical `{name}` template
+ * @property {number} status
+ * @property {string} media
+ * @property {boolean} opaque
+ * @property {Readonly<Record<string, string>>} in - member → location
+ * @property {string | null} body - the whole-body member, or null
+ * @property {string} task
+ * @property {string} idempotency
+ * @property {string} cache
+ * @property {{ resume: string, heartbeatMs: number, maxPatchBytes: number | null }} [stream]
+ *   - the resolved stream policy; present exactly on subscribe operations
+ * @property {{ http: boolean, status: boolean, media: boolean, in: readonly string[], task: boolean, idempotency: boolean, cache: boolean }} inferred
+ *   which of the above the compiler defaulted: `http` when the whole
+ *   binding is the canonical `POST /<id>`, `in` listing the members whose
+ *   location was not declared
+ */
+/**
+ * The description of a contract.
+ * @typedef {Object} ContractDescription
+ * @property {'0.1'} $contract
+ * @property {string | null} id
+ * @property {string | null} version
+ * @property {readonly string[]} compat
+ * @property {string | null} revision - the contract revision (64 lowercase
+ *   hex; docs/CONTRACT-FORMAT.md §14) when `contract.revision()` has
+ *   settled, `null` before — `describe()` stays synchronous and never
+ *   computes it
+ * @property {OperationDescription[]} operations - document order
+ */
+/**
+ * Describe a compiled contract. Reads the compiled operations for the
+ * resolved values and the frozen source document for what was declared.
+ * @param {import('./compile.js').Contract} contract
+ * @returns {ContractDescription}
+ */
+export declare function describeContract(contract: import('./compile.js').Contract): ContractDescription;