stitchkit 0.76.2 → 0.77.0

package/dist/application.js

@@ -30,10 +30,13 @@ import {
 } from "./index-a916km3r.js";
 import {
   ApplicationAdmissionError,
+  ApplicationRestartInputSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartResultSchema,
   ApplicationShutdownBudgetSchema,
   ApplicationShutdownOptionsSchema,
   createApplication
-} from "./index-hvftzz91.js";
+} from "./index-vc1b0b1b.js";
 import {
   defineManagedResource,
   managedResourceDependencyId
@@ -430,23 +433,84 @@ function createBoundedAdmission(config) {
     getSnapshot
   };
 }
+// src/internal/decision.ts
+import { z as z2 } from "zod";
+var PolicyDecisionSchema = z2.discriminatedUnion("outcome", [
+  z2.object({ outcome: z2.literal("allow") }).strict(),
+  z2.object({ outcome: z2.literal("deny"), reason: z2.string().min(1) }).strict(),
+  z2.object({ outcome: z2.literal("defer") }).strict()
+]);
+
+// src/application/decisions.ts
+class DecisionUndecidedError extends Error {
+  trace;
+  constructor(trace) {
+    const ran = trace.length === 0 ? "no policy ran" : trace.map((e) => e.id).join(" → ");
+    super(`Decision pipeline reached its end with no terminal verdict (${ran}). A pipeline needs a policy that answers allow or deny.`);
+    this.name = "DecisionUndecidedError";
+    this.trace = trace;
+  }
+}
+
+class DecisionPolicyError extends Error {
+  policyId;
+  constructor(policyId, detail) {
+    super(`Policy "${policyId}" did not return a decision (${detail}). A policy returns { outcome: "allow" | "deny" | "defer" }, and a deny carries a reason.`);
+    this.name = "DecisionPolicyError";
+    this.policyId = policyId;
+  }
+}
+function createDecisionPipeline(policies) {
+  const seen = new Set;
+  for (const policy of policies) {
+    if (policy.id.trim() === "") {
+      throw new Error("[stitchkit] decision pipeline: a policy needs a non-empty id.");
+    }
+    if (seen.has(policy.id)) {
+      throw new Error(`[stitchkit] decision pipeline: two policies share the id "${policy.id}". The trace names policies by id, and a duplicate makes it ambiguous exactly when it is read to explain a refusal.`);
+    }
+    seen.add(policy.id);
+  }
+  return {
+    policyIds: policies.map((policy) => policy.id),
+    async decide(input) {
+      const trace = [];
+      for (const policy of policies) {
+        const answer = await policy.decide(input);
+        const parsed = PolicyDecisionSchema.safeParse(answer);
+        if (!parsed.success) {
+          throw new DecisionPolicyError(policy.id, parsed.error.issues[0]?.message ?? "invalid");
+        }
+        const decision = parsed.data;
+        trace.push(decision.outcome === "deny" ? { id: policy.id, outcome: "deny", reason: decision.reason } : { id: policy.id, outcome: decision.outcome });
+        if (decision.outcome === "deny") {
+          return { outcome: "deny", reason: decision.reason, trace };
+        }
+        if (decision.outcome === "allow") {
+          return { outcome: "allow", trace };
+        }
+      }
+      throw new DecisionUndecidedError(trace);
+    }
+  };
+}
 // src/application/diagnostic-journal.ts
 import { randomUUID } from "node:crypto";
 
 // src/application/diagnostic-journal-contract.ts
