@effect-agent/platform-node 0.1.0-beta.44 → 0.1.0-beta.46

package/dist/NodeDurableHost.mjs

@@ -0,0 +1,90 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { NodeDurableAgentRuntime, NodeDurableAgentRuntimeConfig } from "./NodeDurableAgentRuntime.mjs";
+import "@effect-agent/core/Identifiers";
+import "@effect-agent/thread/AgentRegistration";
+import { DurableAgentRuntime } from "@effect-agent/thread/DurableAgentRuntime";
+import "@effect-agent/thread/Records";
+import "@effect-agent/thread/SubmissionLedger";
+import "@effect-agent/thread/ThreadStore";
+import { Context, Effect, Layer, Ref, Schema } from "effect";
+import "@effect-agent/thread/Admin";
+import "@effect-agent/thread/OperationAuthorizer";
+//#region src/NodeDurableHost.ts
+var NodeDurableHost_exports = /* @__PURE__ */ __exportAll({
+	AdmissionClosed: () => AdmissionClosed,
+	NodeDurableHost: () => NodeDurableHost
+});
+/**
+* Admission is not open on this host: it is shutting down (deployment §6 step 1, DEPLOY-005).
+* Accepted work is unaffected — only NEW admissions are refused.
+*/
+var AdmissionClosed = class extends Schema.TaggedError()("AdmissionClosed", { message: Schema.String }) {};
+const makeHost = Effect.gen(function* () {
+	const runtime = yield* DurableAgentRuntime;
+	const config = yield* NodeDurableAgentRuntimeConfig;
+	const startupRecovery = yield* runtime.runRecovery;
+	const admission = yield* Ref.make(true);
+	yield* Effect.addFinalizer(() => Ref.set(admission, false));
+	const requireAdmission = Ref.get(admission).pipe(Effect.flatMap((open) => open ? Effect.void : Effect.fail(AdmissionClosed.make({ message: "The host is shutting down; admission is closed." }))));
+	const submit = (agent, input, options) => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));
+	const runWorkers = (worker) => Effect.forEach(Array.from({ length: config.workerConcurrency }, (_, index) => index), () => worker, {
+		concurrency: "unbounded",
+		discard: true
+	});
+	const runResolvedWorkers = runWorkers(runtime.runResolvedWorker);
+	return NodeDurableHost.of({
+		startupRecovery,
+		admissionOpen: Ref.get(admission),
+		submit,
+		awaitSettlement: runtime.awaitSettlement,
+		observe: runtime.observe,
+		abort: runtime.abort,
+		explain: runtime.explain,
+		explainThread: runtime.explainThread,
+		verify: runtime.verify,
+		retry: runtime.retry,
+		wake: runtime.wake,
+		scanObligations: runtime.scanObligations,
+		runWorkers,
+		runResolvedWorkers
+	});
+});
+/**
+* Operational host lifecycle for the DN runtime (deployment §2/§5/§6).
+*
+* Startup gates run during Layer construction, so the service existing implies readiness:
+* configuration was schema-decoded, the SQLite file passed the exact-version compatibility check,
+* and every nonterminal Submission went through one full recovery pass BEFORE admission opened.
+* `startupRecovery` is the auditable evidence of that reconciliation pass.
+*
+* Shutdown runs in reverse Layer order when the owning Scope closes: `submit` starts refusing
+* with `AdmissionClosed` first, then the runtime Layer's ownership drain releases every claim
+* still held so another host can take over the lanes immediately, then the SQLite resources
+* close. Forced termination at any point stays safe — the durability protocol, not graceful
+* shutdown, provides correctness (DEPLOY-006).
+*/
+var NodeDurableHost = class NodeDurableHost extends Context.Service()("@effect-agent/platform-node/NodeDurableHost") {
+	/**
+	* Compile typed registrations and acquire the complete host in one Layer Scope.
+	* Node supplies Crypto; model, tool, instruction, and schema services remain required.
+	* Startup recovery and shutdown gates are unchanged. Workers start only when the caller
+	* runs runResolvedWorkers; this constructor never starts a background worker.
+	*/
+	static layerRegistered(registrations, options) {
+		return NodeDurableHost.layer.pipe(Layer.provideMerge(NodeDurableAgentRuntime.layerRegistered(registrations, options)));
+	}
+	/**
+	* Host gates over an assembled `NodeDurableAgentRuntime` stack. The runtime Layer owns
+	* executable registrations; omission registers no Agents, so resolved work fails closed.
+	*/
+	static layer = Layer.effect(NodeDurableHost)(makeHost);
+	/** The complete DN host: `NodeDurableAgentRuntime.layer(options)` plus the host lifecycle gates. */
+	static layerStack(options) {
+		const { bindings = [], ...runtimeOptions } = options;
+		return NodeDurableHost.layer.pipe(Layer.provideMerge(NodeDurableAgentRuntime.layerWithBindings(bindings, runtimeOptions)));
+	}
+};
+//#endregion
+export { AdmissionClosed, NodeDurableHost, NodeDurableHost_exports as t };
+
+//# sourceMappingURL=NodeDurableHost.mjs.map

