@yolk-sdk/harness 0.1.0-canary.100

package/dist/driver.d.mts

@@ -0,0 +1,126 @@
+import { RunStore } from "./store.mjs";
+import { InterruptReason, Promotable, RunCoordinator } from "./coordinator.mjs";
+import { DrainToken, HitlAdmission, HitlDecision, Inbox, InboxItem, ParkedResponse, PauseDecision } from "./inbox.mjs";
+import { Context, Data, Effect, Layer } from "effect";
+
+//#region src/driver.d.ts
+declare const defaultMaxResumeAttempts = 10;
+declare const InvalidMaxResumeAttempts_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "InvalidMaxResumeAttempts";
+} & Readonly<A>;
+declare class InvalidMaxResumeAttempts extends InvalidMaxResumeAttempts_base<{
+  readonly maxResumeAttempts: number;
+}> {}
+type ResumeSuspendedResult = {
+  readonly resumed: ReadonlyArray<string>;
+  readonly exhausted: ReadonlyArray<string>;
+};
+type DrainContext = {
+  readonly drainToken: DrainToken;
+  readonly readyResponses: ReadonlyArray<ParkedResponse>;
+};
+type Drain = (runId: string, force: boolean, scope: Promotable, context: DrainContext) => Effect.Effect<void, never, Inbox | RunStore>;
+type DriverLayerOptions = {
+  readonly drain?: Drain;
+  readonly maxResumeAttempts?: number;
+};
+type StopDecision = {
+  readonly _tag: 'Interrupted';
+} | {
+  readonly _tag: 'ParkCleared';
+} | {
+  readonly _tag: 'Idle';
+};
+declare const StopDecision: {
+  readonly Interrupted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Interrupted";
+  }, "_tag">;
+  readonly ParkCleared: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ParkCleared";
+  }, "_tag">;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+  readonly $is: <Tag extends "Interrupted" | "ParkCleared" | "Idle">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Interrupted";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ParkCleared";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Interrupted: (args: {
+        readonly _tag: "Interrupted";
+      }) => any;
+      readonly ParkCleared: (args: {
+        readonly _tag: "ParkCleared";
+      }) => any;
+      readonly Idle: (args: {
+        readonly _tag: "Idle";
+      }) => any;
+    }>(cases: Cases): (value: StopDecision) => import("effect/Unify").Unify<ReturnType<Cases["Interrupted" | "ParkCleared" | "Idle"]>>;
+    <Cases extends {
+      readonly Interrupted: (args: {
+        readonly _tag: "Interrupted";
+      }) => any;
+      readonly ParkCleared: (args: {
+        readonly _tag: "ParkCleared";
+      }) => any;
+      readonly Idle: (args: {
+        readonly _tag: "Idle";
+      }) => any;
+    }>(value: StopDecision, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Interrupted" | "ParkCleared" | "Idle"]>>;
+  };
+};
+type DriverApi = {
+  readonly active: Effect.Effect<ReadonlySet<string>>;
+  readonly isActive: (runId: string) => Effect.Effect<boolean>;
+  readonly run: (runId: string) => Effect.Effect<void>;
+  readonly wake: (runId: string, scope?: Promotable) => Effect.Effect<void>;
+  readonly interrupt: (runId: string, options?: {
+    readonly reason?: InterruptReason;
+    readonly awaitSettlement?: boolean;
+  }) => Effect.Effect<boolean>;
+  readonly awaitIdle: (runId: string) => Effect.Effect<void>;
+  readonly resumeSuspended: Effect.Effect<ResumeSuspendedResult>;
+  readonly admit: (item: InboxItem) => Effect.Effect<void>;
+  readonly pause: (runId: string, requestIds: ReadonlyArray<string>, drainToken: DrainToken) => Effect.Effect<PauseDecision>;
+  readonly resumeHitl: (runId: string, admission: HitlAdmission) => Effect.Effect<HitlDecision>;
+  readonly stop: (runId: string) => Effect.Effect<StopDecision>;
+};
+declare const Driver_base: Context.ServiceClass<Driver, "@yolk-sdk/harness/Driver", DriverApi>;
+declare class Driver extends Driver_base {
+  static layer(): Layer.Layer<Driver, never, RunStore | Inbox | RunCoordinator>;
+  static layer(options?: {
+    readonly maxResumeAttempts?: undefined;
+  }): Layer.Layer<Driver, never, RunStore | Inbox | RunCoordinator>;
+  static layer(options?: Pick<DriverLayerOptions, 'maxResumeAttempts'>): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox | RunCoordinator>;
+  static coordinatedLayer(): Layer.Layer<Driver, never, RunStore | Inbox>;
+  static coordinatedLayer(options?: {
+    readonly drain?: Drain;
+    readonly maxResumeAttempts?: undefined;
+  }): Layer.Layer<Driver, never, RunStore | Inbox>;
+  static coordinatedLayer(options?: DriverLayerOptions): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>;
+}
+declare const makeHarness: <DE, DR, SE, SR, IE, IR>(input: {
+  readonly driver: Layer.Layer<Driver, DE, DR>;
+  readonly store: Layer.Layer<RunStore, SE, SR>;
+  readonly inbox: Layer.Layer<Inbox, IE, IR>;
+}) => Layer.Layer<Driver | RunStore | Inbox, DE | SE | IE, DR | SR | IR>;
+declare const admit: (item: InboxItem) => Effect.Effect<void, never, Driver>;
+declare function makeDriverLayer(): Layer.Layer<Driver, never, RunStore | Inbox>;
+declare function makeDriverLayer(options?: {
+  readonly drain?: Drain;
+  readonly maxResumeAttempts?: undefined;
+}): Layer.Layer<Driver, never, RunStore | Inbox>;
+declare function makeDriverLayer(options?: DriverLayerOptions): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>;
+//#endregion
+export { Drain, DrainContext, Driver, DriverApi, DriverLayerOptions, type InterruptReason, InvalidMaxResumeAttempts, ResumeSuspendedResult, StopDecision, admit, defaultMaxResumeAttempts, makeDriverLayer, makeHarness };
+//# sourceMappingURL=driver.d.mts.map

