stitchkit 0.93.0 → 0.94.1

package/dist/internal/errors.d.ts

@@ -1,92 +0,0 @@
-import { type ZodType, z } from 'zod';
-import { AppError } from '../contract/index.js';
-/** One field-level validation issue — the structured sibling of `formatZodError`. */
-export interface ZodIssueSummary {
-    /** Dotted path to the offending field (`(root)` for a top-level issue). */
-    path: string;
-    /** Zod issue code (e.g. `invalid_type`, `too_small`). */
-    code: string;
-    /** Human-readable message for this field. */
-    message: string;
-    /**
-     * 1-based index of the union branch that produced this issue, counted within
-     * the nearest enclosing union. Absent when no union was involved.
-     */
-    branch?: number;
-}
-/**
- * Project a `ZodError` into structured, wire-safe field issues — path / code /
- * message (and a union branch, where one applies) — nothing server-internal.
- * For a machine client that matches on fields rather than parsing the text
- * `message`. Returns every issue; a caller that bounds response size slices it
- * (see `normalizeError`).
- *
- * A failed union contributes its own issue AND one issue per branch failure, so
- * the refusal names the branch and the path instead of only `(root)`.
- */
-export declare function zodIssues(error: z.ZodError): ZodIssueSummary[];
-/**
- * The text a person reads, which is a different job from the structured list.
- *
- * `zodIssues` keeps every branch failure, including the several that sit at the
- * union's own path — a machine addresses them by branch number and wants them
- * all. A reader gains nothing from the same path twice: the union's own line
- * already quotes those reasons, and each repeat costs one of the few lines the
- * cap allows. So the text keeps the first issue at each path and drops the
- * rest, which is what leaves room for the line naming the field.
- */
-export declare function formatZodError(error: z.ZodError): string;
-/**
- * The stable error code for a thrown value — `AppError.code`, `VALIDATION_ERROR`
- * for a `ZodError`, else `undefined`. Side-effect-free (unlike `normalizeError`,
- * it never logs): for access-log attribution on a path where the response is
- * produced elsewhere — a custom `onError` hook that returns its own `Response`.
- */
-export declare function errorCode(err: unknown): string | undefined;
-/**
- * The message a **server-side record** should carry for a failure — an audit
- * row, not a response.
- *
- * Normally the envelope's: it is truthful for an `AppError` or a `ZodError`, and
- * it is what the caller was told, so the record and the response agree. The
- * exception is the scrubbed one — an unexpected throw becomes
- * `INTERNAL_SERVER_ERROR` / "Internal server error", which tells a later reader
- * nothing at all, and there the raw message goes in instead.
- *
- * The line this holds is not "the framework never touches a raw message" but
- * **"a raw message never crosses to the caller"**. Shared by the HTTP and tool
- * paths so that line is one rule in one place. → ADR 0042.
- */
-export declare function recordedErrorMessage(code: string, envelopeMessage: string | undefined, thrown: unknown): string | undefined;
-export declare function normalizeError(err: unknown): AppError;
-/**
- * Validate a handler's return value against the contract `output` schema. A
- * mismatch is a **server** fault (the handler broke its own contract) — shared
- * by the HTTP and tool transports so both report it identically.
- *
- * `onStripped` is the migration diagnostic: a handler returning more than its
- * contract declares has the extra fields **deleted**, correctly but invisibly —
- * types cannot catch it (structural typing does not reject excess properties) and
- * nothing logs it. Pass a reporter to find out; omit it and nothing is computed.
- */
-export declare function validateHandlerOutput(schema: ZodType, data: unknown, onStripped?: (paths: string[]) => void): {
-    ok: true;
-    data: unknown;
-} | {
-    ok: false;
-    message: string;
-};
-/**
- * Enforce the presence or absence of a contract output before a transport
- * presents it. `null` is JSON data when a schema accepts it; `undefined` never
- * is. Without a schema, nullish returns mean "no result" and any other value is
- * an undeclared response.
- */
-export declare function validateDeclaredOutput(schema: ZodType | undefined, data: unknown, onStripped?: (paths: string[]) => void): {
-    ok: true;
-    data: unknown;
-} | {
-    ok: false;
-    message: string;
-};
-//# sourceMappingURL=errors.d.ts.map