package/dist/NodeDurableHost.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeDurableHost.mjs","names":[],"sources":["../src/NodeDurableHost.ts"],"sourcesContent":["import { type ThreadId, type SubmissionId } from \"@effect-agent/core/Identifiers\";\nimport {\n  type IntegrityReport,\n  type ObligationReport,\n  type ObligationThresholds,\n  type RecoveryExplanation,\n  type RetryCommand,\n} from \"@effect-agent/thread/Admin\";\nimport {\n  type AgentRegistration,\n  type ResolvedBinding,\n  type DurableBindingFailure,\n} from \"@effect-agent/thread/AgentRegistration\";\nimport {\n  DurableAgentRuntime,\n  type DurableAbortFailure,\n  type DurableAwaitFailure,\n  type DurableExplainFailure,\n  type DurableObserveOptions,\n  type DurableObligationFailure,\n  type DurableRetryFailure,\n  type DurableSubmitAgent,\n  type DurableSubmitFailure,\n  type DurableSubmitOptions,\n  type DurableVerifyFailure,\n  type DurableWorkerFailure,\n  type Receipt,\n  type RecoveryReport,\n} from \"@effect-agent/thread/DurableAgentRuntime\";\nimport { type OperationDenied } from \"@effect-agent/thread/OperationAuthorizer\";\nimport { type CanonicalRecordEnvelope } from \"@effect-agent/thread/Records\";\nimport {\n  type AbortCommand,\n  type AbortIntent,\n  type Settlement,\n} from \"@effect-agent/thread/SubmissionLedger\";\nimport {\n  type ThreadNotMaterialized,\n  type ThreadStoreError,\n} from \"@effect-agent/thread/ThreadStore\";\nimport { type Stream, Context, type Crypto, Effect, Layer, Ref, Schema } from \"effect\";\n\nimport {\n  NodeDurableAgentRuntime,\n  NodeDurableAgentRuntimeConfig,\n  type NodeDurableAgentRuntimeInitializationError,\n  type NodeDurableAgentRuntimeOptions,\n  type NodeDurableAgentRuntimeServices,\n} from \"./NodeDurableAgentRuntime.ts\";\n\n/**\n * Admission is not open on this host: it is shutting down (deployment §6 step 1, DEPLOY-005).\n * Accepted work is unaffected — only NEW admissions are refused.\n */\nexport class AdmissionClosed extends Schema.TaggedError<AdmissionClosed>()(\"AdmissionClosed\", {\n  message: Schema.String,\n}) {}\n\nconst makeHost = Effect.gen(function* () {\n  const runtime = yield* DurableAgentRuntime;\n  const config = yield* NodeDurableAgentRuntimeConfig;\n\n  // Startup gate (deployment §5, plan §host): configuration decoding and storage compatibility\n  // already gated this Layer's dependencies; the last gate before admission opens is recovering\n  // EVERY nonterminal Submission. Work needing a live Agent Binding is reported `deferred` and\n  // stays a visible obligation for `runWorkers`; lanes durably blocked on an Unknown Outcome are\n  // reported `unknown` and wait for the authorized `resolveUnknown` path (DUR-017) — they consume\n  // no worker permit while the settlement obligation stays owed.\n  const startupRecovery = yield* runtime.runRecovery;\n\n  const admission = yield* Ref.make(true);\n\n  // Shutdown step 1 (DEPLOY-005): admission closes before the ownership drain in the runtime\n  // Layer below releases claims and before the stores close in reverse acquisition order.\n  yield* Effect.addFinalizer(() => Ref.set(admission, false));\n\n  const requireAdmission: Effect.Effect<void, AdmissionClosed> = Ref.get(admission).pipe(\n    Effect.flatMap((open) =>\n      open\n        ? Effect.void\n        : Effect.fail(\n            AdmissionClosed.make({ message: \"The host is shutting down; admission is closed.\" }),\n          ),\n    ),\n  );\n\n  const submit = <InputSchema extends Schema.Top>(\n    agent: DurableSubmitAgent<InputSchema>,\n    input: InputSchema[\"Type\"],\n    options: DurableSubmitOptions,\n  ): Effect.Effect<\n    Receipt,\n    AdmissionClosed | DurableSubmitFailure,\n    InputSchema[\"EncodingServices\"]\n  > => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));\n\n  const runWorkers = <A, E, R>(worker: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> =>\n    Effect.forEach(\n      Array.from({ length: config.workerConcurrency }, (_, index) => index),\n      () => worker,\n      { concurrency: \"unbounded\", discard: true },\n    );\n\n  // S2 multi-binding pool: every claimed head resolves its exact registered Binding through\n  // the host's exact registrations, so one bounded\n  // pool serves parent and child lanes — the spec §12 smallest-pool suspension/wakeup proof\n  // runs `workerConcurrency: 1` over exactly this loop.\n  const runResolvedWorkers = runWorkers(runtime.runResolvedWorker);\n\n  return NodeDurableHost.of({\n    startupRecovery,\n    admissionOpen: Ref.get(admission),\n    submit,\n    awaitSettlement: runtime.awaitSettlement,\n    observe: runtime.observe,\n    abort: runtime.abort,\n    explain: runtime.explain,\n    explainThread: runtime.explainThread,\n    verify: runtime.verify,\n    retry: runtime.retry,\n    wake: runtime.wake,\n    scanObligations: runtime.scanObligations,\n    runWorkers,\n    runResolvedWorkers,\n  });\n});\n\n/**\n * Operational host lifecycle for the DN runtime (deployment §2/§5/§6).\n *\n * Startup gates run during Layer construction, so the service existing implies readiness:\n * configuration was schema-decoded, the SQLite file passed the exact-version compatibility check,\n * and every nonterminal Submission went through one full recovery pass BEFORE admission opened.\n * `startupRecovery` is the auditable evidence of that reconciliation pass.\n *\n * Shutdown runs in reverse Layer order when the owning Scope closes: `submit` starts refusing\n * with `AdmissionClosed` first, then the runtime Layer's ownership drain releases every claim\n * still held so another host can take over the lanes immediately, then the SQLite resources\n * close. Forced termination at any point stays safe — the durability protocol, not graceful\n * shutdown, provides correctness (DEPLOY-006).\n */\nexport class NodeDurableHost extends Context.Service<\n  NodeDurableHost,\n  {\n    /**\n     * The recovery decisions executed (or deferred) by this host's startup reconciliation.\n     * Reports with the `unknown` disposition identify lanes blocked on Unknown Outcomes that\n     * only the authorized DUR-017 resolution path can release.\n     */\n    readonly startupRecovery: ReadonlyArray<RecoveryReport>;\n    /** Admission-role readiness (deployment §7): true until shutdown begins. */\n    readonly admissionOpen: Effect.Effect<boolean>;\n    /** `DurableAgentRuntime.submit` behind the host admission gate. */\n    readonly submit: <InputSchema extends Schema.Top>(\n      agent: DurableSubmitAgent<InputSchema>,\n      input: InputSchema[\"Type\"],\n      options: DurableSubmitOptions,\n    ) => Effect.Effect<\n      Receipt,\n      AdmissionClosed | DurableSubmitFailure,\n      InputSchema[\"EncodingServices\"]\n    >;\n    readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, DurableAwaitFailure>;\n    readonly observe: (\n      receipt: Receipt,\n      options?: DurableObserveOptions,\n    ) => Stream.Stream<\n      CanonicalRecordEnvelope,\n      ThreadStoreError | ThreadNotMaterialized | OperationDenied\n    >;\n    readonly abort: (command: AbortCommand) => Effect.Effect<AbortIntent, DurableAbortFailure>;\n    /** `DurableAgentRuntime.explain` — read-only recovery explanation of one Submission (P7). */\n    readonly explain: (\n      submissionId: SubmissionId,\n    ) => Effect.Effect<RecoveryExplanation, DurableExplainFailure>;\n    /** `DurableAgentRuntime.explainThread` — explain every nonterminal lane member. */\n    readonly explainThread: (\n      threadId: ThreadId,\n    ) => Effect.Effect<ReadonlyArray<RecoveryExplanation>, DurableExplainFailure>;\n    /** `DurableAgentRuntime.verify` — read-only integrity checks, never a repair (P7). */\n    readonly verify: (threadId: ThreadId) => Effect.Effect<IntegrityReport, DurableVerifyFailure>;\n    /** `DurableAgentRuntime.retry` — audited single-Submission re-drive with typed refusals. */\n    readonly retry: (command: RetryCommand) => Effect.Effect<RecoveryReport, DurableRetryFailure>;\n    /** `DurableAgentRuntime.wake` — the documented operator liveness nudge for one lane. */\n    readonly wake: (threadId: ThreadId) => Effect.Effect<void, OperationDenied>;\n    /** `DurableAgentRuntime.scanObligations` — the scan-based DUR-017/OPS-001 report. */\n    readonly scanObligations: (\n      thresholds: ObligationThresholds,\n    ) => Effect.Effect<ObligationReport, DurableObligationFailure>;\n    /**\n     * Run `workerConcurrency` copies of the given worker effect (typically\n     * `DurableAgentRuntime.runWorker(agent)`) until the caller's Scope interrupts them. The\n     * bound is the validated finite configuration value; the host never forks daemon fibers.\n     */\n    readonly runWorkers: <A, E, R>(worker: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>;\n    /**\n     * Run `workerConcurrency` copies of `DurableAgentRuntime.runResolvedWorker` over the host's\n     * registered Bindings (S2): every claimed head resolves its exact stored Binding before any\n     * code runs (SUB-023), so one bounded pool serves parent and attached-child lanes.\n     */\n    readonly runResolvedWorkers: Effect.Effect<void, DurableWorkerFailure | DurableBindingFailure>;\n  }\n>()(\"@effect-agent/platform-node/NodeDurableHost\") {\n  /**\n   * Compile typed registrations and acquire the complete host in one Layer Scope.\n   * Node supplies Crypto; model, tool, instruction, and schema services remain required.\n   * Startup recovery and shutdown gates are unchanged. Workers start only when the caller\n   * runs runResolvedWorkers; this constructor never starts a background worker.\n   */\n  static layerRegistered<\n    const Entries extends ReadonlyArray<AgentRegistration>,\n    ContextError = never,\n    ContextRequirements = never,\n    AuthorizationError = never,\n    AuthorizationRequirements = never,\n  >(\n    registrations: Entries,\n    options: NodeDurableAgentRuntimeOptions<\n      ContextError,\n      ContextRequirements,\n      AuthorizationError,\n      AuthorizationRequirements\n    >,\n  ) {\n    return NodeDurableHost.layer.pipe(\n      Layer.provideMerge(NodeDurableAgentRuntime.layerRegistered(registrations, options)),\n    );\n  }\n\n  /**\n   * Host gates over an assembled `NodeDurableAgentRuntime` stack. The runtime Layer owns\n   * executable registrations; omission registers no Agents, so resolved work fails closed.\n   */\n  static readonly layer: Layer.Layer<\n    NodeDurableHost,\n    DurableWorkerFailure,\n    DurableAgentRuntime | NodeDurableAgentRuntimeConfig\n  > = Layer.effect(NodeDurableHost)(makeHost);\n\n  /** The complete DN host: `NodeDurableAgentRuntime.layer(options)` plus the host lifecycle gates. */\n  static layerStack<\n    ContextError = never,\n    ContextRequirements = never,\n    AuthorizationError = never,\n    AuthorizationRequirements = never,\n  >(\n    options: NodeDurableAgentRuntimeOptions<\n      ContextError,\n      ContextRequirements,\n      AuthorizationError,\n      AuthorizationRequirements\n    > & { readonly bindings?: ReadonlyArray<ResolvedBinding> },\n  ): Layer.Layer<\n    NodeDurableHost | NodeDurableAgentRuntimeServices,\n    | DurableWorkerFailure\n    | NodeDurableAgentRuntimeInitializationError\n    | ContextError\n    | AuthorizationError,\n    Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>\n  > {\n    const { bindings = [], ...runtimeOptions } = options;\n\n    return NodeDurableHost.layer.pipe(\n      Layer.provideMerge(NodeDurableAgentRuntime.layerWithBindings(bindings, runtimeOptions)),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CAAC,mBAAmB,EAC5F,SAAS,OAAO,OAClB,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAM,WAAW,OAAO,IAAI,aAAa;CACvC,MAAM,UAAU,OAAO;CACvB,MAAM,SAAS,OAAO;CAQtB,MAAM,kBAAkB,OAAO,QAAQ;CAEvC,MAAM,YAAY,OAAO,IAAI,KAAK,IAAI;CAItC,OAAO,OAAO,mBAAmB,IAAI,IAAI,WAAW,KAAK,CAAC;CAE1D,MAAM,mBAAyD,IAAI,IAAI,SAAS,CAAC,CAAC,KAChF,OAAO,SAAS,SACd,OACI,OAAO,OACP,OAAO,KACL,gBAAgB,KAAK,EAAE,SAAS,kDAAkD,CAAC,CACrF,CACN,CACF;CAEA,MAAM,UACJ,OACA,OACA,YAKG,iBAAiB,KAAK,OAAO,QAAQ,QAAQ,OAAO,OAAO,OAAO,OAAO,CAAC,CAAC;CAEhF,MAAM,cAAuB,WAC3B,OAAO,QACL,MAAM,KAAK,EAAE,QAAQ,OAAO,kBAAkB,IAAI,GAAG,UAAU,KAAK,SAC9D,QACN;EAAE,aAAa;EAAa,SAAS;CAAK,CAC5C;CAMF,MAAM,qBAAqB,WAAW,QAAQ,iBAAiB;CAE/D,OAAO,gBAAgB,GAAG;EACxB;EACA,eAAe,IAAI,IAAI,SAAS;EAChC;EACA,iBAAiB,QAAQ;EACzB,SAAS,QAAQ;EACjB,OAAO,QAAQ;EACf,SAAS,QAAQ;EACjB,eAAe,QAAQ;EACvB,QAAQ,QAAQ;EAChB,OAAO,QAAQ;EACf,MAAM,QAAQ;EACd,iBAAiB,QAAQ;EACzB;EACA;CACF,CAAC;AACH,CAAC;;;;;;;;;;;;;;;AAgBD,IAAa,kBAAb,MAAa,wBAAwB,QAAQ,QA6D3C,CAAC,CAAC,6CAA6C,CAAC,CAAC;;;;;;;CAOjD,OAAO,gBAOL,eACA,SAMA;EACA,OAAO,gBAAgB,MAAM,KAC3B,MAAM,aAAa,wBAAwB,gBAAgB,eAAe,OAAO,CAAC,CACpF;CACF;;;;;CAMA,OAAgB,QAIZ,MAAM,OAAO,eAAe,CAAC,CAAC,QAAQ;;CAG1C,OAAO,WAML,SAaA;EACA,MAAM,EAAE,WAAW,CAAC,GAAG,GAAG,mBAAmB;EAE7C,OAAO,gBAAgB,MAAM,KAC3B,MAAM,aAAa,wBAAwB,kBAAkB,UAAU,cAAc,CAAC,CACxF;CACF;AACF"}

