stitchkit 0.76.1 → 0.77.0

package/dist/application.js

@@ -27,13 +27,16 @@ import {
 import {
   argumentsDigest,
   stableValue
-} from "./index-vdvmcy7r.js";
+} from "./index-a916km3r.js";
 import {
   ApplicationAdmissionError,
+  ApplicationRestartInputSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartResultSchema,
   ApplicationShutdownBudgetSchema,
   ApplicationShutdownOptionsSchema,
   createApplication
-} from "./index-hvftzz91.js";
+} from "./index-vc1b0b1b.js";
 import {
   defineManagedResource,
   managedResourceDependencyId
@@ -52,7 +55,6 @@ import {
   projectApplicationStatus
 } from "./index-8eywc9zv.js";
 import"./index-3z73fh2c.js";
-import"./index-rxfy4cq7.js";
 import"./index-0w9abg87.js";
 import {
   isRecord
@@ -431,23 +433,84 @@ function createBoundedAdmission(config) {
     getSnapshot
   };
 }
+// src/internal/decision.ts
+import { z as z2 } from "zod";
+var PolicyDecisionSchema = z2.discriminatedUnion("outcome", [
+  z2.object({ outcome: z2.literal("allow") }).strict(),
+  z2.object({ outcome: z2.literal("deny"), reason: z2.string().min(1) }).strict(),
+  z2.object({ outcome: z2.literal("defer") }).strict()
+]);
+
+// src/application/decisions.ts
+class DecisionUndecidedError extends Error {
+  trace;
+  constructor(trace) {
+    const ran = trace.length === 0 ? "no policy ran" : trace.map((e) => e.id).join(" → ");
+    super(`Decision pipeline reached its end with no terminal verdict (${ran}). A pipeline needs a policy that answers allow or deny.`);
+    this.name = "DecisionUndecidedError";
+    this.trace = trace;
+  }
+}
+
+class DecisionPolicyError extends Error {
+  policyId;
+  constructor(policyId, detail) {
+    super(`Policy "${policyId}" did not return a decision (${detail}). A policy returns { outcome: "allow" | "deny" | "defer" }, and a deny carries a reason.`);
+    this.name = "DecisionPolicyError";
+    this.policyId = policyId;
+  }
+}
+function createDecisionPipeline(policies) {
+  const seen = new Set;
+  for (const policy of policies) {
+    if (policy.id.trim() === "") {
+      throw new Error("[stitchkit] decision pipeline: a policy needs a non-empty id.");
+    }
+    if (seen.has(policy.id)) {
+      throw new Error(`[stitchkit] decision pipeline: two policies share the id "${policy.id}". The trace names policies by id, and a duplicate makes it ambiguous exactly when it is read to explain a refusal.`);
+    }
+    seen.add(policy.id);
+  }
+  return {
+    policyIds: policies.map((policy) => policy.id),
+    async decide(input) {
+      const trace = [];
+      for (const policy of policies) {
+        const answer = await policy.decide(input);
+        const parsed = PolicyDecisionSchema.safeParse(answer);
+        if (!parsed.success) {
+          throw new DecisionPolicyError(policy.id, parsed.error.issues[0]?.message ?? "invalid");
+        }
+        const decision = parsed.data;
+        trace.push(decision.outcome === "deny" ? { id: policy.id, outcome: "deny", reason: decision.reason } : { id: policy.id, outcome: decision.outcome });
+        if (decision.outcome === "deny") {
+          return { outcome: "deny", reason: decision.reason, trace };
+        }
+        if (decision.outcome === "allow") {
+          return { outcome: "allow", trace };
+        }
+      }
+      throw new DecisionUndecidedError(trace);
+    }
+  };
+}
 // src/application/diagnostic-journal.ts
 import { randomUUID } from "node:crypto";
 
 // src/application/diagnostic-journal-contract.ts
-import { z as z2 } from "zod";
-var PositiveSafeIntegerSchema2 = z2.number().int().positive().safe();
-var FileModeSchema = z2.number().int().min(0).max(511);
-var DiagnosticJournalLimitsSchema = z2.object({
+import { z as z3 } from "zod";
+var PositiveSafeIntegerSchema2 = z3.number().int().positive().safe();
+var FileModeSchema = z3.number().int().min(0).max(511);
+var DiagnosticJournalLimitsSchema = z3.object({
   maxEventBytes: PositiveSafeIntegerSchema2,
   maxPendingItems: PositiveSafeIntegerSchema2,
   maxPendingBytes: PositiveSafeIntegerSchema2,
   maxFileBytes: PositiveSafeIntegerSchema2,
   maxFiles: PositiveSafeIntegerSchema2
 }).strict().readonly();
-var DiagnosticJournalLockPolicySchema = z2.enum(["refuse", "reclaim-stale"]);
-var DiagnosticJournalStateSchema = z2.enum(["open", "draining", "closed", "failed"]);
-var DiagnosticJournalRefusalReasonSchema = z2.enum([
+var DiagnosticJournalLockPolicySchema = z3.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStateSchema = z3.enum(["open", "draining", "closed", "failed"]);
+var DiagnosticJournalRefusalReasonSchema = z3.enum([
   "closed",
   "failed",
   "invalid",
@@ -455,72 +518,72 @@ var DiagnosticJournalRefusalReasonSchema = z2.enum([
   "item-capacity",
   "byte-capacity"
 ]);
-var DiagnosticJournalRefusalCountersSchema = z2.object({
-  closed: z2.number().int().nonnegative(),
-  failed: z2.number().int().nonnegative(),
-  invalid: z2.number().int().nonnegative(),
-  oversized: z2.number().int().nonnegative(),
-  "item-capacity": z2.number().int().nonnegative(),
-  "byte-capacity": z2.number().int().nonnegative()
+var DiagnosticJournalRefusalCountersSchema = z3.object({
+  closed: z3.number().int().nonnegative(),
+  failed: z3.number().int().nonnegative(),
+  invalid: z3.number().int().nonnegative(),
+  oversized: z3.number().int().nonnegative(),
+  "item-capacity": z3.number().int().nonnegative(),
+  "byte-capacity": z3.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFailurePhaseSchema = z2.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z2.object({
+var DiagnosticJournalFailurePhaseSchema = z3.enum(["write", "rotation", "close"]);
+var DiagnosticJournalStatusSchema = z3.object({
   state: DiagnosticJournalStateSchema,
-  epoch: z2.uuid(),
+  epoch: z3.uuid(),
   limits: DiagnosticJournalLimitsSchema,
-  lock: z2.object({
+  lock: z3.object({
     policy: DiagnosticJournalLockPolicySchema,
-    reclaimedStale: z2.boolean()
+    reclaimedStale: z3.boolean()
   }).strict().readonly(),
-  received: z2.number().int().nonnegative(),
-  accepted: z2.number().int().nonnegative(),
-  refused: z2.number().int().nonnegative(),
+  received: z3.number().int().nonnegative(),
+  accepted: z3.number().int().nonnegative(),
+  refused: z3.number().int().nonnegative(),
   refusals: DiagnosticJournalRefusalCountersSchema,
-  written: z2.number().int().nonnegative(),
-  failedRecords: z2.number().int().nonnegative(),
-  pendingItems: z2.number().int().nonnegative(),
-  pendingBytes: z2.number().int().nonnegative(),
-  inFlight: z2.boolean(),
-  rotations: z2.number().int().nonnegative(),
-  rotationFailures: z2.number().int().nonnegative(),
-  partialTails: z2.number().int().nonnegative(),
-  currentFileBytes: z2.number().int().nonnegative(),
-  retainedFiles: z2.number().int().nonnegative(),
-  lastAcceptedSequence: z2.number().int().positive().optional(),
-  lastWrittenSequence: z2.number().int().positive().optional(),
-  lastSettledSequence: z2.number().int().positive().optional(),
-  lastFailure: z2.object({
+  written: z3.number().int().nonnegative(),
+  failedRecords: z3.number().int().nonnegative(),
+  pendingItems: z3.number().int().nonnegative(),
+  pendingBytes: z3.number().int().nonnegative(),
+  inFlight: z3.boolean(),
+  rotations: z3.number().int().nonnegative(),
+  rotationFailures: z3.number().int().nonnegative(),
+  partialTails: z3.number().int().nonnegative(),
+  currentFileBytes: z3.number().int().nonnegative(),
+  retainedFiles: z3.number().int().nonnegative(),
+  lastAcceptedSequence: z3.number().int().positive().optional(),
+  lastWrittenSequence: z3.number().int().positive().optional(),
+  lastSettledSequence: z3.number().int().positive().optional(),
+  lastFailure: z3.object({
     phase: DiagnosticJournalFailurePhaseSchema,
-    sequence: z2.number().int().positive().optional()
+    sequence: z3.number().int().positive().optional()
   }).strict().readonly().optional()
 }).strict().readonly();
-var DiagnosticJournalSubmitResultSchema = z2.discriminatedUnion("outcome", [
-  z2.object({
-    outcome: z2.literal("accepted"),
-    epoch: z2.uuid(),
-    sequence: z2.number().int().positive()
+var DiagnosticJournalSubmitResultSchema = z3.discriminatedUnion("outcome", [
+  z3.object({
+    outcome: z3.literal("accepted"),
+    epoch: z3.uuid(),
+    sequence: z3.number().int().positive()
   }).strict().readonly(),
-  z2.object({
-    outcome: z2.literal("refused"),
+  z3.object({
+    outcome: z3.literal("refused"),
     reason: DiagnosticJournalRefusalReasonSchema
   }).strict().readonly()
 ]);
-var DiagnosticJournalWaitResultSchema = z2.object({
-  outcome: z2.enum(["settled", "timed-out", "cancelled"]),
+var DiagnosticJournalWaitResultSchema = z3.object({
+  outcome: z3.enum(["settled", "timed-out", "cancelled"]),
   state: DiagnosticJournalStateSchema,
-  throughSequence: z2.number().int().nonnegative(),
-  settledSequence: z2.number().int().nonnegative()
+  throughSequence: z3.number().int().nonnegative(),
+  settledSequence: z3.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z2.object({
-  outcome: z2.enum(["closed", "timed-out", "cancelled"]),
+var DiagnosticJournalCloseResultSchema = z3.object({
+  outcome: z3.enum(["closed", "timed-out", "cancelled"]),
   state: DiagnosticJournalStateSchema,
-  pendingItems: z2.number().int().nonnegative()
+  pendingItems: z3.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFrameSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  epoch: z2.uuid(),
-  sequence: z2.number().int().positive(),
-  event: z2.json()
+var DiagnosticJournalFrameSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  epoch: z3.uuid(),
+  sequence: z3.number().int().positive(),
+  event: z3.json()
 }).strict().readonly();
 function parseDiagnosticJournalMode(mode) {
   return FileModeSchema.parse(mode ?? 384);
@@ -533,7 +596,7 @@ function readDiagnosticJournalLockDiagnosis(error) {
 }
 
 // src/application/diagnostic-journal-manager.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/application/diagnostic-journal-storage.ts
 import { constants as constants2 } from "node:fs";
@@ -1059,7 +1122,7 @@ function createDiagnosticJournalManager(config, storage) {
       const parsed = config.eventSchema.safeParse(event);
       if (!parsed.success)
         return refuse("invalid");
-      const json = z3.json().safeParse(parsed.data);
+      const json = z4.json().safeParse(parsed.data);
       if (!json.success)
         return refuse("invalid");
       const payload = encoder.encode(JSON.stringify(json.data));
@@ -1142,17 +1205,17 @@ async function createDiagnosticJournal(config) {
   }, storage);
 }
 // src/application/events.ts
-import { z as z4 } from "zod";
-var ApplicationLifecycleEventSchema = z4.object({
-  type: z4.literal("application-state"),
+import { z as z5 } from "zod";
+var ApplicationLifecycleEventSchema = z5.object({
+  type: z5.literal("application-state"),
   applicationId: ApplicationIdSchema,
-  epoch: z4.string().uuid(),
-  revision: z4.number().int().nonnegative(),
+  epoch: z5.string().uuid(),
+  revision: z5.number().int().nonnegative(),
   lifecycle: ApplicationLifecycleSchema,
   health: ApplicationHealthSchema,
-  ready: z4.boolean(),
-  capturedAt: z4.string().datetime({ offset: true }),
-  resources: z4.array(ManagedResourceSnapshotSchema).readonly()
+  ready: z5.boolean(),
+  capturedAt: z5.string().datetime({ offset: true }),
+  resources: z5.array(ManagedResourceSnapshotSchema).readonly()
 }).strict().readonly();
 function applicationLifecycleEvent(snapshot) {
   return ApplicationLifecycleEventSchema.parse({
@@ -1183,13 +1246,13 @@ function createApplicationEventSink(config) {
   };
 }
 // src/application/health.ts
-import { z as z5 } from "zod";
-var ApplicationHealthHandlerOptionsSchema = z5.object({
-  kind: z5.enum(["liveness", "readiness"]),
-  retryAfterSeconds: z5.number().int().nonnegative().default(5)
+import { z as z6 } from "zod";
+var ApplicationHealthHandlerOptionsSchema = z6.object({
+  kind: z6.enum(["liveness", "readiness"]),
+  retryAfterSeconds: z6.number().int().nonnegative().default(5)
 });
-var ApplicationOperationalHandlersOptionsSchema = z5.object({
-  retryAfterSeconds: z5.number().int().nonnegative().default(5)
+var ApplicationOperationalHandlersOptionsSchema = z6.object({
+  retryAfterSeconds: z6.number().int().nonnegative().default(5)
 });
 function createApplicationHealthHandler(application, options) {
   const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
@@ -1431,12 +1494,12 @@ function managedServerResource(config) {
   });
 }
 // src/browser/resumable.ts
-import { z as z6 } from "zod";
-var PositiveSafeIntegerSchema3 = z6.number().int().positive().safe();
-var BackoffPolicySchema = z6.object({
+import { z as z7 } from "zod";
+var PositiveSafeIntegerSchema3 = z7.number().int().positive().safe();
+var BackoffPolicySchema = z7.object({
   minDelayMs: PositiveSafeIntegerSchema3,
   maxDelayMs: PositiveSafeIntegerSchema3,
-  jitter: z6.number().min(0).max(1)
+  jitter: z7.number().min(0).max(1)
 }).strict().readonly().refine((policy) => policy.maxDelayMs >= policy.minDelayMs, {
   message: "maxDelayMs must be at least minDelayMs"
 });
@@ -1457,12 +1520,12 @@ function createBackoff(policy, random = Math.random) {
 }
 
 // src/live/watch-contract.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/browser/live-state.ts
-import { z as z7 } from "zod";
-var PositiveSafeIntegerSchema4 = z7.number().int().positive().safe();
-var LiveStatePhaseSchema = z7.enum([
+import { z as z8 } from "zod";
+var PositiveSafeIntegerSchema4 = z8.number().int().positive().safe();
+var LiveStatePhaseSchema = z8.enum([
   "idle",
   "opening",
   "live",
@@ -1470,7 +1533,7 @@ var LiveStatePhaseSchema = z7.enum([
   "unavailable",
   "closed"
 ]);
-var LiveStateStopReasonSchema = z7.enum([
+var LiveStateStopReasonSchema = z8.enum([
   "gap",
   "buffer-overflow",
   "source-unavailable",
@@ -1478,42 +1541,42 @@ var LiveStateStopReasonSchema = z7.enum([
   "controller-error",
   "controller-capacity"
 ]);
-var LiveStateControllerStatusSchema = z7.object({
+var LiveStateControllerStatusSchema = z8.object({
   phase: LiveStatePhaseSchema,
-  generation: z7.number().int().nonnegative(),
-  hasValue: z7.boolean(),
-  bufferedEvents: z7.number().int().nonnegative(),
-  bufferedBytes: z7.number().int().nonnegative(),
-  receivedEvents: z7.number().int().nonnegative(),
-  appliedEvents: z7.number().int().nonnegative(),
-  duplicateEvents: z7.number().int().nonnegative(),
-  gapEvents: z7.number().int().nonnegative(),
-  refusedEvents: z7.number().int().nonnegative(),
+  generation: z8.number().int().nonnegative(),
+  hasValue: z8.boolean(),
+  bufferedEvents: z8.number().int().nonnegative(),
+  bufferedBytes: z8.number().int().nonnegative(),
+  receivedEvents: z8.number().int().nonnegative(),
+  appliedEvents: z8.number().int().nonnegative(),
+  duplicateEvents: z8.number().int().nonnegative(),
+  gapEvents: z8.number().int().nonnegative(),
+  refusedEvents: z8.number().int().nonnegative(),
   reason: LiveStateStopReasonSchema.optional()
 }).strict().readonly();
 
 // src/live/watch-contract.ts
-var WatchKeySchema = z8.object({
-  service: z8.string().min(1),
-  action: z8.string().min(1),
-  digest: z8.string().min(1)
+var WatchKeySchema = z9.object({
+  service: z9.string().min(1),
+  action: z9.string().min(1),
+  digest: z9.string().min(1)
 }).strict().readonly();
-var WatchOpenSchema = z8.object({ key: WatchKeySchema, args: z8.unknown() }).readonly();
-var WatchAcceptedSchema = z8.object({
-  accepted: z8.boolean(),
-  reason: z8.string().optional()
+var WatchOpenSchema = z9.object({ key: WatchKeySchema, args: z9.unknown() }).readonly();
+var WatchAcceptedSchema = z9.object({
+  accepted: z9.boolean(),
+  reason: z9.string().optional()
 }).strict().readonly();
-var WatchValueSchema = z8.object({
+var WatchValueSchema = z9.object({
   key: WatchKeySchema,
-  revision: z8.number().int().nonnegative(),
-  value: z8.unknown()
+  revision: z9.number().int().nonnegative(),
+  value: z9.unknown()
 }).readonly();
-var WatchStateSchema = z8.object({
+var WatchStateSchema = z9.object({
   key: WatchKeySchema,
   phase: LiveStatePhaseSchema,
   reason: LiveStateStopReasonSchema.optional(),
-  code: z8.string().optional(),
-  message: z8.string().optional()
+  code: z9.string().optional(),
+  message: z9.string().optional()
 }).readonly();
 var WATCH_OPEN = "stitchkit.watch.open";
 var WATCH_CLOSE = "stitchkit.watch.close";
@@ -1521,12 +1584,12 @@ var WATCH_VALUE = "stitchkit.watch.value";
 var WATCH_STATE = "stitchkit.watch.state";
 var watchContract = {
   serverToClient: {
-    [WATCH_VALUE]: { args: z8.tuple([WatchValueSchema]) },
-    [WATCH_STATE]: { args: z8.tuple([WatchStateSchema]) }
+    [WATCH_VALUE]: { args: z9.tuple([WatchValueSchema]) },
+    [WATCH_STATE]: { args: z9.tuple([WatchStateSchema]) }
   },
   clientToServer: {
-    [WATCH_OPEN]: { args: z8.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
-    [WATCH_CLOSE]: { args: z8.tuple([z8.object({ key: WatchKeySchema }).readonly()]) }
+    [WATCH_OPEN]: { args: z9.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
+    [WATCH_CLOSE]: { args: z9.tuple([z9.object({ key: WatchKeySchema }).readonly()]) }
   }
 };
 function watchKeyString(key) {
@@ -1535,12 +1598,12 @@ function watchKeyString(key) {
 
 // src/application/watch-hub.ts
 var DEFAULT_BACKOFF = { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
-async function watchKey(operation, args) {
+function watchKey(operation, args) {
   const record = typeof args === "object" && args !== null && !Array.isArray(args) ? args : { value: args };
   return {
     service: operation.service,
     action: operation.action,
-    digest: await argumentsDigest(record)
+    digest: argumentsDigest(record)
   };
 }
 function createWatchHub(config) {
@@ -1757,6 +1820,7 @@ export {
   createWatchHub,
   createManagedSchedule,
   createDiagnosticJournal,
+  createDecisionPipeline,
   createCreditWindow,
   createBoundedChannel,
   createBoundedAdmission,
@@ -1767,6 +1831,7 @@ export {
   createApplication,
   createActivityProjection,
   applicationLifecycleEvent,
+  PolicyDecisionSchema,
   ManagedScheduleStatusSchema,
   ManagedScheduleOverlapSchema,
   ManagedScheduleErrorPolicySchema,
@@ -1783,6 +1848,8 @@ export {
   DiagnosticJournalFrameSchema,
   DiagnosticJournalFailurePhaseSchema,
   DiagnosticJournalCloseResultSchema,
+  DecisionUndecidedError,
+  DecisionPolicyError,
   CreditWindowSnapshotSchema,
   BoundedRateBudgetSchema,
   BoundedOperationWaitError,
@@ -1802,6 +1869,9 @@ export {
   ApplicationShutdownResultSchema,
   ApplicationShutdownOptionsSchema,
   ApplicationShutdownBudgetSchema,
+  ApplicationRestartResultSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartInputSchema,
   ApplicationResourceShutdownSchema,
   ApplicationOperationalHandlersOptionsSchema,
   ApplicationLifecycleSchema,

package/dist/cli.js

@@ -5,18 +5,17 @@ import {
   emitResult,
   parseCliArgs,
   pollUntilDone
-} from "./index-9my2n66s.js";
-import"./index-9c5dbr5q.js";
+} from "./index-s2rchahr.js";
+import"./index-k2zczx1g.js";
 import"./index-wwst0td5.js";
-import"./index-885chjxq.js";
-import"./index-k68e5jz0.js";
-import"./index-e0a57ymn.js";
+import"./index-7qy2ex0m.js";
+import"./index-s4c8wy8m.js";
+import"./index-nemjkxjp.js";
 import"./index-sbdmyz75.js";
 import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
 import"./index-nt1mp8km.js";
-import"./index-hsz2mmk0.js";
-import"./index-rxfy4cq7.js";
+import"./index-vj3vvpaa.js";
 import"./index-0w9abg87.js";
 import"./index-qyrqwr4c.js";
 import"./index-6k1937bx.js";

package/dist/contract/index.js

@@ -20,8 +20,7 @@ import {
   paginatedSchema,
   rateLimited,
   unauthorized
-} from "../index-4kp4fxvp.js";
-import"../index-rxfy4cq7.js";
+} from "../index-f6n5n7nz.js";
 import"../index-ksp6e2ye.js";
 export {
   unauthorized,

package/dist/{index-v5dm4bwq.js → index-58jzmnn4.js}

@@ -8,7 +8,7 @@ import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   isRecord,
   mapObject,

package/dist/{index-885chjxq.js → index-7qy2ex0m.js}

@@ -1,6 +1,6 @@
 import {
   executeToolMethod
-} from "./index-k68e5jz0.js";
+} from "./index-s4c8wy8m.js";
 import {
   assertToolExtensionCompatible,
   mergeSchemas,

package/dist/index-a916km3r.js

@@ -0,0 +1,45 @@
+// src/internal/stable-digest.ts
+function stableValue(value) {
+  if (Array.isArray(value))
+    return value.map(stableValue);
+  if (value === null || typeof value !== "object")
+    return value;
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    result[key] = stableValue(Reflect.get(value, key));
+  }
+  return result;
+}
+function mix128(input) {
+  let a = 2654435769;
+  let b = 2246822507;
+  let c = 3266489909;
+  let d = 668265263;
+  for (let index = 0;index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    a = Math.imul(a ^ code, 2246822519);
+    b = Math.imul(b ^ code, 3266489917);
+    c = Math.imul(c ^ code, 668265263);
+    d = Math.imul(d ^ code, 374761393);
+    a = a << 13 | a >>> 19;
+    b = b << 17 | b >>> 15;
+    c = c << 7 | c >>> 25;
+    d = d << 11 | d >>> 21;
+  }
+  a ^= b >>> 15;
+  b ^= c >>> 13;
+  c ^= d >>> 11;
+  d ^= a >>> 9;
+  return [
+    Math.imul(a ^ a >>> 16, 575075507) >>> 0,
+    Math.imul(b ^ b >>> 13, 2654435761) >>> 0,
+    Math.imul(c ^ c >>> 16, 2246822507) >>> 0,
+    Math.imul(d ^ d >>> 15, 3266489909) >>> 0
+  ];
+}
+function argumentsDigest(args) {
+  const lanes = mix128(JSON.stringify(stableValue(args)) ?? "undefined");
+  return lanes.map((lane) => lane.toString(16).padStart(8, "0")).join("");
+}
+
+export { stableValue, argumentsDigest };

package/dist/{index-28jsdwt1.js → index-aczggrty.js}

@@ -1,6 +1,6 @@
 import {
   isUnsafeKey
-} from "./index-hsz2mmk0.js";
+} from "./index-vj3vvpaa.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/{index-65kathdm.js → index-da1aqnhb.js}

@@ -2,15 +2,13 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-endzd8sj.js";
+} from "./index-vbf2p6me.js";
 import {
+  base64UrlToBytes,
+  bytesToBase64Url,
   isUnsafeKey,
   safeJsonParse
-} from "./index-hsz2mmk0.js";
-import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
+} from "./index-vj3vvpaa.js";
 import {
   forbidden,
   unauthorized

package/dist/{index-xgahrwdf.js → index-ezmn6ac6.js}

@@ -3,15 +3,15 @@ import {
 } from "./index-3xnq72rz.js";
 import {
   collectToolSurface
-} from "./index-9c5dbr5q.js";
+} from "./index-k2zczx1g.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-885chjxq.js";
+} from "./index-7qy2ex0m.js";
 import {
   isToolExecutionControlError,
   toolResultFromError
-} from "./index-k68e5jz0.js";
+} from "./index-s4c8wy8m.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/{index-4kp4fxvp.js → index-f6n5n7nz.js}

@@ -1,7 +1,3 @@
-import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
 import {
   mapObjectTypeBoundary
 } from "./index-ksp6e2ye.js";
@@ -435,6 +431,24 @@ var ManagedFileRefSchema = z3.object({
 });
 // src/contract/pagination.ts
 import { z as z4 } 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/pagination.ts
 function paginatedSchema(itemSchema) {
   return z4.object({
     items: z4.array(itemSchema),