stitchkit 0.93.0 → 0.94.1

package/dist/index-wc4x00bn.js

@@ -1,103 +0,0 @@
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/application/diagnostic-journal-contract.ts
-import { z } from "zod";
-var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var FileModeSchema = z.number().int().min(0).max(511);
-var DiagnosticJournalLimitsSchema = z.object({
-  maxEventBytes: PositiveSafeIntegerSchema,
-  maxPendingItems: PositiveSafeIntegerSchema,
-  maxPendingBytes: PositiveSafeIntegerSchema,
-  maxFileBytes: PositiveSafeIntegerSchema,
-  maxFiles: PositiveSafeIntegerSchema
-}).strict().readonly();
-var DiagnosticJournalLockPolicySchema = z.enum(["refuse", "reclaim-stale"]);
-var DiagnosticJournalStateSchema = z.enum(["open", "draining", "closed", "failed"]);
-var DiagnosticJournalRefusalReasonSchema = z.enum([
-  "closed",
-  "failed",
-  "invalid",
-  "oversized",
-  "item-capacity",
-  "byte-capacity"
-]);
-var DiagnosticJournalRefusalCountersSchema = z.object({
-  closed: z.number().int().nonnegative(),
-  failed: z.number().int().nonnegative(),
-  invalid: z.number().int().nonnegative(),
-  oversized: z.number().int().nonnegative(),
-  "item-capacity": z.number().int().nonnegative(),
-  "byte-capacity": z.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalFailurePhaseSchema = z.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z.object({
-  state: DiagnosticJournalStateSchema,
-  epoch: z.uuid(),
-  limits: DiagnosticJournalLimitsSchema,
-  lock: z.object({
-    policy: DiagnosticJournalLockPolicySchema,
-    reclaimedStale: z.boolean()
-  }).strict().readonly(),
-  received: z.number().int().nonnegative(),
-  accepted: z.number().int().nonnegative(),
-  refused: z.number().int().nonnegative(),
-  refusals: DiagnosticJournalRefusalCountersSchema,
-  written: z.number().int().nonnegative(),
-  failedRecords: z.number().int().nonnegative(),
-  pendingItems: z.number().int().nonnegative(),
-  pendingBytes: z.number().int().nonnegative(),
-  inFlight: z.boolean(),
-  rotations: z.number().int().nonnegative(),
-  rotationFailures: z.number().int().nonnegative(),
-  partialTails: z.number().int().nonnegative(),
-  currentFileBytes: z.number().int().nonnegative(),
-  retainedFiles: z.number().int().nonnegative(),
-  lastAcceptedSequence: z.number().int().positive().optional(),
-  lastWrittenSequence: z.number().int().positive().optional(),
-  lastSettledSequence: z.number().int().positive().optional(),
-  lastFailure: z.object({
-    phase: DiagnosticJournalFailurePhaseSchema,
-    sequence: z.number().int().positive().optional()
-  }).strict().readonly().optional()
-}).strict().readonly();
-var DiagnosticJournalSubmitResultSchema = z.discriminatedUnion("outcome", [
-  z.object({
-    outcome: z.literal("accepted"),
-    epoch: z.uuid(),
-    sequence: z.number().int().positive()
-  }).strict().readonly(),
-  z.object({
-    outcome: z.literal("refused"),
-    reason: DiagnosticJournalRefusalReasonSchema
-  }).strict().readonly()
-]);
-var DiagnosticJournalWaitResultSchema = z.object({
-  outcome: z.enum(["settled", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
-  throughSequence: z.number().int().nonnegative(),
-  settledSequence: z.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z.object({
-  outcome: z.enum(["closed", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
-  pendingItems: z.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalFrameSchema = z.object({
-  schemaVersion: z.literal(1),
-  epoch: z.uuid(),
-  sequence: z.number().int().positive(),
-  event: z.json()
-}).strict().readonly();
-function parseDiagnosticJournalMode(mode) {
-  return FileModeSchema.parse(mode ?? 384);
-}
-function readDiagnosticJournalLockDiagnosis(error) {
-  if (!isRecord(error))
-    return;
-  const diagnosis = error.journalLock;
-  return isRecord(diagnosis) ? diagnosis : undefined;
-}
-
-export { DiagnosticJournalLimitsSchema, DiagnosticJournalLockPolicySchema, DiagnosticJournalStateSchema, DiagnosticJournalRefusalReasonSchema, DiagnosticJournalFailurePhaseSchema, DiagnosticJournalStatusSchema, DiagnosticJournalSubmitResultSchema, DiagnosticJournalWaitResultSchema, DiagnosticJournalCloseResultSchema, DiagnosticJournalFrameSchema, parseDiagnosticJournalMode, readDiagnosticJournalLockDiagnosis };

package/dist/index-wnfk50r0.js

@@ -1,211 +0,0 @@
-// src/observability/status.ts
-import { z } from "zod";
-var NonNegativeIntegerSchema = z.number().int().nonnegative();
-var ObservabilitySinkStatusSchema = z.object({
-  capacity: NonNegativeIntegerSchema,
-  received: NonNegativeIntegerSchema,
-  accepted: NonNegativeIntegerSchema,
-  filtered: NonNegativeIntegerSchema,
-  completed: NonNegativeIntegerSchema,
-  dropped: NonNegativeIntegerSchema,
-  failed: NonNegativeIntegerSchema,
-  preparationFailed: NonNegativeIntegerSchema,
-  preparing: NonNegativeIntegerSchema,
-  pending: NonNegativeIntegerSchema,
-  closed: z.boolean()
-}).readonly();
-var ObservabilityStatusObjectSchema = z.object({
-  request: ObservabilitySinkStatusSchema.optional(),
-  tools: ObservabilitySinkStatusSchema.optional(),
-  total: ObservabilitySinkStatusSchema
-});
-var ObservabilityStatusSchema = ObservabilityStatusObjectSchema.readonly();
-var ObservabilityDrainReportSchema = ObservabilityStatusObjectSchema.extend({
-  durationMs: z.number().nonnegative(),
-  drained: z.boolean()
-}).readonly();
-var SUMMED_STATUS_KEYS = [
-  "capacity",
-  "received",
-  "accepted",
-  "filtered",
-  "completed",
-  "dropped",
-  "failed",
-  "preparationFailed",
-  "preparing",
-  "pending"
-];
-function aggregateObservabilityStatus(surfaces, closed) {
-  const totals = {
-    capacity: 0,
-    received: 0,
-    accepted: 0,
-    filtered: 0,
-    completed: 0,
-    dropped: 0,
-    failed: 0,
-    preparationFailed: 0,
-    preparing: 0,
-    pending: 0
-  };
-  for (const surface of surfaces) {
-    for (const key of SUMMED_STATUS_KEYS)
-      totals[key] += surface[key];
-  }
-  return ObservabilitySinkStatusSchema.parse({ ...totals, closed });
-}
-
-// src/internal/observability-sink.ts
-function assertDrainBound(bound) {
-  const timeoutMs = bound?.timeoutMs;
-  if (timeoutMs === undefined)
-    return;
-  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
-    throw new TypeError("Observability drain timeoutMs must be a non-negative finite number");
-  }
-}
-function withinBound(work, bound) {
-  assertDrainBound(bound);
-  const { timeoutMs, signal } = bound ?? {};
-  if (timeoutMs === undefined && !signal)
-    return work.then(() => true);
-  let timer;
-  let onAbort;
-  const reached = new Promise((resolve) => {
-    const give = () => resolve(false);
-    if (signal?.aborted) {
-      give();
-      return;
-    }
-    if (signal) {
-      onAbort = give;
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-    if (timeoutMs !== undefined)
-      timer = setTimeout(give, timeoutMs);
-  });
-  return Promise.race([work.then(() => true), reached]).finally(() => {
-    if (timer !== undefined)
-      clearTimeout(timer);
-    if (onAbort && signal)
-      signal.removeEventListener("abort", onAbort);
-  });
-}
-var DEFAULT_MAX_PENDING = 1000;
-function invokeIsolated(callback) {
-  if (!callback)
-    return;
-  Promise.resolve().then(callback).catch(() => {});
-}
-function createBoundedSinkManager(config) {
-  const maxPending = config.maxPending ?? DEFAULT_MAX_PENDING;
-  if (!Number.isSafeInteger(maxPending) || maxPending <= 0) {
-    throw new TypeError("Observability maxPending must be a positive safe integer");
-  }
-  let sequence = 0;
-  let closed = false;
-  let received = 0;
-  let accepted = 0;
-  let filtered = 0;
-  let completed = 0;
-  let dropped = 0;
-  let failed = 0;
-  let preparationFailed = 0;
-  let drain;
-  const preparing = new Map;
-  const writes = new Map;
-  const reportError = (error, event) => {
-    invokeIsolated(config.onSinkError ? () => config.onSinkError?.({ error, ...event !== undefined && { event } }) : undefined);
-  };
-  const reportDrop = (reason, event) => {
-    invokeIsolated(config.onDrop ? () => config.onDrop?.({ reason, event, pending: writes.size }) : undefined);
-  };
-  const admit = (id, event) => {
-    try {
-      if (config.filter && !config.filter(event)) {
-        filtered += 1;
-        return;
-      }
-    } catch (error) {
-      preparationFailed += 1;
-      reportError(error, event);
-      return;
-    }
-    if (writes.size >= maxPending) {
-      dropped += 1;
-      reportDrop("capacity", event);
-      return;
-    }
-    accepted += 1;
-    const settle = (record) => {
-      record();
-      writes.delete(id);
-    };
-    const write = Promise.resolve().then(() => config.write(event)).then(() => settle(() => {
-      completed += 1;
-    }), (error) => settle(() => {
-      failed += 1;
-      reportError(error, event);
-    }));
-    writes.set(id, write);
-  };
-  const awaitGeneration = async (boundary) => {
-    const through = (values) => [...values].filter(([id]) => id <= boundary).map(([, value]) => value);
-    await Promise.allSettled(through(preparing));
-    await Promise.allSettled(through(writes));
-  };
-  return {
-    submit(produce) {
-      received += 1;
-      const id = ++sequence;
-      if (closed) {
-        Promise.resolve().then(produce).then((event) => {
-          dropped += 1;
-          reportDrop("closed", event);
-        }).catch((error) => {
-          preparationFailed += 1;
-          reportError(error);
-        });
-        return;
-      }
-      const preparation = Promise.resolve().then(produce).then((event) => {
-        preparing.delete(id);
-        admit(id, event);
-      }, (error) => {
-        preparing.delete(id);
-        preparationFailed += 1;
-        reportError(error);
-      });
-      preparing.set(id, preparation);
-    },
-    flush(bound) {
-      assertDrainBound(bound);
-      return withinBound(awaitGeneration(sequence), bound);
-    },
-    getStatus,
-    close(bound) {
-      assertDrainBound(bound);
-      drain ??= awaitGeneration(sequence);
-      closed = true;
-      return withinBound(drain, bound).then(getStatus);
-    }
-  };
-  function getStatus() {
-    return ObservabilitySinkStatusSchema.parse({
-      capacity: maxPending,
-      received,
-      accepted,
-      filtered,
-      completed,
-      dropped,
-      failed,
-      preparationFailed,
-      preparing: preparing.size,
-      pending: writes.size,
-      closed
-    });
-  }
-}
-
-export { ObservabilitySinkStatusSchema, ObservabilityStatusSchema, ObservabilityDrainReportSchema, aggregateObservabilityStatus, assertDrainBound, withinBound, createBoundedSinkManager };