package/dist/NodeScheduling.d.mts

@@ -0,0 +1,22 @@
+import { NodeDurableHost } from "./NodeDurableHost.mjs";
+import { ScheduleAuthorizer, ScheduleStore, ScheduleValidationError, ScheduleWake, SchedulingLimits } from "@effect-agent/thread/Schedule";
+import { Layer } from "effect";
+import { Scheduling } from "@effect-agent/thread/Scheduling";
+declare namespace NodeScheduling_d_exports {
+  export { NodeScheduling, NodeSchedulingOptions, nodeScheduleWakeLayer };
+}
+/** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */
+declare const nodeScheduleWakeLayer: Layer.Layer<ScheduleWake>;
+interface NodeSchedulingOptions {
+  readonly limits?: SchedulingLimits | undefined;
+}
+/**
+ * Optional Scope-owned Node scheduling service and driver. The caller must provide the existing
+ * host, its SQLite ScheduleStore, and an explicit ScheduleAuthorizer.
+ */
+declare class NodeScheduling {
+  static layer(options?: NodeSchedulingOptions): Layer.Layer<Scheduling, ScheduleValidationError, NodeDurableHost | ScheduleStore | ScheduleAuthorizer>;
+}
+//#endregion
+export { NodeScheduling, NodeSchedulingOptions, nodeScheduleWakeLayer, NodeScheduling_d_exports as t };
+//# sourceMappingURL=NodeScheduling.d.mts.map

package/dist/NodeScheduling.mjs