package/dist/internal/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQvC,qFAAqF;AACrF,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAwID;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,eAAe,EAAE,CAI9D;AAKD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,MAAM,CAgBxD;AAKD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAI1D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,MAAM,EAAE,OAAO,GACd,MAAM,GAAG,SAAS,CAYpB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,QAAQ,CAyBrD;AA4BD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,OAAO,EACb,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,GACrC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAe9D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,IAAI,EAAE,OAAO,EACb,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,GACrC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAe9D"}

package/dist/internal/observability-sink.d.ts

@@ -1,81 +0,0 @@
-import { type ObservabilitySinkStatus } from '../observability/status.js';
-export type BoundedSinkDropReason = 'capacity' | 'closed';
-export interface BoundedSinkError<EVENT> {
-    error: unknown;
-    event?: EVENT;
-}
-export interface BoundedSinkDrop<EVENT> {
-    reason: BoundedSinkDropReason;
-    event: EVENT;
-    pending: number;
-}
-export interface BoundedSinkConfig<EVENT> {
-    write(event: EVENT): void | Promise<void>;
-    filter?(event: EVENT): boolean;
-    maxPending?: number;
-    onSinkError?(failure: BoundedSinkError<EVENT>): void | Promise<void>;
-    onDrop?(drop: BoundedSinkDrop<EVENT>): void | Promise<void>;
-}
-/**
- * A caller's limit on how long a drain may WAIT.
- *
- * Unbounded, a drain waits for every accepted event however long the sink
- * takes — correct when the sink is healthy, fatal when it is not. One write
- * that never settles, a database that has stopped answering, held `close()`
- * forever; an application whose shutdown graph gives every other step a
- * deadline then spent its whole budget here and exited by force. A drain that
- * cannot be bounded cannot take part in a shutdown budget: it either fits, or
- * it cancels the budget.
- *
- * The bound ends the WAITING, not the writes: a sink's `write` is handed no
- * cancellation, so an outstanding one keeps running against whatever the caller
- * closes next. And it is a bound on waiting for I/O, not on wall time — no
- * bound can preempt a `write` that occupies the event loop.
- */
-export interface ObservabilityDrainBound {
-    /** Give up waiting after this many milliseconds. */
-    timeoutMs?: number;
-    /** Give up waiting when this signal aborts. */
-    signal?: AbortSignal;
-}
-/**
- * Refuse a nonsensical bound BEFORE anything is mutated, so a call that throws
- * has no effect — admission stays open rather than half-closed.
- */
-export declare function assertDrainBound(bound: ObservabilityDrainBound | undefined): void;
-/**
- * Wait for `work`, but not past `bound`. Resolves `true` when the work settled
- * first, `false` when the bound did.
- *
- * Composed by hand rather than with `AbortSignal.any`, because the composite it
- * returns registers itself on the caller's signal and is never released: on Bun
- * that is a dependent leaked per drain against a process-lifetime signal, and
- * `flush({ signal })` per batch is exactly the shape that accumulates them.
- * A listener and a timer, both disposed here, cost nothing and leave nothing.
- *
- * The timer is REF'D, and that is the whole mechanism. Unref'ing it reads like
- * good hygiene — a drain bound should not keep a process alive while it is
- * shutting down — and it silently destroys the feature: a pending write holds
- * nothing, so when the stuck write is the last thing left, an unref'd timer
- * lets the loop empty and the bound never fires at all. That is not an edge
- * case, it is the case this exists for. The timer cannot outlive the deadline
- * the caller itself asked for, so holding the loop for exactly that long is
- * what was wanted. Found only by installing the published package and running
- * it under `node`, where the process exits 13 on an unsettled top-level await;
- * every in-process test passes because the runner keeps the loop alive.
- */
-export declare function withinBound(work: Promise<unknown>, bound: ObservabilityDrainBound | undefined): Promise<boolean>;
-export interface BoundedSinkManager<EVENT> {
-    submit(produce: () => EVENT | Promise<EVENT>): void;
-    /** Whether the generation admitted before this call settled inside the bound. */
-    flush(bound?: ObservabilityDrainBound): Promise<boolean>;
-    getStatus(): ObservabilitySinkStatus;
-    /**
-     * Stop admission and drain. The status is read AFTER the wait ends, so
-     * `pending` and `preparing` say what the sink had not written — including
-     * when the bound ended the wait early.
-     */
-    close(bound?: ObservabilityDrainBound): Promise<ObservabilitySinkStatus>;
-}
-export declare function createBoundedSinkManager<EVENT>(config: BoundedSinkConfig<EVENT>): BoundedSinkManager<EVENT>;
-//# sourceMappingURL=observability-sink.d.ts.map

