stitchkit 0.77.0 → 0.78.0

package/dist/index-3cwck0rm.js

@@ -1,897 +0,0 @@
-import {
-  ApplicationIdSchema
-} from "./index-8eywc9zv.js";
-
-// src/application/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,
-  queuedItems: z.number().int().nonnegative(),
-  queuedBytes: z.number().int().nonnegative(),
-  waitingReader: z.boolean(),
-  offered: 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(),
-  lastAcceptedRevision: SnapshotRevisionSchema.optional(),
-  lastDeliveredRevision: SnapshotRevisionSchema.optional()
-}).strict().readonly();
-function createApplicationSnapshotSink(config) {
-  let accepting = true;
-  let received = 0;
-  let accepted = 0;
-  let rejected = 0;
-  let delivered = 0;
-  let coalesced = 0;
-  let failed = 0;
-  let lastAcceptedRevision;
-  let lastDeliveredRevision;
-  let inFlight;
-  let closePromise;
-  let resolveClose;
-  const pending = createBoundedChannel({
-    policy: "latest",
-    maxItems: 1,
-    maxBytes: 1,
-    sizeOf: () => 1
-  });
-  const getStatus = () => ApplicationSnapshotSinkStatusSchema.parse({
-    accepting,
-    received,
-    accepted,
-    rejected,
-    delivered,
-    coalesced,
-    failed,
-    inFlight: inFlight !== undefined,
-    pending: pending.getSnapshot().queuedItems > 0,
-    ...lastAcceptedRevision !== undefined && { lastAcceptedRevision },
-    ...lastDeliveredRevision !== undefined && { lastDeliveredRevision }
-  });
-  const reportFailure = (error, snapshot) => {
-    if (!config.onSinkError)
-      return;
-    Promise.resolve().then(() => config.onSinkError?.({ error, snapshot })).catch(() => {
-      return;
-    });
-  };
-  const settleCloseIfIdle = () => {
-    if (accepting || inFlight || pending.getSnapshot().queuedItems > 0 || !resolveClose)
-      return;
-    const resolve = resolveClose;
-    resolveClose = undefined;
-    resolve(getStatus());
-  };
-  const startWrite = (snapshot) => {
-    const write = Promise.resolve().then(() => config.write(snapshot)).then(() => {
-      delivered += 1;
-      lastDeliveredRevision = snapshot.revision;
-    }).catch((error) => {
-      failed += 1;
-      reportFailure(error, snapshot);
-    }).finally(() => {
-      if (pending.getSnapshot().queuedItems > 0) {
-        pending.next().then((next) => {
-          if (next.done) {
-            inFlight = undefined;
-            settleCloseIfIdle();
-          } else {
-            startWrite(next.value);
-          }
-        });
-      } else {
-        inFlight = undefined;
-        settleCloseIfIdle();
-      }
-    });
-    inFlight = write;
-  };
-  return {
-    publish(snapshot) {
-      received += 1;
-      const revision = SnapshotRevisionSchema.parse(snapshot.revision);
-      if (!accepting || lastAcceptedRevision !== undefined && revision <= lastAcceptedRevision) {
-        rejected += 1;
-        return false;
-      }
-      accepted += 1;
-      lastAcceptedRevision = revision;
-      if (!inFlight) {
-        startWrite(snapshot);
-      } else {
-        const offered = pending.offer(snapshot);
-        if (offered.outcome === "coalesced")
-          coalesced += offered.replaced;
-      }
-      return true;
-    },
-    getStatus,
-    close() {
-      if (closePromise)
-        return closePromise;
-      accepting = false;
-      pending.close({ mode: "drain" });
-      closePromise = new Promise((resolve) => {
-        resolveClose = resolve;
-        settleCloseIfIdle();
-      });
-      return closePromise;
-    }
-  };
-}
-
-// 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();
-var ActivityIdSchema = BoundedOperationalIdSchema;
-var ActivityStageIdSchema = BoundedOperationalIdSchema;
-var ActivityStageSnapshotSchema = z3.object({
-  id: ActivityStageIdSchema,
-  active: NonNegativeIntegerSchema,
-  queued: NonNegativeIntegerSchema,
-  completed: NonNegativeIntegerSchema,
-  failed: NonNegativeIntegerSchema
-}).strict().readonly();
-var ActivityTotalsSchema = z3.object({
-  active: NonNegativeIntegerSchema,
-  queued: NonNegativeIntegerSchema,
-  completed: NonNegativeIntegerSchema,
-  failed: NonNegativeIntegerSchema
-}).strict().readonly();
-var ActivitySnapshotSchema = z3.object({
-  id: ActivityIdSchema,
-  epoch: z3.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(),
-  totals: ActivityTotalsSchema
-}).strict().readonly();
-var ActivityLiveStateSchema = z3.enum(["active", "queued"]);
-var ActivityTokenBrand = Symbol("stitchkit.application.activity");
-function emptyCounters() {
-  return { active: 0, queued: 0, completed: 0, failed: 0 };
-}
-function totalsOf(stages) {
-  return stages.reduce((totals, stage) => ({
-    active: totals.active + stage.active,
-    queued: totals.queued + stage.queued,
-    completed: totals.completed + stage.completed,
-    failed: totals.failed + stage.failed
-  }), emptyCounters());
-}
-function createActivityProjection(config) {
-  const id = ActivityIdSchema.parse(config.id);
-  const declaredStages = z3.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 now = config.now ?? (() => new Date);
-  const counters = new Map(declaredStages.map((stage) => [stage, emptyCounters()]));
-  const activities = new WeakMap;
-  const subscribers = new Set;
-  let revision = 0;
-  let changedAt = now().toISOString();
-  const countersFor = (stage) => {
-    const value = counters.get(stage);
-    if (!value) {
-      throw new Error(`[stitchkit] createActivityProjection: undeclared stage "${stage}"`);
-    }
-    return value;
-  };
-  const getSnapshot = () => {
-    const stages = declaredStages.map((stage) => ({ id: stage, ...countersFor(stage) }));
-    return ActivitySnapshotSchema.parse({
-      id,
-      epoch,
-      revision,
-      capturedAt: now().toISOString(),
-      changedAt,
-      stages,
-      totals: totalsOf(stages)
-    });
-  };
-  const publishChange = () => {
-    revision += 1;
-    changedAt = now().toISOString();
-    const snapshot = getSnapshot();
-    for (const subscriber of subscribers)
-      subscriber.publish(snapshot);
-  };
-  const requireActivity = (token) => {
-    const activity = activities.get(token);
-    if (!activity) {
-      throw new Error("[stitchkit] activity token belongs to another projection");
-    }
-    return activity;
-  };
-  const leaveLiveState = (activity) => {
-    if (activity.state === "active" || activity.state === "queued") {
-      countersFor(activity.stage)[activity.state] -= 1;
-    }
-  };
-  const settle = (token, terminal) => {
-    const activity = requireActivity(token);
-    if (activity.state === "completed" || activity.state === "failed")
-      return false;
-    leaveLiveState(activity);
-    countersFor(activity.stage)[terminal] += 1;
-    activity.state = terminal;
-    publishChange();
-    return true;
-  };
-  return {
-    open(stage, rawState = "active") {
-      const parsedStage = ActivityStageIdSchema.parse(stage);
-      const state = ActivityLiveStateSchema.parse(rawState);
-      countersFor(parsedStage)[state] += 1;
-      const token = Object.freeze({
-        get [ActivityTokenBrand]() {
-          return true;
-        }
-      });
-      activities.set(token, { stage: parsedStage, state });
-      publishChange();
-      return token;
-    },
-    transition(token, input) {
-      const activity = requireActivity(token);
-      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);
-      countersFor(stage);
-      if (activity.stage === stage && activity.state === state)
-        return false;
-      leaveLiveState(activity);
-      countersFor(stage)[state] += 1;
-      activity.stage = stage;
-      activity.state = state;
-      publishChange();
-      return true;
-    },
-    complete: (token) => settle(token, "completed"),
-    fail: (token) => settle(token, "failed"),
-    getSnapshot,
-    subscribe(listener) {
-      const sink = createApplicationSnapshotSink({
-        write: listener,
-        ...config.onSubscriberError && { onSinkError: config.onSubscriberError }
-      });
-      subscribers.add(sink);
-      sink.publish(getSnapshot());
-      return () => {
-        subscribers.delete(sink);
-        sink.close();
-      };
-    }
-  };
-}
-
-// 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
-  }).readonly()
-]);
-var ManagedScheduleErrorPolicySchema = z4.enum(["continue", "stop-schedule"]);
-var ManagedScheduleDescriptorSchema = z4.object({
-  id: ApplicationIdSchema,
-  everyMs: PositiveSafeIntegerSchema2,
-  startAfterMs: NonNegativeSafeIntegerSchema,
-  overlap: ManagedScheduleOverlapSchema,
-  errorPolicy: ManagedScheduleErrorPolicySchema
-}).readonly();
-var ManagedScheduleStatusSchema = z4.object({
-  descriptor: ManagedScheduleDescriptorSchema,
-  state: z4.enum(["inactive", "scheduled", "running", "draining", "stopped"]),
-  revision: NonNegativeSafeIntegerSchema,
-  capturedAt: z4.string().datetime({ offset: true }),
-  changedAt: z4.string().datetime({ offset: true }),
-  accepting: z4.boolean(),
-  active: NonNegativeSafeIntegerSchema,
-  queued: z4.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()
-}).readonly();
-var systemClock = {
-  now: () => performance.now(),
-  wallNow: () => new Date,
-  schedule(callback, delayMs) {
-    const timer = setTimeout(callback, delayMs);
-    return { cancel: () => clearTimeout(timer) };
-  }
-};
-var DEFAULT_OVERLAP = { mode: "skip" };
-function createManagedSchedule(config) {
-  const descriptor = ManagedScheduleDescriptorSchema.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 clock = config.clock ?? systemClock;
-  let revision = 0;
-  let accepting = false;
-  let activated = false;
-  let stopped = false;
-  let timer = null;
-  let activationContext = null;
-  let nextRunAt = null;
-  let queuedAt = null;
-  let runsStarted = 0;
-  let runsCompleted = 0;
-  let runsFailed = 0;
-  let ticksSkipped = 0;
-  let lastScheduledAt = null;
-  let lastStartedAt = null;
-  let lastFinishedAt = null;
-  let changedAt = clock.wallNow().toISOString();
-  const active = new Set;
-  const changed = () => {
-    revision += 1;
-    changedAt = clock.wallNow().toISOString();
-  };
-  const cancelFuture = () => {
-    timer?.cancel();
-    timer = null;
-    nextRunAt = null;
-    queuedAt = null;
-  };
-  const stopAdmission = () => {
-    if (!accepting && stopped)
-      return;
-    accepting = false;
-    stopped = true;
-    cancelFuture();
-    changed();
-  };
-  const reportError = (error, context) => {
-    if (!config.onError)
-      return;
-    Promise.resolve().then(() => config.onError?.(error, context)).catch(() => {});
-  };
-  const state = () => {
-    if (!activated)
-      return stopped ? "stopped" : "inactive";
-    if (!accepting)
-      return active.size > 0 ? "draining" : "stopped";
-    return active.size > 0 ? "running" : "scheduled";
-  };
-  const wallAt = (monotonicAt, anchor) => {
-    if (monotonicAt === null)
-      return null;
-    return new Date(anchor.wallNow + monotonicAt - anchor.monotonicNow).toISOString();
-  };
-  const status = () => {
-    const captured = clock.wallNow();
-    const anchor = { monotonicNow: clock.now(), wallNow: captured.getTime() };
-    return ManagedScheduleStatusSchema.parse({
-      descriptor,
-      state: state(),
-      revision,
-      capturedAt: captured.toISOString(),
-      changedAt,
-      accepting,
-      active: active.size,
-      queued: queuedAt !== null,
-      runsStarted,
-      runsCompleted,
-      runsFailed,
-      ticksSkipped,
-      nextRunAt: wallAt(nextRunAt, anchor),
-      lastScheduledAt,
-      lastStartedAt,
-      lastFinishedAt
-    });
-  };
-  let startExecution = () => {
-    return;
-  };
-  const settleExecution = () => {
-    if (!accepting || queuedAt === null || active.size !== 0)
-      return;
-    const successorAt = queuedAt;
-    queuedAt = null;
-    changed();
-    startExecution(successorAt);
-  };
-  startExecution = (scheduledAt) => {
-    const resourceContext = activationContext;
-    if (!accepting || !resourceContext)
-      return;
-    const startedAt = clock.now();
-    const wallStartedAt = clock.wallNow().getTime();
-    const runContext = {
-      applicationId: resourceContext.applicationId,
-      signal: resourceContext.signal,
-      scheduledAt,
-      startedAt,
-      now: () => clock.now()
-    };
-    runsStarted += 1;
-    lastScheduledAt = new Date(wallStartedAt + scheduledAt - startedAt).toISOString();
-    lastStartedAt = new Date(wallStartedAt).toISOString();
-    changed();
-    let tracked;
-    tracked = Promise.resolve().then(() => config.run(runContext)).then(() => {
-      runsCompleted += 1;
-      lastFinishedAt = clock.wallNow().toISOString();
-      if (descriptor.errorPolicy === "continue" && accepting) {
-        resourceContext.reportHealth("healthy");
-      }
-    }, (error) => {
-      runsFailed += 1;
-      lastFinishedAt = clock.wallNow().toISOString();
-      reportError(error, runContext);
-      if (descriptor.errorPolicy === "stop-schedule") {
-        resourceContext.reportHealth("unhealthy");
-        stopAdmission();
-      } else {
-        resourceContext.reportHealth("degraded");
-      }
-    }).finally(() => {
-      active.delete(tracked);
-      changed();
-      settleExecution();
-    });
-    active.add(tracked);
-  };
-  const dispatchTick = (scheduledAt) => {
-    if (!accepting)
-      return;
-    if (descriptor.overlap.mode === "skip") {
-      if (active.size > 0) {
-        ticksSkipped += 1;
-        changed();
-        return;
-      }
-      startExecution(scheduledAt);
-      return;
-    }
-    if (descriptor.overlap.mode === "queue-one") {
-      if (active.size > 0) {
-        queuedAt = scheduledAt;
-        changed();
-        return;
-      }
-      startExecution(scheduledAt);
-      return;
-    }
-    if (active.size >= descriptor.overlap.maxConcurrent) {
-      ticksSkipped += 1;
-      changed();
-      return;
-    }
-    startExecution(scheduledAt);
-  };
-  const arm = () => {
-    if (!accepting || nextRunAt === null)
-      return;
-    const delayMs = Math.max(0, nextRunAt - clock.now());
-    timer = clock.schedule(() => {
-      timer = null;
-      if (!accepting || nextRunAt === null)
-        return;
-      const scheduledAt = nextRunAt;
-      const observedAt = clock.now();
-      const elapsedIntervals = Math.max(1, Math.floor((observedAt - scheduledAt) / descriptor.everyMs) + 1);
-      if (elapsedIntervals > 1) {
-        ticksSkipped += elapsedIntervals - 1;
-        changed();
-      }
-      nextRunAt = scheduledAt + elapsedIntervals * descriptor.everyMs;
-      arm();
-      dispatchTick(scheduledAt);
-    }, delayMs);
-  };
-  const waitForActive = async (context, deadlineAt) => {
-    if (active.size === 0 || context.signal.aborted)
-      return;
-    await new Promise((resolve) => {
-      let settled = false;
-      let deadlineTimer = null;
-      const finish = () => {
-        if (settled)
-          return;
-        settled = true;
-        deadlineTimer?.cancel();
-        context.signal.removeEventListener("abort", finish);
-        resolve();
-      };
-      context.signal.addEventListener("abort", finish, { once: true });
-      if (deadlineAt !== undefined) {
-        deadlineTimer = clock.schedule(finish, Math.max(0, deadlineAt - context.now()));
-      }
-      Promise.allSettled([...active]).then(finish);
-    });
-  };
-  const drain = async (context) => {
-    stopAdmission();
-    await waitForActive(context, context.deadlineAt);
-  };
-  return {
-    id: descriptor.id,
-    ...dependsOn && { dependsOn },
-    ...config.required !== undefined && { required: config.required },
-    get status() {
-      return status();
-    },
-    start() {
-      if (stopped)
-        throw new Error(`[stitchkit] schedule "${descriptor.id}" is stopped`);
-    },
-    activate(context) {
-      if (activated || stopped)
-        return;
-      activated = true;
-      accepting = true;
-      activationContext = context;
-      nextRunAt = clock.now() + descriptor.startAfterMs;
-      context.reportHealth("healthy");
-      changed();
-      arm();
-    },
-    stopAdmission() {
-      stopAdmission();
-    },
-    drain,
-    close() {
-      stopAdmission();
-    },
-    async force(context) {
-      stopAdmission();
-      await waitForActive(context, context.forceDeadlineAt);
-      if (active.size > 0) {
-        throw new Error(`[stitchkit] schedule "${descriptor.id}" still has active executions`);
-      }
-    }
-  };
-}
-
-export { BoundedChannelPolicySchema, BoundedChannelStateSchema, BoundedChannelSnapshotSchema, BoundedChannelReaderError, createBoundedChannel, CreditWindowSnapshotSchema, createCreditWindow, ApplicationSnapshotSinkStatusSchema, createApplicationSnapshotSink, ActivityIdSchema, ActivityStageIdSchema, ActivityStageSnapshotSchema, ActivitySnapshotSchema, ActivityLiveStateSchema, ActivityTokenBrand, createActivityProjection, ManagedScheduleOverlapSchema, ManagedScheduleErrorPolicySchema, ManagedScheduleDescriptorSchema, ManagedScheduleStatusSchema, createManagedSchedule };