@@ -0,0 +1,59 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { nodeScheduledInputAdmissionLayer } from "./NodeSubscriptions.mjs";
+import { ScheduleStorageError, ScheduleStore, ScheduleWake, defaultSchedulingLimits } from "@effect-agent/thread/Schedule";
+import { NodeCrypto } from "@effect/platform-node";
+import { Cause, Duration, Effect, Layer, Option, PubSub, Result } from "effect";
+import { ScheduleDriver, Scheduling } from "@effect-agent/thread/Scheduling";
+//#region src/NodeScheduling.ts
+var NodeScheduling_exports = /* @__PURE__ */ __exportAll({
+	NodeScheduling: () => NodeScheduling,
+	nodeScheduleWakeLayer: () => nodeScheduleWakeLayer
+});
+/** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */
+const nodeScheduleWakeLayer = Layer.effect(ScheduleWake, Effect.gen(function* () {
+	const hints = yield* PubSub.sliding(1);
+	const subscription = yield* PubSub.subscribe(hints);
+	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
+	return ScheduleWake.of({
+		notify: PubSub.publish(hints, void 0).pipe(Effect.asVoid),
+		await: PubSub.take(subscription)
+	});
+}));
+const reportPassFailure = (cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.logWarning("Node scheduling pass failed").pipe(Effect.annotateLogs({ failureTag: Option.match(Cause.findErrorOption(cause), {
+	onNone: () => "Defect",
+	onSome: (error) => error._tag
+}) }), Effect.as(false));
+const nodeSchedulingDriverLayer = (limits) => Layer.effectDiscard(Effect.gen(function* () {
+	const scheduling = yield* ScheduleDriver;
+	const store = yield* ScheduleStore;
+	const wake = yield* ScheduleWake;
+	const run = Effect.gen(function* () {
+		while (true) {
+			const passSucceeded = yield* scheduling.runDue().pipe(Effect.map((pass) => pass.failed === 0), Effect.catchCause(reportPassFailure));
+			const deadlineResult = passSucceeded ? yield* store.nextDeadline().pipe(Effect.result) : Result.fail(ScheduleStorageError.make({
+				operation: "driver pass",
+				reason: "unavailable"
+			}));
+			if (Result.isFailure(deadlineResult) && passSucceeded) yield* Effect.logWarning("Node scheduling deadline query failed");
+			const nowMillis = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+			const deadlineDelay = Result.isSuccess(deadlineResult) && deadlineResult.success !== null ? Math.max(0, deadlineResult.success - nowMillis) : limits.recoveryPollMillis;
+			const delay = Math.min(deadlineDelay, limits.recoveryPollMillis);
+			yield* Effect.raceFirst(wake.await, Effect.sleep(Duration.millis(delay)));
+		}
+	});
+	yield* Effect.forkScoped(run);
+}));
+/**
+* Optional Scope-owned Node scheduling service and driver. The caller must provide the existing
+* host, its SQLite ScheduleStore, and an explicit ScheduleAuthorizer.
+*/
+var NodeScheduling = class {
+	static layer(options = {}) {
+		const limits = options.limits ?? defaultSchedulingLimits;
+		return nodeSchedulingDriverLayer(limits).pipe(Layer.provide(ScheduleDriver.layer(limits)), Layer.merge(Scheduling.layer(limits))).pipe(Layer.provide(Layer.mergeAll(nodeScheduledInputAdmissionLayer, nodeScheduleWakeLayer, NodeCrypto.layer)));
+	}
+};
+//#endregion
+export { NodeScheduling, nodeScheduleWakeLayer, NodeScheduling_exports as t };
+
+//# sourceMappingURL=NodeScheduling.mjs.map

package/dist/NodeScheduling.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeScheduling.mjs","names":[],"sources":["../src/NodeScheduling.ts"],"sourcesContent":["import {\n  type ScheduleAuthorizer,\n  type SchedulingLimits,\n  ScheduleStorageError,\n  ScheduleStore,\n  type ScheduleValidationError,\n  ScheduleWake,\n  defaultSchedulingLimits,\n} from \"@effect-agent/thread/Schedule\";\nimport {\n  type ScheduleProcessFailure,\n  Scheduling,\n  ScheduleDriver,\n} from \"@effect-agent/thread/Scheduling\";\nimport { NodeCrypto } from \"@effect/platform-node\";\nimport { Cause, Duration, Effect, Layer, Option, PubSub, Result } from \"effect\";\n\nimport type { NodeDurableHost } from \"./NodeDurableHost.ts\";\nimport { nodeScheduledInputAdmissionLayer } from \"./NodeSubscriptions.ts\";\n\n/** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */\nexport const nodeScheduleWakeLayer: Layer.Layer<ScheduleWake> = Layer.effect(\n  ScheduleWake,\n  Effect.gen(function* () {\n    const hints = yield* PubSub.sliding<void>(1);\n    const subscription = yield* PubSub.subscribe(hints);\n\n    yield* Effect.addFinalizer(() => PubSub.shutdown(hints));\n\n    return ScheduleWake.of({\n      notify: PubSub.publish(hints, undefined).pipe(Effect.asVoid),\n      await: PubSub.take(subscription),\n    });\n  }),\n);\n\nconst reportPassFailure = (cause: Cause.Cause<ScheduleProcessFailure>): Effect.Effect<boolean> =>\n  Cause.hasInterruptsOnly(cause)\n    ? Effect.interrupt\n    : Effect.logWarning(\"Node scheduling pass failed\").pipe(\n        Effect.annotateLogs({\n          failureTag: Option.match(Cause.findErrorOption(cause), {\n            onNone: () => \"Defect\",\n            onSome: (error) => error._tag,\n          }),\n        }),\n        Effect.as(false),\n      );\n\nconst nodeSchedulingDriverLayer = (\n  limits: SchedulingLimits,\n): Layer.Layer<never, never, ScheduleDriver | ScheduleStore | ScheduleWake> =>\n  Layer.effectDiscard(\n    Effect.gen(function* () {\n      const scheduling = yield* ScheduleDriver;\n      const store = yield* ScheduleStore;\n      const wake = yield* ScheduleWake;\n\n      const run = Effect.gen(function* () {\n        while (true) {\n          const passSucceeded = yield* scheduling.runDue().pipe(\n            Effect.map((pass) => pass.failed === 0),\n            Effect.catchCause(reportPassFailure),\n          );\n\n          const deadlineResult = passSucceeded\n            ? yield* store.nextDeadline().pipe(Effect.result)\n            : Result.fail(\n                ScheduleStorageError.make({ operation: \"driver pass\", reason: \"unavailable\" }),\n              );\n\n          if (Result.isFailure(deadlineResult) && passSucceeded) {\n            yield* Effect.logWarning(\"Node scheduling deadline query failed\");\n          }\n          const nowMillis = yield* Effect.clockWith((clock) => clock.currentTimeMillis);\n\n          const deadlineDelay =\n            Result.isSuccess(deadlineResult) && deadlineResult.success !== null\n              ? Math.max(0, deadlineResult.success - nowMillis)\n              : limits.recoveryPollMillis;\n\n          const delay = Math.min(deadlineDelay, limits.recoveryPollMillis);\n\n          yield* Effect.raceFirst(wake.await, Effect.sleep(Duration.millis(delay)));\n        }\n      });\n\n      yield* Effect.forkScoped(run);\n    }),\n  );\n\nexport interface NodeSchedulingOptions {\n  readonly limits?: SchedulingLimits | undefined;\n}\n\n/**\n * Optional Scope-owned Node scheduling service and driver. The caller must provide the existing\n * host, its SQLite ScheduleStore, and an explicit ScheduleAuthorizer.\n */\nexport class NodeScheduling {\n  static layer(\n    options: NodeSchedulingOptions = {},\n  ): Layer.Layer<\n    Scheduling,\n    ScheduleValidationError,\n    NodeDurableHost | ScheduleStore | ScheduleAuthorizer\n  > {\n    const limits = options.limits ?? defaultSchedulingLimits;\n\n    const schedulingWithDriver = nodeSchedulingDriverLayer(limits).pipe(\n      Layer.provide(ScheduleDriver.layer(limits)),\n      Layer.merge(Scheduling.layer(limits)),\n    );\n\n    return schedulingWithDriver.pipe(\n      Layer.provide(\n        Layer.mergeAll(nodeScheduledInputAdmissionLayer, nodeScheduleWakeLayer, NodeCrypto.layer),\n      ),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAqBA,MAAa,wBAAmD,MAAM,OACpE,cACA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO,OAAO,QAAc,CAAC;CAC3C,MAAM,eAAe,OAAO,OAAO,UAAU,KAAK;CAElD,OAAO,OAAO,mBAAmB,OAAO,SAAS,KAAK,CAAC;CAEvD,OAAO,aAAa,GAAG;EACrB,QAAQ,OAAO,QAAQ,OAAO,KAAA,CAAS,CAAC,CAAC,KAAK,OAAO,MAAM;EAC3D,OAAO,OAAO,KAAK,YAAY;CACjC,CAAC;AACH,CAAC,CACH;AAEA,MAAM,qBAAqB,UACzB,MAAM,kBAAkB,KAAK,IACzB,OAAO,YACP,OAAO,WAAW,6BAA6B,CAAC,CAAC,KAC/C,OAAO,aAAa,EAClB,YAAY,OAAO,MAAM,MAAM,gBAAgB,KAAK,GAAG;CACrD,cAAc;CACd,SAAS,UAAU,MAAM;AAC3B,CAAC,EACH,CAAC,GACD,OAAO,GAAG,KAAK,CACjB;AAEN,MAAM,6BACJ,WAEA,MAAM,cACJ,OAAO,IAAI,aAAa;CACtB,MAAM,aAAa,OAAO;CAC1B,MAAM,QAAQ,OAAO;CACrB,MAAM,OAAO,OAAO;CAEpB,MAAM,MAAM,OAAO,IAAI,aAAa;EAClC,OAAO,MAAM;GACX,MAAM,gBAAgB,OAAO,WAAW,OAAO,CAAC,CAAC,KAC/C,OAAO,KAAK,SAAS,KAAK,WAAW,CAAC,GACtC,OAAO,WAAW,iBAAiB,CACrC;GAEA,MAAM,iBAAiB,gBACnB,OAAO,MAAM,aAAa,CAAC,CAAC,KAAK,OAAO,MAAM,IAC9C,OAAO,KACL,qBAAqB,KAAK;IAAE,WAAW;IAAe,QAAQ;GAAc,CAAC,CAC/E;GAEJ,IAAI,OAAO,UAAU,cAAc,KAAK,eACtC,OAAO,OAAO,WAAW,uCAAuC;GAElE,MAAM,YAAY,OAAO,OAAO,WAAW,UAAU,MAAM,iBAAiB;GAE5E,MAAM,gBACJ,OAAO,UAAU,cAAc,KAAK,eAAe,YAAY,OAC3D,KAAK,IAAI,GAAG,eAAe,UAAU,SAAS,IAC9C,OAAO;GAEb,MAAM,QAAQ,KAAK,IAAI,eAAe,OAAO,kBAAkB;GAE/D,OAAO,OAAO,UAAU,KAAK,OAAO,OAAO,MAAM,SAAS,OAAO,KAAK,CAAC,CAAC;EAC1E;CACF,CAAC;CAED,OAAO,OAAO,WAAW,GAAG;AAC9B,CAAC,CACH;;;;;AAUF,IAAa,iBAAb,MAA4B;CAC1B,OAAO,MACL,UAAiC,CAAC,GAKlC;EACA,MAAM,SAAS,QAAQ,UAAU;EAOjC,OAL6B,0BAA0B,MAAM,CAAC,CAAC,KAC7D,MAAM,QAAQ,eAAe,MAAM,MAAM,CAAC,GAC1C,MAAM,MAAM,WAAW,MAAM,MAAM,CAAC,CAGZ,CAAC,CAAC,KAC1B,MAAM,QACJ,MAAM,SAAS,kCAAkC,uBAAuB,WAAW,KAAK,CAC1F,CACF;CACF;AACF"}