package/dist/internal/observability-sink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observability-sink.d.ts","sourceRoot":"","sources":["../../src/internal/observability-sink.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE1D,MAAM,WAAW,gBAAgB,CAAC,KAAK;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,eAAe,CAAC,KAAK;IACpC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB,CAAC,KAAK;IACtC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,MAAM,CAAC,CAAC,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,uBAAuB;IACtC,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,uBAAuB,GAAG,SAAS,GAAG,IAAI,CAMjF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,EACtB,KAAK,EAAE,uBAAuB,GAAG,SAAS,GACzC,OAAO,CAAC,OAAO,CAAC,CA2BlB;AAED,MAAM,WAAW,kBAAkB,CAAC,KAAK;IACvC,MAAM,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACpD,iFAAiF;IACjF,KAAK,CAAC,KAAK,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,SAAS,IAAI,uBAAuB,CAAC;IACrC;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC1E;AAaD,wBAAgB,wBAAwB,CAAC,KAAK,EAC5C,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAC/B,kBAAkB,CAAC,KAAK,CAAC,CAuJ3B"}

package/dist/live.d.ts

@@ -1,19 +0,0 @@
-/**
- * `stitchkit/live` — declarations for the things that change while a caller is
- * watching: announcements and watched reads.
- *
- * Browser-safe and evolving. Browser-safe because both halves are declarations
- * plus a client, and a client that cannot run in a browser is not a client.
- * Evolving because the shape here is being found with its first consumers — the
- * entrypoint says so rather than leaving a reader to discover it in a minor.
- *
- * What lives here is deliberately small: this entrypoint owns no transport. The
- * wire is the Socket.IO realtime contract from `stitchkit`, the in-process
- * delivery is `createEventBus` from `stitchkit/server`, and the server halves of
- * a watched read live in `stitchkit/application`. → ADR 0150.
- */
-export { defineEvents, type EventDeliveryMode, type EventPayloads, type EventsConfig, type EventsDeclaration, type EventTopicDeclaration, type EventTopicRegistry, type EventTopicsOfMode, type PolicyDecision, toRealtimeContract, type UndecidedOutcome, type WireTopic, } from './live/events.js';
-export { createWatchClient, type RealtimeClientLike, type TypedWatchClient, type WatchClientConfig, type WatchHandle, type WatchInboundEvents, type WatchListeners, type WatchTransport, watchTransport, } from './live/watch-client.js';
-export { WATCH_CLOSE, WATCH_OPEN, WATCH_STATE, WATCH_VALUE, type WatchHave, WatchHaveSchema, type WatchKey, WatchKeySchema, type WatchStateFrame, WatchStateSchema, type WatchValueFrame, WatchValueSchema, watchContract, watchKeyString, } from './live/watch-contract.js';
-export { apply as applyWatchDelta, deltaWins as watchDeltaWins, diff as watchDiff, type WatchArrayOp, WatchArrayOpSchema, type WatchDelta, WatchDeltaSchema, } from './live/watch-delta.js';
-//# sourceMappingURL=live.d.ts.map

package/dist/live.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../src/live.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,SAAS,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,iBAAiB,EACjB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,KAAK,SAAS,EACd,eAAe,EACf,KAAK,QAAQ,EACb,cAAc,EACd,KAAK,eAAe,EACpB,gBAAgB,EAChB,KAAK,eAAe,EACpB,gBAAgB,EAChB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,IAAI,eAAe,EACxB,SAAS,IAAI,cAAc,EAC3B,IAAI,IAAI,SAAS,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,UAAU,EACf,gBAAgB,GACjB,MAAM,oBAAoB,CAAC"}

package/dist/live.js

