stitchkit 0.77.0 → 0.79.0

package/dist/{index-3cwck0rm.js → index-6s7n2v50.js}

@@ -1,345 +1,23 @@
 import {
   ApplicationIdSchema
-} from "./index-8eywc9zv.js";
+} from "./index-3gye9wzb.js";
+import {
+  createBoundedChannel
+} from "./index-7gnkny4z.js";
 
-// src/application/channel.ts
+// src/application/latest-sink.ts
 import { z } from "zod";
-var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var BoundedChannelPolicySchema = z.enum(["ordered", "latest"]);
-var BoundedChannelStateSchema = z.enum(["open", "draining", "closed", "failed"]);
-var BoundedChannelSnapshotSchema = z.object({
-  state: BoundedChannelStateSchema,
-  policy: BoundedChannelPolicySchema,
-  queuedItems: z.number().int().nonnegative(),
-  queuedBytes: z.number().int().nonnegative(),
-  waitingReader: z.boolean(),
-  offered: z.number().int().nonnegative(),
+var SnapshotRevisionSchema = z.number().int().nonnegative();
+var ApplicationSnapshotSinkStatusSchema = z.object({
+  accepting: z.boolean(),
+  received: z.number().int().nonnegative(),
+  accepted: z.number().int().nonnegative(),
+  rejected: z.number().int().nonnegative(),
   delivered: z.number().int().nonnegative(),
-  queued: z.number().int().nonnegative(),
   coalesced: z.number().int().nonnegative(),
-  refused: z.number().int().nonnegative(),
-  discarded: z.number().int().nonnegative()
-}).strict().readonly();
-
-class BoundedChannelReaderError extends Error {
-  constructor() {
-    super("A bounded channel permits only one pending next() call");
-    this.name = "BoundedChannelReaderError";
-  }
-}
-function createBoundedChannel(config) {
-  const policy = BoundedChannelPolicySchema.parse(config.policy);
-  const maxItems = PositiveSafeIntegerSchema.parse(config.maxItems);
-  const maxBytes = PositiveSafeIntegerSchema.parse(config.maxBytes);
-  const queue = [];
-  let state = "open";
-  let queuedBytes = 0;
-  let waiting;
-  let failure;
-  let hasFailure = false;
-  let offered = 0;
-  let delivered = 0;
-  let queued = 0;
-  let coalesced = 0;
-  let refused = 0;
-  let discarded = 0;
-  const removeAbortListener = () => {
-    config.signal?.removeEventListener("abort", abortChannel);
-  };
-  const snapshot = () => BoundedChannelSnapshotSchema.parse({
-    state,
-    policy,
-    queuedItems: queue.length,
-    queuedBytes,
-    waitingReader: waiting !== undefined,
-    offered,
-    delivered,
-    queued,
-    coalesced,
-    refused,
-    discarded
-  });
-  const clearQueue = () => {
-    discarded += queue.length;
-    queue.length = 0;
-    queuedBytes = 0;
-  };
-  const settleClosed = () => {
-    if (state !== "draining" || queue.length > 0)
-      return;
-    state = "closed";
-    removeAbortListener();
-    const reader = waiting;
-    waiting = undefined;
-    reader?.resolve({ done: true, value: undefined });
-  };
-  const close = (options = {}) => {
-    if (state === "closed" || state === "failed")
-      return snapshot();
-    const mode = options.mode ?? "drain";
-    if (mode !== "drain" && mode !== "discard") {
-      throw new TypeError("Bounded channel close mode must be drain or discard");
-    }
-    if (mode === "discard") {
-      clearQueue();
-      state = "closed";
-      removeAbortListener();
-      const reader = waiting;
-      waiting = undefined;
-      reader?.resolve({ done: true, value: undefined });
-      return snapshot();
-    }
-    state = "draining";
-    settleClosed();
-    return snapshot();
-  };
-  function abortChannel() {
-    close({ mode: "discard" });
-  }
-  const channel = {
-    [Symbol.asyncIterator]() {
-      return channel;
-    },
-    offer(value) {
-      offered += 1;
-      if (state !== "open") {
-        refused += 1;
-        return { outcome: "refused", reason: "not-open" };
-      }
-      const bytes = config.sizeOf(value);
-      if (!Number.isSafeInteger(bytes) || bytes < 0) {
-        throw new TypeError("Bounded channel sizeOf() must return a non-negative safe integer");
-      }
-      if (bytes > maxBytes) {
-        refused += 1;
-        return { outcome: "refused", reason: "item-too-large" };
-      }
-      const reader = waiting;
-      if (reader) {
-        waiting = undefined;
-        delivered += 1;
-        reader.resolve({ done: false, value });
-        return { outcome: "delivered" };
-      }
-      if (policy === "latest" && queue.length > 0) {
-        const previous = queue[0];
-        if (!previous)
-          throw new Error("Bounded latest channel lost its pending value");
-        queue[0] = { value, bytes };
-        queuedBytes += bytes - previous.bytes;
-        coalesced += 1;
-        return { outcome: "coalesced", replaced: 1 };
-      }
-      if (queue.length >= maxItems) {
-        refused += 1;
-        return { outcome: "refused", reason: "item-capacity" };
-      }
-      if (queuedBytes + bytes > maxBytes) {
-        refused += 1;
-        return { outcome: "refused", reason: "byte-capacity" };
-      }
-      queue.push({ value, bytes });
-      queuedBytes += bytes;
-      queued += 1;
-      return { outcome: "queued" };
-    },
-    next() {
-      if (hasFailure)
-        return Promise.reject(failure);
-      const next = queue.shift();
-      if (next) {
-        queuedBytes -= next.bytes;
-        delivered += 1;
-        settleClosed();
-        return Promise.resolve({ done: false, value: next.value });
-      }
-      if (state === "closed" || state === "draining") {
-        settleClosed();
-        return Promise.resolve({ done: true, value: undefined });
-      }
-      if (waiting)
-        return Promise.reject(new BoundedChannelReaderError);
-      return new Promise((resolve, reject) => {
-        waiting = { resolve, reject };
-      });
-    },
-    return() {
-      close({ mode: "discard" });
-      return Promise.resolve({ done: true, value: undefined });
-    },
-    throw(error) {
-      channel.fail(error);
-      return Promise.reject(error);
-    },
-    close,
-    fail(error) {
-      if (state === "closed" || state === "failed")
-        return snapshot();
-      failure = error;
-      hasFailure = true;
-      state = "failed";
-      clearQueue();
-      removeAbortListener();
-      const reader = waiting;
-      waiting = undefined;
-      reader?.reject(error);
-      return snapshot();
-    },
-    getSnapshot: snapshot
-  };
-  if (config.signal?.aborted)
-    abortChannel();
-  else
-    config.signal?.addEventListener("abort", abortChannel, { once: true });
-  return channel;
-}
-var CreditWindowSnapshotSchema = z.object({
-  state: z.enum(["open", "closed"]),
-  capacityBytes: PositiveSafeIntegerSchema,
-  availableBytes: z.number().int().nonnegative(),
-  leasedBytes: z.number().int().nonnegative(),
-  acquired: z.number().int().nonnegative(),
-  refused: z.number().int().nonnegative(),
-  replenishedBytes: z.number().int().nonnegative(),
-  waiting: z.number().int().nonnegative()
-}).strict().readonly();
-function createCreditWindow(config) {
-  const capacityBytes = PositiveSafeIntegerSchema.parse(config.capacityBytes);
-  let availableBytes = capacityBytes;
-  let state = "open";
-  let acquired = 0;
-  let refused = 0;
-  let replenishedBytes = 0;
-  const waiters = new Set;
-  const snapshot = () => CreditWindowSnapshotSchema.parse({
-    state,
-    capacityBytes,
-    availableBytes,
-    leasedBytes: capacityBytes - availableBytes,
-    acquired,
-    refused,
-    replenishedBytes,
-    waiting: waiters.size
-  });
-  const serveWaiters = () => {
-    for (const waiter of waiters) {
-      if (waiter.bytes > availableBytes)
-        return;
-      waiter.settle({ outcome: "leased", lease: lease(waiter.bytes) });
-    }
-  };
-  const lease = (requested) => {
-    availableBytes -= requested;
-    acquired += 1;
-    let leaseReleased = false;
-    return {
-      bytes: requested,
-      get released() {
-        return leaseReleased;
-      },
-      release() {
-        if (leaseReleased)
-          return;
-        leaseReleased = true;
-        availableBytes += requested;
-        replenishedBytes += requested;
-        if (availableBytes > capacityBytes) {
-          throw new Error("Credit window accounting exceeded its capacity");
-        }
-        serveWaiters();
-      }
-    };
-  };
-  const tryLease = (requested) => {
-    if (state === "closed")
-      return { outcome: "refused", reason: "closed" };
-    if (requested > capacityBytes) {
-      return { outcome: "refused", reason: "larger-than-window" };
-    }
-    if (requested > availableBytes) {
-      return { outcome: "refused", reason: "insufficient-credit" };
-    }
-    return { outcome: "leased", lease: lease(requested) };
-  };
-  const acquireNow = (requested) => {
-    const result = tryLease(requested);
-    if (result.outcome === "refused")
-      refused += 1;
-    return result;
-  };
-  const acquireWaiting = (requested, options) => {
-    const timeoutMs = options.timeoutMs === undefined ? undefined : PositiveSafeIntegerSchema.parse(options.timeoutMs);
-    const immediate = tryLease(requested);
-    if (immediate.outcome === "leased")
-      return Promise.resolve(immediate);
-    if (immediate.reason !== "insufficient-credit") {
-      refused += 1;
-      return Promise.resolve({ outcome: "refused", reason: immediate.reason });
-    }
-    if (options.signal?.aborted) {
-      refused += 1;
-      return Promise.resolve({ outcome: "refused", reason: "aborted" });
-    }
-    return new Promise((resolve) => {
-      let settled = false;
-      let timer;
-      const waiter = {
-        bytes: requested,
-        settle(result) {
-          if (settled)
-            return;
-          settled = true;
-          if (timer !== undefined)
-            clearTimeout(timer);
-          options.signal?.removeEventListener("abort", onAbort);
-          waiters.delete(waiter);
-          if (result.outcome === "refused")
-            refused += 1;
-          resolve(result);
-        }
-      };
-      function onAbort() {
-        waiter.settle({ outcome: "refused", reason: "aborted" });
-      }
-      waiters.add(waiter);
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-      if (timeoutMs !== undefined) {
-        timer = setTimeout(() => {
-          waiter.settle({ outcome: "refused", reason: "timed-out" });
-        }, timeoutMs);
-      }
-    });
-  };
-  function acquire(bytes, options) {
-    const requested = PositiveSafeIntegerSchema.parse(bytes);
-    return options === undefined ? acquireNow(requested) : acquireWaiting(requested, options);
-  }
-  return {
-    acquire,
-    close() {
-      state = "closed";
-      for (const waiter of [...waiters]) {
-        waiter.settle({ outcome: "refused", reason: "closed" });
-      }
-      return snapshot();
-    },
-    getSnapshot: snapshot
-  };
-}
-
-// src/application/latest-sink.ts
-import { z as z2 } from "zod";
-var SnapshotRevisionSchema = z2.number().int().nonnegative();
-var ApplicationSnapshotSinkStatusSchema = z2.object({
-  accepting: z2.boolean(),
-  received: z2.number().int().nonnegative(),
-  accepted: z2.number().int().nonnegative(),
-  rejected: z2.number().int().nonnegative(),
-  delivered: z2.number().int().nonnegative(),
-  coalesced: z2.number().int().nonnegative(),
-  failed: z2.number().int().nonnegative(),
-  inFlight: z2.boolean(),
-  pending: z2.boolean(),
+  failed: z.number().int().nonnegative(),
+  inFlight: z.boolean(),
+  pending: z.boolean(),
   lastAcceptedRevision: SnapshotRevisionSchema.optional(),
   lastDeliveredRevision: SnapshotRevisionSchema.optional()
 }).strict().readonly();
@@ -448,34 +126,34 @@ function createApplicationSnapshotSink(config) {
 }
 
 // src/application/activity.ts
-import { z as z3 } from "zod";
-var BoundedOperationalIdSchema = z3.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
-var NonNegativeIntegerSchema = z3.number().int().nonnegative();
+import { z as z2 } from "zod";
+var BoundedOperationalIdSchema = z2.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
+var NonNegativeIntegerSchema = z2.number().int().nonnegative();
 var ActivityIdSchema = BoundedOperationalIdSchema;
 var ActivityStageIdSchema = BoundedOperationalIdSchema;
-var ActivityStageSnapshotSchema = z3.object({
+var ActivityStageSnapshotSchema = z2.object({
   id: ActivityStageIdSchema,
   active: NonNegativeIntegerSchema,
   queued: NonNegativeIntegerSchema,
   completed: NonNegativeIntegerSchema,
   failed: NonNegativeIntegerSchema
 }).strict().readonly();
-var ActivityTotalsSchema = z3.object({
+var ActivityTotalsSchema = z2.object({
   active: NonNegativeIntegerSchema,
   queued: NonNegativeIntegerSchema,
   completed: NonNegativeIntegerSchema,
   failed: NonNegativeIntegerSchema
 }).strict().readonly();
-var ActivitySnapshotSchema = z3.object({
+var ActivitySnapshotSchema = z2.object({
   id: ActivityIdSchema,
-  epoch: z3.string().uuid(),
+  epoch: z2.string().uuid(),
   revision: NonNegativeIntegerSchema,
-  capturedAt: z3.string().datetime({ offset: true }),
-  changedAt: z3.string().datetime({ offset: true }),
-  stages: z3.array(ActivityStageSnapshotSchema).min(1).max(64).readonly(),
+  capturedAt: z2.string().datetime({ offset: true }),
+  changedAt: z2.string().datetime({ offset: true }),
+  stages: z2.array(ActivityStageSnapshotSchema).min(1).max(64).readonly(),
   totals: ActivityTotalsSchema
 }).strict().readonly();
-var ActivityLiveStateSchema = z3.enum(["active", "queued"]);
+var ActivityLiveStateSchema = z2.enum(["active", "queued"]);
 var ActivityTokenBrand = Symbol("stitchkit.application.activity");
 function emptyCounters() {
   return { active: 0, queued: 0, completed: 0, failed: 0 };
@@ -490,12 +168,12 @@ function totalsOf(stages) {
 }
 function createActivityProjection(config) {
   const id = ActivityIdSchema.parse(config.id);
-  const declaredStages = z3.array(ActivityStageIdSchema).min(1).max(64).parse(config.stages);
+  const declaredStages = z2.array(ActivityStageIdSchema).min(1).max(64).parse(config.stages);
   const uniqueStages = new Set(declaredStages);
   if (uniqueStages.size !== declaredStages.length) {
     throw new Error("[stitchkit] createActivityProjection: stage ids must be unique");
   }
-  const epoch = z3.string().uuid().parse(config.epoch ?? crypto.randomUUID());
+  const epoch = z2.string().uuid().parse(config.epoch ?? crypto.randomUUID());
   const now = config.now ?? (() => new Date);
   const counters = new Map(declaredStages.map((stage) => [stage, emptyCounters()]));
   const activities = new WeakMap;
@@ -600,42 +278,42 @@ function createActivityProjection(config) {
 }
 
 // src/application/schedule.ts
-import { z as z4 } from "zod";
-var NonNegativeSafeIntegerSchema = z4.number().int().nonnegative().refine(Number.isSafeInteger, "Expected a safe integer");
-var PositiveSafeIntegerSchema2 = NonNegativeSafeIntegerSchema.refine((value) => value > 0, "Expected a positive integer");
-var ManagedScheduleOverlapSchema = z4.discriminatedUnion("mode", [
-  z4.object({ mode: z4.literal("skip") }).readonly(),
-  z4.object({ mode: z4.literal("queue-one") }).readonly(),
-  z4.object({
-    mode: z4.literal("parallel"),
-    maxConcurrent: PositiveSafeIntegerSchema2
+import { z as z3 } from "zod";
+var NonNegativeSafeIntegerSchema = z3.number().int().nonnegative().refine(Number.isSafeInteger, "Expected a safe integer");
+var PositiveSafeIntegerSchema = NonNegativeSafeIntegerSchema.refine((value) => value > 0, "Expected a positive integer");
+var ManagedScheduleOverlapSchema = z3.discriminatedUnion("mode", [
+  z3.object({ mode: z3.literal("skip") }).readonly(),
+  z3.object({ mode: z3.literal("queue-one") }).readonly(),
+  z3.object({
+    mode: z3.literal("parallel"),
+    maxConcurrent: PositiveSafeIntegerSchema
   }).readonly()
 ]);
-var ManagedScheduleErrorPolicySchema = z4.enum(["continue", "stop-schedule"]);
-var ManagedScheduleDescriptorSchema = z4.object({
+var ManagedScheduleErrorPolicySchema = z3.enum(["continue", "stop-schedule"]);
+var ManagedScheduleDescriptorSchema = z3.object({
   id: ApplicationIdSchema,
-  everyMs: PositiveSafeIntegerSchema2,
+  everyMs: PositiveSafeIntegerSchema,
   startAfterMs: NonNegativeSafeIntegerSchema,
   overlap: ManagedScheduleOverlapSchema,
   errorPolicy: ManagedScheduleErrorPolicySchema
 }).readonly();
-var ManagedScheduleStatusSchema = z4.object({
+var ManagedScheduleStatusSchema = z3.object({
   descriptor: ManagedScheduleDescriptorSchema,
-  state: z4.enum(["inactive", "scheduled", "running", "draining", "stopped"]),
+  state: z3.enum(["inactive", "scheduled", "running", "draining", "stopped"]),
   revision: NonNegativeSafeIntegerSchema,
-  capturedAt: z4.string().datetime({ offset: true }),
-  changedAt: z4.string().datetime({ offset: true }),
-  accepting: z4.boolean(),
+  capturedAt: z3.string().datetime({ offset: true }),
+  changedAt: z3.string().datetime({ offset: true }),
+  accepting: z3.boolean(),
   active: NonNegativeSafeIntegerSchema,
-  queued: z4.boolean(),
+  queued: z3.boolean(),
   runsStarted: NonNegativeSafeIntegerSchema,
   runsCompleted: NonNegativeSafeIntegerSchema,
   runsFailed: NonNegativeSafeIntegerSchema,
   ticksSkipped: NonNegativeSafeIntegerSchema,
-  nextRunAt: z4.string().datetime({ offset: true }).nullable(),
-  lastScheduledAt: z4.string().datetime({ offset: true }).nullable(),
-  lastStartedAt: z4.string().datetime({ offset: true }).nullable(),
-  lastFinishedAt: z4.string().datetime({ offset: true }).nullable()
+  nextRunAt: z3.string().datetime({ offset: true }).nullable(),
+  lastScheduledAt: z3.string().datetime({ offset: true }).nullable(),
+  lastStartedAt: z3.string().datetime({ offset: true }).nullable(),
+  lastFinishedAt: z3.string().datetime({ offset: true }).nullable()
 }).readonly();
 var systemClock = {
   now: () => performance.now(),
@@ -863,8 +541,16 @@ function createManagedSchedule(config) {
       return status();
     },
     start() {
-      if (stopped)
-        throw new Error(`[stitchkit] schedule "${descriptor.id}" is stopped`);
+      if (active.size > 0) {
+        throw new Error(`[stitchkit] schedule "${descriptor.id}" still has executions from its previous generation`);
+      }
+      cancelFuture();
+      stopped = false;
+      accepting = false;
+      activated = false;
+      activationContext = null;
+      queuedAt = null;
+      changed();
     },
     activate(context) {
       if (activated || stopped)
@@ -894,4 +580,4 @@ function createManagedSchedule(config) {
   };
 }
 
-export { BoundedChannelPolicySchema, BoundedChannelStateSchema, BoundedChannelSnapshotSchema, BoundedChannelReaderError, createBoundedChannel, CreditWindowSnapshotSchema, createCreditWindow, ApplicationSnapshotSinkStatusSchema, createApplicationSnapshotSink, ActivityIdSchema, ActivityStageIdSchema, ActivityStageSnapshotSchema, ActivitySnapshotSchema, ActivityLiveStateSchema, ActivityTokenBrand, createActivityProjection, ManagedScheduleOverlapSchema, ManagedScheduleErrorPolicySchema, ManagedScheduleDescriptorSchema, ManagedScheduleStatusSchema, createManagedSchedule };
+export { ApplicationSnapshotSinkStatusSchema, createApplicationSnapshotSink, ActivityIdSchema, ActivityStageIdSchema, ActivityStageSnapshotSchema, ActivitySnapshotSchema, ActivityLiveStateSchema, ActivityTokenBrand, createActivityProjection, ManagedScheduleOverlapSchema, ManagedScheduleErrorPolicySchema, ManagedScheduleDescriptorSchema, ManagedScheduleStatusSchema, createManagedSchedule };

package/dist/{index-s4c8wy8m.js → index-758zx2ha.js}

@@ -1,108 +1,29 @@
 import {
   getRequestContext,
   runWithRequestContext
-} from "./index-nemjkxjp.js";
+} from "./index-dwf1f2ap.js";
 import {
   objectShapeKeys
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
+import {
+  coerceJsonArgs
+} from "./index-7zbps32p.js";
 import {
   formatZodError,
   normalizeError,
   validateDeclaredOutput
-} from "./index-nt1mp8km.js";
-import {
-  isUnsafeKey,
-  safeJsonParse
-} from "./index-vj3vvpaa.js";
+} from "./index-fxz0v7vg.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,
   isStitchErrorCode
 } from "./index-0w9abg87.js";
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
-
-// src/tools/coerce.ts
-import { z } from "zod";
-function needsJsonCoercion(schema) {
-  if (schema instanceof z.ZodArray || schema instanceof z.ZodObject || schema instanceof z.ZodRecord || schema instanceof z.ZodTuple || schema instanceof z.ZodUnion) {
-    return true;
-  }
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
-    return needsJsonCoercion(schema.unwrap());
-  }
-  return false;
-}
-function acceptsRawString(schema) {
-  const type = schema._zod.def.type;
-  if (type === "string" || type === "template_literal")
-    return true;
-  if (schema instanceof z.ZodLiteral) {
-    return schema.def.values.some((value) => typeof value === "string");
-  }
-  if (schema instanceof z.ZodEnum) {
-    return schema.options.some((value) => typeof value === "string");
-  }
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
-    return acceptsRawString(schema.unwrap());
-  }
-  if (schema instanceof z.ZodUnion) {
-    return schema.def.options.some((option) => acceptsRawString(option));
-  }
-  return false;
-}
-function matchingVariant(union, value) {
-  const disc = union.def.discriminator;
-  const tag = value[disc];
-  for (const option of union.def.options) {
-    if (!(option instanceof z.ZodObject))
-      continue;
-    const field = option.shape[disc];
-    if (field instanceof z.ZodLiteral && field.def.values.some((v) => v === tag))
-      return option;
-    if (field instanceof z.ZodEnum && field.options.some((v) => v === tag))
-      return option;
-  }
-  return;
-}
-function coerceValue(value, schema) {
-  if (!schema)
-    return value;
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
-    return coerceValue(value, schema.unwrap());
-  }
-  let current = value;
-  if (typeof current === "string" && needsJsonCoercion(schema)) {
-    if (acceptsRawString(schema))
-      return current;
-    try {
-      current = safeJsonParse(current);
-    } catch {
-      return value;
-    }
-  }
-  if (schema instanceof z.ZodObject && isRecord(current)) {
-    const shape = schema.shape;
-    const out = {};
-    for (const [key, item] of Object.entries(current)) {
-      out[key] = coerceValue(item, shape[key]);
-    }
-    return out;
-  }
-  if (schema instanceof z.ZodArray && Array.isArray(current)) {
-    return current.map((item) => coerceValue(item, schema.element));
-  }
-  if (schema instanceof z.ZodDiscriminatedUnion && isRecord(current)) {
-    const variant = matchingVariant(schema, current);
-    return variant ? coerceValue(current, variant) : current;
-  }
-  return current;
-}
-function coerceJsonArgs(args, schema) {
-  const coerced = coerceValue(args, schema);
-  return isRecord(coerced) ? coerced : args;
-}
+} from "./index-77fekveh.js";
 
 // src/tools/execute.ts
 class ToolExecutionControlError extends Error {
@@ -337,4 +258,4 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
   }
 }
 
-export { coerceJsonArgs, ToolExecutionControlError, isToolExecutionControlError, toolResultFromError, toolErrorFromResult, executeToolMethod };
+export { ToolExecutionControlError, isToolExecutionControlError, toolResultFromError, toolErrorFromResult, executeToolMethod };

package/dist/{index-qyrqwr4c.js → index-77fekveh.js}

@@ -37,5 +37,8 @@ function mapObject(source, mapper) {
   }
   return result;
 }
+function mapObjectTypeBoundary(source, mapper) {
+  return mapObject(source, (key, value) => mapper(key, value));
+}
 
-export { typedEntries, isRecord, callRuntimeHandler, executableAgentRuntimeTools, transportResult, mapObject };
+export { typedEntries, isRecord, callRuntimeHandler, executableAgentRuntimeTools, transportResult, mapObject, mapObjectTypeBoundary };