stitchkit 0.76.1 → 0.77.0

package/dist/{index-6wr9f6qm.js → index-jqtsc9mj.js}

@@ -1,10 +1,10 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-885chjxq.js";
+} from "./index-7qy2ex0m.js";
 import {
   toolErrorFromResult
-} from "./index-k68e5jz0.js";
+} from "./index-s4c8wy8m.js";
 import {
   assertUniqueToolName
 } from "./index-22by16v6.js";

package/dist/{index-9c5dbr5q.js → index-k2zczx1g.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-wwst0td5.js";
 import {
   contractToolMountable
-} from "./index-885chjxq.js";
+} from "./index-7qy2ex0m.js";
 import {
   projectToolSurface
 } from "./index-22by16v6.js";

package/dist/{index-v7xjfy10.js → index-m668wzyc.js}

@@ -15,7 +15,7 @@ import {
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-k68e5jz0.js";
+} from "./index-s4c8wy8m.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,

package/dist/{index-e0a57ymn.js → index-nemjkxjp.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-nt1mp8km.js";
 import {
   isUnsafeKey
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/{index-9my2n66s.js → index-s2rchahr.js}

@@ -1,14 +1,14 @@
 import {
   collectToolSurface
-} from "./index-9c5dbr5q.js";
+} from "./index-k2zczx1g.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-885chjxq.js";
+} from "./index-7qy2ex0m.js";
 import {
   coerceJsonArgs,
   toolResultFromError
-} from "./index-k68e5jz0.js";
+} from "./index-s4c8wy8m.js";
 import {
   isWithinDir
 } from "./index-sbdmyz75.js";