package/dist/driver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.mts","names":[],"sources":["../src/driver.ts"],"mappings":"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"}

package/dist/driver.mjs

@@ -0,0 +1,96 @@
+import { StopDecision as StopDecision$1 } from "./outcome-constructors-internal.mjs";
+import { RunStore } from "./store.mjs";
+import { RunCoordinator } from "./coordinator.mjs";
+import { DrainBegin, Inbox, RecoveryAttempt } from "./inbox.mjs";
+import { Context, Data, Effect, Exit, Layer, Predicate, Semaphore } from "effect";
+//#region src/driver.ts
+const defaultMaxResumeAttempts = 10;
+var InvalidMaxResumeAttempts = class extends Data.TaggedError("InvalidMaxResumeAttempts") {};
+const isValidMaxResumeAttempts = (value) => Number.isSafeInteger(value) && value >= 0;
+const StopDecision = StopDecision$1;
+var Driver = class Driver extends Context.Service()("@yolk-sdk/harness/Driver") {
+	static layer(options) {
+		return Layer.effect(Driver, Effect.gen(function* () {
+			const maxResumeAttempts = options?.maxResumeAttempts ?? 10;
+			if (!isValidMaxResumeAttempts(maxResumeAttempts)) return yield* Effect.fail(new InvalidMaxResumeAttempts({ maxResumeAttempts }));
+			const store = yield* RunStore;
+			const inbox = yield* Inbox;
+			const sweep = yield* Semaphore.make(1);
+			const coordinator = yield* RunCoordinator;
+			const resumeSuspended = sweep.withPermits(1)(Effect.gen(function* () {
+				const claimed = yield* store.claimed;
+				const resumed = [];
+				const exhausted = [];
+				for (const runId of claimed) {
+					const admission = yield* inbox.admitRecovery(runId, Effect.gen(function* () {
+						if (yield* coordinator.isActive(runId)) return RecoveryAttempt.Skip();
+						if (!(yield* store.isClaimed(runId))) return RecoveryAttempt.Skip();
+						if ((yield* store.resumeCount(runId)) >= maxResumeAttempts) {
+							yield* store.release(runId);
+							return RecoveryAttempt.Exhausted();
+						}
+						yield* store.incrementResumeCount(runId);
+						return RecoveryAttempt.Resume();
+					}), coordinator.wake(runId, "input"));
+					if (Predicate.isTagged(admission, "Resumed")) resumed.push(runId);
+					else if (Predicate.isTagged(admission, "Exhausted")) exhausted.push(runId);
+				}
+				return {
+					resumed,
+					exhausted
+				};
+			}));
+			return Driver.of({
+				active: coordinator.active,
+				isActive: coordinator.isActive,
+				run: (runId) => {
+					const continueRun = () => inbox.startIfUnblocked(runId, coordinator.captureRun(runId)).pipe(Effect.flatMap((ticket) => {
+						if (ticket === void 0) return Effect.void;
+						if (Predicate.isTagged(ticket, "Stopping")) return ticket.awaitSettlement.pipe(Effect.andThen(Effect.suspend(continueRun)));
+						return ticket.join;
+					}));
+					return continueRun();
+				},
+				wake: (runId, scope = "input") => inbox.wakeIfUnblocked(runId, scope, coordinator.wake(runId, scope)).pipe(Effect.asVoid),
+				interrupt: (runId, interruptOptions) => coordinator.interrupt(runId, interruptOptions?.reason ?? "user", interruptOptions),
+				awaitIdle: coordinator.awaitIdle,
+				resumeSuspended,
+				admit: (item) => inbox.enqueueAndWake(item, coordinator.wake(item.runId, item.delivery === "steer" ? "steer" : "input")),
+				pause: (runId, requestIds, drainToken) => inbox.park(runId, requestIds, drainToken),
+				resumeHitl: (runId, admission) => inbox.acceptHitl(runId, admission, coordinator.wake(runId, "input")),
+				stop: (runId) => inbox.invalidate(runId, coordinator.terminalStop(runId, "user").pipe(Effect.map((receipt) => Predicate.isTagged(receipt, "Interrupted") || Predicate.isTagged(receipt, "LiveStopping"))), store.isClaimed(runId).pipe(Effect.flatMap((claimed) => claimed ? store.release(runId) : Effect.void))).pipe(Effect.map((result) => {
+					if (result.interrupted) return StopDecision.Interrupted();
+					if (result.hadPark) return StopDecision.ParkCleared();
+					return StopDecision.Idle();
+				}))
+			});
+		}));
+	}
+	static coordinatedLayer(options) {
+		return Layer.unwrap(Effect.gen(function* () {
+			const store = yield* RunStore;
+			const inbox = yield* Inbox;
+			const hostDrain = options?.drain ?? ((_runId, _force, _scope, _context) => Effect.void);
+			const maxResumeAttempts = options?.maxResumeAttempts ?? 10;
+			const storeLayer = Layer.succeed(RunStore, store);
+			const inboxLayer = Layer.succeed(Inbox, inbox);
+			const coordinator = RunCoordinator.layer({ drain: (runId, force, scope) => inbox.beginDrain(runId, scope).pipe(Effect.flatMap((begun) => {
+				if (DrainBegin.$is("Skip")(begun)) return Effect.void;
+				return Effect.suspend(() => hostDrain(runId, force, scope, {
+					drainToken: begun.drainToken,
+					readyResponses: begun.readyResponses
+				})).pipe(Effect.provideService(Inbox, inbox), Effect.provideService(RunStore, store), Effect.onExit((exit) => inbox.endDrain(runId, begun.drainToken, Exit.isSuccess(exit))));
+			})) }).pipe(Layer.provide(storeLayer));
+			return Driver.layer({ maxResumeAttempts }).pipe(Layer.provide(coordinator), Layer.provide(storeLayer), Layer.provide(inboxLayer));
+		}));
+	}
+};
+const makeHarness = (input) => Layer.mergeAll(input.driver, input.store, input.inbox);
+const admit = (item) => Effect.flatMap(Driver, (driver) => driver.admit(item));
+function makeDriverLayer(options) {
+	return options === void 0 ? Driver.coordinatedLayer() : Driver.coordinatedLayer(options);
+}
+//#endregion
+export { Driver, InvalidMaxResumeAttempts, StopDecision, admit, defaultMaxResumeAttempts, makeDriverLayer, makeHarness };
+
+//# sourceMappingURL=driver.mjs.map

