@jarenjs/contract 0.43.1

package/dist/types/app/binding.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @file `contractAppBinding(contract, options)`: the generated
+ * `@jarenjs/app` documents of a contract (docs/CONTRACT-FORMAT.md §11) —
+ * pure JSON, the `fsmToApp` shape, with no import in either direction.
+ * For every operation the app uses it emits one task slot in a state
+ * slice, a `start`, a `done` and a `reset` action in the async-task
+ * convention of `@jarenjs/app`'s TASKS.md (a monotonic slot `id`, the
+ * start patches the slot AND hands the new id to the effect, the
+ * completion guards on that id so an out-of-order response is a
+ * provable no-op), and a JSON Schema for the slice to compose into
+ * `validateState`. The app document names ONE effect, `run: "contract"`;
+ * the per-operation task mode is never NAMED in the document — it comes
+ * from `policy.task` through `createContractEffect` — but the generator
+ * derives the document's state-side guards from it exactly as it
+ * derives the document's shape from `kind`, so that the slot and the
+ * effect tell the same story in every mode (D10): an `exhaust`
+ * operation's `start` is a no-op in state while its slot is `loading`
+ * (the effect would ignore the duplicate start; state decides first, so
+ * the one completion that arrives carries the current id and lands).
+ */
+export type Contract = import('../compile.js').Contract;
+export type ContractAppBindingOptions = {
+    /**
+     * - the action-name prefix; default `contract/`
+     */
+    namespace?: string;
+    /**
+     * - where the slice lives in app state, as a
+     * chain of identifier-safe segments; default `/contract`
+     */
+    statePath?: string;
+    /**
+     * - the operations the app uses; default every operation
+     */
+    ops?: readonly string[];
+};
+export type TaskSlot = {
+    id: number;
+    status: 'idle' | 'loading' | 'done' | 'error';
+    kind: 'failure' | 'network' | 'contract' | null;
+    value: unknown;
+    error: unknown;
+    meta: unknown;
+};
+export type StreamSlot = {
+    id: number;
+    status: 'idle' | 'live' | 'error';
+    kind: 'failure' | 'network' | 'contract' | null;
+    input: unknown;
+    value: unknown;
+    error: unknown;
+    meta: unknown;
+    seq: number;
+};
+export type ContractAppBinding = {
+    /**
+     * - operation id → its initial slot; mount it at `statePath`
+     */
+    slice: Record<string, TaskSlot | StreamSlot>;
+    /**
+     * - per read/command operation
+     * `<namespace><op>/start`, `/done` and `/reset`; per subscribe operation
+     * `/start`, `/stop`, `/snapshot`, `/patch`, `/error` and `/reset`
+     */
+    actions: Record<string, any>;
+    /**
+     * - one subscription entry per subscribe operation
+     * (`run: "contract-stream"`); spread into the app document's `subs`
+     */
+    subs: any[];
+    /**
+     * - the slice's JSON Schema, `$defs` of the contract carried, for `validateState`
+     */
+    schema: any;
+    /**
+     * - the effect name the task actions invoke
+     */
+    effect: 'contract';
+    /**
+     * - the handler name the subs entries run
+     */
+    subscription: 'contract-stream';
+};
+/**
+ * Generate the app documents of a contract: a state slice with one task
+ * slot per operation, `start`/`done`/`reset` actions per operation with
+ * the TASKS.md id guard built in, and the slice's JSON Schema.
+ *
+ * The `start` action takes the operation's input as `$payload`: it
+ * increments the slot `id`, sets `status: "loading"`, clears `kind` and
+ * `error`, and runs the `contract` effect with `{ op, input: $payload, id, done,
+ * slot }` — the `id` written as the same increment expression the patch
+ * uses (everything in an action evaluates against the PRE-transition
+ * state). For an operation whose `policy.task` is `exhaust` the whole
+ * start is wrapped in `$if: [{ $ne: [<slot>.status, "loading"] }, …]`
+ * — a `$if` without else is the empty sequence (APP-FORMAT §3.2): no
+ * patch, no effect, no render — so a duplicate start leaves the slot id
+ * where it is and the single completion lands. The `done` action guards
+ * on `$payload.id` against the slot id, reads the outcome from
+ * `$payload.result` (or `$payload.error`, where a host failure projected
+ * by the effect lands), and stores it: `ok` → `status: "done"`, `kind:
+ * null`, `value`, `meta`, `error: null`; otherwise `status: "error"`,
+ * `kind` (the outcome's), `error`, `meta`, and `value` UNTOUCHED — a
+ * failed reload keeps the last good value. The `reset` action releases
+ * the slot: `status: "idle"`, `kind: null`, `error: null`; `id`, `value`
+ * and `meta` stay (the id must stay monotonic so a late completion of a
+ * cancelled attempt is still rejected; the last good value survives a
+ * reset as it survives an error).
+ *
+ * @param {Contract} contract
+ * @param {ContractAppBindingOptions} [options]
+ * @returns {ContractAppBinding}
+ * @throws {ContractHostError} `JC1007` for an unknown/uncarriable operation in `ops` or a malformed option
+ * @example
+ * const { slice, actions, schema } = contractAppBinding(contract, { ops: ['catalog.load', 'product.save'] });
+ * createApp({ state: { contract: slice }, view, actions: { ...actions, ...own } }, {
+ *   effects: { contract: createContractEffect(client, { createTaskEffect }) },
+ *   validateState: (state) => validate(state),   // validate compiled over { properties: { contract: schema } }
+ * });
+ * app.dispatch('contract/catalog.load/start', { since: '2026-01-01T00:00:00Z' });
+ */
+export declare function contractAppBinding(contract: Contract, options?: ContractAppBindingOptions): ContractAppBinding;