@@ -27,7 +27,7 @@ import {
 import {
   isUnsafeKey,
   safeJsonParse
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/{index-k68e5jz0.js → index-s4c8wy8m.js}

@@ -1,7 +1,7 @@
 import {
   getRequestContext,
   runWithRequestContext
-} from "./index-e0a57ymn.js";
+} from "./index-nemjkxjp.js";
 import {
   objectShapeKeys
 } from "./index-22by16v6.js";
@@ -13,7 +13,7 @@ import {
 import {
   isUnsafeKey,
   safeJsonParse
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,

package/dist/{index-52400rdd.js → index-t8qyvrvg.js}

@@ -7,7 +7,7 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-endzd8sj.js";
+} from "./index-vbf2p6me.js";
 import {
   extractIp,
   getClientInfo,
@@ -18,7 +18,7 @@ import {
   runWithRequestContext,
   setRequestEndpoint,
   setRequestError
-} from "./index-e0a57ymn.js";
+} from "./index-nemjkxjp.js";
 import {
   ShutdownOptionsSchema,
   isStreamCancellation,
@@ -39,7 +39,7 @@ import {
   joinRoutePath,
   parseTrailingWildcard,
   safeJsonParse
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   AppError,
   badRequest

package/dist/{index-endzd8sj.js → index-vbf2p6me.js}

@@ -1,7 +1,7 @@
 import {
   isUnsafeKey,
   mergeMeta
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   callRuntimeHandler,
   isRecord,

package/dist/{index-hvftzz91.js → index-vc1b0b1b.js}

@@ -13,6 +13,9 @@ import {
   AppError
 } from "./index-0w9abg87.js";
 
+// src/application/kernel.ts
+import { z } from "zod";
+
 // src/application/graph.ts
 function resolveResourceGraph(resources) {
   const entries = resources.map((resource, declarationIndex) => ({
@@ -82,6 +85,15 @@ var ApplicationShutdownBudgetSchema = ShutdownOptionsSchema.pick({
   gracePeriodMs: true,
   forceTimeoutMs: true
 });
+var ApplicationRestartInputSchema = z.object({ resourceId: z.string().min(1) }).strict().readonly();
+var ApplicationRestartOutcomeSchema = z.enum(["restarted", "failed", "refused"]);
+var ApplicationRestartResultSchema = z.object({
+  resourceId: z.string(),
+  affected: z.array(z.string()).readonly(),
+  outcome: ApplicationRestartOutcomeSchema,
+  reason: z.string().optional(),
+  durationMs: z.number().int().nonnegative()
+}).strict().readonly();
 
 class ApplicationAdmissionError extends AppError {
   constructor() {
@@ -294,138 +306,221 @@ function createApplication(config) {
       publish();
     }
   };
-  const runStart = async () => {
-    lifecycle = "starting";
-    publish();
-    let startFailure;
-    try {
-      for (const entry of ordered) {
-        if (shutdownRequested || startupAbort.signal.aborted) {
+  const startEach = async (entries, signal) => {
+    for (const entry of entries) {
+      if (shutdownRequested || signal.aborted) {
+        throw new ApplicationStartupInterruptedError;
+      }
+      const record = records.get(entry.id);
+      if (!record)
+        throw new Error("Managed resource record disappeared");
+      const dependencyFailed = entry.dependsOn.some((dependencyId) => records.get(dependencyId)?.state !== "ready");
+      if (dependencyFailed) {
+        record.state = "failed";
+        record.health = "unhealthy";
+        record.failures.push("start");
+        publish();
+        if (entry.required) {
+          throw new Error(`[stitchkit] required resource "${entry.id}" has an unavailable dependency`);
+        }
+        continue;
+      }
+      record.attempted = true;
+      record.state = "starting";
+      publish();
+      try {
+        const started = await entry.resource.start(contextFor(record, { signal }));
+        if (shutdownRequested || signal.aborted) {
           throw new ApplicationStartupInterruptedError;
         }
-        const record = records.get(entry.id);
-        if (!record)
-          throw new Error("Managed resource record disappeared");
-        const dependencyFailed = entry.dependsOn.some((dependencyId) => records.get(dependencyId)?.state !== "ready");
-        if (dependencyFailed) {
+        if (isStartResult(started)) {
+          record.runtime = started;
+          if (started.value !== undefined)
+            published.set(entry.id, started.value);
+          let resourceReady = started.ready === undefined;
+          let completionSettled = false;
+          let completionFailure;
+          const completion = started.completion?.then(() => {
+            completionSettled = true;
+            if (resourceReady)
+              markLateCompletion(record);
+          }, (error) => {
+            completionSettled = true;
+            completionFailure = error;
+            if (resourceReady)
+              markLateCompletion(record, { error });
+          });
+          if (started.ready && completion) {
+            const readiness = started.ready.then(() => "ready");
+            const completionBeforeReady = completion.then(() => "completion");
+            const first = await Promise.race([readiness, completionBeforeReady]);
+            if (first === "completion") {
+              throw new ResourceCompletionBeforeReadyError(entry.id, completionFailure);
+            }
+            resourceReady = true;
+            if (completionSettled) {
+              throw new ResourceCompletionBeforeReadyError(entry.id, completionFailure);
+            }
+          } else if (started.ready) {
+            await started.ready;
+            resourceReady = true;
+          } else if (completion) {}
+        }
+        if (shutdownRequested || signal.aborted) {
+          throw new ApplicationStartupInterruptedError;
+        }
+        record.state = "ready";
+        if (!record.healthReported) {
+          record.health = "healthy";
+          record.everHealthy = true;
+        }
+        publish();
+      } catch (error) {
+        const interrupted = shutdownRequested || signal.aborted;
+        if (!(error instanceof ApplicationStartupInterruptedError)) {
+          record.failures.push(error instanceof ResourceCompletionBeforeReadyError ? "completion" : record.runtime?.ready ? "ready" : "start");
           record.state = "failed";
           record.health = "unhealthy";
-          record.failures.push("start");
+          reportFailure(entry.id, record.failures[record.failures.length - 1] ?? "start", error);
           publish();
-          if (entry.required) {
-            throw new Error(`[stitchkit] required resource "${entry.id}" has an unavailable dependency`);
-          }
-          continue;
         }
-        record.attempted = true;
-        record.state = "starting";
+        if (interrupted || entry.required)
+          throw error;
+      }
+    }
+  };
+  const activateEach = async (entries, signal) => {
+    for (const entry of entries) {
+      if (shutdownRequested || signal.aborted) {
+        throw new ApplicationStartupInterruptedError;
+      }
+      const record = records.get(entry.id);
+      if (record?.state !== "ready")
+        continue;
+      const dependencyUnavailable = entry.dependsOn.some((dependencyId) => {
+        const dependency = records.get(dependencyId);
+        return dependency?.state !== "ready" || !dependency.activated;
+      });
+      if (dependencyUnavailable) {
+        record.failures.push("start");
+        record.state = "failed";
+        record.health = "unhealthy";
         publish();
-        try {
-          const started = await entry.resource.start(contextFor(record, { signal: startupAbort.signal }));
-          if (shutdownRequested || startupAbort.signal.aborted) {
-            throw new ApplicationStartupInterruptedError;
-          }
-          if (isStartResult(started)) {
-            record.runtime = started;
-            if (started.value !== undefined)
-              published.set(entry.id, started.value);
-            let resourceReady = started.ready === undefined;
-            let completionSettled = false;
-            let completionFailure;
-            const completion = started.completion?.then(() => {
-              completionSettled = true;
-              if (resourceReady)
-                markLateCompletion(record);
-            }, (error) => {
-              completionSettled = true;
-              completionFailure = error;
-              if (resourceReady)
-                markLateCompletion(record, { error });
-            });
-            if (started.ready && completion) {
-              const readiness = started.ready.then(() => "ready");
-              const completionBeforeReady = completion.then(() => "completion");
-              const first = await Promise.race([readiness, completionBeforeReady]);
-              if (first === "completion") {
-                throw new ResourceCompletionBeforeReadyError(entry.id, completionFailure);
-              }
-              resourceReady = true;
-              if (completionSettled) {
-                throw new ResourceCompletionBeforeReadyError(entry.id, completionFailure);
-              }
-            } else if (started.ready) {
-              await started.ready;
-              resourceReady = true;
-            } else if (completion) {}
-          }
-          if (shutdownRequested || startupAbort.signal.aborted) {
-            throw new ApplicationStartupInterruptedError;
-          }
-          record.state = "ready";
-          if (!record.healthReported) {
-            record.health = "healthy";
-            record.everHealthy = true;
-          }
-          publish();
-        } catch (error) {
-          const interrupted = shutdownRequested || startupAbort.signal.aborted;
-          if (!(error instanceof ApplicationStartupInterruptedError)) {
-            record.failures.push(error instanceof ResourceCompletionBeforeReadyError ? "completion" : record.runtime?.ready ? "ready" : "start");
-            record.state = "failed";
-            record.health = "unhealthy";
-            reportFailure(entry.id, record.failures[record.failures.length - 1] ?? "start", error);
-            publish();
-          }
-          if (interrupted || entry.required)
-            throw error;
+        if (entry.required) {
+          throw new Error(`[stitchkit] required resource "${entry.id}" has an unavailable activation dependency`);
         }
+        continue;
       }
-      lifecycle = "ready";
-      publish();
-      for (const entry of ordered) {
-        if (shutdownRequested || startupAbort.signal.aborted) {
+      try {
+        await entry.resource.activate?.(contextFor(record));
+        if (shutdownRequested || signal.aborted) {
           throw new ApplicationStartupInterruptedError;
         }
-        const record = records.get(entry.id);
-        if (record?.state !== "ready")
-          continue;
-        const dependencyUnavailable = entry.dependsOn.some((dependencyId) => {
-          const dependency = records.get(dependencyId);
-          return dependency?.state !== "ready" || !dependency.activated;
-        });
-        if (dependencyUnavailable) {
+        record.activated = true;
+        if (entry.required && (record.state !== "ready" || record.health !== "healthy")) {
+          const observed = `${record.state}/${record.health}`;
+          throw new Error(record.everHealthy ? `[stitchkit] required resource "${entry.id}" lost readiness during activation (${observed})` : `[stitchkit] required resource "${entry.id}" is not healthy (${observed}). A required resource must be healthy for the application to be ready; a resource that is expected to start degraded belongs behind \`required: false\`.`);
+        }
+      } catch (error) {
+        const interrupted = shutdownRequested || signal.aborted;
+        if (!(error instanceof ApplicationStartupInterruptedError)) {
           record.failures.push("start");
           record.state = "failed";
           record.health = "unhealthy";
+          reportFailure(entry.id, "start", error);
           publish();
-          if (entry.required) {
-            throw new Error(`[stitchkit] required resource "${entry.id}" has an unavailable activation dependency`);
-          }
-          continue;
-        }
-        try {
-          await entry.resource.activate?.(contextFor(record));
-          if (shutdownRequested || startupAbort.signal.aborted) {
-            throw new ApplicationStartupInterruptedError;
-          }
-          record.activated = true;
-          if (entry.required && (record.state !== "ready" || record.health !== "healthy")) {
-            const observed = `${record.state}/${record.health}`;
-            throw new Error(record.everHealthy ? `[stitchkit] required resource "${entry.id}" lost readiness during activation (${observed})` : `[stitchkit] required resource "${entry.id}" is not healthy (${observed}). A required resource must be healthy for the application to be ready; a resource that is expected to start degraded belongs behind \`required: false\`.`);
-          }
-        } catch (error) {
-          const interrupted = shutdownRequested || startupAbort.signal.aborted;
-          if (!(error instanceof ApplicationStartupInterruptedError)) {
-            record.failures.push("start");
-            record.state = "failed";
-            record.health = "unhealthy";
-            reportFailure(entry.id, "start", error);
-            publish();
-          }
-          if (interrupted || entry.required)
-            throw error;
         }
+        if (interrupted || entry.required)
+          throw error;
+      }
+    }
+  };
+  const subtreeOf = (resourceId) => {
+    const affected = new Set([resourceId]);
+    for (const entry of ordered) {
+      if (entry.dependsOn.some((dependencyId) => affected.has(dependencyId))) {
+        affected.add(entry.id);
       }
+    }
+    return ordered.filter((entry) => affected.has(entry.id));
+  };
+  const closeOne = async (entry, record, signal) => {
+    const context = () => contextFor(record, { signal });
+    if (record.attempted && !record.closed) {
+      await entry.resource.stopAdmission?.(context());
+      await entry.resource.drain?.(context());
+      record.closeInvoked = true;
+      await entry.resource.close?.(context());
+    }
+    record.closed = false;
+    record.closeInvoked = false;
+    record.attempted = false;
+    record.activated = false;
+    record.state = "registered";
+    record.health = "unknown";
+    record.healthReported = false;
+    record.runtime = undefined;
+    published.delete(entry.id);
+  };
+  let restarting = Promise.resolve();
+  const runRestart = async (input) => {
+    const startedAt = Date.now();
+    const parsed = ApplicationRestartInputSchema.parse(input);
+    const affected = subtreeOf(parsed.resourceId);
+    const affectedIds = affected.map((entry) => entry.id);
+    const refuse = (reason) => ({
+      resourceId: parsed.resourceId,
+      affected: affectedIds,
+      outcome: "refused",
+      reason,
+      durationMs: Date.now() - startedAt
+    });
+    if (!records.has(parsed.resourceId)) {
+      return refuse(`no resource is registered as "${parsed.resourceId}"`);
+    }
+    if (shutdownRequested) {
+      return refuse("the application is shutting down");
+    }
+    if (lifecycle !== "ready") {
+      return refuse(`the application is ${lifecycle}, not ready`);
+    }
+    const restartAbort = new AbortController;
+    try {
+      for (const entry of [...affected].reverse()) {
+        const record = records.get(entry.id);
+        if (record)
+          await closeOne(entry, record, restartAbort.signal);
+      }
+      publish();
+      await startEach(affected, restartAbort.signal);
+      await activateEach(affected, restartAbort.signal);
+      publish();
+      return {
+        resourceId: parsed.resourceId,
+        affected: affectedIds,
+        outcome: "restarted",
+        durationMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      publish();
+      return {
+        resourceId: parsed.resourceId,
+        affected: affectedIds,
+        outcome: "failed",
+        reason: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - startedAt
+      };
+    }
+  };
+  const runStart = async () => {
+    lifecycle = "starting";
+    publish();
+    let startFailure;
+    try {
+      await startEach(ordered, startupAbort.signal);
+      lifecycle = "ready";
+      publish();
+      await activateEach(ordered, startupAbort.signal);
       if (shutdownRequested) {
         throw new ApplicationStartupInterruptedError;
       }
@@ -714,8 +809,17 @@ function createApplication(config) {
       listener(snapshot());
       return () => listeners.delete(listener);
     },
-    shutdown
+    shutdown,
+    restart(input) {
+      const queued = restarting.then(() => runRestart(input));
+      restarting = queued.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return queued;
+    }
   };
 }
 
-export { ApplicationShutdownOptionsSchema, ApplicationShutdownBudgetSchema, ApplicationAdmissionError, createApplication };
+export { ApplicationShutdownOptionsSchema, ApplicationShutdownBudgetSchema, ApplicationRestartInputSchema, ApplicationRestartOutcomeSchema, ApplicationRestartResultSchema, ApplicationAdmissionError, createApplication };

package/dist/{index-hsz2mmk0.js → index-vj3vvpaa.js}

@@ -272,6 +272,22 @@ function mergeMeta(contractMeta, endpointMeta) {
 import { z as z2 } from "zod";
 // src/contract/pagination.ts
 import { z as z3 } from "zod";
+
+// src/internal/base64url.ts
+function bytesToBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToBytes(segment) {
+  if (!/^[A-Za-z0-9_-]*$/.test(segment) || segment.length % 4 === 1) {
+    throw new Error("invalid base64url segment");
+  }
+  const b64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+  return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+}
 // src/contract/stream.ts
 import { z as z4 } from "zod";
 var DEFAULT_CONTRACT_STREAM_FRAME_BYTES = 256 * 1024;
@@ -288,4 +304,4 @@ var ContractStreamFrameSchema = z4.discriminatedUnion("type", [
   }).strict(),
   z4.object({ type: z4.literal("end") }).strict()
 ]);
-export { joinRoutePath, parseTrailingWildcard, isUnsafeKey, safeJsonParse, defineContract, mergeMeta, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };
+export { joinRoutePath, parseTrailingWildcard, isUnsafeKey, safeJsonParse, defineContract, mergeMeta, bytesToBase64Url, base64UrlToBytes, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };

package/dist/index.js

@@ -27,8 +27,7 @@ import {
   parseTrailingWildcard,
   rateLimited,
   unauthorized
-} from "./index-4kp4fxvp.js";
-import"./index-rxfy4cq7.js";
+} from "./index-f6n5n7nz.js";
 import {
   isRecord,
   mapObject,

package/dist/internal/decision.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+/**
+ * One answer to "may this happen?", from one answerer.
+ *
+ * Three outcomes and no fourth, because the third is the one that gets left out
+ * and then invented: `defer` means *not my call*, which is a different statement
+ * from `allow`. Collapsing them makes every answerer that had no opinion into an
+ * answerer that approved, and nothing in the result says which happened.
+ *
+ * `deny` carries its reason as a required field. A refusal without one reaches a
+ * human as "denied" and sends them to read the policy source to find out what
+ * they did, which is the moment a policy engine stops being worth having.
+ *
+ * Browser-safe and shared on purpose: an event listener voting on a topic
+ * (`stitchkit/live`) and a policy in an ordered pipeline
+ * (`stitchkit/application`) are different mechanisms answering the same
+ * question, and one question with two vocabularies is a codebase where `grep`
+ * finds half the answerers.
+ */
+export declare const PolicyDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"allow">;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"deny">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"defer">;
+}, z.core.$strict>], "outcome">;
+export type PolicyDecision = z.infer<typeof PolicyDecisionSchema>;
+/** What is concluded when nobody claimed the question — see each mechanism for which it uses. */
+export type UndecidedOutcome = 'allow' | 'deny';
+//# sourceMappingURL=decision.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decision.d.ts","sourceRoot":"","sources":["../../src/internal/decision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;+BAI/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,iGAAiG;AACjG,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,MAAM,CAAC"}

package/dist/internal/stable-digest.d.ts

@@ -1,3 +1,38 @@
+/**
+ * A stable identity for a call's arguments — one implementation, two callers.
+ *
+ * Two callers need the same thing for different reasons. The MCP round keys a
+ * tool invocation by `(operation, arguments)` so a retry is recognised as the
+ * same round; a watched read keys its shared source by `(operation, arguments)`
+ * so two browsers asking the same question are one read on the server. If those
+ * two computed the key differently, the same arguments would be the same round
+ * and two different watches — and nothing would say so.
+ *
+ * The stability that matters is key order: `{a:1,b:2}` and `{b:2,a:1}` are the
+ * same arguments and `JSON.stringify` disagrees, so a naive key silently splits
+ * one shared source into two whenever a caller builds its object in a different
+ * order. That is not a hypothetical: object literal order follows the source
+ * that wrote it, and two components asking the same question rarely share one.
+ *
+ * ## Why this is not SHA-256
+ *
+ * It was, and that made every watched read fail on an ordinary intranet. Web
+ * Crypto — `crypto.subtle` — exists only in a **secure context**, so a page
+ * served over plain HTTP from a LAN name has no `crypto.subtle` at all and the
+ * first digest throws `Cannot read properties of undefined`. `localhost` is
+ * secure by definition, which is exactly why nothing caught it until a browser
+ * opened the app by its name.
+ *
+ * The fix is not a fallback, it is admitting what this is for: **identity, not
+ * secrecy**. Nothing here resists an adversary — an attacker who can choose your
+ * watch arguments can already ask the question directly. So the requirement is
+ * distribution and determinism, both ends agreeing, and no ambient capability;
+ * a cryptographic hash bought none of that and cost the entire non-secure web.
+ *
+ * Being synchronous is the second thing it buys. A promise for a key made the
+ * first subscription of a question asynchronous, which meant a component could
+ * not be handed a retained value in the same turn it subscribed.
+ */
 /**
  * The value with every object's keys sorted, recursively — arrays keep their
  * order, because in an array order *is* the value.
@@ -7,12 +42,11 @@
  */
 export declare function stableValue(value: unknown): unknown;
 /**
- * A bounded, order-independent digest of a call's arguments.
+ * A bounded, order-independent identity for a call's arguments.
  *
- * SHA-256 over the key-sorted JSON, base64url without padding. Bounded because
- * the key travels on the wire and arguments do not have a bounded size; a hash
- * rather than the JSON itself so a large argument object does not become a
- * large subscription key repeated in every frame.
+ * 128 bits as 32 lowercase hex characters. Deterministic across runtimes and
+ * across both ends of a socket, synchronous, and dependent on no ambient
+ * capability — see the module header for why that last one is the whole point.
  *
  * What it cannot do, stated because the limit is easy to walk into: values
  * `JSON.stringify` drops or transforms — `undefined` members, a `Date`, a `Map`,
@@ -20,5 +54,5 @@ export declare function stableValue(value: unknown): unknown;
  * Contract arguments are parsed JSON, so this is the argument shape by
  * construction; a caller digesting something else has to say what it means.
  */
-export declare function argumentsDigest(args: Record<string, unknown>): Promise<string>;
+export declare function argumentsDigest(args: Record<string, unknown>): string;
 //# sourceMappingURL=stable-digest.d.ts.map

package/dist/internal/stable-digest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stable-digest.d.ts","sourceRoot":"","sources":["../../src/internal/stable-digest.ts"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQnD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAGpF"}
+{"version":3,"file":"stable-digest.d.ts","sourceRoot":"","sources":["../../src/internal/stable-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQnD;AAyCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAGrE"}