@@ -1,282 +0,0 @@
-import {
-  WATCH_CLOSE,
-  WATCH_OPEN,
-  WATCH_STATE,
-  WATCH_VALUE,
-  WatchArrayOpSchema,
-  WatchDeltaSchema,
-  WatchHaveSchema,
-  WatchKeySchema,
-  WatchStateSchema,
-  WatchValueSchema,
-  apply,
-  deltaWins,
-  diff,
-  watchContract,
-  watchKeyString
-} from "./index-2na0qrfn.js";
-import"./index-ywd0y6m1.js";
-import"./index-7gnkny4z.js";
-import {
-  argumentsDigest
-} from "./index-a916km3r.js";
-
-// src/live/events.ts
-import { z } from "zod";
-function assertName(kind, value) {
-  if (value.length === 0) {
-    throw new Error(`[stitchkit] defineEvents: ${kind} name cannot be empty.`);
-  }
-  if (/\s/.test(value)) {
-    throw new Error(`[stitchkit] defineEvents: ${kind} name "${value}" cannot contain whitespace.`);
-  }
-}
-function defineEvents(config, topics) {
-  const prefix = config.prefix;
-  if (prefix !== undefined)
-    assertName("prefix", prefix);
-  const declared = {};
-  for (const [name, topic] of Object.entries(topics)) {
-    assertName("topic", name);
-    if (topic.mode === "emit") {
-      if (topic.whenAllDefer !== undefined) {
-        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares whenAllDefer, which only a 'decision' topic has. Its mode is 'emit'.`);
-      }
-      if (topic.listenerTimeoutMs !== undefined) {
-        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares listenerTimeoutMs, but mode 'emit' never waits for a listener.`);
-      }
-    } else {
-      if (topic.listenerTimeoutMs === undefined) {
-        throw new Error(`[stitchkit] defineEvents: topic "${name}" has mode '${topic.mode}', which waits for listeners, so it must declare listenerTimeoutMs.`);
-      }
-      if (!Number.isFinite(topic.listenerTimeoutMs) || topic.listenerTimeoutMs <= 0) {
-        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares listenerTimeoutMs ${String(topic.listenerTimeoutMs)}; it must be finite and greater than zero.`);
-      }
-      if (topic.mode === "decision" && topic.whenAllDefer === undefined) {
-        throw new Error(`[stitchkit] defineEvents: topic "${name}" has mode 'decision', so it must declare whenAllDefer: 'allow' or 'deny' — the outcome when every listener defers. There is no default, because a default would decide it silently.`);
-      }
-      if (topic.mode === "serial" && topic.whenAllDefer !== undefined) {
-        throw new Error(`[stitchkit] defineEvents: topic "${name}" declares whenAllDefer, which only a 'decision' topic has. Its mode is 'serial'.`);
-      }
-    }
-    declared[prefix === undefined ? name : `${prefix}.${name}`] = topic;
-  }
-  return { prefix, topics: declared };
-}
-function toRealtimeContract(declaration) {
-  const serverToClient = {};
-  for (const [topic, definition] of Object.entries(declaration.topics)) {
-    const schema = definition.schema;
-    serverToClient[topic] = { args: z.tuple([schema]) };
-  }
-  return { serverToClient, clientToServer: {} };
-}
-// src/live/watch-client.ts
-function watchTransport(client) {
-  return client;
-}
-function createWatchClient(contract, config) {
-  const entries = new Map;
-  const holdMs = config.holdMs ?? 0;
-  const openTimeoutMs = config.openTimeoutMs ?? 1e4;
-  const service = contract.meta.prefix;
-  function publishState(entry, state) {
-    entry.state = state;
-    for (const listener of [...entry.listeners])
-      listener.state?.(state);
-  }
-  function resynchronise(entry, message) {
-    entry.hasValue = false;
-    entry.value = undefined;
-    entry.revision = 0;
-    entry.fingerprint = undefined;
-    entry.opened = false;
-    publishState(entry, { key: entry.key, phase: "resync-required", message });
-    config.transport.emit(WATCH_CLOSE, { key: entry.key });
-    open(entry);
-  }
-  config.transport.on(WATCH_VALUE, (frame) => {
-    const entry = entries.get(watchKeyString(frame.key));
-    if (!entry)
-      return;
-    if (frame.kind === "unchanged") {
-      if (!entry.hasValue) {
-        resynchronise(entry, "the server confirmed a value this client does not hold");
-        return;
-      }
-      entry.revision = frame.revision;
-      entry.fingerprint = frame.fingerprint;
-      return;
-    }
-    if (entry.hasValue && frame.revision <= entry.revision)
-      return;
-    let value;
-    if (frame.kind === "full") {
-      value = frame.value;
-    } else {
-      if (!entry.hasValue || entry.revision !== frame.base) {
-        resynchronise(entry, `a difference against revision ${frame.base} arrived while holding ${entry.hasValue ? String(entry.revision) : "nothing"}`);
-        return;
-      }
-      try {
-        value = apply(entry.value, frame.delta);
-      } catch (error) {
-        resynchronise(entry, error instanceof Error ? error.message : String(error));
-        return;
-      }
-      if (argumentsDigest({ value }) !== frame.fingerprint) {
-        resynchronise(entry, "the rebuilt value did not match the fingerprint the server sent");
-        return;
-      }
-    }
-    entry.revision = frame.revision;
-    entry.value = value;
-    entry.fingerprint = frame.fingerprint;
-    entry.hasValue = true;
-    for (const listener of [...entry.listeners])
-      listener.value(value);
-  });
-  config.transport.on(WATCH_STATE, (frame) => {
-    const entry = entries.get(watchKeyString(frame.key));
-    if (!entry)
-      return;
-    publishState(entry, frame);
-  });
-  config.transport.onConnectionChange((connected, reason) => {
-    if (!connected) {
-      for (const entry of entries.values()) {
-        entry.opened = false;
-        publishState(entry, {
-          key: entry.key,
-          phase: "unavailable",
-          reason: "source-unavailable",
-          ...reason !== undefined && { message: reason }
-        });
-      }
-      return;
-    }
-    for (const entry of entries.values()) {
-      if (entry.listeners.size === 0)
-        continue;
-      publishState(entry, { key: entry.key, phase: "opening" });
-      open(entry);
-    }
-  });
-  function entryFor(key, args) {
-    const id = watchKeyString(key);
-    const existing = entries.get(id);
-    if (existing) {
-      clearTimeout(existing.release);
-      existing.release = undefined;
-      return existing;
-    }
-    const entry = {
-      key,
-      args,
-      listeners: new Set,
-      revision: 0,
-      hasValue: false,
-      opened: false,
-      state: { key, phase: "opening" }
-    };
-    entries.set(id, entry);
-    return entry;
-  }
-  async function open(entry) {
-    if (entry.opened)
-      return;
-    entry.opened = true;
-    try {
-      const have = entry.hasValue && entry.fingerprint !== undefined ? { revision: entry.revision, fingerprint: entry.fingerprint } : undefined;
-      const acknowledgement = await config.transport.request(WATCH_OPEN, { key: entry.key, args: entry.args, ...have !== undefined && { have } }, { timeoutMs: openTimeoutMs });
-      if (!acknowledgement.accepted) {
-        const reason = acknowledgement.reason ?? "the server refused this watch";
-        config.onRefused?.(entry.key, reason);
-        publishState(entry, {
-          key: entry.key,
-          phase: "unavailable",
-          reason: "source-unavailable",
-          message: reason
-        });
-      }
-    } catch (error) {
-      entry.opened = false;
-      const code = typeof error === "object" && error !== null && "code" in error ? String(Reflect.get(error, "code")) : undefined;
-      publishState(entry, {
-        key: entry.key,
-        phase: "unavailable",
-        reason: "source-unavailable",
-        ...code !== undefined && { code },
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  function releaseEntry(entry) {
-    if (entry.listeners.size > 0)
-      return;
-    const drop = () => {
-      if (entry.listeners.size > 0)
-        return;
-      entries.delete(watchKeyString(entry.key));
-      config.transport.emit(WATCH_CLOSE, { key: entry.key });
-    };
-    if (holdMs === 0) {
-      drop();
-      return;
-    }
-    entry.release = setTimeout(drop, holdMs);
-    entry.release.unref?.();
-  }
-  function handleFor(action, args) {
-    const mine = new Set;
-    const entry = entryFor({ service, action, digest: argumentsDigest(args) }, args);
-    return {
-      subscribe(listeners) {
-        const registered = listeners;
-        mine.add(registered);
-        entry.listeners.add(registered);
-        if (entry.hasValue)
-          registered.value(entry.value);
-        registered.state?.(entry.state);
-        open(entry);
-        return () => {
-          mine.delete(registered);
-          entry.listeners.delete(registered);
-          releaseEntry(entry);
-        };
-      },
-      close() {
-        for (const listener of mine)
-          entry.listeners.delete(listener);
-        mine.clear();
-        releaseEntry(entry);
-      }
-    };
-  }
-  const client = {};
-  for (const action of Object.keys(contract.endpoints)) {
-    client[action] = (args = {}) => handleFor(action, args);
-  }
-  return client;
-}
-export {
-  watchTransport,
-  watchKeyString,
-  diff as watchDiff,
-  deltaWins as watchDeltaWins,
-  watchContract,
-  toRealtimeContract,
-  defineEvents,
-  createWatchClient,
-  apply as applyWatchDelta,
-  WatchValueSchema,
-  WatchStateSchema,
-  WatchKeySchema,
-  WatchHaveSchema,
-  WatchDeltaSchema,
-  WatchArrayOpSchema,
-  WATCH_VALUE,
-  WATCH_STATE,
-  WATCH_OPEN,
-  WATCH_CLOSE
-};

package/dist/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxD,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACzD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1D"}

package/dist/node.d.ts

@@ -1,18 +0,0 @@
-/**
- * `stitchkit/node` — the Node entrypoint. Everything a Node app needs without
- * touching the Bun-named `createServer`: the Fetch-clean `createHandler`, the
- * srvx-backed `serveNode`, `implement`, the error helpers and (lazily-loaded,
- * Node-safe) `createSocketIOServer`.
- */
-export { AppError, appError, badRequest, conflict, forbidden, notFound, rateLimited, unauthorized, } from './contract/index.js';
-export { createHandler } from './server/create.js';
-export { createImplement, createImplementRegistry, createMultipartStream, createScopedImplement, createScopedImplementRegistry, type ExactRegistryHandlers, type ExactScopedRegistryHandlers, type ImplementationRegistry, implement, implementRegistry, type KeyedServices, type MultipartStreamConfig, type RegistryHandlers, type ScopedImplementationRegistry, type ScopedRegistryHandlers, type StreamScope, } from './server/implement.js';
-export type { LogFormat } from './server/logger.js';
-export { type NodeRuntimeServer, type NodeServerConfig, type NodeServerHandle, type NodeSocketLifecycle, serveNode, } from './server/node.js';
-export { bindProcessSignals, type ProcessSignalName, type ProcessSignalsBinding, type ProcessSignalsErrorPhase, type ProcessSignalsOptions, type ShutdownTarget, type SignalSource, } from './server/process-signals.js';
-export { bindRealtimeServer, type RealtimeServer, type RealtimeServerConnection, type RealtimeServerHandle, } from './server/realtime.js';
-export { type ManagedServerHandle, type ShutdownOptions, ShutdownOptionsSchema, type ShutdownResult, ShutdownResultSchema, type ShutdownState, ShutdownStateSchema, type ShutdownStatus, ShutdownStatusSchema, } from './server/shutdown.js';
-export { createNodeSocketIOServer as createSocketIOServer, type NodeSocketIOServerHandle as SocketIOServerHandle, type SocketIOHandshakeConfig, type SocketIOPeerLoaders, type SocketIORequestPolicy, type SocketIOServerConfig, } from './server/socket-io-node.js';
-export type { EffectiveScope, FetchComposition, FetchHandler, HandlerConfig, LoggingConfig, LogOutcome, RawRoute, RawRouteContext, ScopeContexts, ScopedHandlers, ServiceDef, } from './server/types.js';
-export { createUnixClientTransport, type UnixClientDeliveryState, type UnixClientTransport, type UnixClientTransportConfig, UnixClientTransportError, type UnixClientTransportErrorCode, type UnixResponseBodyMode, } from './server/unix-client.js';
-//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,SAAS,EACT,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,EAC3B,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,wBAAwB,IAAI,oBAAoB,EAChD,KAAK,wBAAwB,IAAI,oBAAoB,EACrD,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,QAAQ,EACR,eAAe,EACf,aAAa,EACb,cAAc,EACd,UAAU,GACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,yBAAyB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,wBAAwB,EACxB,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}