package/dist/types/app/effect.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file `createContractEffect(client, options)`: ONE `@jarenjs/app`
+ * effect handler (`run: "contract"`) that calls any operation of a
+ * client and settles every descriptor with a D6 outcome
+ * (docs/CONTRACT-FORMAT.md §11). It owns one task effect per distinct
+ * `policy.task` mode the contract uses — built lazily through the
+ * `createTaskEffect` factory the host hands in from `@jarenjs/app` —
+ * and routes each descriptor `{ op, input, id, done, fail?, slot? }` to
+ * the mode's inner effect, so the per-operation concurrency semantics
+ * come from the contract's policy and never appear in the app document.
+ * This package imports nothing from `@jarenjs/app`; the factory crosses
+ * as a function, the documents as JSON.
+ *
+ * Settlement: the inner effect's `run` invokes the client with the
+ * slot's signal and the descriptor's `id` as the attempt; an outcome of
+ * `kind: "cancelled"` is turned into an `AbortError` so the task effect
+ * dispatches nothing (a superseded task is dead by design); every other
+ * outcome resolves and lands as `{ id, result: outcome }`; a host throw
+ * is projected — never flattened to a string — into a `JC2058` outcome
+ * that lands as `{ id, error: outcome }`.
+ */
+export type Contract = import('../compile.js').Contract;
+export type Outcome = import('../client/outcome.js').Outcome;
+export type ClientLike = {
+    invoke: (op: string, input: unknown, ctx: {
+        signal: AbortSignal;
+        attempt: unknown;
+    }) => Promise<Outcome> | Outcome;
+    contract: Contract;
+};
+export type TaskEffectFactory = (run: (props: any, signal: AbortSignal) => any, options: {
+    mode: string;
+    projectError: (err: unknown, props: any) => any;
+}) => TaskEffectLike;
+export type TaskEffectLike = ((props: any, dispatch: (name: string, payload?: any) => void) => void) & {
+    cancel: (slot?: string) => void;
+    cancelAll: () => void;
+    dispose: () => void;
+};
+export type ContractEffectOptions = {
+    /**
+     * - `createTaskEffect` from `@jarenjs/app` (required)
+     */
+    createTaskEffect: TaskEffectFactory;
+    /**
+     * - consulted
+     * first when the host throws; a result that is not an outcome falls
+     * back to the `JC2058` outcome
+     */
+    projectError?: (err: unknown, props: any) => any;
+    /**
+     * - compiled catalog for the `JC2058` message
+     */
+    catalog?: Record<string, (params: object) => string> | null;
+};
+export type ContractEffect = ((props: any, dispatch: (name: string, payload?: any) => void) => void) & {
+    cancel: (slot?: string) => void;
+    cancelAll: () => void;
+    dispose: () => void;
+};
+/**
+ * Make the `contract` effect of an app over a client. Register it as
+ * `effects: { contract: createContractEffect(client, { createTaskEffect }) }`;
+ * the generated actions of `contractAppBinding` invoke it.
+ *
+ * @param {ClientLike} client - an open client (`openHttpClient`, …)
+ * @param {ContractEffectOptions} options
+ * @returns {ContractEffect}
+ * @throws {ContractHostError} `JC1008` for a malformed client or option
+ * @example
+ * // createApp and createTaskEffect are the host's, imported from @jarenjs/app;
+ * // openHttpClient from '@jarenjs/contract/client', createContractEffect from '@jarenjs/contract/app'
+ * const client = openHttpClient(contract, { baseUrl });
+ * const effect = createContractEffect(client, { createTaskEffect });
+ * createApp(doc, { effects: { contract: effect } });
+ */
+export declare function createContractEffect(client: ClientLike, options: ContractEffectOptions): ContractEffect;