package/dist/NodeSubscriptions.d.mts

@@ -0,0 +1,27 @@
+import { NodeDurableHost } from "./NodeDurableHost.mjs";
+import { ScheduledInputAdmission } from "@effect-agent/thread/Schedule";
+import { Layer } from "effect";
+import { EventSources } from "@effect-agent/thread/EventSource";
+import { PreparedInputAdmission } from "@effect-agent/thread/PreparedInputAdmission";
+import { SubscriptionAuthorizer, SubscriptionError, SubscriptionLimits, SubscriptionStore } from "@effect-agent/thread/Subscription";
+import { SubscriptionInputBindings } from "@effect-agent/thread/SubscriptionInput";
+import { SubscriptionIntake, Subscriptions } from "@effect-agent/thread/Subscriptions";
+declare namespace NodeSubscriptions_d_exports {
+  export { NodeSubscriptions, NodeSubscriptionsOptions, nodePreparedInputAdmissionLayer, nodeScheduledInputAdmissionLayer };
+}
+/** Ordinary prepared admission through the Scope-owned Node host gate. */
+declare const nodePreparedInputAdmissionLayer: Layer.Layer<PreparedInputAdmission, never, NodeDurableHost>;
+declare const nodeScheduledInputAdmissionLayer: Layer.Layer<ScheduledInputAdmission, never, NodeDurableHost>;
+interface NodeSubscriptionsOptions {
+  readonly limits?: SubscriptionLimits | undefined;
+}
+/**
+ * One Scope-owned subscription partition in the sole process owning its SQLite database.
+ * Indexed polling repairs restart and lost wake state; closing the Scope interrupts the driver.
+ */
+declare class NodeSubscriptions {
+  static layer(options?: NodeSubscriptionsOptions): Layer.Layer<Subscriptions | SubscriptionIntake, SubscriptionError, NodeDurableHost | SubscriptionStore | SubscriptionAuthorizer | EventSources | SubscriptionInputBindings>;
+}
+//#endregion
+export { NodeSubscriptions, NodeSubscriptionsOptions, nodePreparedInputAdmissionLayer, nodeScheduledInputAdmissionLayer, NodeSubscriptions_d_exports as t };
+//# sourceMappingURL=NodeSubscriptions.d.mts.map

package/dist/NodeSubscriptions.mjs

