stitchkit 0.100.2 → 0.100.3

package/dist/{index-ensd0r74.js → index-v14qqmys.js}

@@ -1,18 +1,18 @@
 import {
-  ApplicationIdSchema
-} from "./index-3gye9wzb.js";
+  createBoundedChannel2
+} from "./index-w0eqdhyd.js";
 import {
   assertDrainBound,
   withinBound
-} from "./index-h6eeys1v.js";
+} from "./index-h97tqqp1.js";
 import {
-  createBoundedChannel
-} from "./index-d9pk3td4.js";
+  ApplicationIdSchema2
+} from "./index-w5s3xftz.js";
 
 // src/application/latest-sink.ts
 import { z } from "zod";
 var SnapshotRevisionSchema = z.number().int().nonnegative();
-var ApplicationSnapshotSinkStatusSchema = z.object({
+var ApplicationSnapshotSinkStatusSchema2 = z.object({
   accepting: z.boolean(),
   received: z.number().int().nonnegative(),
   accepted: z.number().int().nonnegative(),
@@ -25,7 +25,7 @@ var ApplicationSnapshotSinkStatusSchema = z.object({
   lastAcceptedRevision: SnapshotRevisionSchema.optional(),
   lastDeliveredRevision: SnapshotRevisionSchema.optional()
 }).strict().readonly();
-function createApplicationSnapshotSink(config) {
+function createApplicationSnapshotSink2(config) {
   let accepting = true;
   let received = 0;
   let accepted = 0;
@@ -38,13 +38,13 @@ function createApplicationSnapshotSink(config) {
   let inFlight;
   let closePromise;
   let resolveClose;
-  const pending = createBoundedChannel({
+  const pending = createBoundedChannel2({
     policy: "latest",
     maxItems: 1,
     maxBytes: 1,
     sizeOf: () => 1
   });
-  const getStatus = () => ApplicationSnapshotSinkStatusSchema.parse({
+  const getStatus = () => ApplicationSnapshotSinkStatusSchema2.parse({
     accepting,
     received,
     accepted,
@@ -134,10 +134,10 @@ function createApplicationSnapshotSink(config) {
 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 = z2.object({
-  id: ActivityStageIdSchema,
+var ActivityIdSchema2 = BoundedOperationalIdSchema;
+var ActivityStageIdSchema2 = BoundedOperationalIdSchema;
+var ActivityStageSnapshotSchema2 = z2.object({
+  id: ActivityStageIdSchema2,
   active: NonNegativeIntegerSchema,
   queued: NonNegativeIntegerSchema,
   completed: NonNegativeIntegerSchema,
@@ -149,17 +149,17 @@ var ActivityTotalsSchema = z2.object({
   completed: NonNegativeIntegerSchema,
   failed: NonNegativeIntegerSchema
 }).strict().readonly();
-var ActivitySnapshotSchema = z2.object({
-  id: ActivityIdSchema,
+var ActivitySnapshotSchema2 = z2.object({
+  id: ActivityIdSchema2,
   epoch: z2.string().uuid(),
   revision: NonNegativeIntegerSchema,
   capturedAt: z2.string().datetime({ offset: true }),
   changedAt: z2.string().datetime({ offset: true }),
-  stages: z2.array(ActivityStageSnapshotSchema).min(1).max(64).readonly(),
+  stages: z2.array(ActivityStageSnapshotSchema2).min(1).max(64).readonly(),
   totals: ActivityTotalsSchema
 }).strict().readonly();
-var ActivityLiveStateSchema = z2.enum(["active", "queued"]);
-var ActivityTokenBrand = Symbol("stitchkit.application.activity");
+var ActivityLiveStateSchema2 = z2.enum(["active", "queued"]);
+var ActivityTokenBrand2 = Symbol("stitchkit.application.activity");
 function emptyCounters() {
   return { active: 0, queued: 0, completed: 0, failed: 0 };
 }
@@ -171,9 +171,9 @@ function totalsOf(stages) {
     failed: totals.failed + stage.failed
   }), emptyCounters());
 }
-function createActivityProjection(config) {
-  const id = ActivityIdSchema.parse(config.id);
-  const declaredStages = z2.array(ActivityStageIdSchema).min(1).max(64).parse(config.stages);
+function createActivityProjection2(config) {
+  const id = ActivityIdSchema2.parse(config.id);
+  const declaredStages = z2.array(ActivityStageIdSchema2).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");
@@ -194,7 +194,7 @@ function createActivityProjection(config) {
   };
   const getSnapshot = () => {
     const stages = declaredStages.map((stage) => ({ id: stage, ...countersFor(stage) }));
-    return ActivitySnapshotSchema.parse({
+    return ActivitySnapshotSchema2.parse({
       id,
       epoch,
       revision,
@@ -235,11 +235,11 @@ function createActivityProjection(config) {
   };
   return {
     open(stage, rawState = "active") {
-      const parsedStage = ActivityStageIdSchema.parse(stage);
-      const state = ActivityLiveStateSchema.parse(rawState);
+      const parsedStage = ActivityStageIdSchema2.parse(stage);
+      const state = ActivityLiveStateSchema2.parse(rawState);
       countersFor(parsedStage)[state] += 1;
       const token = Object.freeze({
-        get [ActivityTokenBrand]() {
+        get [ActivityTokenBrand2]() {
           return true;
         }
       });
@@ -252,8 +252,8 @@ function createActivityProjection(config) {
       if (activity.state === "completed" || activity.state === "failed") {
         throw new Error("[stitchkit] cannot transition a terminal activity");
       }
-      const stage = ActivityStageIdSchema.parse(input.stage);
-      const state = ActivityLiveStateSchema.parse(input.state);
+      const stage = ActivityStageIdSchema2.parse(input.stage);
+      const state = ActivityLiveStateSchema2.parse(input.state);
       countersFor(stage);
       if (activity.stage === stage && activity.state === state)
         return false;
@@ -268,7 +268,7 @@ function createActivityProjection(config) {
     fail: (token) => settle(token, "failed"),
     getSnapshot,
     subscribe(listener) {
-      const sink = createApplicationSnapshotSink({
+      const sink = createApplicationSnapshotSink2({
         write: listener,
         ...config.onSubscriberError && { onSinkError: config.onSubscriberError }
       });
@@ -286,7 +286,7 @@ function createActivityProjection(config) {
 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", [
+var ManagedScheduleOverlapSchema2 = z3.discriminatedUnion("mode", [
   z3.object({ mode: z3.literal("skip") }).readonly(),
   z3.object({ mode: z3.literal("queue-one") }).readonly(),
   z3.object({
@@ -294,16 +294,16 @@ var ManagedScheduleOverlapSchema = z3.discriminatedUnion("mode", [
     maxConcurrent: PositiveSafeIntegerSchema
   }).readonly()
 ]);
-var ManagedScheduleErrorPolicySchema = z3.enum(["continue", "stop-schedule"]);
-var ManagedScheduleDescriptorSchema = z3.object({
-  id: ApplicationIdSchema,
+var ManagedScheduleErrorPolicySchema2 = z3.enum(["continue", "stop-schedule"]);
+var ManagedScheduleDescriptorSchema2 = z3.object({
+  id: ApplicationIdSchema2,
   everyMs: PositiveSafeIntegerSchema,
   startAfterMs: NonNegativeSafeIntegerSchema,
-  overlap: ManagedScheduleOverlapSchema,
-  errorPolicy: ManagedScheduleErrorPolicySchema
+  overlap: ManagedScheduleOverlapSchema2,
+  errorPolicy: ManagedScheduleErrorPolicySchema2
 }).readonly();
-var ManagedScheduleStatusSchema = z3.object({
-  descriptor: ManagedScheduleDescriptorSchema,
+var ManagedScheduleStatusSchema2 = z3.object({
+  descriptor: ManagedScheduleDescriptorSchema2,
   state: z3.enum(["inactive", "scheduled", "running", "draining", "stopped"]),
   revision: NonNegativeSafeIntegerSchema,
   capturedAt: z3.string().datetime({ offset: true }),
@@ -413,15 +413,15 @@ async function executeRun(deps, scheduledAt) {
 function elapsedIntervals(scheduledAt, observedAt, everyMs) {
   return Math.max(1, Math.floor((observedAt - scheduledAt) / everyMs) + 1);
 }
-function createManagedSchedule(config) {
-  const descriptor = ManagedScheduleDescriptorSchema.parse({
+function createManagedSchedule2(config) {
+  const descriptor = ManagedScheduleDescriptorSchema2.parse({
     id: config.id,
     everyMs: config.everyMs,
     startAfterMs: config.startAfterMs ?? config.everyMs,
     overlap: config.overlap ?? DEFAULT_OVERLAP,
     errorPolicy: config.errorPolicy ?? "continue"
   });
-  const dependsOn = config.dependsOn?.map((id) => ApplicationIdSchema.parse(id));
+  const dependsOn = config.dependsOn?.map((id) => ApplicationIdSchema2.parse(id));
   const clock = config.clock ?? systemClock;
   let revision = 0;
   let accepting = false;
@@ -463,7 +463,7 @@ function createManagedSchedule(config) {
   const status = () => {
     const captured = clock.wallNow();
     const anchor = { monotonicNow: clock.now(), wallNow: captured.getTime() };
-    return ManagedScheduleStatusSchema.parse({
+    return ManagedScheduleStatusSchema2.parse({
       descriptor,
       state: scheduleState(activated, stopped, accepting, active.size),
       revision,
@@ -592,4 +592,4 @@ function createManagedSchedule(config) {
   };
 }
 
-export { ApplicationSnapshotSinkStatusSchema, createApplicationSnapshotSink, ActivityIdSchema, ActivityStageIdSchema, ActivityStageSnapshotSchema, ActivitySnapshotSchema, ActivityLiveStateSchema, ActivityTokenBrand, createActivityProjection, ManagedScheduleOverlapSchema, ManagedScheduleErrorPolicySchema, ManagedScheduleDescriptorSchema, ManagedScheduleStatusSchema, createManagedSchedule };
+export { ApplicationSnapshotSinkStatusSchema2, createApplicationSnapshotSink2, ActivityIdSchema2, ActivityStageIdSchema2, ActivityStageSnapshotSchema2, ActivitySnapshotSchema2, ActivityLiveStateSchema2, ActivityTokenBrand2, createActivityProjection2, ManagedScheduleOverlapSchema2, ManagedScheduleErrorPolicySchema2, ManagedScheduleDescriptorSchema2, ManagedScheduleStatusSchema2, createManagedSchedule2 };

package/dist/{index-paz6sgdp.js → index-v4a2fjtk.js}

@@ -1,10 +1,10 @@
 import {
-  ManagedFilePathSchema,
-  ManagedFileRefSchema
-} from "./index-6k1937bx.js";
+  ManagedFilePathSchema2,
+  ManagedFileRefSchema2
+} from "./index-xqhede6x.js";
 import {
-  isWithinDir
-} from "./index-sbdmyz75.js";
+  isWithinDir2
+} from "./index-5cc6r990.js";
 
 // src/files/boundary.ts
 import { randomUUID } from "node:crypto";
@@ -13,7 +13,7 @@ import { link, mkdir, open, realpath, rename, stat, unlink } from "node:fs/promi
 import { basename, dirname, resolve } from "node:path";
 
 // src/files/file-io.ts
-var ManagedFileInspectionSchema = ManagedFileRefSchema.pick({
+var ManagedFileInspectionSchema = ManagedFileRefSchema2.pick({
   mediaType: true,
   name: true
 });
@@ -50,20 +50,20 @@ async function inspectFile(inspector, input, timeoutMs, outerSignal) {
   } catch (error) {
     if (outerSignal?.aborted)
       throw abortReason(outerSignal);
-    throw new ManagedFileError("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: error });
+    throw new ManagedFileError2("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: error });
   }
 }
 function inspectedRef(path, size, inspection, fallback = {}) {
   const mediaType = inspection.mediaType ?? fallback.mediaType;
   const name = inspection.name ?? fallback.name;
-  const parsed = ManagedFileRefSchema.safeParse({
+  const parsed = ManagedFileRefSchema2.safeParse({
     path,
     size,
     ...mediaType ? { mediaType } : {},
     ...name ? { name } : {}
   });
   if (!parsed.success) {
-    throw new ManagedFileError("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: parsed.error });
+    throw new ManagedFileError2("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: parsed.error });
   }
   return parsed.data;
 }
@@ -74,7 +74,7 @@ async function readHandle(handle, maxBytes, signal) {
     signal?.throwIfAborted();
     const capacity = Math.min(64 * 1024, maxBytes + 1 - total);
     if (capacity <= 0) {
-      throw new ManagedFileError("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
+      throw new ManagedFileError2("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
     }
     const chunk = new Uint8Array(capacity);
     const { bytesRead } = await handle.read(chunk, 0, capacity);
@@ -82,7 +82,7 @@ async function readHandle(handle, maxBytes, signal) {
       break;
     total += bytesRead;
     if (total > maxBytes) {
-      throw new ManagedFileError("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
+      throw new ManagedFileError2("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
     }
     chunks.push(chunk.subarray(0, bytesRead));
   }
@@ -111,7 +111,7 @@ async function writeSource(handle, source, maxBytes, inspectionBytes, signal) {
     signal?.throwIfAborted();
     size += chunk.byteLength;
     if (size > maxBytes) {
-      throw new ManagedFileError("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
+      throw new ManagedFileError2("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
     }
     if (prefixSize < inspectionBytes) {
       const kept = chunk.subarray(0, inspectionBytes - prefixSize);
@@ -159,7 +159,7 @@ var noFollow = () => {
   return nofollowFlag;
 };
 
-class ManagedFileError extends Error {
+class ManagedFileError2 extends Error {
   code;
   constructor(code, message, options) {
     super(message, options);
@@ -175,9 +175,9 @@ function positiveLimit(value, fallback, name) {
   return resolved;
 }
 function filePath(path) {
-  const parsed = ManagedFilePathSchema.safeParse(path);
+  const parsed = ManagedFilePathSchema2.safeParse(path);
   if (!parsed.success) {
-    throw new ManagedFileError("FILE_INVALID_PATH", "invalid managed-file path");
+    throw new ManagedFileError2("FILE_INVALID_PATH", "invalid managed-file path");
   }
   return parsed.data;
 }
@@ -187,9 +187,9 @@ function errorCode(error) {
   return typeof error.code === "string" ? error.code : undefined;
 }
 function ioError(message, error) {
-  if (error instanceof ManagedFileError)
+  if (error instanceof ManagedFileError2)
     return error;
-  return new ManagedFileError("FILE_IO_ERROR", message, { cause: error });
+  return new ManagedFileError2("FILE_IO_ERROR", message, { cause: error });
 }
 async function realpathOrNull(path, message) {
   try {
@@ -206,20 +206,20 @@ async function bindRoot(config) {
   if (canonical === null && config.createRoot) {
     const parent = await realpathOrNull(dirname(requested), "failed to resolve managed-file root parent");
     if (parent === null) {
-      throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root parent must exist");
+      throw new ManagedFileError2("FILE_NOT_FOUND", "managed-file root parent must exist");
     }
     const parentInfo = await stat(parent).catch((error) => {
       throw ioError("failed to inspect managed-file root parent", error);
     });
     if (!parentInfo.isDirectory()) {
-      throw new ManagedFileError("FILE_NOT_REGULAR", "managed-file root parent must be a directory");
+      throw new ManagedFileError2("FILE_NOT_REGULAR", "managed-file root parent must be a directory");
     }
     try {
       await mkdir(requested, { mode: 448 });
     } catch (error) {
       if (errorCode(error) !== "EEXIST") {
         if (errorCode(error) === "ENOENT") {
-          throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root parent must exist");
+          throw new ManagedFileError2("FILE_NOT_FOUND", "managed-file root parent must exist");
         }
         throw ioError("failed to create managed-file root", error);
       }
@@ -227,33 +227,33 @@ async function bindRoot(config) {
     canonical = await realpathOrNull(requested, "failed to resolve managed-file root");
   }
   if (canonical === null) {
-    throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root must exist");
+    throw new ManagedFileError2("FILE_NOT_FOUND", "managed-file root must exist");
   }
   const info = await stat(canonical).catch((error) => {
     throw ioError("failed to inspect managed-file root", error);
   });
   if (!info.isDirectory()) {
-    throw new ManagedFileError("FILE_NOT_REGULAR", "managed-file root must be a directory");
+    throw new ManagedFileError2("FILE_NOT_REGULAR", "managed-file root must be a directory");
   }
   return canonical;
 }
 async function existingParent(root, target) {
   const parent = await realpathOrNull(dirname(target), "failed to resolve managed-file parent directory");
   if (parent === null) {
-    throw new ManagedFileError("FILE_NOT_FOUND", "managed-file parent directory not found");
+    throw new ManagedFileError2("FILE_NOT_FOUND", "managed-file parent directory not found");
   }
-  if (!isWithinDir(root, parent)) {
-    throw new ManagedFileError("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
+  if (!isWithinDir2(root, parent)) {
+    throw new ManagedFileError2("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
   }
   const info = await stat(parent).catch((error) => {
     throw ioError("failed to inspect managed-file parent directory", error);
   });
   if (!info.isDirectory()) {
-    throw new ManagedFileError("FILE_NOT_REGULAR", "managed-file parent is not a directory");
+    throw new ManagedFileError2("FILE_NOT_REGULAR", "managed-file parent is not a directory");
   }
   return parent;
 }
-async function createManagedFileBoundary(config) {
+async function createManagedFileBoundary2(config) {
   const root = await bindRoot(config);
   const maxReadBytes = positiveLimit(config.maxReadBytes, DEFAULT_MAX_BYTES, "maxReadBytes");
   const maxWriteBytes = positiveLimit(config.maxWriteBytes, DEFAULT_MAX_BYTES, "maxWriteBytes");
@@ -262,8 +262,8 @@ async function createManagedFileBoundary(config) {
   const targetFor = (path) => {
     const relative = filePath(path);
     const target = resolve(root, ...relative.split("/"));
-    if (!isWithinDir(root, target)) {
-      throw new ManagedFileError("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
+    if (!isWithinDir2(root, target)) {
+      throw new ManagedFileError2("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
     }
     return { path: relative, target };
   };
@@ -273,10 +273,10 @@ async function createManagedFileBoundary(config) {
       options.signal?.throwIfAborted();
       const realTarget = await realpathOrNull(resolved.target, "failed to resolve managed file");
       if (realTarget === null) {
-        throw new ManagedFileError("FILE_NOT_FOUND", "managed file not found");
+        throw new ManagedFileError2("FILE_NOT_FOUND", "managed file not found");
       }
-      if (!isWithinDir(root, realTarget)) {
-        throw new ManagedFileError("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
+      if (!isWithinDir2(root, realTarget)) {
+        throw new ManagedFileError2("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
       }
       const maxBytes = positiveLimit(options.maxBytes, maxReadBytes, "maxBytes");
       let handle;
@@ -284,7 +284,7 @@ async function createManagedFileBoundary(config) {
         handle = await open(realTarget, constants.O_RDONLY | noFollow());
         const info = await handle.stat();
         if (!info.isFile()) {
-          throw new ManagedFileError("FILE_NOT_REGULAR", "managed path is not a regular file");
+          throw new ManagedFileError2("FILE_NOT_REGULAR", "managed path is not a regular file");
         }
         const bytes = await readHandle(handle, maxBytes, options.signal);
         const inspection = await inspectFile(config.inspect, {
@@ -299,7 +299,7 @@ async function createManagedFileBoundary(config) {
         if (options.signal?.aborted && error === options.signal.reason)
           throw error;
         if (errorCode(error) === "ENOENT") {
-          throw new ManagedFileError("FILE_NOT_FOUND", "managed file not found");
+          throw new ManagedFileError2("FILE_NOT_FOUND", "managed file not found");
         }
         throw ioError("failed to read managed file", error);
       } finally {
@@ -340,7 +340,7 @@ async function createManagedFileBoundary(config) {
             committed = true;
           } catch (error) {
             if (errorCode(error) === "EEXIST") {
-              throw new ManagedFileError("FILE_EXISTS", "managed file already exists");
+              throw new ManagedFileError2("FILE_EXISTS", "managed file already exists");
             }
             throw error;
           }
@@ -368,4 +368,4 @@ async function createManagedFileBoundary(config) {
   };
 }
 
-export { ManagedFileError, createManagedFileBoundary };
+export { ManagedFileError2, createManagedFileBoundary2 };

package/dist/{index-d9pk3td4.js → index-w0eqdhyd.js}

@@ -1,11 +1,11 @@
 // src/internal/channel.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,
+var BoundedChannelPolicySchema2 = z.enum(["ordered", "latest"]);
+var BoundedChannelStateSchema2 = z.enum(["open", "draining", "closed", "failed"]);
+var BoundedChannelSnapshotSchema2 = z.object({
+  state: BoundedChannelStateSchema2,
+  policy: BoundedChannelPolicySchema2,
   queuedItems: z.number().int().nonnegative(),
   queuedBytes: z.number().int().nonnegative(),
   waitingReader: z.boolean(),
@@ -17,14 +17,14 @@ var BoundedChannelSnapshotSchema = z.object({
   discarded: z.number().int().nonnegative()
 }).strict().readonly();
 
-class BoundedChannelReaderError extends Error {
+class BoundedChannelReaderError2 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);
+function createBoundedChannel2(config) {
+  const policy = BoundedChannelPolicySchema2.parse(config.policy);
   const maxItems = PositiveSafeIntegerSchema.parse(config.maxItems);
   const maxBytes = PositiveSafeIntegerSchema.parse(config.maxBytes);
   const queue = [];
@@ -42,7 +42,7 @@ function createBoundedChannel(config) {
   const removeAbortListener = () => {
     config.signal?.removeEventListener("abort", abortChannel);
   };
-  const snapshot = () => BoundedChannelSnapshotSchema.parse({
+  const snapshot = () => BoundedChannelSnapshotSchema2.parse({
     state,
     policy,
     queuedItems: queue.length,
@@ -154,7 +154,7 @@ function createBoundedChannel(config) {
         return Promise.resolve({ done: true, value: undefined });
       }
       if (waiting)
-        return Promise.reject(new BoundedChannelReaderError);
+        return Promise.reject(new BoundedChannelReaderError2);
       return new Promise((resolve, reject) => {
         waiting = { resolve, reject };
       });
@@ -189,7 +189,7 @@ function createBoundedChannel(config) {
     config.signal?.addEventListener("abort", abortChannel, { once: true });
   return channel;
 }
-var CreditWindowSnapshotSchema = z.object({
+var CreditWindowSnapshotSchema2 = z.object({
   state: z.enum(["open", "closed"]),
   capacityBytes: PositiveSafeIntegerSchema,
   availableBytes: z.number().int().nonnegative(),
@@ -199,7 +199,7 @@ var CreditWindowSnapshotSchema = z.object({
   replenishedBytes: z.number().int().nonnegative(),
   waiting: z.number().int().nonnegative()
 }).strict().readonly();
-function createCreditWindow(config) {
+function createCreditWindow2(config) {
   const capacityBytes = PositiveSafeIntegerSchema.parse(config.capacityBytes);
   let availableBytes = capacityBytes;
   let state = "open";
@@ -207,7 +207,7 @@ function createCreditWindow(config) {
   let refused = 0;
   let replenishedBytes = 0;
   const waiters = new Set;
-  const snapshot = () => CreditWindowSnapshotSchema.parse({
+  const snapshot = () => CreditWindowSnapshotSchema2.parse({
     state,
     capacityBytes,
     availableBytes,
@@ -323,4 +323,4 @@ function createCreditWindow(config) {
   };
 }
 
-export { BoundedChannelPolicySchema, BoundedChannelStateSchema, BoundedChannelSnapshotSchema, BoundedChannelReaderError, createBoundedChannel, CreditWindowSnapshotSchema, createCreditWindow };
+export { BoundedChannelPolicySchema2, BoundedChannelStateSchema2, BoundedChannelSnapshotSchema2, BoundedChannelReaderError2, createBoundedChannel2, CreditWindowSnapshotSchema2, createCreditWindow2 };