package/dist/types/app/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file The `@jarenjs/app` binding of a contract (docs/CONTRACT-FORMAT.md
+ * §11): `contractAppBinding` generates the state slice, the
+ * start/done/reset actions and the slice schema as pure JSON (the
+ * state-side guards derived from `policy.task`, the mode never named);
+ * `createContractEffect`
+ * makes the one `contract` effect those actions invoke, over any open
+ * client. Neither imports `@jarenjs/app` — the documents cross as JSON
+ * and the task-effect factory crosses as a function the host passes in.
+ */
+export { contractAppBinding } from './binding.js';
+export { createContractEffect } from './effect.js';
+export { createContractSubscription } from './subscription.js';
+export type ContractAppBinding = import('./binding.js').ContractAppBinding;
+export type ContractAppBindingOptions = import('./binding.js').ContractAppBindingOptions;
+export type TaskSlot = import('./binding.js').TaskSlot;
+export type StreamSlot = import('./binding.js').StreamSlot;
+export type ContractEffect = import('./effect.js').ContractEffect;
+export type ContractEffectOptions = import('./effect.js').ContractEffectOptions;
+export type ClientLike = import('./effect.js').ClientLike;
+export type StreamClientLike = import('./subscription.js').StreamClientLike;
+/**
+ * @typedef {import('./binding.js').ContractAppBinding} ContractAppBinding
+ * @typedef {import('./binding.js').ContractAppBindingOptions} ContractAppBindingOptions
+ * @typedef {import('./binding.js').TaskSlot} TaskSlot
+ * @typedef {import('./binding.js').StreamSlot} StreamSlot
+ * @typedef {import('./effect.js').ContractEffect} ContractEffect
+ * @typedef {import('./effect.js').ContractEffectOptions} ContractEffectOptions
+ * @typedef {import('./effect.js').ClientLike} ClientLike
+ * @typedef {import('./subscription.js').StreamClientLike} StreamClientLike
+ */