@@ -0,0 +1,103 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { NodeDurableHost } from "./NodeDurableHost.mjs";
+import "@effect-agent/core/Identifiers";
+import "@effect-agent/thread/DurableAgentRuntime";
+import { PersistedJson } from "@effect-agent/thread/Records";
+import { ScheduleStorageError, ScheduledInputAdmission, ScheduledInputRetryable } from "@effect-agent/thread/Schedule";
+import { NodeCrypto } from "@effect/platform-node";
+import { Cause, Duration, Effect, Exit, Layer, Option } from "effect";
+import "@effect-agent/thread/EventSource";
+import { PreparedInputAdmission } from "@effect-agent/thread/PreparedInputAdmission";
+import { SubscriptionStore, defaultSubscriptionLimits } from "@effect-agent/thread/Subscription";
+import "@effect-agent/thread/SubscriptionInput";
+import { SubscriptionDriver, SubscriptionIntake, Subscriptions } from "@effect-agent/thread/Subscriptions";
+//#region src/NodeSubscriptions.ts
+var NodeSubscriptions_exports = /* @__PURE__ */ __exportAll({
+	NodeSubscriptions: () => NodeSubscriptions,
+	nodePreparedInputAdmissionLayer: () => nodePreparedInputAdmissionLayer,
+	nodeScheduledInputAdmissionLayer: () => nodeScheduledInputAdmissionLayer
+});
+const passthroughSubmitAgent = (agentId) => ({ definition: {
+	id: agentId,
+	input: PersistedJson
+} });
+const ambiguous = () => ScheduledInputRetryable.make({ reason: "ambiguous" });
+const corrupt = (operation) => ScheduleStorageError.make({
+	operation,
+	reason: "corrupt"
+});
+/** Ordinary prepared admission through the Scope-owned Node host gate. */
+const nodePreparedInputAdmissionLayer = Layer.effect(PreparedInputAdmission, Effect.gen(function* () {
+	const host = yield* NodeDurableHost;
+	return PreparedInputAdmission.of({ submit: (envelope) => host.submit(passthroughSubmitAgent(envelope.agentId), envelope.input, {
+		threadId: envelope.threadId,
+		principal: envelope.deliveryPrincipal,
+		idempotencyKey: envelope.admissionKey,
+		definitions: envelope.definitions
+	}).pipe(Effect.catchTags({
+		AdmissionClosed: () => Effect.fail(ScheduledInputRetryable.make({ reason: "host-closed" })),
+		AgentInputError: () => Effect.fail(corrupt("prepared admission input")),
+		AdmissionConflict: () => Effect.fail(corrupt("prepared admission conflict")),
+		DigestError: () => Effect.fail(ambiguous()),
+		LedgerError: () => Effect.fail(ambiguous()),
+		ThreadStoreError: () => Effect.fail(ambiguous()),
+		ThreadNotMaterialized: () => Effect.fail(ambiguous()),
+		AppendConflict: () => Effect.fail(ambiguous()),
+		FenceRejected: () => Effect.fail(ambiguous()),
+		DurableRuntimeFailpointError: () => Effect.fail(ambiguous())
+	})) });
+}));
+const preparedFromSchedule = (envelope) => ({
+	schemaVersion: 1,
+	threadId: envelope.threadId,
+	deliveryPrincipal: envelope.deliveryPrincipal,
+	agentId: envelope.agentId,
+	definitions: envelope.definitions,
+	input: envelope.input,
+	inputDigest: envelope.inputDigest,
+	admissionKey: envelope.admissionKey,
+	authorization: envelope.authorization
+});
+const nodeScheduledInputAdmissionLayer = Layer.effect(ScheduledInputAdmission, Effect.map(PreparedInputAdmission, (admission) => ScheduledInputAdmission.of({ submit: (envelope) => admission.submit(preparedFromSchedule(envelope)) }))).pipe(Layer.provide(nodePreparedInputAdmissionLayer));
+const reportPassFailure = (cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.logWarning("Node subscription pass failed").pipe(Effect.annotateLogs({ failureTag: Option.match(Cause.findErrorOption(cause), {
+	onNone: () => "Defect",
+	onSome: (error) => error._tag
+}) }), Effect.as(false));
+const nodeSubscriptionDriverLayer = (limits) => Layer.effectDiscard(Effect.gen(function* () {
+	const driver = yield* SubscriptionDriver;
+	const store = yield* SubscriptionStore;
+	const run = Effect.gen(function* () {
+		while (true) {
+			if (!(yield* driver.runDue.pipe(Effect.map((pass) => pass.failed === 0), Effect.catchCause(reportPassFailure)))) {
+				yield* Effect.sleep(Duration.millis(limits.retryMillis));
+				continue;
+			}
+			const deadline = yield* store.nextDeadline.pipe(Effect.exit);
+			if (Exit.isFailure(deadline)) {
+				yield* reportPassFailure(deadline.cause);
+				yield* Effect.sleep(Duration.millis(limits.retryMillis));
+				continue;
+			}
+			const nowMillis = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+			const delay = deadline.value === null ? limits.retryMillis : Math.max(1, Math.min(deadline.value - nowMillis, limits.retryMillis));
+			yield* Effect.sleep(Duration.millis(delay));
+		}
+	});
+	yield* Effect.forkScoped(run);
+}));
+/**
+* One Scope-owned subscription partition in the sole process owning its SQLite database.
+* Indexed polling repairs restart and lost wake state; closing the Scope interrupts the driver.
+*/
+var NodeSubscriptions = class {
+	static layer(options = {}) {
+		const limits = options.limits ?? defaultSubscriptionLimits;
+		const publicServices = Layer.merge(Subscriptions.layer(limits), SubscriptionIntake.layer(limits));
+		const driver = nodeSubscriptionDriverLayer(limits).pipe(Layer.provide(SubscriptionDriver.layer(limits)));
+		return Layer.merge(publicServices, driver).pipe(Layer.provide(nodePreparedInputAdmissionLayer), Layer.provide(NodeCrypto.layer));
+	}
+};
+//#endregion
+export { NodeSubscriptions, nodePreparedInputAdmissionLayer, nodeScheduledInputAdmissionLayer, NodeSubscriptions_exports as t };
+
+//# sourceMappingURL=NodeSubscriptions.mjs.map

package/dist/NodeSubscriptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeSubscriptions.mjs","names":[],"sources":["../src/NodeSubscriptions.ts"],"sourcesContent":["import { type AgentId } from \"@effect-agent/core/Identifiers\";\nimport { type DurableSubmitAgent } from \"@effect-agent/thread/DurableAgentRuntime\";\nimport { type EventSources } from \"@effect-agent/thread/EventSource\";\nimport { PreparedInputAdmission } from \"@effect-agent/thread/PreparedInputAdmission\";\nimport { PersistedJson } from \"@effect-agent/thread/Records\";\nimport {\n  type ScheduledEnvelope,\n  ScheduledInputAdmission,\n  ScheduledInputRetryable,\n  ScheduleStorageError,\n} from \"@effect-agent/thread/Schedule\";\nimport {\n  type PreparedInput,\n  type SubscriptionAuthorizer,\n  type SubscriptionError,\n  type SubscriptionLimits,\n  type SubscriptionStoreFailure,\n  SubscriptionStore,\n  defaultSubscriptionLimits,\n} from \"@effect-agent/thread/Subscription\";\nimport { type SubscriptionInputBindings } from \"@effect-agent/thread/SubscriptionInput\";\nimport {\n  SubscriptionDriver,\n  SubscriptionIntake,\n  Subscriptions,\n} from \"@effect-agent/thread/Subscriptions\";\nimport { NodeCrypto } from \"@effect/platform-node\";\nimport { Cause, Duration, Effect, Exit, Layer, Option } from \"effect\";\n\nimport { NodeDurableHost } from \"./NodeDurableHost.ts\";\n\nconst passthroughSubmitAgent = (agentId: AgentId): DurableSubmitAgent<typeof PersistedJson> => ({\n  definition: { id: agentId, input: PersistedJson },\n});\n\nconst ambiguous = (): ScheduledInputRetryable =>\n  ScheduledInputRetryable.make({ reason: \"ambiguous\" });\n\nconst corrupt = (operation: string): ScheduleStorageError =>\n  ScheduleStorageError.make({ operation, reason: \"corrupt\" });\n\n/** Ordinary prepared admission through the Scope-owned Node host gate. */\nexport const nodePreparedInputAdmissionLayer: Layer.Layer<\n  PreparedInputAdmission,\n  never,\n  NodeDurableHost\n> = Layer.effect(\n  PreparedInputAdmission,\n  Effect.gen(function* () {\n    const host = yield* NodeDurableHost;\n\n    return PreparedInputAdmission.of({\n      submit: (envelope) =>\n        host\n          .submit(passthroughSubmitAgent(envelope.agentId), envelope.input, {\n            threadId: envelope.threadId,\n            principal: envelope.deliveryPrincipal,\n            idempotencyKey: envelope.admissionKey,\n            definitions: envelope.definitions,\n          })\n          .pipe(\n            Effect.catchTags({\n              AdmissionClosed: () =>\n                Effect.fail(ScheduledInputRetryable.make({ reason: \"host-closed\" })),\n              AgentInputError: () => Effect.fail(corrupt(\"prepared admission input\")),\n              AdmissionConflict: () => Effect.fail(corrupt(\"prepared admission conflict\")),\n              DigestError: () => Effect.fail(ambiguous()),\n              LedgerError: () => Effect.fail(ambiguous()),\n              ThreadStoreError: () => Effect.fail(ambiguous()),\n              ThreadNotMaterialized: () => Effect.fail(ambiguous()),\n              AppendConflict: () => Effect.fail(ambiguous()),\n              FenceRejected: () => Effect.fail(ambiguous()),\n              DurableRuntimeFailpointError: () => Effect.fail(ambiguous()),\n            }),\n          ),\n    });\n  }),\n);\n\nconst preparedFromSchedule = (envelope: ScheduledEnvelope): PreparedInput => ({\n  schemaVersion: 1,\n  threadId: envelope.threadId,\n  deliveryPrincipal: envelope.deliveryPrincipal,\n  agentId: envelope.agentId,\n  definitions: envelope.definitions,\n  input: envelope.input,\n  inputDigest: envelope.inputDigest,\n  admissionKey: envelope.admissionKey,\n  authorization: envelope.authorization,\n});\n\n/** Compatibility adapter retaining the public scheduling admission port. */\nconst nodeScheduledInputAdmissionFromPreparedLayer: Layer.Layer<\n  ScheduledInputAdmission,\n  never,\n  PreparedInputAdmission\n> = Layer.effect(\n  ScheduledInputAdmission,\n  Effect.map(PreparedInputAdmission, (admission) =>\n    ScheduledInputAdmission.of({\n      submit: (envelope) => admission.submit(preparedFromSchedule(envelope)),\n    }),\n  ),\n);\n\nexport const nodeScheduledInputAdmissionLayer: Layer.Layer<\n  ScheduledInputAdmission,\n  never,\n  NodeDurableHost\n> = nodeScheduledInputAdmissionFromPreparedLayer.pipe(\n  Layer.provide(nodePreparedInputAdmissionLayer),\n);\n\nconst reportPassFailure = (cause: Cause.Cause<SubscriptionStoreFailure>): Effect.Effect<boolean> =>\n  Cause.hasInterruptsOnly(cause)\n    ? Effect.interrupt\n    : Effect.logWarning(\"Node subscription pass failed\").pipe(\n        Effect.annotateLogs({\n          failureTag: Option.match(Cause.findErrorOption(cause), {\n            onNone: () => \"Defect\",\n            onSome: (error) => error._tag,\n          }),\n        }),\n        Effect.as(false),\n      );\n\nconst nodeSubscriptionDriverLayer = (\n  limits: SubscriptionLimits,\n): Layer.Layer<never, never, SubscriptionDriver | SubscriptionStore> =>\n  Layer.effectDiscard(\n    Effect.gen(function* () {\n      const driver = yield* SubscriptionDriver;\n      const store = yield* SubscriptionStore;\n\n      const run = Effect.gen(function* () {\n        while (true) {\n          const passSucceeded = yield* driver.runDue.pipe(\n            Effect.map((pass) => pass.failed === 0),\n            Effect.catchCause(reportPassFailure),\n          );\n\n          if (!passSucceeded) {\n            yield* Effect.sleep(Duration.millis(limits.retryMillis));\n            continue;\n          }\n\n          const deadline = yield* store.nextDeadline.pipe(Effect.exit);\n\n          if (Exit.isFailure(deadline)) {\n            yield* reportPassFailure(deadline.cause);\n            yield* Effect.sleep(Duration.millis(limits.retryMillis));\n            continue;\n          }\n\n          const nowMillis = yield* Effect.clockWith((clock) => clock.currentTimeMillis);\n\n          const delay =\n            deadline.value === null\n              ? limits.retryMillis\n              : Math.max(1, Math.min(deadline.value - nowMillis, limits.retryMillis));\n\n          yield* Effect.sleep(Duration.millis(delay));\n        }\n      });\n\n      yield* Effect.forkScoped(run);\n    }),\n  );\n\nexport interface NodeSubscriptionsOptions {\n  readonly limits?: SubscriptionLimits | undefined;\n}\n\n/**\n * One Scope-owned subscription partition in the sole process owning its SQLite database.\n * Indexed polling repairs restart and lost wake state; closing the Scope interrupts the driver.\n */\nexport class NodeSubscriptions {\n  static layer(\n    options: NodeSubscriptionsOptions = {},\n  ): Layer.Layer<\n    Subscriptions | SubscriptionIntake,\n    SubscriptionError,\n    | NodeDurableHost\n    | SubscriptionStore\n    | SubscriptionAuthorizer\n    | EventSources\n    | SubscriptionInputBindings\n  > {\n    const limits = options.limits ?? defaultSubscriptionLimits;\n\n    const publicServices = Layer.merge(\n      Subscriptions.layer(limits),\n      SubscriptionIntake.layer(limits),\n    );\n\n    const driver = nodeSubscriptionDriverLayer(limits).pipe(\n      Layer.provide(SubscriptionDriver.layer(limits)),\n    );\n\n    return Layer.merge(publicServices, driver).pipe(\n      Layer.provide(nodePreparedInputAdmissionLayer),\n      Layer.provide(NodeCrypto.layer),\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/NodeWakeScheduler-DWdHIhWA.d.mts

@@ -0,0 +1,27 @@
+import { SubmissionLedger } from "@effect-agent/thread/SubmissionLedger";
+import { WakeScheduler } from "@effect-agent/thread/WakeScheduler";
+import { Context, Duration, Layer } from "effect";
+declare namespace NodeWakeScheduler_d_exports {
+  export { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer };
+}
+declare const NodeWakeSchedulerConfig_base: Context.ServiceClass<NodeWakeSchedulerConfig, "@effect-agent/platform-node/NodeWakeSchedulerConfig", {
+  /** Interval between ledger scans that re-emit every nonterminal Thread lane. */
+  readonly scanInterval: Duration.Duration;
+}>;
+/** Cadence authority for the Node wake scheduler's ledger-scan fallback loop. */
+declare class NodeWakeSchedulerConfig extends NodeWakeSchedulerConfig_base {
+  static layer(options: {
+    readonly scanInterval: Duration.Duration;
+  }): Layer.Layer<NodeWakeSchedulerConfig>;
+}
+/**
+ * In-process Node `WakeScheduler`: `notify` publishes to a bounded sliding PubSub for prompt
+ * same-process wakeups, and every `wakes` subscription additionally runs a periodic
+ * `SubmissionLedger.scanNonterminal` fallback so a dropped, coalesced, or never-sent notification
+ * can never strand accepted work (persistence §14). Delivery may duplicate; consumers already
+ * treat wakes as pure liveness hints.
+ */
+declare const nodeWakeSchedulerLayer: Layer.Layer<WakeScheduler, never, SubmissionLedger | NodeWakeSchedulerConfig>;
+//#endregion
+export { NodeWakeScheduler_d_exports as n, nodeWakeSchedulerLayer as r, NodeWakeSchedulerConfig as t };
+//# sourceMappingURL=NodeWakeScheduler-DWdHIhWA.d.mts.map

package/dist/NodeWakeScheduler.d.mts

@@ -0,0 +1,2 @@
+import { r as nodeWakeSchedulerLayer, t as NodeWakeSchedulerConfig } from "./NodeWakeScheduler-DWdHIhWA.mjs";
+export { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer };

package/dist/NodeWakeScheduler.mjs

@@ -0,0 +1,61 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import "@effect-agent/core/Identifiers";
+import { SubmissionLedger } from "@effect-agent/thread/SubmissionLedger";
+import { WakeScheduler, makeWakeSubscriptionHub } from "@effect-agent/thread/WakeScheduler";
+import { Context, Effect, Layer, PubSub, Stream } from "effect";
+//#region src/NodeWakeScheduler.ts
+var NodeWakeScheduler_exports = /* @__PURE__ */ __exportAll({
+	NodeWakeSchedulerConfig: () => NodeWakeSchedulerConfig,
+	nodeWakeSchedulerLayer: () => nodeWakeSchedulerLayer
+});
+/**
+* Bounded in-process wake buffer. Wake hints are droppable by contract (the ledger-scan fallback
+* keeps liveness), so a full buffer slides out the oldest hint instead of growing without bound.
+*/
+const WAKE_BUFFER_CAPACITY = 1024;
+/** Cadence authority for the Node wake scheduler's ledger-scan fallback loop. */
+var NodeWakeSchedulerConfig = class NodeWakeSchedulerConfig extends Context.Service()("@effect-agent/platform-node/NodeWakeSchedulerConfig") {
+	static layer(options) {
+		return Layer.succeed(NodeWakeSchedulerConfig)({ scanInterval: options.scanInterval });
+	}
+};
+const makeWakeScheduler = Effect.gen(function* () {
+	const ledger = yield* SubmissionLedger;
+	const config = yield* NodeWakeSchedulerConfig;
+	const hints = yield* PubSub.sliding(WAKE_BUFFER_CAPACITY);
+	const progress = yield* makeWakeSubscriptionHub;
+	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
+	/**
+	* One fallback scan: every Thread lane with nonterminal work, deduplicated. A scan
+	* failure degrades to "no hints this round" — the wake channel has no error contract and the
+	* next round retries — but is logged so a persistently failing ledger stays visible.
+	*/
+	const scanOnce = Stream.runCollect(ledger.scanNonterminal).pipe(Effect.map((snapshots) => {
+		const lanes = /* @__PURE__ */ new Set();
+		for (const snapshot of snapshots) lanes.add(snapshot.threadId);
+		return [...lanes];
+	}), Effect.catch((error) => Effect.logWarning("NodeWakeScheduler fallback scan failed", error).pipe(Effect.as([]))));
+	/**
+	* Deployment §3: correctness must not depend on in-memory notifications, so every `wakes` run
+	* merges its PubSub subscription with a Clock-driven ledger-scan loop. Both live entirely in
+	* the consuming run's Scope; no fiber outlives its subscriber.
+	*/
+	const fallbackScans = Stream.fromIterableEffectRepeat(Effect.sleep(config.scanInterval).pipe(Effect.andThen(scanOnce)));
+	return WakeScheduler.of({
+		notify: (threadId) => progress.notify(threadId).pipe(Effect.andThen(PubSub.publish(hints, threadId)), Effect.asVoid),
+		subscribe: progress.subscribe,
+		wakes: Stream.merge(Stream.fromPubSub(hints), fallbackScans)
+	});
+});
+/**
+* In-process Node `WakeScheduler`: `notify` publishes to a bounded sliding PubSub for prompt
+* same-process wakeups, and every `wakes` subscription additionally runs a periodic
+* `SubmissionLedger.scanNonterminal` fallback so a dropped, coalesced, or never-sent notification
+* can never strand accepted work (persistence §14). Delivery may duplicate; consumers already
+* treat wakes as pure liveness hints.
+*/
+const nodeWakeSchedulerLayer = Layer.effect(WakeScheduler)(makeWakeScheduler);
+//#endregion
+export { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer, NodeWakeScheduler_exports as t };
+
+//# sourceMappingURL=NodeWakeScheduler.mjs.map

package/dist/NodeWakeScheduler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeWakeScheduler.mjs","names":[],"sources":["../src/NodeWakeScheduler.ts"],"sourcesContent":["import { type ThreadId } from \"@effect-agent/core/Identifiers\";\nimport { SubmissionLedger } from \"@effect-agent/thread/SubmissionLedger\";\nimport { makeWakeSubscriptionHub, WakeScheduler } from \"@effect-agent/thread/WakeScheduler\";\nimport type { Duration } from \"effect\";\nimport { Context, Effect, Layer, PubSub, Stream } from \"effect\";\n\n/**\n * Bounded in-process wake buffer. Wake hints are droppable by contract (the ledger-scan fallback\n * keeps liveness), so a full buffer slides out the oldest hint instead of growing without bound.\n */\nconst WAKE_BUFFER_CAPACITY = 1_024;\n\n/** Cadence authority for the Node wake scheduler's ledger-scan fallback loop. */\nexport class NodeWakeSchedulerConfig extends Context.Service<\n  NodeWakeSchedulerConfig,\n  {\n    /** Interval between ledger scans that re-emit every nonterminal Thread lane. */\n    readonly scanInterval: Duration.Duration;\n  }\n>()(\"@effect-agent/platform-node/NodeWakeSchedulerConfig\") {\n  static layer(options: {\n    readonly scanInterval: Duration.Duration;\n  }): Layer.Layer<NodeWakeSchedulerConfig> {\n    return Layer.succeed(NodeWakeSchedulerConfig)({ scanInterval: options.scanInterval });\n  }\n}\n\nconst makeWakeScheduler = Effect.gen(function* () {\n  const ledger = yield* SubmissionLedger;\n  const config = yield* NodeWakeSchedulerConfig;\n  const hints = yield* PubSub.sliding<ThreadId>(WAKE_BUFFER_CAPACITY);\n  const progress = yield* makeWakeSubscriptionHub;\n\n  yield* Effect.addFinalizer(() => PubSub.shutdown(hints));\n\n  /**\n   * One fallback scan: every Thread lane with nonterminal work, deduplicated. A scan\n   * failure degrades to \"no hints this round\" — the wake channel has no error contract and the\n   * next round retries — but is logged so a persistently failing ledger stays visible.\n   */\n  const scanOnce: Effect.Effect<ReadonlyArray<ThreadId>> = Stream.runCollect(\n    ledger.scanNonterminal,\n  ).pipe(\n    Effect.map((snapshots) => {\n      const lanes = new Set<ThreadId>();\n\n      for (const snapshot of snapshots) {\n        lanes.add(snapshot.threadId);\n      }\n\n      return [...lanes];\n    }),\n    Effect.catch((error) =>\n      Effect.logWarning(\"NodeWakeScheduler fallback scan failed\", error).pipe(\n        Effect.as([] as ReadonlyArray<ThreadId>),\n      ),\n    ),\n  );\n\n  /**\n   * Deployment §3: correctness must not depend on in-memory notifications, so every `wakes` run\n   * merges its PubSub subscription with a Clock-driven ledger-scan loop. Both live entirely in\n   * the consuming run's Scope; no fiber outlives its subscriber.\n   */\n  const fallbackScans: Stream.Stream<ThreadId> = Stream.fromIterableEffectRepeat(\n    Effect.sleep(config.scanInterval).pipe(Effect.andThen(scanOnce)),\n  );\n\n  return WakeScheduler.of({\n    notify: (threadId) =>\n      progress\n        .notify(threadId)\n        .pipe(Effect.andThen(PubSub.publish(hints, threadId)), Effect.asVoid),\n    subscribe: progress.subscribe,\n    wakes: Stream.merge(Stream.fromPubSub(hints), fallbackScans),\n  });\n});\n\n/**\n * In-process Node `WakeScheduler`: `notify` publishes to a bounded sliding PubSub for prompt\n * same-process wakeups, and every `wakes` subscription additionally runs a periodic\n * `SubmissionLedger.scanNonterminal` fallback so a dropped, coalesced, or never-sent notification\n * can never strand accepted work (persistence §14). Delivery may duplicate; consumers already\n * treat wakes as pure liveness hints.\n */\nexport const nodeWakeSchedulerLayer: Layer.Layer<\n  WakeScheduler,\n  never,\n  SubmissionLedger | NodeWakeSchedulerConfig\n> = Layer.effect(WakeScheduler)(makeWakeScheduler);\n"],"mappings":";;;;;;;;;;;;;;AAUA,MAAM,uBAAuB;;AAG7B,IAAa,0BAAb,MAAa,gCAAgC,QAAQ,QAMnD,CAAC,CAAC,qDAAqD,CAAC,CAAC;CACzD,OAAO,MAAM,SAE4B;EACvC,OAAO,MAAM,QAAQ,uBAAuB,CAAC,CAAC,EAAE,cAAc,QAAQ,aAAa,CAAC;CACtF;AACF;AAEA,MAAM,oBAAoB,OAAO,IAAI,aAAa;CAChD,MAAM,SAAS,OAAO;CACtB,MAAM,SAAS,OAAO;CACtB,MAAM,QAAQ,OAAO,OAAO,QAAkB,oBAAoB;CAClE,MAAM,WAAW,OAAO;CAExB,OAAO,OAAO,mBAAmB,OAAO,SAAS,KAAK,CAAC;;;;;;CAOvD,MAAM,WAAmD,OAAO,WAC9D,OAAO,eACT,CAAC,CAAC,KACA,OAAO,KAAK,cAAc;EACxB,MAAM,wBAAQ,IAAI,IAAc;EAEhC,KAAK,MAAM,YAAY,WACrB,MAAM,IAAI,SAAS,QAAQ;EAG7B,OAAO,CAAC,GAAG,KAAK;CAClB,CAAC,GACD,OAAO,OAAO,UACZ,OAAO,WAAW,0CAA0C,KAAK,CAAC,CAAC,KACjE,OAAO,GAAG,CAAC,CAA4B,CACzC,CACF,CACF;;;;;;CAOA,MAAM,gBAAyC,OAAO,yBACpD,OAAO,MAAM,OAAO,YAAY,CAAC,CAAC,KAAK,OAAO,QAAQ,QAAQ,CAAC,CACjE;CAEA,OAAO,cAAc,GAAG;EACtB,SAAS,aACP,SACG,OAAO,QAAQ,CAAC,CAChB,KAAK,OAAO,QAAQ,OAAO,QAAQ,OAAO,QAAQ,CAAC,GAAG,OAAO,MAAM;EACxE,WAAW,SAAS;EACpB,OAAO,OAAO,MAAM,OAAO,WAAW,KAAK,GAAG,aAAa;CAC7D,CAAC;AACH,CAAC;;;;;;;;AASD,MAAa,yBAIT,MAAM,OAAO,aAAa,CAAC,CAAC,iBAAiB"}

