stitchkit 0.59.3 → 0.60.0

package/dist/index-x8v8b7rc.js

@@ -0,0 +1,560 @@
+import {
+  ApplicationIdSchema
+} from "./index-8eywc9zv.js";
+
+// src/application/latest-sink.ts
+import { z } from "zod";
+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(),
+  coalesced: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  inFlight: z.boolean(),
+  pending: z.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 pending;
+  let closePromise;
+  let resolveClose;
+  const getStatus = () => ApplicationSnapshotSinkStatusSchema.parse({
+    accepting,
+    received,
+    accepted,
+    rejected,
+    delivered,
+    coalesced,
+    failed,
+    inFlight: inFlight !== undefined,
+    pending: pending !== undefined,
+    ...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 || !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(() => {
+      inFlight = undefined;
+      const next = pending;
+      pending = undefined;
+      if (next)
+        startWrite(next);
+      else
+        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 {
+        if (pending)
+          coalesced += 1;
+        pending = snapshot;
+      }
+      return true;
+    },
+    getStatus,
+    close() {
+      if (closePromise)
+        return closePromise;
+      accepting = false;
+      closePromise = new Promise((resolve) => {
+        resolveClose = resolve;
+        settleCloseIfIdle();
+      });
+      return closePromise;
+    }
+  };
+}
+
+// src/application/activity.ts
+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,
+  active: NonNegativeIntegerSchema,
+  queued: NonNegativeIntegerSchema,
+  completed: NonNegativeIntegerSchema,
+  failed: NonNegativeIntegerSchema
+}).strict().readonly();
+var ActivityTotalsSchema = z2.object({
+  active: NonNegativeIntegerSchema,
+  queued: NonNegativeIntegerSchema,
+  completed: NonNegativeIntegerSchema,
+  failed: NonNegativeIntegerSchema
+}).strict().readonly();
+var ActivitySnapshotSchema = z2.object({
+  id: ActivityIdSchema,
+  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(),
+  totals: ActivityTotalsSchema
+}).strict().readonly();
+var ActivityLiveStateSchema = z2.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 = 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 = 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;
+  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 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 = z3.enum(["continue", "stop-schedule"]);
+var ManagedScheduleDescriptorSchema = z3.object({
+  id: ApplicationIdSchema,
+  everyMs: PositiveSafeIntegerSchema,
+  startAfterMs: NonNegativeSafeIntegerSchema,
+  overlap: ManagedScheduleOverlapSchema,
+  errorPolicy: ManagedScheduleErrorPolicySchema
+}).readonly();
+var ManagedScheduleStatusSchema = z3.object({
+  descriptor: ManagedScheduleDescriptorSchema,
+  state: z3.enum(["inactive", "scheduled", "running", "draining", "stopped"]),
+  revision: NonNegativeSafeIntegerSchema,
+  capturedAt: z3.string().datetime({ offset: true }),
+  changedAt: z3.string().datetime({ offset: true }),
+  accepting: z3.boolean(),
+  active: NonNegativeSafeIntegerSchema,
+  queued: z3.boolean(),
+  runsStarted: NonNegativeSafeIntegerSchema,
+  runsCompleted: NonNegativeSafeIntegerSchema,
+  runsFailed: NonNegativeSafeIntegerSchema,
+  ticksSkipped: NonNegativeSafeIntegerSchema,
+  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(),
+  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 { ApplicationSnapshotSinkStatusSchema, createApplicationSnapshotSink, ActivityIdSchema, ActivityStageIdSchema, ActivityStageSnapshotSchema, ActivitySnapshotSchema, ActivityLiveStateSchema, ActivityTokenBrand, createActivityProjection, ManagedScheduleOverlapSchema, ManagedScheduleErrorPolicySchema, ManagedScheduleDescriptorSchema, ManagedScheduleStatusSchema, createManagedSchedule };

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   parseTrailingWildcard,
   rateLimited,
   unauthorized
-} from "./index-28cqssm3.js";
+} from "./index-9h1vba8n.js";
 import {
   isRecord,
   mapObject,

package/dist/internal/observability-sink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observability-sink.d.ts","sourceRoot":"","sources":["../../src/internal/observability-sink.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE1D,MAAM,WAAW,gBAAgB,CAAC,KAAK;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,eAAe,CAAC,KAAK;IACpC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB,CAAC,KAAK;IACtC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,MAAM,CAAC,CAAC,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,kBAAkB,CAAC,KAAK;IACvC,MAAM,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,uBAAuB,CAAC;IACrC,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC3C;AAaD,wBAAgB,wBAAwB,CAAC,KAAK,EAC5C,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAC/B,kBAAkB,CAAC,KAAK,CAAC,CAuI3B"}
+{"version":3,"file":"observability-sink.d.ts","sourceRoot":"","sources":["../../src/internal/observability-sink.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE1D,MAAM,WAAW,gBAAgB,CAAC,KAAK;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,eAAe,CAAC,KAAK;IACpC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB,CAAC,KAAK;IACtC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,MAAM,CAAC,CAAC,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,kBAAkB,CAAC,KAAK;IACvC,MAAM,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,uBAAuB,CAAC;IACrC,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC3C;AAaD,wBAAgB,wBAAwB,CAAC,KAAK,EAC5C,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAC/B,kBAAkB,CAAC,KAAK,CAAC,CA8H3B"}

package/dist/internal/route-pattern.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Join route parts into one absolute path, tolerating stray slashes on either
+ * side of every part.
+ *
+ * One home rather than three. The router, the OpenAPI generator and the surface
+ * manifest each carried a byte-identical copy, and a route path that all three
+ * must agree on is exactly the thing that must not be computed three ways.
+ */
+export declare function joinRoutePath(...parts: Array<string | undefined>): string;
 export interface TrailingWildcard {
     name: string;
     segmentIndex: number;

package/dist/internal/route-pattern.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-pattern.d.ts","sourceRoot":"","sources":["../../src/internal/route-pattern.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA2C3E"}
+{"version":3,"file":"route-pattern.d.ts","sourceRoot":"","sources":["../../src/internal/route-pattern.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAOzE;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA2C3E"}

package/dist/node.d.ts

@@ -12,6 +12,6 @@ export { type NodeRuntimeServer, type NodeServerConfig, type NodeServerHandle, t
 export { bindProcessSignals, type ProcessSignalName, type ProcessSignalsBinding, type ProcessSignalsErrorPhase, type ProcessSignalsOptions, type ShutdownTarget, type SignalSource, } from './server/process-signals';
 export { bindRealtimeServer, type RealtimeServer, type RealtimeServerConnection, type RealtimeServerHandle, } from './server/realtime';
 export { type ManagedServerHandle, type ShutdownOptions, ShutdownOptionsSchema, type ShutdownResult, ShutdownResultSchema, type ShutdownState, ShutdownStateSchema, type ShutdownStatus, ShutdownStatusSchema, } from './server/shutdown';
-export { createNodeSocketIOServer as createSocketIOServer, type NodeSocketIOServerHandle as SocketIOServerHandle, type SocketIOHandshakeConfig, type SocketIORequestPolicy, type SocketIOServerConfig, } from './server/socket-io-node';
+export { createNodeSocketIOServer as createSocketIOServer, type NodeSocketIOServerHandle as SocketIOServerHandle, type SocketIOHandshakeConfig, type SocketIOPeerLoaders, type SocketIORequestPolicy, type SocketIOServerConfig, } from './server/socket-io-node';
 export type { EffectiveScope, FetchComposition, FetchHandler, HandlerConfig, LoggingConfig, LogOutcome, RawRoute, RawRouteContext, ScopeContexts, ScopedHandlers, ServiceDef, } from './server/types';
 //# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,SAAS,EACT,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,EAC3B,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,wBAAwB,IAAI,oBAAoB,EAChD,KAAK,wBAAwB,IAAI,oBAAoB,EACrD,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,QAAQ,EACR,eAAe,EACf,aAAa,EACb,cAAc,EACd,UAAU,GACX,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,6BAA6B,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,SAAS,EACT,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,EAC3B,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,wBAAwB,IAAI,oBAAoB,EAChD,KAAK,wBAAwB,IAAI,oBAAoB,EACrD,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,QAAQ,EACR,eAAe,EACf,aAAa,EACb,cAAc,EACd,UAAU,GACX,MAAM,gBAAgB,CAAC"}

package/dist/node.js

@@ -3,14 +3,7 @@ import {
   bindRealtimeServer,
   createHandler,
   createSocketIOServer
-} from "./index-0tszzfxp.js";
-import {
-  ShutdownOptionsSchema,
-  ShutdownResultSchema,
-  ShutdownStateSchema,
-  ShutdownStatusSchema,
-  createServerLifecycle
-} from "./index-dk6e56g0.js";
+} from "./index-f7521k0x.js";
 import {
   createImplement,
   createImplementRegistry,
@@ -19,9 +12,16 @@ import {
   createScopedImplementRegistry,
   implement,
   implementRegistry
-} from "./index-41wm56v0.js";
+} from "./index-3hn10n4c.js";
 import"./index-557by2db.js";
-import"./index-7c0gkyvj.js";
+import {
+  ShutdownOptionsSchema,
+  ShutdownResultSchema,
+  ShutdownStateSchema,
+  ShutdownStatusSchema,
+  createServerLifecycle
+} from "./index-dk6e56g0.js";
+import"./index-6fbp58g8.js";
 import {
   AppError,
   appError,
@@ -31,9 +31,9 @@ import {
   notFound,
   rateLimited,
   unauthorized
-} from "./index-ps5pxp3h.js";
+} from "./index-v6e8hnkx.js";
 import"./index-6k1937bx.js";
-import"./index-y2rb7dwx.js";
+import"./index-pzyt11ch.js";
 import"./index-smpbdg6k.js";
 // src/server/node.ts
 import { serve } from "srvx/node";

package/dist/observability/index.js

@@ -4,13 +4,13 @@ import {
   ObservabilityStatusSchema,
   aggregateObservabilityStatus,
   createBoundedSinkManager
-} from "../index-0nc0cddp.js";
+} from "../index-a59da114.js";
 import {
   measureSize,
   redact,
   sanitizePayload,
   truncatePreview
-} from "../index-gnvzyw0k.js";
+} from "../index-8es1hrv4.js";
 import {
   getRequestContext,
   getTraceId,
@@ -22,8 +22,8 @@ import {
   setRequestError,
   setRequestUser,
   wrapInRequestContext
-} from "../index-7c0gkyvj.js";
-import"../index-ps5pxp3h.js";
+} from "../index-6fbp58g8.js";
+import"../index-v6e8hnkx.js";
 import"../index-6k1937bx.js";
 import {
   childSpan,
@@ -32,7 +32,7 @@ import {
   parseTraceparent,
   resolvePropagationContext,
   resolveTraceContext
-} from "../index-y2rb7dwx.js";
+} from "../index-pzyt11ch.js";
 import {
   isRecord
 } from "../index-smpbdg6k.js";