package/dist/types/app/subscription.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @file `createContractSubscription(client)`: the ONE `contract-stream`
+ * subscription handler the generated subs entries of
+ * `contractAppBinding` run (docs/CONTRACT-FORMAT.md §11.4). A handler is
+ * `(props, dispatch) => cleanup` — the `@jarenjs/app` subscription
+ * shape — so no task-effect factory is needed and this package still
+ * imports nothing from `@jarenjs/app`: the entry documents cross as
+ * JSON and the handler crosses as a function over a client.
+ *
+ * The handler subscribes through `client.subscribe`, maintains the
+ * document HOST-SIDE by applying each `{ patch, seq }` emission with
+ * `@jarenjs/json/patch` (copy-on-write — structural sharing is
+ * preserved end to end, which is what keeps the O(k) renderer's fast
+ * paths alive), and dispatches the named actions with `{ id, … }`
+ * payloads — the generated actions guard on the id (and, for `patch`,
+ * on a strictly greater `seq`), so a stale instance's dispatch is a
+ * provable no-op in state. An `onError` outcome lands in the error
+ * action as-is; a server `end` lands there too, as a `network`-kind
+ * outcome with the channel-closed code — the stream is gone and the
+ * slot must say so, so a view can offer a reconnect (a new `start`).
+ */
+import { CLIENT_ERRORS } from '../client/outcome.js';
+export type Contract = import('../compile.js').Contract;
+export type Outcome = import('../client/outcome.js').Outcome;
+export type Catalog = import('../http/wire.js').Catalog;
+export type StreamClientLike = {
+    subscribe: (op: string, input: unknown, options: object) => {
+        stop: () => void;
+    };
+    contract: Contract;
+};
+export type ContractSubscriptionOptions = {
+    /**
+     * - compiled catalog for the end/apply messages
+     */
+    catalog?: Catalog | null;
+};
+export type StreamProps = {
+    op: string;
+    id: number;
+    input: unknown;
+    snapshot: string;
+    patch: string;
+    error: string;
+};
+/**
+ * @typedef {import('../compile.js').Contract} Contract
+ * @typedef {import('../client/outcome.js').Outcome} Outcome
+ * @typedef {import('../http/wire.js').Catalog} Catalog
+ */
+/**
+ * A client binding that carries streams: what `openHttpClient` and
+ * `openPortClient` return. The handler reads `subscribe` only.
+ * @typedef {{ subscribe: (op: string, input: unknown, options: object) => { stop: () => void }, contract: Contract }} StreamClientLike
+ */
+/**
+ * @typedef {Object} ContractSubscriptionOptions
+ * @property {Catalog | null} [catalog] - compiled catalog for the end/apply messages
+ */
+/**
+ * The props of one generated subs entry: the operation, the slot id and
+ * input resolved from state, and the action names to dispatch.
+ * @typedef {{ op: string, id: number, input: unknown, snapshot: string, patch: string, error: string }} StreamProps
+ */
+/**
+ * Make the `contract-stream` subscription handler of an app over a
+ * client. Register it as `subs: { 'contract-stream':
+ * createContractSubscription(client) }`; the generated entries of
+ * `contractAppBinding` run it.
+ *
+ * @param {StreamClientLike} client - an open client whose `capabilities.stream` is true
+ * @param {ContractSubscriptionOptions} [options]
+ * @returns {(props: StreamProps, dispatch: (name: string, payload?: any) => void) => (() => void)}
+ * @throws {ContractHostError} `JC1008` for a malformed client or option
+ * @example
+ * createApp({ ...doc, subs: [...binding.subs] }, {
+ *   effects: { contract: createContractEffect(client, { createTaskEffect }) },
+ *   subs: { 'contract-stream': createContractSubscription(client) },
+ * });
+ */
+export declare function createContractSubscription(client: StreamClientLike, options?: ContractSubscriptionOptions): (props: StreamProps, dispatch: (name: string, payload?: any) => void) => (() => void);
+export { CLIENT_ERRORS };