package/dist/NodeWorkflow.d.mts

@@ -0,0 +1,27 @@
+import { Cause, Duration, Layer, Schema } from "effect";
+import { WorkflowDispatchError, WorkflowDispatchStore, WorkflowRepairTrigger } from "@effect-agent/workflow/WorkflowDispatch";
+import { SqlClient } from "effect/unstable/sql";
+//#region src/NodeWorkflow.d.ts
+/**
+ * Durable dispatch outbox over an application-supplied SqlClient. This adapter uses
+ * SQLite/PostgreSQL SQL syntax and is certified with SQLite. It does not own an engine
+ * or a database connection. Agent admission, dispatch persistence, and native Workflow
+ * storage are separate commits; the registered repair trigger closes those gaps.
+ * Stored version or shape mismatches fail typed and require an explicit data reset.
+ */
+declare class SqlWorkflowDispatchStore {
+  static readonly layer: Layer.Layer<WorkflowDispatchStore, WorkflowDispatchError, SqlClient.SqlClient>;
+}
+declare const NodeWorkflowRepairConfigError_base: Schema.Class<NodeWorkflowRepairConfigError, Schema.TaggedStruct<"NodeWorkflowRepairConfigError", {
+  readonly message: Schema.String;
+}>, Cause.YieldableError>;
+declare class NodeWorkflowRepairConfigError extends NodeWorkflowRepairConfigError_base {}
+/** A host-scoped startup and polling trigger. No ordinary Node agent worker is started. */
+declare class NodeWorkflowRepairTrigger {
+  static layer(options?: {
+    readonly interval?: Duration.Input;
+  }): Layer.Layer<WorkflowRepairTrigger, NodeWorkflowRepairConfigError>;
+}
+//#endregion
+export { NodeWorkflowRepairConfigError, NodeWorkflowRepairTrigger, SqlWorkflowDispatchStore };
+//# sourceMappingURL=NodeWorkflow.d.mts.map