package/dist/driver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.mjs","names":["stopDecision"],"sources":["../src/driver.ts"],"sourcesContent":["import { Context, Data, Effect, Exit, Layer, Predicate, Semaphore } from 'effect'\nimport { StopDecision as stopDecision } from './outcome-constructors-internal.ts'\nimport { RunCoordinator, type InterruptReason, type Promotable } from './coordinator.ts'\nimport {\n  DrainBegin,\n  Inbox,\n  RecoveryAttempt,\n  type DrainToken,\n  type HitlAdmission,\n  type HitlDecision,\n  type InboxItem,\n  type ParkedResponse,\n  type PauseDecision\n} from './inbox.ts'\nimport { RunStore } from './store.ts'\n\nexport type { InterruptReason } from './coordinator.ts'\n\nexport const defaultMaxResumeAttempts = 10\n\nexport class InvalidMaxResumeAttempts extends Data.TaggedError('InvalidMaxResumeAttempts')<{\n  readonly maxResumeAttempts: number\n}> {}\n\nconst isValidMaxResumeAttempts = (value: number) => Number.isSafeInteger(value) && value >= 0\n\nexport type ResumeSuspendedResult = {\n  readonly resumed: ReadonlyArray<string>\n  readonly exhausted: ReadonlyArray<string>\n}\n\nexport type DrainContext = {\n  readonly drainToken: DrainToken\n  readonly readyResponses: ReadonlyArray<ParkedResponse>\n}\n\nexport type Drain = (\n  runId: string,\n  force: boolean,\n  scope: Promotable,\n  context: DrainContext\n) => Effect.Effect<void, never, Inbox | RunStore>\n\nexport type DriverLayerOptions = {\n  readonly drain?: Drain\n  readonly maxResumeAttempts?: number\n}\n\nexport type StopDecision =\n  | { readonly _tag: 'Interrupted' }\n  | { readonly _tag: 'ParkCleared' }\n  | { readonly _tag: 'Idle' }\n\nexport const StopDecision = stopDecision\n\nexport type DriverApi = {\n  readonly active: Effect.Effect<ReadonlySet<string>>\n  readonly isActive: (runId: string) => Effect.Effect<boolean>\n  readonly run: (runId: string) => Effect.Effect<void>\n  readonly wake: (runId: string, scope?: Promotable) => Effect.Effect<void>\n  readonly interrupt: (\n    runId: string,\n    options?: { readonly reason?: InterruptReason; readonly awaitSettlement?: boolean }\n  ) => Effect.Effect<boolean>\n  readonly awaitIdle: (runId: string) => Effect.Effect<void>\n  readonly resumeSuspended: Effect.Effect<ResumeSuspendedResult>\n  readonly admit: (item: InboxItem) => Effect.Effect<void>\n  readonly pause: (\n    runId: string,\n    requestIds: ReadonlyArray<string>,\n    drainToken: DrainToken\n  ) => Effect.Effect<PauseDecision>\n  readonly resumeHitl: (runId: string, admission: HitlAdmission) => Effect.Effect<HitlDecision>\n  readonly stop: (runId: string) => Effect.Effect<StopDecision>\n}\n\nexport class Driver extends Context.Service<Driver, DriverApi>()('@yolk-sdk/harness/Driver') {\n  static layer(): Layer.Layer<Driver, never, RunStore | Inbox | RunCoordinator>\n  static layer(options?: {\n    readonly maxResumeAttempts?: undefined\n  }): Layer.Layer<Driver, never, RunStore | Inbox | RunCoordinator>\n  static layer(\n    options?: Pick<DriverLayerOptions, 'maxResumeAttempts'>\n  ): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox | RunCoordinator>\n  static layer(options?: Pick<DriverLayerOptions, 'maxResumeAttempts'>) {\n    return Layer.effect(\n      Driver,\n      Effect.gen(function* () {\n        const maxResumeAttempts = options?.maxResumeAttempts ?? defaultMaxResumeAttempts\n\n        if (!isValidMaxResumeAttempts(maxResumeAttempts)) {\n          return yield* Effect.fail(new InvalidMaxResumeAttempts({ maxResumeAttempts }))\n        }\n\n        const store = yield* RunStore\n        const inbox = yield* Inbox\n        const sweep = yield* Semaphore.make(1)\n        const coordinator = yield* RunCoordinator\n\n        const resumeSuspended = sweep.withPermits(1)(\n          Effect.gen(function* () {\n            const claimed = yield* store.claimed\n            const resumed: Array<string> = []\n            const exhausted: Array<string> = []\n\n            for (const runId of claimed) {\n              const admission = yield* inbox.admitRecovery(\n                runId,\n                Effect.gen(function* () {\n                  if (yield* coordinator.isActive(runId)) return RecoveryAttempt.Skip()\n\n                  if (!(yield* store.isClaimed(runId))) return RecoveryAttempt.Skip()\n                  const count = yield* store.resumeCount(runId)\n\n                  if (count >= maxResumeAttempts) {\n                    yield* store.release(runId)\n\n                    return RecoveryAttempt.Exhausted()\n                  }\n\n                  yield* store.incrementResumeCount(runId)\n\n                  return RecoveryAttempt.Resume()\n                }),\n                coordinator.wake(runId, 'input')\n              )\n\n              if (Predicate.isTagged(admission, 'Resumed')) resumed.push(runId)\n              else if (Predicate.isTagged(admission, 'Exhausted')) exhausted.push(runId)\n            }\n\n            return { resumed, exhausted }\n          })\n        )\n\n        return Driver.of({\n          active: coordinator.active,\n          isActive: coordinator.isActive,\n          run: runId => {\n            const continueRun = (): Effect.Effect<void> =>\n              inbox.startIfUnblocked(runId, coordinator.captureRun(runId)).pipe(\n                Effect.flatMap(ticket => {\n                  if (ticket === undefined) return Effect.void\n\n                  if (Predicate.isTagged(ticket, 'Stopping')) {\n                    return ticket.awaitSettlement.pipe(Effect.andThen(Effect.suspend(continueRun)))\n                  }\n\n                  return ticket.join\n                })\n              )\n\n            return continueRun()\n          },\n          wake: (runId, scope = 'input') =>\n            inbox.wakeIfUnblocked(runId, scope, coordinator.wake(runId, scope)).pipe(Effect.asVoid),\n          interrupt: (runId, interruptOptions) =>\n            coordinator.interrupt(runId, interruptOptions?.reason ?? 'user', interruptOptions),\n          awaitIdle: coordinator.awaitIdle,\n          resumeSuspended,\n          admit: item =>\n            inbox.enqueueAndWake(\n              item,\n              coordinator.wake(item.runId, item.delivery === 'steer' ? 'steer' : 'input')\n            ),\n          pause: (runId, requestIds, drainToken) => inbox.park(runId, requestIds, drainToken),\n          resumeHitl: (runId, admission) =>\n            inbox.acceptHitl(runId, admission, coordinator.wake(runId, 'input')),\n          stop: runId =>\n            inbox\n              .invalidate(\n                runId,\n                coordinator\n                  .terminalStop(runId, 'user')\n                  .pipe(\n                    Effect.map(\n                      receipt =>\n                        Predicate.isTagged(receipt, 'Interrupted') ||\n                        Predicate.isTagged(receipt, 'LiveStopping')\n                    )\n                  ),\n                store\n                  .isClaimed(runId)\n                  .pipe(Effect.flatMap(claimed => (claimed ? store.release(runId) : Effect.void)))\n              )\n              .pipe(\n                Effect.map(result => {\n                  if (result.interrupted) return StopDecision.Interrupted()\n\n                  if (result.hadPark) return StopDecision.ParkCleared()\n\n                  return StopDecision.Idle()\n                })\n              )\n        })\n      })\n    )\n  }\n\n  static coordinatedLayer(): Layer.Layer<Driver, never, RunStore | Inbox>\n  static coordinatedLayer(options?: {\n    readonly drain?: Drain\n    readonly maxResumeAttempts?: undefined\n  }): Layer.Layer<Driver, never, RunStore | Inbox>\n  static coordinatedLayer(\n    options?: DriverLayerOptions\n  ): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>\n  static coordinatedLayer(options?: DriverLayerOptions) {\n    return Layer.unwrap(\n      Effect.gen(function* () {\n        const store = yield* RunStore\n        const inbox = yield* Inbox\n        // Keep compatibility option reads lazy and in drain/max order.\n        const hostDrain = options?.drain ?? ((_runId, _force, _scope, _context) => Effect.void)\n        const maxResumeAttempts = options?.maxResumeAttempts ?? defaultMaxResumeAttempts\n        const storeLayer = Layer.succeed(RunStore, store)\n        const inboxLayer = Layer.succeed(Inbox, inbox)\n\n        const coordinator = RunCoordinator.layer({\n          drain: (runId, force, scope) =>\n            inbox.beginDrain(runId, scope).pipe(\n              Effect.flatMap(begun => {\n                if (DrainBegin.$is('Skip')(begun)) return Effect.void\n\n                return Effect.suspend(() =>\n                  hostDrain(runId, force, scope, {\n                    drainToken: begun.drainToken,\n                    readyResponses: begun.readyResponses\n                  })\n                ).pipe(\n                  Effect.provideService(Inbox, inbox),\n                  Effect.provideService(RunStore, store),\n                  Effect.onExit(exit =>\n                    inbox.endDrain(runId, begun.drainToken, Exit.isSuccess(exit))\n                  )\n                )\n              })\n            )\n        }).pipe(Layer.provide(storeLayer))\n\n        return Driver.layer({ maxResumeAttempts }).pipe(\n          Layer.provide(coordinator),\n          Layer.provide(storeLayer),\n          Layer.provide(inboxLayer)\n        )\n      })\n    )\n  }\n}\n\nexport const makeHarness = <DE, DR, SE, SR, IE, IR>(input: {\n  readonly driver: Layer.Layer<Driver, DE, DR>\n  readonly store: Layer.Layer<RunStore, SE, SR>\n  readonly inbox: Layer.Layer<Inbox, IE, IR>\n}): Layer.Layer<Driver | RunStore | Inbox, DE | SE | IE, DR | SR | IR> =>\n  Layer.mergeAll(input.driver, input.store, input.inbox)\n\nexport const admit = (item: InboxItem) => Effect.flatMap(Driver, driver => driver.admit(item))\n\nexport function makeDriverLayer(): Layer.Layer<Driver, never, RunStore | Inbox>\nexport function makeDriverLayer(options?: {\n  readonly drain?: Drain\n  readonly maxResumeAttempts?: undefined\n}): Layer.Layer<Driver, never, RunStore | Inbox>\nexport function makeDriverLayer(\n  options?: DriverLayerOptions\n): Layer.Layer<Driver, InvalidMaxResumeAttempts, RunStore | Inbox>\nexport function makeDriverLayer(options?: DriverLayerOptions) {\n  return options === undefined ? Driver.coordinatedLayer() : Driver.coordinatedLayer(options)\n}\n"],"mappings":"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"}

package/dist/inbox.d.mts

@@ -0,0 +1,368 @@
+import { CapturedRun, Promotable } from "./coordinator.mjs";
+import { Context, Data, Effect, Layer } from "effect";
+import * as Schema from "effect/Schema";
+
+//#region src/inbox.d.ts
+/** Nominal identity only. All strings stay admissible so stale/empty/foreign
+ * tokens retain the inbox's existing no-op decisions rather than parse failures. */
+declare const DrainToken: Schema.brand<Schema.String, "DrainToken">;
+type DrainToken = typeof DrainToken.Type;
+/** Nominal identity only; freshness and instance ownership are checked by Inbox. */
+declare const ParkGeneration: Schema.brand<Schema.String, "ParkGeneration">;
+type ParkGeneration = typeof ParkGeneration.Type;
+type InboxKind = 'input' | 'hitl';
+type InboxItem = {
+  readonly id: string;
+  readonly runId: string;
+  readonly delivery: Promotable | 'queue';
+  readonly kind: InboxKind;
+};
+type ParkedResponse = {
+  readonly itemId: string;
+  readonly requestId: string;
+};
+type ParkedState = {
+  readonly generation: ParkGeneration;
+  readonly requestIds: ReadonlyArray<string>;
+  readonly responses: ReadonlyArray<ParkedResponse>;
+  readonly ready: boolean;
+};
+type HitlAdmission = {
+  readonly itemId: string;
+  readonly requestId: string;
+  readonly generation: ParkGeneration;
+};
+type HitlDecision = {
+  readonly _tag: 'Accepted';
+} | {
+  readonly _tag: 'Ready';
+} | {
+  readonly _tag: 'Duplicate';
+} | {
+  readonly _tag: 'Stale';
+} | {
+  readonly _tag: 'UnknownRequest';
+} | {
+  readonly _tag: 'NotParked';
+};
+type PauseDecision = {
+  readonly _tag: 'Parked';
+  readonly generation: ParkGeneration;
+} | {
+  readonly _tag: 'Stale';
+};
+type RecoveryAttempt = {
+  readonly _tag: 'Skip';
+} | {
+  readonly _tag: 'Exhausted';
+} | {
+  readonly _tag: 'Resume';
+};
+type RecoveryAdmission = {
+  readonly _tag: 'Skip';
+} | {
+  readonly _tag: 'Exhausted';
+} | {
+  readonly _tag: 'Resumed';
+};
+type DrainBegin = {
+  readonly _tag: 'Skip';
+} | {
+  readonly _tag: 'Run';
+  readonly drainToken: DrainToken;
+  readonly readyResponses: ReadonlyArray<ParkedResponse>;
+};
+declare const HitlDecision: {
+  readonly Accepted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Accepted";
+  }, "_tag">;
+  readonly Ready: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Ready";
+  }, "_tag">;
+  readonly Duplicate: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Duplicate";
+  }, "_tag">;
+  readonly Stale: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Stale";
+  }, "_tag">;
+  readonly UnknownRequest: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "UnknownRequest";
+  }, "_tag">;
+  readonly NotParked: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "NotParked";
+  }, "_tag">;
+  readonly $is: <Tag extends "Accepted" | "Ready" | "Duplicate" | "Stale" | "UnknownRequest" | "NotParked">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Accepted";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Ready";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Duplicate";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Stale";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "UnknownRequest";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "NotParked";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Accepted: (args: {
+        readonly _tag: "Accepted";
+      }) => any;
+      readonly Ready: (args: {
+        readonly _tag: "Ready";
+      }) => any;
+      readonly Duplicate: (args: {
+        readonly _tag: "Duplicate";
+      }) => any;
+      readonly Stale: (args: {
+        readonly _tag: "Stale";
+      }) => any;
+      readonly UnknownRequest: (args: {
+        readonly _tag: "UnknownRequest";
+      }) => any;
+      readonly NotParked: (args: {
+        readonly _tag: "NotParked";
+      }) => any;
+    }>(cases: Cases): (value: HitlDecision) => import("effect/Unify").Unify<ReturnType<Cases["Accepted" | "Ready" | "Duplicate" | "Stale" | "UnknownRequest" | "NotParked"]>>;
+    <Cases extends {
+      readonly Accepted: (args: {
+        readonly _tag: "Accepted";
+      }) => any;
+      readonly Ready: (args: {
+        readonly _tag: "Ready";
+      }) => any;
+      readonly Duplicate: (args: {
+        readonly _tag: "Duplicate";
+      }) => any;
+      readonly Stale: (args: {
+        readonly _tag: "Stale";
+      }) => any;
+      readonly UnknownRequest: (args: {
+        readonly _tag: "UnknownRequest";
+      }) => any;
+      readonly NotParked: (args: {
+        readonly _tag: "NotParked";
+      }) => any;
+    }>(value: HitlDecision, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Accepted" | "Ready" | "Duplicate" | "Stale" | "UnknownRequest" | "NotParked"]>>;
+  };
+};
+declare const PauseDecision: {
+  readonly Stale: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Stale";
+  }, "_tag">;
+  readonly Parked: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Parked";
+    readonly generation: ParkGeneration;
+  }, "_tag">;
+  readonly $is: <Tag extends "Stale" | "Parked">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Parked";
+    readonly generation: ParkGeneration;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Stale";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Stale: (args: {
+        readonly _tag: "Stale";
+      }) => any;
+      readonly Parked: (args: {
+        readonly _tag: "Parked";
+        readonly generation: ParkGeneration;
+      }) => any;
+    }>(cases: Cases): (value: PauseDecision) => import("effect/Unify").Unify<ReturnType<Cases["Stale" | "Parked"]>>;
+    <Cases extends {
+      readonly Stale: (args: {
+        readonly _tag: "Stale";
+      }) => any;
+      readonly Parked: (args: {
+        readonly _tag: "Parked";
+        readonly generation: ParkGeneration;
+      }) => any;
+    }>(value: PauseDecision, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Stale" | "Parked"]>>;
+  };
+};
+declare const RecoveryAttempt: {
+  readonly Skip: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Skip";
+  }, "_tag">;
+  readonly Exhausted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Exhausted";
+  }, "_tag">;
+  readonly Resume: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Resume";
+  }, "_tag">;
+  readonly $is: <Tag extends "Skip" | "Exhausted" | "Resume">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Skip";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Exhausted";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Resume";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Skip: (args: {
+        readonly _tag: "Skip";
+      }) => any;
+      readonly Exhausted: (args: {
+        readonly _tag: "Exhausted";
+      }) => any;
+      readonly Resume: (args: {
+        readonly _tag: "Resume";
+      }) => any;
+    }>(cases: Cases): (value: RecoveryAttempt) => import("effect/Unify").Unify<ReturnType<Cases["Skip" | "Exhausted" | "Resume"]>>;
+    <Cases extends {
+      readonly Skip: (args: {
+        readonly _tag: "Skip";
+      }) => any;
+      readonly Exhausted: (args: {
+        readonly _tag: "Exhausted";
+      }) => any;
+      readonly Resume: (args: {
+        readonly _tag: "Resume";
+      }) => any;
+    }>(value: RecoveryAttempt, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Skip" | "Exhausted" | "Resume"]>>;
+  };
+};
+declare const RecoveryAdmission: {
+  readonly Skip: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Skip";
+  }, "_tag">;
+  readonly Exhausted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Exhausted";
+  }, "_tag">;
+  readonly Resumed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Resumed";
+  }, "_tag">;
+  readonly $is: <Tag extends "Skip" | "Exhausted" | "Resumed">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Skip";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Exhausted";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Resumed";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Skip: (args: {
+        readonly _tag: "Skip";
+      }) => any;
+      readonly Exhausted: (args: {
+        readonly _tag: "Exhausted";
+      }) => any;
+      readonly Resumed: (args: {
+        readonly _tag: "Resumed";
+      }) => any;
+    }>(cases: Cases): (value: RecoveryAdmission) => import("effect/Unify").Unify<ReturnType<Cases["Skip" | "Exhausted" | "Resumed"]>>;
+    <Cases extends {
+      readonly Skip: (args: {
+        readonly _tag: "Skip";
+      }) => any;
+      readonly Exhausted: (args: {
+        readonly _tag: "Exhausted";
+      }) => any;
+      readonly Resumed: (args: {
+        readonly _tag: "Resumed";
+      }) => any;
+    }>(value: RecoveryAdmission, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Skip" | "Exhausted" | "Resumed"]>>;
+  };
+};
+declare const DrainBegin: {
+  readonly Skip: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Skip";
+  }, "_tag">;
+  readonly Run: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Run";
+    readonly drainToken: DrainToken;
+    readonly readyResponses: ReadonlyArray<ParkedResponse>;
+  }, "_tag">;
+  readonly $is: <Tag extends "Skip" | "Run">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Skip";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Run";
+    readonly drainToken: DrainToken;
+    readonly readyResponses: ReadonlyArray<ParkedResponse>;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Skip: (args: {
+        readonly _tag: "Skip";
+      }) => any;
+      readonly Run: (args: {
+        readonly _tag: "Run";
+        readonly drainToken: DrainToken;
+        readonly readyResponses: ReadonlyArray<ParkedResponse>;
+      }) => any;
+    }>(cases: Cases): (value: DrainBegin) => import("effect/Unify").Unify<ReturnType<Cases["Skip" | "Run"]>>;
+    <Cases extends {
+      readonly Skip: (args: {
+        readonly _tag: "Skip";
+      }) => any;
+      readonly Run: (args: {
+        readonly _tag: "Run";
+        readonly drainToken: DrainToken;
+        readonly readyResponses: ReadonlyArray<ParkedResponse>;
+      }) => any;
+    }>(value: DrainBegin, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Skip" | "Run"]>>;
+  };
+};
+type InboxApi = {
+  readonly enqueue: (item: InboxItem) => Effect.Effect<void>;
+  readonly takePromotable: (runId: string, scope: Promotable, drainToken: DrainToken) => Effect.Effect<InboxItem | undefined>;
+  readonly pending: (runId: string) => Effect.Effect<ReadonlyArray<InboxItem>>;
+  readonly parked: (runId: string) => Effect.Effect<ParkedState | undefined>;
+  readonly park: (runId: string, requestIds: ReadonlyArray<string>, drainToken: DrainToken) => Effect.Effect<PauseDecision>;
+  readonly acceptHitl: (runId: string, admission: HitlAdmission, onReady: Effect.Effect<void>) => Effect.Effect<HitlDecision>;
+  readonly clearPark: (runId: string, generation: ParkGeneration) => Effect.Effect<boolean>;
+  readonly beginDrain: (runId: string, scope: Promotable) => Effect.Effect<DrainBegin>;
+  readonly endDrain: (runId: string, drainToken: DrainToken, acknowledged: boolean) => Effect.Effect<void>;
+  readonly invalidate: (runId: string, interrupt: Effect.Effect<boolean>, releaseIdleClaim: Effect.Effect<void>) => Effect.Effect<{
+    readonly hadPark: boolean;
+    readonly interrupted: boolean;
+  }>;
+  readonly enqueueAndWake: (item: InboxItem, wake: Effect.Effect<void>) => Effect.Effect<void>;
+  readonly wakeIfUnblocked: (runId: string, scope: Promotable, wake: Effect.Effect<void>) => Effect.Effect<boolean>;
+  readonly startIfUnblocked: <E, R>(runId: string, start: Effect.Effect<CapturedRun<E>, E, R>) => Effect.Effect<CapturedRun<E> | undefined, E, R>;
+  readonly admitRecovery: <E, R>(runId: string, attempt: Effect.Effect<RecoveryAttempt, E, R>, wake: Effect.Effect<void>) => Effect.Effect<RecoveryAdmission, E, R>;
+};
+declare const Inbox_base: Context.ServiceClass<Inbox, "@yolk-sdk/harness/Inbox", InboxApi>;
+declare class Inbox extends Inbox_base {
+  /** Fresh queue, admission gate and HITL generations per layer acquisition. */
+  static layer: () => Layer.Layer<Inbox>;
+}
+/** Backward-compatible delegation to the owning inbox layer. */
+declare const makeInMemoryInboxLayer: () => Layer.Layer<Inbox>;
+//#endregion
+export { DrainBegin, DrainToken, HitlAdmission, HitlDecision, Inbox, InboxApi, InboxItem, InboxKind, ParkGeneration, ParkedResponse, ParkedState, PauseDecision, RecoveryAdmission, RecoveryAttempt, makeInMemoryInboxLayer };
+//# sourceMappingURL=inbox.d.mts.map

package/dist/inbox.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.d.mts","names":[],"sources":["../src/inbox.ts"],"mappings":"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"}