package/dist/types/bundle.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Same-document schema reachability and bundling — the one place in
+ * the suite that answers "which `$defs` does this schema need?" and
+ * "make this schema stand alone". The public projection keeps exactly
+ * the reachable `$defs` of the retained operations (05 hashes that); a
+ * tool definition carries its input schema with the reachable `$defs`
+ * inlined under the schema's own `$defs`, because a tool schema must be
+ * self-contained.
+ *
+ * Reachability follows same-document `$ref`s (`#`, `#/…` pointers,
+ * `#anchor`) with the resolver `compileContract` itself uses
+ * (`@jarenjs/validate/normalize`), so a reference the compiler accepted
+ * resolves here by the same rules. A target is attributed to the `$defs`
+ * entry that CONTAINS it — `#/$defs/Product/properties/id` needs
+ * `Product` — and the entry is walked in turn. References that do not
+ * land inside `$defs` (`#`, a pointer into another operation's schema,
+ * an absolute `$id`) are left as written: the document states where
+ * shared schemas live, and that is `$defs`.
+ */
+/**
+ * The names of the document's `$defs` reachable from `roots` by
+ * same-document `$ref`, transitively, in first-reference order: the
+ * roots are walked in the order given, depth-first in member order, and
+ * a `$defs` entry is walked at the moment it is first reached. Data
+ * keywords (`const`, `enum`, `default`, `examples`) are not walked.
+ * @param {readonly unknown[]} roots - schemas (objects or booleans) rooted in `doc`
+ * @param {any} doc - the document holding `$defs` (a contract document, or any schema root)
+ * @returns {string[]}
+ */
+export declare function reachableDefs(roots: readonly unknown[], doc: any): string[];
+/**
+ * Make a schema stand alone: the schema with the `$defs` it reaches
+ * (transitively, first-reference order) copied under its own `$defs`, so
+ * every `#/$defs/X` it carries resolves inside the returned document. A
+ * boolean schema is returned as is; a schema that reaches nothing gains no
+ * `$defs`. A schema that declared its own `$defs` member loses it — at the
+ * new root that member would shadow the document's, and its entries were
+ * only addressable by a pointer through the operation anyway.
+ * @param {any} schema - a schema rooted in `doc`
+ * @param {any} doc - the document holding `$defs`
+ * @returns {any} a fresh top-level object sharing the schema's subtrees
+ */
+export declare function bundleSameDocument(schema: any, doc: any): any;

package/dist/types/cli.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * @file The `jaren-contract` command: compile a contract document and
+ * print or write one of its projections — `describe` (the `describe()`
+ * summary), `public` (the public projection), `openapi`, `types`
+ * (TypeScript declarations), `docs` (Markdown) — with `--check` to fail
+ * CI when a written artifact has drifted from what the document projects
+ * today; plus `diff --from a.json --to b.json`, the classified change
+ * report (docs/CONTRACT-FORMAT.md §13), whose `--fail-on <classes>`
+ * makes it a compatibility gate. Exit codes: 0 current/written (diff:
+ * no failing class), 1 drift under `--check` (diff: a `--fail-on` class
+ * is non-empty), 2 a usage error, an unreadable document or a compile
+ * refusal (printed as `code docPath message`).
+ */
+export {};

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