-import { z as z2 } from "zod";
-var PositiveSafeIntegerSchema2 = z2.number().int().positive().safe();
-var FileModeSchema = z2.number().int().min(0).max(511);
-var DiagnosticJournalLimitsSchema = z2.object({
+import { z as z3 } from "zod";
+var PositiveSafeIntegerSchema2 = z3.number().int().positive().safe();
+var FileModeSchema = z3.number().int().min(0).max(511);
+var DiagnosticJournalLimitsSchema = z3.object({
   maxEventBytes: PositiveSafeIntegerSchema2,
   maxPendingItems: PositiveSafeIntegerSchema2,
   maxPendingBytes: PositiveSafeIntegerSchema2,
   maxFileBytes: PositiveSafeIntegerSchema2,
   maxFiles: PositiveSafeIntegerSchema2
 }).strict().readonly();
-var DiagnosticJournalLockPolicySchema = z2.enum(["refuse", "reclaim-stale"]);
-var DiagnosticJournalStateSchema = z2.enum(["open", "draining", "closed", "failed"]);
-var DiagnosticJournalRefusalReasonSchema = z2.enum([
+var DiagnosticJournalLockPolicySchema = z3.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStateSchema = z3.enum(["open", "draining", "closed", "failed"]);
+var DiagnosticJournalRefusalReasonSchema = z3.enum([
   "closed",
   "failed",
   "invalid",
@@ -454,72 +518,72 @@ var DiagnosticJournalRefusalReasonSchema = z2.enum([
   "item-capacity",
   "byte-capacity"
 ]);
-var DiagnosticJournalRefusalCountersSchema = z2.object({
-  closed: z2.number().int().nonnegative(),
-  failed: z2.number().int().nonnegative(),
-  invalid: z2.number().int().nonnegative(),
-  oversized: z2.number().int().nonnegative(),
-  "item-capacity": z2.number().int().nonnegative(),
-  "byte-capacity": z2.number().int().nonnegative()
+var DiagnosticJournalRefusalCountersSchema = z3.object({
+  closed: z3.number().int().nonnegative(),
+  failed: z3.number().int().nonnegative(),
+  invalid: z3.number().int().nonnegative(),
+  oversized: z3.number().int().nonnegative(),
+  "item-capacity": z3.number().int().nonnegative(),
+  "byte-capacity": z3.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFailurePhaseSchema = z2.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z2.object({
+var DiagnosticJournalFailurePhaseSchema = z3.enum(["write", "rotation", "close"]);
+var DiagnosticJournalStatusSchema = z3.object({
   state: DiagnosticJournalStateSchema,
-  epoch: z2.uuid(),
+  epoch: z3.uuid(),
   limits: DiagnosticJournalLimitsSchema,
-  lock: z2.object({
+  lock: z3.object({
     policy: DiagnosticJournalLockPolicySchema,
-    reclaimedStale: z2.boolean()
+    reclaimedStale: z3.boolean()
   }).strict().readonly(),
-  received: z2.number().int().nonnegative(),
-  accepted: z2.number().int().nonnegative(),
-  refused: z2.number().int().nonnegative(),
+  received: z3.number().int().nonnegative(),
+  accepted: z3.number().int().nonnegative(),
+  refused: z3.number().int().nonnegative(),
   refusals: DiagnosticJournalRefusalCountersSchema,
-  written: z2.number().int().nonnegative(),
-  failedRecords: z2.number().int().nonnegative(),
-  pendingItems: z2.number().int().nonnegative(),
-  pendingBytes: z2.number().int().nonnegative(),
-  inFlight: z2.boolean(),
-  rotations: z2.number().int().nonnegative(),
-  rotationFailures: z2.number().int().nonnegative(),
-  partialTails: z2.number().int().nonnegative(),
-  currentFileBytes: z2.number().int().nonnegative(),
-  retainedFiles: z2.number().int().nonnegative(),
-  lastAcceptedSequence: z2.number().int().positive().optional(),
-  lastWrittenSequence: z2.number().int().positive().optional(),
-  lastSettledSequence: z2.number().int().positive().optional(),
-  lastFailure: z2.object({
+  written: z3.number().int().nonnegative(),
+  failedRecords: z3.number().int().nonnegative(),
+  pendingItems: z3.number().int().nonnegative(),
+  pendingBytes: z3.number().int().nonnegative(),
+  inFlight: z3.boolean(),
+  rotations: z3.number().int().nonnegative(),
+  rotationFailures: z3.number().int().nonnegative(),
+  partialTails: z3.number().int().nonnegative(),
+  currentFileBytes: z3.number().int().nonnegative(),
+  retainedFiles: z3.number().int().nonnegative(),
+  lastAcceptedSequence: z3.number().int().positive().optional(),
+  lastWrittenSequence: z3.number().int().positive().optional(),
+  lastSettledSequence: z3.number().int().positive().optional(),
+  lastFailure: z3.object({
     phase: DiagnosticJournalFailurePhaseSchema,
-    sequence: z2.number().int().positive().optional()
+    sequence: z3.number().int().positive().optional()
   }).strict().readonly().optional()
 }).strict().readonly();
-var DiagnosticJournalSubmitResultSchema = z2.discriminatedUnion("outcome", [
-  z2.object({
-    outcome: z2.literal("accepted"),
-    epoch: z2.uuid(),
-    sequence: z2.number().int().positive()
+var DiagnosticJournalSubmitResultSchema = z3.discriminatedUnion("outcome", [
+  z3.object({
+    outcome: z3.literal("accepted"),
+    epoch: z3.uuid(),
+    sequence: z3.number().int().positive()
   }).strict().readonly(),
-  z2.object({
-    outcome: z2.literal("refused"),
+  z3.object({
+    outcome: z3.literal("refused"),
     reason: DiagnosticJournalRefusalReasonSchema
   }).strict().readonly()
 ]);
-var DiagnosticJournalWaitResultSchema = z2.object({
-  outcome: z2.enum(["settled", "timed-out", "cancelled"]),
+var DiagnosticJournalWaitResultSchema = z3.object({
+  outcome: z3.enum(["settled", "timed-out", "cancelled"]),
   state: DiagnosticJournalStateSchema,
-  throughSequence: z2.number().int().nonnegative(),
-  settledSequence: z2.number().int().nonnegative()
+  throughSequence: z3.number().int().nonnegative(),
+  settledSequence: z3.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z2.object({
-  outcome: z2.enum(["closed", "timed-out", "cancelled"]),
+var DiagnosticJournalCloseResultSchema = z3.object({
+  outcome: z3.enum(["closed", "timed-out", "cancelled"]),
   state: DiagnosticJournalStateSchema,
-  pendingItems: z2.number().int().nonnegative()
+  pendingItems: z3.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFrameSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  epoch: z2.uuid(),
-  sequence: z2.number().int().positive(),
-  event: z2.json()
+var DiagnosticJournalFrameSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  epoch: z3.uuid(),
+  sequence: z3.number().int().positive(),
+  event: z3.json()
 }).strict().readonly();
 function parseDiagnosticJournalMode(mode) {
   return FileModeSchema.parse(mode ?? 384);
@@ -532,7 +596,7 @@ function readDiagnosticJournalLockDiagnosis(error) {
 }
 
 // src/application/diagnostic-journal-manager.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/application/diagnostic-journal-storage.ts
 import { constants as constants2 } from "node:fs";
@@ -1058,7 +1122,7 @@ function createDiagnosticJournalManager(config, storage) {
       const parsed = config.eventSchema.safeParse(event);
       if (!parsed.success)
         return refuse("invalid");
-      const json = z3.json().safeParse(parsed.data);
+      const json = z4.json().safeParse(parsed.data);
       if (!json.success)
         return refuse("invalid");
       const payload = encoder.encode(JSON.stringify(json.data));
@@ -1141,17 +1205,17 @@ async function createDiagnosticJournal(config) {
   }, storage);
 }
 // src/application/events.ts
-import { z as z4 } from "zod";
-var ApplicationLifecycleEventSchema = z4.object({
-  type: z4.literal("application-state"),
+import { z as z5 } from "zod";
+var ApplicationLifecycleEventSchema = z5.object({
+  type: z5.literal("application-state"),
   applicationId: ApplicationIdSchema,
-  epoch: z4.string().uuid(),
-  revision: z4.number().int().nonnegative(),
+  epoch: z5.string().uuid(),
+  revision: z5.number().int().nonnegative(),
   lifecycle: ApplicationLifecycleSchema,
   health: ApplicationHealthSchema,
-  ready: z4.boolean(),
-  capturedAt: z4.string().datetime({ offset: true }),
-  resources: z4.array(ManagedResourceSnapshotSchema).readonly()
+  ready: z5.boolean(),
+  capturedAt: z5.string().datetime({ offset: true }),
+  resources: z5.array(ManagedResourceSnapshotSchema).readonly()
 }).strict().readonly();
 function applicationLifecycleEvent(snapshot) {
   return ApplicationLifecycleEventSchema.parse({
@@ -1182,13 +1246,13 @@ function createApplicationEventSink(config) {
   };
 }
 // src/application/health.ts
-import { z as z5 } from "zod";
-var ApplicationHealthHandlerOptionsSchema = z5.object({
-  kind: z5.enum(["liveness", "readiness"]),
-  retryAfterSeconds: z5.number().int().nonnegative().default(5)
+import { z as z6 } from "zod";
+var ApplicationHealthHandlerOptionsSchema = z6.object({
+  kind: z6.enum(["liveness", "readiness"]),
+  retryAfterSeconds: z6.number().int().nonnegative().default(5)
 });
-var ApplicationOperationalHandlersOptionsSchema = z5.object({
-  retryAfterSeconds: z5.number().int().nonnegative().default(5)
+var ApplicationOperationalHandlersOptionsSchema = z6.object({
+  retryAfterSeconds: z6.number().int().nonnegative().default(5)
 });
 function createApplicationHealthHandler(application, options) {
   const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
@@ -1430,12 +1494,12 @@ function managedServerResource(config) {
   });
 }
 // src/browser/resumable.ts
-import { z as z6 } from "zod";
-var PositiveSafeIntegerSchema3 = z6.number().int().positive().safe();
-var BackoffPolicySchema = z6.object({
+import { z as z7 } from "zod";
+var PositiveSafeIntegerSchema3 = z7.number().int().positive().safe();
+var BackoffPolicySchema = z7.object({
   minDelayMs: PositiveSafeIntegerSchema3,
   maxDelayMs: PositiveSafeIntegerSchema3,
-  jitter: z6.number().min(0).max(1)
+  jitter: z7.number().min(0).max(1)
 }).strict().readonly().refine((policy) => policy.maxDelayMs >= policy.minDelayMs, {
   message: "maxDelayMs must be at least minDelayMs"
 });
@@ -1456,12 +1520,12 @@ function createBackoff(policy, random = Math.random) {
 }
 
 // src/live/watch-contract.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/browser/live-state.ts
-import { z as z7 } from "zod";
-var PositiveSafeIntegerSchema4 = z7.number().int().positive().safe();
-var LiveStatePhaseSchema = z7.enum([
+import { z as z8 } from "zod";
+var PositiveSafeIntegerSchema4 = z8.number().int().positive().safe();
+var LiveStatePhaseSchema = z8.enum([
   "idle",
   "opening",
   "live",
@@ -1469,7 +1533,7 @@ var LiveStatePhaseSchema = z7.enum([
   "unavailable",
   "closed"
 ]);
-var LiveStateStopReasonSchema = z7.enum([
+var LiveStateStopReasonSchema = z8.enum([
   "gap",
   "buffer-overflow",
   "source-unavailable",
@@ -1477,42 +1541,42 @@ var LiveStateStopReasonSchema = z7.enum([
   "controller-error",
   "controller-capacity"
 ]);
-var LiveStateControllerStatusSchema = z7.object({
+var LiveStateControllerStatusSchema = z8.object({
   phase: LiveStatePhaseSchema,
-  generation: z7.number().int().nonnegative(),
-  hasValue: z7.boolean(),
-  bufferedEvents: z7.number().int().nonnegative(),
-  bufferedBytes: z7.number().int().nonnegative(),
-  receivedEvents: z7.number().int().nonnegative(),
-  appliedEvents: z7.number().int().nonnegative(),
-  duplicateEvents: z7.number().int().nonnegative(),
-  gapEvents: z7.number().int().nonnegative(),
-  refusedEvents: z7.number().int().nonnegative(),
+  generation: z8.number().int().nonnegative(),
+  hasValue: z8.boolean(),
+  bufferedEvents: z8.number().int().nonnegative(),
+  bufferedBytes: z8.number().int().nonnegative(),
+  receivedEvents: z8.number().int().nonnegative(),
+  appliedEvents: z8.number().int().nonnegative(),
+  duplicateEvents: z8.number().int().nonnegative(),
+  gapEvents: z8.number().int().nonnegative(),
+  refusedEvents: z8.number().int().nonnegative(),
   reason: LiveStateStopReasonSchema.optional()
 }).strict().readonly();
 
 // src/live/watch-contract.ts
-var WatchKeySchema = z8.object({
-  service: z8.string().min(1),
-  action: z8.string().min(1),
-  digest: z8.string().min(1)
+var WatchKeySchema = z9.object({
+  service: z9.string().min(1),
+  action: z9.string().min(1),
+  digest: z9.string().min(1)
 }).strict().readonly();
-var WatchOpenSchema = z8.object({ key: WatchKeySchema, args: z8.unknown() }).readonly();
-var WatchAcceptedSchema = z8.object({
-  accepted: z8.boolean(),
-  reason: z8.string().optional()
+var WatchOpenSchema = z9.object({ key: WatchKeySchema, args: z9.unknown() }).readonly();
+var WatchAcceptedSchema = z9.object({
+  accepted: z9.boolean(),
+  reason: z9.string().optional()
 }).strict().readonly();
-var WatchValueSchema = z8.object({
+var WatchValueSchema = z9.object({
   key: WatchKeySchema,
-  revision: z8.number().int().nonnegative(),
-  value: z8.unknown()
+  revision: z9.number().int().nonnegative(),
+  value: z9.unknown()
 }).readonly();
-var WatchStateSchema = z8.object({
+var WatchStateSchema = z9.object({
   key: WatchKeySchema,
   phase: LiveStatePhaseSchema,
   reason: LiveStateStopReasonSchema.optional(),
-  code: z8.string().optional(),
-  message: z8.string().optional()
+  code: z9.string().optional(),
+  message: z9.string().optional()
 }).readonly();
 var WATCH_OPEN = "stitchkit.watch.open";
 var WATCH_CLOSE = "stitchkit.watch.close";
@@ -1520,12 +1584,12 @@ var WATCH_VALUE = "stitchkit.watch.value";
 var WATCH_STATE = "stitchkit.watch.state";
 var watchContract = {
   serverToClient: {
-    [WATCH_VALUE]: { args: z8.tuple([WatchValueSchema]) },
-    [WATCH_STATE]: { args: z8.tuple([WatchStateSchema]) }
+    [WATCH_VALUE]: { args: z9.tuple([WatchValueSchema]) },
+    [WATCH_STATE]: { args: z9.tuple([WatchStateSchema]) }
   },
   clientToServer: {
-    [WATCH_OPEN]: { args: z8.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
-    [WATCH_CLOSE]: { args: z8.tuple([z8.object({ key: WatchKeySchema }).readonly()]) }
+    [WATCH_OPEN]: { args: z9.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
+    [WATCH_CLOSE]: { args: z9.tuple([z9.object({ key: WatchKeySchema }).readonly()]) }
   }
 };
 function watchKeyString(key) {
@@ -1756,6 +1820,7 @@ export {
   createWatchHub,
   createManagedSchedule,
   createDiagnosticJournal,
+  createDecisionPipeline,
   createCreditWindow,
   createBoundedChannel,
   createBoundedAdmission,
@@ -1766,6 +1831,7 @@ export {
   createApplication,
   createActivityProjection,
   applicationLifecycleEvent,
+  PolicyDecisionSchema,
   ManagedScheduleStatusSchema,
   ManagedScheduleOverlapSchema,
   ManagedScheduleErrorPolicySchema,
@@ -1782,6 +1848,8 @@ export {
   DiagnosticJournalFrameSchema,
   DiagnosticJournalFailurePhaseSchema,
   DiagnosticJournalCloseResultSchema,
+  DecisionUndecidedError,
+  DecisionPolicyError,
   CreditWindowSnapshotSchema,
   BoundedRateBudgetSchema,
   BoundedOperationWaitError,
@@ -1801,6 +1869,9 @@ export {
   ApplicationShutdownResultSchema,
   ApplicationShutdownOptionsSchema,
   ApplicationShutdownBudgetSchema,
+  ApplicationRestartResultSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartInputSchema,
   ApplicationResourceShutdownSchema,
   ApplicationOperationalHandlersOptionsSchema,
   ApplicationLifecycleSchema,