@effect-agent/platform-node 0.1.0-beta.42 → 0.1.0-beta.45

package/src/host.ts

@@ -1,6 +1,5 @@
 import type { ThreadId, SubmissionId } from "@effect-agent/core";
 import {
-  compileRegistrations,
   type AgentRegistration,
   DurableAgentRuntime,
   type AbortCommand,
@@ -31,15 +30,14 @@ import {
   type RetryCommand,
   type Settlement,
 } from "@effect-agent/thread";
-import { NodeCrypto } from "@effect/platform-node";
 import { type Stream, Context, type Crypto, Effect, Layer, Ref, Schema } from "effect";
 
 import {
-  NodeDurableRuntime,
-  NodeDurableRuntimeConfig,
-  type NodeDurableRuntimeInitializationError,
-  type NodeDurableRuntimeOptions,
-  type NodeDurableRuntimeServices,
+  NodeDurableAgentRuntime,
+  NodeDurableAgentRuntimeConfig,
+  type NodeDurableAgentRuntimeInitializationError,
+  type NodeDurableAgentRuntimeOptions,
+  type NodeDurableAgentRuntimeServices,
 } from "./layers.ts";
 
 /**
@@ -50,74 +48,74 @@ export class AdmissionClosed extends Schema.TaggedError<AdmissionClosed>()("Admi
   message: Schema.String,
 }) {}
 
-const makeHost = (bindings: ReadonlyArray<ResolvedBinding>) =>
-  Effect.gen(function* () {
-    const runtime = yield* DurableAgentRuntime;
-    const config = yield* NodeDurableRuntimeConfig;
+const makeHost = Effect.gen(function* () {
+  const runtime = yield* DurableAgentRuntime;
+  const config = yield* NodeDurableAgentRuntimeConfig;
 
-    // Startup gate (deployment §5, plan §host): configuration decoding and storage compatibility
-    // already gated this Layer's dependencies; the last gate before admission opens is recovering
-    // EVERY nonterminal Submission. Work needing a live Agent Binding is reported `deferred` and
-    // stays a visible obligation for `runWorkers`; lanes durably blocked on an Unknown Outcome are
-    // reported `unknown` and wait for the authorized `resolveUnknown` path (DUR-017) — they consume
-    // no worker permit while the settlement obligation stays owed.
-    const startupRecovery = yield* runtime.runRecovery;
+  // Startup gate (deployment §5, plan §host): configuration decoding and storage compatibility
+  // already gated this Layer's dependencies; the last gate before admission opens is recovering
+  // EVERY nonterminal Submission. Work needing a live Agent Binding is reported `deferred` and
+  // stays a visible obligation for `runWorkers`; lanes durably blocked on an Unknown Outcome are
+  // reported `unknown` and wait for the authorized `resolveUnknown` path (DUR-017) — they consume
+  // no worker permit while the settlement obligation stays owed.
+  const startupRecovery = yield* runtime.runRecovery;
 
-    const admission = yield* Ref.make(true);
-    // Shutdown step 1 (DEPLOY-005): admission closes before the ownership drain in the runtime
-    // Layer below releases claims and before the stores close in reverse acquisition order.
-    yield* Effect.addFinalizer(() => Ref.set(admission, false));
+  const admission = yield* Ref.make(true);
 
-    const requireAdmission: Effect.Effect<void, AdmissionClosed> = Ref.get(admission).pipe(
-      Effect.flatMap((open) =>
-        open
-          ? Effect.void
-          : Effect.fail(
-              AdmissionClosed.make({ message: "The host is shutting down; admission is closed." }),
-            ),
-      ),
-    );
+  // Shutdown step 1 (DEPLOY-005): admission closes before the ownership drain in the runtime
+  // Layer below releases claims and before the stores close in reverse acquisition order.
+  yield* Effect.addFinalizer(() => Ref.set(admission, false));
 
-    const submit = <InputSchema extends Schema.Top>(
-      agent: DurableSubmitAgent<InputSchema>,
-      input: InputSchema["Type"],
-      options: DurableSubmitOptions,
-    ): Effect.Effect<
-      Receipt,
-      AdmissionClosed | DurableSubmitFailure,
-      InputSchema["EncodingServices"]
-    > => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));
+  const requireAdmission: Effect.Effect<void, AdmissionClosed> = 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 = <InputSchema extends Schema.Top>(
+    agent: DurableSubmitAgent<InputSchema>,
+    input: InputSchema["Type"],
+    options: DurableSubmitOptions,
+  ): Effect.Effect<
+    Receipt,
+    AdmissionClosed | DurableSubmitFailure,
+    InputSchema["EncodingServices"]
+  > => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));
 
-    const runWorkers = <A, E, R>(worker: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> =>
-      Effect.forEach(
-        Array.from({ length: config.workerConcurrency }, (_, index) => index),
-        () => worker,
-        { concurrency: "unbounded", discard: true },
-      );
+  const runWorkers = <A, E, R>(worker: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> =>
+    Effect.forEach(
+      Array.from({ length: config.workerConcurrency }, (_, index) => index),
+      () => worker,
+      { concurrency: "unbounded", discard: true },
+    );
 
-    // S2 multi-binding pool: every claimed head resolves its exact registered Binding through
-    // the host's exact registrations, so one bounded
-    // pool serves parent and child lanes — the spec §12 smallest-pool suspension/wakeup proof
-    // runs `workerConcurrency: 1` over exactly this loop.
-    const runResolvedWorkers = runWorkers(runtime.runResolvedWorker(bindings));
+  // S2 multi-binding pool: every claimed head resolves its exact registered Binding through
+  // the host's exact registrations, so one bounded
+  // pool serves parent and child lanes — the spec §12 smallest-pool suspension/wakeup proof
+  // runs `workerConcurrency: 1` over exactly this loop.
+  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,
-    });
+  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).
@@ -209,56 +207,53 @@ export class NodeDurableHost extends Context.Service<
     AuthorizationRequirements = never,
   >(
     registrations: Entries,
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     >,
   ) {
-    return Layer.unwrap(
-      Effect.map(compileRegistrations(registrations), (bindings) =>
-        NodeDurableHost.layerStack({ ...options, bindings }),
-      ),
-    ).pipe(Layer.provide(NodeCrypto.layer));
+    return NodeDurableHost.layer.pipe(
+      Layer.provideMerge(NodeDurableAgentRuntime.layerRegistered(registrations, options)),
+    );
   }
 
   /**
-   * Host gates over an assembled `NodeDurableRuntime` stack. Bindings must carry the exact
-   * digests stored by submitters. Omission registers no Agents, so resolved work fails closed.
+   * Host gates over an assembled `NodeDurableAgentRuntime` stack. The runtime Layer owns
+   * executable registrations; omission registers no Agents, so resolved work fails closed.
    */
-  static readonly layer = (
-    bindings: ReadonlyArray<ResolvedBinding> = [],
-  ): Layer.Layer<
+  static readonly layer: Layer.Layer<
     NodeDurableHost,
     DurableWorkerFailure,
-    DurableAgentRuntime | NodeDurableRuntimeConfig
-  > => Layer.effect(NodeDurableHost)(makeHost(bindings));
+    DurableAgentRuntime | NodeDurableAgentRuntimeConfig
+  > = Layer.effect(NodeDurableHost)(makeHost);
 
-  /** The complete DN host: `NodeDurableRuntime.layer(options)` plus the host lifecycle gates. */
+  /** The complete DN host: `NodeDurableAgentRuntime.layer(options)` plus the host lifecycle gates. */
   static layerStack<
     ContextError = never,
     ContextRequirements = never,
     AuthorizationError = never,
     AuthorizationRequirements = never,
   >(
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     > & { readonly bindings?: ReadonlyArray<ResolvedBinding> },
   ): Layer.Layer<
-    NodeDurableHost | NodeDurableRuntimeServices,
+    NodeDurableHost | NodeDurableAgentRuntimeServices,
     | DurableWorkerFailure
-    | NodeDurableRuntimeInitializationError
+    | NodeDurableAgentRuntimeInitializationError
     | ContextError
     | AuthorizationError,
     Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>
   > {
     const { bindings = [], ...runtimeOptions } = options;
-    return NodeDurableHost.layer(bindings).pipe(
-      Layer.provideMerge(NodeDurableRuntime.layer(runtimeOptions)),
+
+    return NodeDurableHost.layer.pipe(
+      Layer.provideMerge(NodeDurableAgentRuntime.layerWithBindings(bindings, runtimeOptions)),
     );
   }
 }

package/src/layers.ts

@@ -19,6 +19,8 @@ import {
   type SqliteStorageInitializationError,
 } from "@effect-agent/storage-sqlite";
 import {
+  type AgentRegistration,
+  type ResolvedBinding,
   type ScheduleStore,
   type ThreadStore,
   type WakeScheduler,
@@ -42,6 +44,7 @@ import { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer } from "./wake-schedule
 
 const PositiveMillis = Schema.Int.check(Schema.isGreaterThan(0));
 const NonNegativeMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+
 const WorkerConcurrency = Schema.Int.check(
   Schema.isGreaterThanOrEqualTo(1),
   Schema.isLessThanOrEqualTo(64),
@@ -61,8 +64,8 @@ export class NodePlatformConfigError extends Schema.TaggedError<NodePlatformConf
  * construction, exposed as a typed service). Every cadence is in milliseconds and every bound is
  * finite; `workerConcurrency` caps how many worker loops `NodeDurableHost.runWorkers` drives.
  */
-export class NodeDurableRuntimeConfigValue extends Schema.Class<NodeDurableRuntimeConfigValue>(
-  "@effect-agent/platform-node/NodeDurableRuntimeConfigValue",
+export class NodeDurableAgentRuntimeConfigValue extends Schema.Class<NodeDurableAgentRuntimeConfigValue>(
+  "@effect-agent/platform-node/NodeDurableAgentRuntimeConfigValue",
 )({
   /** SQLite database file backing BOTH the Thread Log and the Submission Ledger. */
   filename: Schema.NonEmptyString,
@@ -89,17 +92,17 @@ export class NodeDurableRuntimeConfigValue extends Schema.Class<NodeDurableRunti
 }) {}
 
 /** Explicit configuration authority for the assembled Node durable runtime. */
-export class NodeDurableRuntimeConfig extends Context.Service<
-  NodeDurableRuntimeConfig,
-  NodeDurableRuntimeConfigValue
->()("@effect-agent/platform-node/NodeDurableRuntimeConfig") {}
+export class NodeDurableAgentRuntimeConfig extends Context.Service<
+  NodeDurableAgentRuntimeConfig,
+  NodeDurableAgentRuntimeConfigValue
+>()("@effect-agent/platform-node/NodeDurableAgentRuntimeConfig") {}
 
 /**
- * Raw (unvalidated) construction options for `NodeDurableRuntime.layer`. Optional fields default
+ * Raw (unvalidated) construction options for `NodeDurableAgentRuntime.layer`. Optional fields default
  * to the documented production values; everything is schema-decoded into
- * `NodeDurableRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
+ * `NodeDurableAgentRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
  */
-export interface NodeDurableRuntimeOptions<
+export interface NodeDurableAgentRuntimeOptions<
   ContextError = never,
   ContextRequirements = never,
   AuthorizationError = never,
@@ -160,25 +163,25 @@ export interface NodeDurableRuntimeOptions<
 }
 
 /** Built-in construction failures. `layer` also preserves supplied service Layers' errors. */
-export type NodeDurableRuntimeInitializationError =
+export type NodeDurableAgentRuntimeInitializationError =
   | NodePlatformConfigError
   | SqliteStorageInitializationError;
 
-/** The services `NodeDurableRuntime.layer` provides. */
-export type NodeDurableRuntimeServices =
+/** The services `NodeDurableAgentRuntime.layer` provides. */
+export type NodeDurableAgentRuntimeServices =
   | DurableAgentRuntime
   | SubmissionLedger
   | ThreadStore
   | ScheduleStore
   | WakeScheduler
   | DurableRuntimeConfig
-  | NodeDurableRuntimeConfig;
+  | NodeDurableAgentRuntimeConfig;
 
-const decodeConfigValue = Schema.decodeUnknownEffect(NodeDurableRuntimeConfigValue);
+const decodeConfigValue = Schema.decodeUnknownEffect(NodeDurableAgentRuntimeConfigValue);
 
 const configFromOptions = (
-  options: Omit<NodeDurableRuntimeOptions, "runContext" | "toolAuthorization">,
-): Effect.Effect<NodeDurableRuntimeConfigValue, NodePlatformConfigError> =>
+  options: Omit<NodeDurableAgentRuntimeOptions, "runContext" | "toolAuthorization">,
+): Effect.Effect<NodeDurableAgentRuntimeConfigValue, NodePlatformConfigError> =>
   decodeConfigValue({
     filename: options.filename,
     deploymentId: options.deploymentId,
@@ -203,26 +206,31 @@ const configFromOptions = (
   );
 
 /** SQLite storage configuration derived from the single validated Node configuration. */
-const sqliteStorageConfigLayer: Layer.Layer<SqliteStorageConfig, never, NodeDurableRuntimeConfig> =
-  Layer.effect(SqliteStorageConfig)(
-    Effect.gen(function* () {
-      const config = yield* NodeDurableRuntimeConfig;
-      return SqliteStorageConfigValue.make({
-        observationPollInterval: config.observationPollInterval,
-        busyTimeout: config.busyTimeout,
-        ownershipLeaseDuration: config.ownershipLeaseDuration,
-        verifyOnOpen: config.verifyOnOpen,
-      });
-    }),
-  );
+const sqliteStorageConfigLayer: Layer.Layer<
+  SqliteStorageConfig,
+  never,
+  NodeDurableAgentRuntimeConfig
+> = Layer.effect(SqliteStorageConfig)(
+  Effect.gen(function* () {
+    const config = yield* NodeDurableAgentRuntimeConfig;
+
+    return SqliteStorageConfigValue.make({
+      observationPollInterval: config.observationPollInterval,
+      busyTimeout: config.busyTimeout,
+      ownershipLeaseDuration: config.ownershipLeaseDuration,
+      verifyOnOpen: config.verifyOnOpen,
+    });
+  }),
+);
 
 /** Thread coordinator configuration derived from the single validated Node configuration. */
 const durableRuntimeConfigLayer = (
   estimateCostMicrousd: RunCostEstimator | undefined,
-): Layer.Layer<DurableRuntimeConfig, never, NodeDurableRuntimeConfig> =>
+): Layer.Layer<DurableRuntimeConfig, never, NodeDurableAgentRuntimeConfig> =>
   Layer.effect(DurableRuntimeConfig)(
     Effect.gen(function* () {
-      const config = yield* NodeDurableRuntimeConfig;
+      const config = yield* NodeDurableAgentRuntimeConfig;
+
       return DurableRuntimeConfig.make({
         deploymentId: config.deploymentId,
         producerId: config.producerId,
@@ -238,10 +246,11 @@ const durableRuntimeConfigLayer = (
 const wakeSchedulerConfigLayer: Layer.Layer<
   NodeWakeSchedulerConfig,
   never,
-  NodeDurableRuntimeConfig
+  NodeDurableAgentRuntimeConfig
 > = Layer.effect(NodeWakeSchedulerConfig)(
   Effect.gen(function* () {
-    const config = yield* NodeDurableRuntimeConfig;
+    const config = yield* NodeDurableAgentRuntimeConfig;
+
     return { scanInterval: Duration.millis(config.wakeScanInterval) };
   }),
 );
@@ -252,6 +261,7 @@ const releaseTrackedOwnership = (
 ): Effect.Effect<void> =>
   Effect.gen(function* () {
     const tracked = yield* Ref.getAndSet(registry, new Map<SubmissionId, OwnershipToken>());
+
     for (const [submissionId, ownershipToken] of tracked) {
       yield* ledger
         .releaseOwnership(ReleaseOwnershipRequest.make({ submissionId, ownershipToken }))
@@ -280,16 +290,20 @@ export const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissio
   Layer.effect(SubmissionLedger)(
     Effect.gen(function* () {
       const ledger = yield* SubmissionLedger;
+
       const registry = yield* Ref.make<ReadonlyMap<SubmissionId, OwnershipToken>>(
         new Map<SubmissionId, OwnershipToken>(),
       );
 
       const track = (submissionId: SubmissionId, ownershipToken: OwnershipToken) =>
         Ref.update(registry, (tracked) => new Map(tracked).set(submissionId, ownershipToken));
+
       const untrack = (submissionId: SubmissionId) =>
         Ref.update(registry, (tracked) => {
           const next = new Map(tracked);
+
           next.delete(submissionId);
+
           return next;
         });
 
@@ -364,7 +378,7 @@ export const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissio
  * verified during construction: an incompatible database file fails the Layer with
  * `SqliteStorageCompatibilityError` before anything is mutated (DEPLOY-008).
  */
-export class NodeDurableRuntime {
+export class NodeDurableAgentRuntime {
   /** Validated configuration Layer; fails typed when the supplied options are out of bounds. */
   static configLayer<
     ContextError = never,
@@ -372,14 +386,14 @@ export class NodeDurableRuntime {
     AuthorizationError = never,
     AuthorizationRequirements = never,
   >(
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     >,
-  ): Layer.Layer<NodeDurableRuntimeConfig, NodePlatformConfigError> {
-    return Layer.effect(NodeDurableRuntimeConfig)(configFromOptions(options));
+  ): Layer.Layer<NodeDurableAgentRuntimeConfig, NodePlatformConfigError> {
+    return Layer.effect(NodeDurableAgentRuntimeConfig)(configFromOptions(options));
   }
 
   /** The full DN runtime stack over one SQLite file. */
@@ -389,20 +403,83 @@ export class NodeDurableRuntime {
     AuthorizationError = never,
     AuthorizationRequirements = never,
   >(
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     >,
   ): Layer.Layer<
-    NodeDurableRuntimeServices,
-    NodeDurableRuntimeInitializationError | ContextError | AuthorizationError,
+    NodeDurableAgentRuntimeServices,
+    NodeDurableAgentRuntimeInitializationError | ContextError | AuthorizationError,
     Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>
   > {
-    return Layer.unwrap(
+    return NodeDurableAgentRuntime.assemble(DurableAgentRuntime.layerWithServices, options);
+  }
+
+  /** Own typed executable registrations for every worker using this Node runtime. */
+  static layerRegistered<
+    const Entries extends ReadonlyArray<AgentRegistration>,
+    ContextError = never,
+    ContextRequirements = never,
+    AuthorizationError = never,
+    AuthorizationRequirements = never,
+  >(
+    registrations: Entries,
+    options: NodeDurableAgentRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
+  ) {
+    return NodeDurableAgentRuntime.assemble(
+      DurableAgentRuntime.layerRegistered(registrations),
+      options,
+    );
+  }
+
+  /** Construct from registrations already resolved within the enclosing application Scope. */
+  static layerWithBindings<
+    ContextError = never,
+    ContextRequirements = never,
+    AuthorizationError = never,
+    AuthorizationRequirements = never,
+  >(
+    bindings: ReadonlyArray<ResolvedBinding>,
+    options: NodeDurableAgentRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
+  ) {
+    return NodeDurableAgentRuntime.assemble(
+      DurableAgentRuntime.layerWithBindings(bindings),
+      options,
+    );
+  }
+
+  private static assemble<
+    RuntimeError,
+    RuntimeRequirements,
+    ContextError,
+    ContextRequirements,
+    AuthorizationError,
+    AuthorizationRequirements,
+  >(
+    runtimeLayer: Layer.Layer<DurableAgentRuntime, RuntimeError, RuntimeRequirements>,
+    options: NodeDurableAgentRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
+  ) {
+    const assembled = Layer.unwrap(
       Effect.map(configFromOptions(options), (config) => {
-        const nodeConfigLayer = Layer.succeed(NodeDurableRuntimeConfig)(config);
+        const nodeConfigLayer = Layer.succeed(NodeDurableAgentRuntimeConfig)(config);
+
         const infrastructure = Layer.mergeAll(
           sqliteStorageConfigLayer,
           storageFailpointLayer({
@@ -412,15 +489,19 @@ export class NodeDurableRuntime {
           SqliteClient.layer({ filename: config.filename }),
           NodeCrypto.layer,
         );
+
         const runtimeFailpointLayer =
           options.runtimeFailpoint === undefined
             ? DurableRuntimeFailpoint.layer
             : Layer.succeed(DurableRuntimeFailpoint)({ hit: options.runtimeFailpoint });
+
         const reconcilerLayer = options.toolReconciler ?? ToolReconciler.uncertain;
+
         const observerLayer =
           options.toolFailureObserver === undefined
             ? Layer.succeed(CurrentToolFailureObserver)(undefined)
             : toolFailureObserverLayer(options.toolFailureObserver);
+
         const ports = Layer.mergeAll(
           threadStoreLayer,
           scheduleStoreLayer,
@@ -428,7 +509,8 @@ export class NodeDurableRuntime {
             Layer.provideMerge(ownershipDrainLayer.pipe(Layer.provide(submissionLedgerLayer))),
           ),
         );
-        return DurableAgentRuntime.layerWithServices.pipe(
+
+        return runtimeLayer.pipe(
           Layer.provideMerge(
             Layer.mergeAll(ports, durableRuntimeConfigLayer(options.estimateCostMicrousd)),
           ),
@@ -451,5 +533,13 @@ export class NodeDurableRuntime {
         );
       }),
     );
+
+    const runtime: Layer.Layer<
+      NodeDurableAgentRuntimeServices,
+      Layer.Error<typeof assembled>,
+      Layer.Services<typeof assembled>
+    > = assembled;
+
+    return runtime;
   }
 }

package/src/scheduling.ts

@@ -22,7 +22,9 @@ export const nodeScheduleWakeLayer: Layer.Layer<ScheduleWake> = Layer.effect(
   Effect.gen(function* () {
     const hints = yield* PubSub.sliding<void>(1);
     const subscription = yield* PubSub.subscribe(hints);
+
     yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
+
     return ScheduleWake.of({
       notify: PubSub.publish(hints, undefined).pipe(Effect.asVoid),
       await: PubSub.take(subscription),
@@ -58,20 +60,25 @@ const nodeSchedulingDriverLayer = (
             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)));
         }
       });
@@ -97,10 +104,12 @@ export class NodeScheduling {
     NodeDurableHost | ScheduleStore | ScheduleAuthorizer
   > {
     const limits = options.limits ?? defaultSchedulingLimits;
+
     const schedulingWithDriver = nodeSchedulingDriverLayer(limits).pipe(
       Layer.provide(ScheduleDriver.layer(limits)),
       Layer.merge(Scheduling.layer(limits)),
     );
+
     return schedulingWithDriver.pipe(
       Layer.provide(
         Layer.mergeAll(nodeScheduledInputAdmissionLayer, nodeScheduleWakeLayer, NodeCrypto.layer),

package/src/subscriptions.ts

@@ -44,6 +44,7 @@ export const nodePreparedInputAdmissionLayer: Layer.Layer<
   PreparedInputAdmission,
   Effect.gen(function* () {
     const host = yield* NodeDurableHost;
+
     return PreparedInputAdmission.of({
       submit: (envelope) =>
         host
@@ -140,6 +141,7 @@ const nodeSubscriptionDriverLayer = (
           }
 
           const deadline = yield* store.nextDeadline.pipe(Effect.exit);
+
           if (Exit.isFailure(deadline)) {
             yield* reportPassFailure(deadline.cause);
             yield* Effect.sleep(Duration.millis(limits.retryMillis));
@@ -147,10 +149,12 @@ const nodeSubscriptionDriverLayer = (
           }
 
           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));
         }
       });
@@ -180,13 +184,16 @@ export class NodeSubscriptions {
     | SubscriptionInputBindings
   > {
     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),