@@ -0,0 +1,242 @@
+/**
+ * @file `openHttpClient(contract, options)`: the HTTP client binding of a
+ * compiled contract (docs/CONTRACT-FORMAT.md §10) — the `open(contract,
+ * options) → Client` half of the driver pair whose server half is
+ * `serveHttp`. `invoke(op, input, ctx)` validates the input with the
+ * SAME compiled validator the server will run, splits it by the declared
+ * locations (path, query, header, body), sends it through an injectable
+ * `fetch`, and resolves a D6 outcome for every possible result — success,
+ * declared failure, network failure, contract violation, cancellation —
+ * keeping the three identities apart: the caller's `attempt` (carried
+ * in `meta`, never sent), the server's `trace` (read from
+ * `x-jaren-trace`, never generated here) and the idempotency `key`
+ * (generated here per command, sent as `Idempotency-Key`, optionally
+ * recorded in a durable `storage` WITHOUT the input).
+ *
+ * `invoke` NEVER rejects for anything a server or a network can do; it
+ * throws only for the host's own mistakes (`JC1005`: an unknown or
+ * opaque operation). `url(op, input)` builds the URL of any operation —
+ * what an `<img src>` uses for an opaque one. `negotiate()` asks the
+ * server's well-known description whether the two ends speak compatible
+ * versions. Everything per operation is decided once at `open`.
+ */
+import { JarenValidator } from '@jarenjs/validate';
+import { CLIENT_ERRORS } from './outcome.js';
+export { CLIENT_ERRORS };
+export type Contract = import('../compile.js').Contract;
+export type CompiledOperation = import('../compile.js').CompiledOperation;
+export type Catalog = import('../http/wire.js').Catalog;
+export type Outcome = import('./outcome.js').Outcome;
+export type OutcomeMeta = import('./outcome.js').OutcomeMeta;
+export type OutcomeError = import('./outcome.js').OutcomeError;
+export type OutcomeRoute = import('./outcome.js').OutcomeRoute;
+export type KeyStorage = {
+    read: () => any;
+    write: (value: any) => any;
+};
+export type HttpClientOptions = {
+    /**
+     * - default `globalThis.fetch`
+     */
+    fetch?: (url: string, init: RequestInit) => Promise<any>;
+    /**
+     * - prefixed to every path; default `''` (relative URLs)
+     */
+    baseUrl?: string;
+    /**
+     * - static headers, merged under per-call ones
+     */
+    headers?: Record<string, string>;
+    /**
+     * - the idempotency key generator; default `crypto.randomUUID`
+     */
+    keys?: () => string;
+    /**
+     * - durable key records; default `null`
+     */
+    storage?: KeyStorage | null;
+    /**
+     * - per request; `0` (default) means none; composed with `ctx.signal`
+     */
+    timeoutMs?: number;
+    /**
+     * - the retry backoff sleeper (injectable for tests)
+     */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /**
+     * - a message catalog consulted before the English one
+     */
+    catalog?: Record<string, string | ((params: object) => string)>;
+    /**
+     * - the server's description path; default `/.well-known/jaren-contract`
+     */
+    wellKnown?: string;
+    /**
+     * - the clock stamped into key records; default `Date.now`
+     */
+    now?: () => number;
+    /**
+     * - the validator `url()` compiles its path/query check with
+     */
+    validator?: JarenValidator<any>;
+};
+export type InvokeContext = {
+    /**
+     * - cancels the request (`kind: "cancelled"`)
+     */
+    signal?: AbortSignal;
+    /**
+     * - the caller's attempt id, echoed in `meta.attempt`, never sent
+     */
+    attempt?: unknown;
+    /**
+     * - the key to send instead of a generated one
+     */
+    idempotencyKey?: string;
+    /**
+     * - per-call headers (over the static ones)
+     */
+    headers?: Record<string, string>;
+    /**
+     * - sent as `If-None-Match`
+     */
+    ifNoneMatch?: string;
+    /**
+     * - sent as `If-Match`
+     */
+    ifMatch?: string;
+};
+export type Negotiation = {
+    compatible: boolean;
+    reason: 'same-version' | 'server-accepts' | 'client-accepts' | 'version-mismatch' | 'unreachable' | 'not-a-contract';
+    server: {
+        id: string | null;
+        version: string | null;
+        compat: string[];
+        revision: string | null;
+    } | null;
+    /**
+     * - `null` when compatible
+     */
+    error: {
+        code: string;
+        message: string;
+    } | null;
+};
+export type HttpClientCapabilities = {
+    name: 'http';
+    status: true;
+    headers: true;
+    media: true;
+    etag: true;
+    idempotency: true;
+    /**
+     * - a `storage` was given
+     */
+    durableKeys: boolean;
+    /**
+     * - `subscribe` carries SSE streams (docs/CONTRACT-FORMAT.md §19)
+     */
+    stream: true;
+    cancel: 'signal';
+};
+export type SubscribeOptions = {
+    onSnapshot?: (value: unknown, info: {
+        seq: number;
+        resumed: boolean;
+    }) => void;
+    onPatch?: (emission: {
+        patch: unknown[];
+        seq: number;
+    }) => void;
+    onError?: (outcome: Outcome) => void;
+    onEnd?: (info: {
+        reason: string;
+    }) => void;
+    /**
+     * - stops the subscription silently
+     */
+    signal?: AbortSignal;
+    /**
+     * - the resume seq (what a reconnect passes)
+     */
+    lastSeq?: number;
+};
+export type HttpClient = {
+    invoke: (op: string, input?: unknown, ctx?: InvokeContext) => Promise<Outcome>;
+    subscribe: (op: string, input?: unknown, options?: SubscribeOptions) => {
+        stop: () => void;
+    };
+    url: (op: string, input?: unknown) => string;
+    negotiate: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<Negotiation>;
+    /**
+     * - the key records a restart must reconcile
+     */
+    pending: () => Promise<{
+        op: string;
+        key: string;
+    }[]>;
+    capabilities: HttpClientCapabilities;
+    contract: Contract;
+    describe: () => any;
+    /**
+     * - aborts every in-flight request; later invokes resolve `cancelled`
+     */
+    close: () => void;
+};
+export type TransportCheck = {
+    validate: ((value: unknown) => any) | null;
+};
+export type ClientRoute = {
+    op: CompiledOperation;
+    id: string;
+    method: string;
+    segments: readonly import('../path.js').PathSegment[];
+    queryMembers: readonly string[];
+    queryRepeated: ReadonlySet<string>;
+    headerMembers: readonly string[];
+    headerNames: readonly string[];
+    /**
+     * - body-located members when the body is their object
+     */
+    bodyMembers: readonly string[];
+    /**
+     * - the member whose value IS the body
+     */
+    wholeBody: string | null;
+    hasBody: boolean;
+    media: string;
+    opaque: boolean;
+    hasInput: boolean;
+    validateInput: ((value: unknown) => any) | null;
+    details: 'none' | 'paths' | 'full';
+    idempotency: 'none' | 'optional' | 'required';
+    retry: {
+        max: number;
+        on: readonly string[];
+    } | null;
+    retryOn: ReadonlySet<string>;
+    outcome: OutcomeRoute;
+    /**
+     * - lazily compiled for `url()`
+     */
+    transport: TransportCheck;
+};
+/**
+ * Open an HTTP client over a compiled contract.
+ *
+ * @param {Contract} contract
+ * @param {HttpClientOptions} [options]
+ * @returns {HttpClient}
+ * @throws {ContractHostError} `JC1008` for a malformed argument or option
+ * @example
+ * const client = openHttpClient(contract, { baseUrl: 'https://api.example', timeoutMs: 5000 });
+ * const outcome = await client.invoke('catalog.load', { since: '2026-01-01T00:00:00Z' });
+ * if (outcome.ok) render(outcome.value);
+ * else if (outcome.kind === 'failure') show(outcome.error.code);   // a declared error, e.g. 'stale'
+ * else if (outcome.kind === 'network') retryLater();
+ */
+export declare function openHttpClient(contract: Contract, options?: HttpClientOptions): HttpClient;
+export { okOutcome, failedOutcome, makeMeta, outcomeError, isOutcome, assembleOutcome, prepareOutcomeRoute, hostFailureOutcome, OUTCOME_ERROR_MEMBERS, OUTCOME_META_MEMBERS, } from './outcome.js';