@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/DeferredPersistence.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Durable deferred delivery and absolute clock scheduling.
+ *
+ * @since 0.1.0
+ */
+import { type DurableClock, type DurableDeferred, type Flow, FlowRuntime } from "@smthrs/flow";
+import { Journal } from "@smthrs/journal";
+import type { Ownership } from "@smthrs/run-store";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Schedule from "effect/Schedule";
+import type * as Scope from "effect/Scope";
+import * as DurableEngineState from "../DurableEngineState.ts";
+/**
+ * Reasons passed to the single claim-gated resume scheduler.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ResumeReason = "deferred" | "clock";
+/**
+ * Dependencies for durable deferred and clock persistence.
+ *
+ * `scheduleResume` must enter the run coordinator and ownership claim path. It
+ * must never invoke a flow handler directly.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Dependencies {
+    readonly owner: Ownership.OwnerId;
+    readonly journalSource: string;
+    readonly scheduleResume: (flowName: string, executionId: string, reason: ResumeReason, sourceId?: string | undefined) => Effect.Effect<void>;
+    /**
+     * Redispatch policy for a durable clock whose fire failed. Defaults to
+     * {@link defaultFireRetryPolicy}; a composition supplies its own the way
+     * the engine's `suspendedRetryPolicy` option is supplied, rather than
+     * editing the constant.
+     */
+    readonly fireRetryPolicy?: FireRetryPolicy | undefined;
+}
+/**
+ * Encoded deferred completion with optional opaque correlation metadata.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface DeferredDoneOptions {
+    readonly flowName: string;
+    readonly executionId: string;
+    readonly deferredName: string;
+    readonly exit: Exit.Exit<unknown, unknown>;
+    readonly metadata?: unknown;
+}
+/**
+ * Durable deferred and clock operations composed into the encoded engine.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Service {
+    readonly deferredResult: (deferred: DurableDeferred.Any) => Effect.Effect<Option.Option<Exit.Exit<unknown, unknown>>, never, FlowRuntime.FlowInstance>;
+    readonly deferredDone: (options: DeferredDoneOptions) => Effect.Effect<void>;
+    readonly deferredDoneIfWaiting: (options: DeferredDoneOptions & {
+        readonly reason: string;
+        readonly token: string;
+    }) => Effect.Effect<FlowRuntime.DeferredDoneIfWaitingOutcome>;
+    readonly scheduleClock: (flow: Flow.Any, options: {
+        readonly executionId: string;
+        readonly clock: DurableClock.DurableClock;
+    }) => Effect.Effect<void>;
+    readonly sweepDue: (flowName?: string) => Effect.Effect<void>;
+}
+/**
+ * A clock-fire redispatch policy. The input is the sandboxed cause of a failed
+ * fire, so any schedule that recurs on an arbitrary input fits.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type FireRetryPolicy = Schedule.Schedule<unknown, unknown>;
+/**
+ * The default redispatch policy for a durable clock whose fire failed.
+ *
+ * Temporal redispatches timer-queue tasks with backoff until they are acked
+ * (`reference/temporal` `service/history` timer queue + `common/backoff`); we
+ * mirror that here so one transient journal/flush error at fire time cannot
+ * lose the timer until a process restart. Exponential from 100ms, capped at
+ * 30s, forever — the fire is idempotent (first-writer deferred completion,
+ * deduplicated journal admission, CAS clock completion), so retrying an
+ * arbitrary prefix is safe.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const defaultFireRetryPolicy: FireRetryPolicy;
+/**
+ * Constructs durable deferred and clock persistence.
+ *
+ * Delivery ordering is `durable state -> durable journal -> claim-gated
+ * resume`. The delivery operation itself never invokes a flow handler.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: (dependencies: Dependencies) => Effect.Effect<Service, never, DurableEngineState.DurableEngineState | Journal.Journal | Scope.Scope>;
+//# sourceMappingURL=DeferredPersistence.d.ts.map

package/dist/cjs/internal/DeferredPersistence.d.ts.map

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

package/dist/cjs/internal/DeferredPersistence.js

@@ -0,0 +1,270 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DeferredPersistence_exports = {};
+__export(DeferredPersistence_exports, {
+  defaultFireRetryPolicy: () => defaultFireRetryPolicy,
+  make: () => make
+});
+module.exports = __toCommonJS(DeferredPersistence_exports);
+var import_engine = require("@smthrs/engine");
+var import_flow = require("@smthrs/flow");
+var import_journal = require("@smthrs/journal");
+var Clock = __toESM(require("effect/Clock"), 1);
+var Duration = __toESM(require("effect/Duration"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var FiberMap = __toESM(require("effect/FiberMap"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schedule = __toESM(require("effect/Schedule"), 1);
+var DurableEngineState = __toESM(require("../DurableEngineState.js"), 1);
+var JournalRecords = __toESM(require("./JournalRecords.js"), 1);
+var StateTransaction = __toESM(require("./StateTransaction.js"), 1);
+const clockKey = (row) => JSON.stringify([row.flowName, row.executionId, row.clockName]);
+const defaultFireRetryPolicy = Schedule.min([
+  Schedule.exponential("100 millis"),
+  Schedule.spaced("30 seconds")
+]);
+const make = (dependencies) => Effect.gen(function* () {
+  const state = yield* DurableEngineState.DurableEngineState;
+  const journal = yield* import_journal.Journal.Journal;
+  const transactState = StateTransaction.make(state, journal);
+  const timers = yield* FiberMap.make();
+  const fireRetryPolicy = dependencies.fireRetryPolicy ?? defaultFireRetryPolicy;
+  const flushLossy = journal.flush.pipe(
+    Effect.catchCause(
+      (cause) => Effect.logWarning(
+        "engine-store: lossy journal flush failed after a committed durable write; continuing",
+        cause
+      )
+    )
+  );
+  const persistDeferred = (options, reason = "deferred", expectedWaiting, alongside = Effect.void) => Effect.gen(function* () {
+    const completedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+    const admission = yield* transactState(
+      Effect.gen(function* () {
+        if (expectedWaiting !== void 0) {
+          const waiting = yield* state.waiting(options.executionId);
+          if (Option.isNone(waiting) || waiting.value.reason !== expectedWaiting.reason || waiting.value.token !== expectedWaiting.token) {
+            return { _tag: "NotWaiting" };
+          }
+        }
+        const completion = yield* state.completeDeferred({
+          flowName: options.flowName,
+          executionId: options.executionId,
+          deferredName: options.deferredName,
+          exit: options.exit,
+          ...options.metadata === void 0 ? {} : { metadata: options.metadata },
+          completedAtMs
+        });
+        const row2 = completion.row;
+        yield* journal.emitDurableUnfenced(
+          JournalRecords.deferredCompleted({
+            runId: options.executionId,
+            lineageId: import_engine.FlowEngine.Lineage.root(options.executionId),
+            sourceId: `${dependencies.journalSource}:deferred:${JSON.stringify([options.flowName, options.executionId, options.deferredName])}`,
+            sourceSeq: 0
+          }, {
+            flowName: row2.flowName,
+            executionId: row2.executionId,
+            deferredName: row2.deferredName,
+            completedAtMs: row2.completedAtMs,
+            exitDigest: completion.digest.exit,
+            metadataDigest: completion.digest.metadata
+          })
+        ).pipe(Effect.orDie);
+        yield* alongside;
+        return { _tag: "Admitted", completion };
+      })
+    ).pipe(Effect.orDie);
+    if (admission._tag === "NotWaiting") return "NotWaiting";
+    const row = admission.completion.row;
+    yield* flushLossy;
+    yield* dependencies.scheduleResume(
+      row.flowName,
+      row.executionId,
+      reason
+    );
+    return admission.completion._tag;
+  });
+  const completeDeferred = (options, reason = "deferred") => persistDeferred(options, reason).pipe(Effect.asVoid);
+  const fireClock = (row) => Effect.gen(function* () {
+    const completedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+    yield* persistDeferred(
+      {
+        flowName: row.flowName,
+        executionId: row.executionId,
+        deferredName: row.deferredName,
+        exit: Exit.void,
+        metadata: {
+          clockName: row.clockName,
+          dueAtMs: row.dueAtMs,
+          completedAtMs
+        }
+      },
+      "clock",
+      void 0,
+      Effect.flatMap(
+        state.completeClock(row, completedAtMs),
+        (completed) => completed._tag === "Completed" ? emitClockCompleted(completed.row, completedAtMs) : Effect.void
+      )
+    );
+  });
+  const armClock = (row) => (
+    // A replayed sleep re-schedules its clock and gets the existing row
+    // back. A fired clock whose completion stands is not armed again: firing
+    // it would re-admit that completion and wake the run, whose replay would
+    // re-schedule the clock again, re-driving the parked run forever. A
+    // rewind can drop the completion and keep the fired row; that clock
+    // still has to fire.
+    (row.completedAtMs === null ? Effect.succeed(false) : Effect.map(state.deferred(row), Option.isSome)).pipe(
+      Effect.flatMap((fired) => fired ? Effect.void : armTimer(row))
+    )
+  );
+  const armTimer = (row) => Clock.currentTimeMillis.pipe(Effect.map(Math.floor)).pipe(
+    Effect.flatMap(
+      (nowMs) => fireClock(row).pipe(
+        // A failed fire (journal emit/flush defect included) must not kill
+        // the one-shot timer fiber: expose the full cause and redispatch
+        // with backoff until the fire is durably acked.
+        Effect.sandbox,
+        Effect.retry(fireRetryPolicy),
+        Effect.orDie,
+        Effect.delay(Duration.millis(Math.max(0, row.dueAtMs - nowMs))),
+        FiberMap.run(timers, clockKey(row), { onlyIfMissing: true })
+      )
+    ),
+    Effect.asVoid
+  );
+  const emitClockCompleted = (row, completedAtMs) => journal.emitDurableUnfenced(
+    JournalRecords.clockCompletedFor(
+      dependencies.journalSource,
+      import_engine.FlowEngine.Lineage.root(row.executionId),
+      row,
+      completedAtMs
+    )
+  ).pipe(Effect.asVoid, Effect.orDie);
+  const emitClockScheduled = (row) => journal.emitDurableUnfenced(
+    JournalRecords.clockScheduled({
+      runId: row.executionId,
+      lineageId: import_engine.FlowEngine.Lineage.root(row.executionId),
+      sourceId: `${dependencies.journalSource}:clock:${JSON.stringify([row.flowName, row.executionId, row.clockName])}`,
+      sourceSeq: 0
+    }, {
+      flowName: row.flowName,
+      executionId: row.executionId,
+      clockName: row.clockName,
+      deferredName: row.deferredName,
+      dueAtMs: row.dueAtMs
+    })
+  ).pipe(Effect.asVoid, Effect.orDie);
+  const recordClockScheduled = (row) => emitClockScheduled(row).pipe(Effect.andThen(flushLossy));
+  const scheduleClock = Effect.fn("DeferredPersistence.scheduleClock")(
+    (flow, options) => Effect.gen(function* () {
+      const nowMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+      const scheduled = yield* transactState(
+        Effect.gen(function* () {
+          const scheduled2 = yield* state.scheduleClock({
+            flowName: flow._tag,
+            executionId: options.executionId,
+            clockName: options.clock.name,
+            deferredName: options.clock.deferred.name,
+            dueAtMs: nowMs + Duration.toMillis(options.clock.duration),
+            completedAtMs: null
+          }, dependencies.owner);
+          yield* emitClockScheduled(scheduled2.row);
+          return scheduled2;
+        })
+      ).pipe(Effect.orDie);
+      yield* flushLossy;
+      yield* armClock(scheduled.row);
+    })
+  );
+  const sweepDue = Effect.fn("DeferredPersistence.sweepDue")(
+    (flowName) => Effect.gen(function* () {
+      const rows = yield* state.pendingClocks(flowName === void 0 ? {} : { flowName });
+      yield* Effect.forEach(
+        rows,
+        (row) => recordClockScheduled(row).pipe(Effect.andThen(armClock(row))),
+        { discard: true }
+      );
+      if (flowName !== void 0) {
+        const completions = yield* state.completedDeferreds(flowName);
+        yield* Effect.forEach(
+          completions,
+          (address) => dependencies.scheduleResume(
+            address.flowName,
+            address.executionId,
+            "deferred",
+            `${dependencies.journalSource}:wake:${JSON.stringify([
+              address.flowName,
+              address.executionId,
+              address.deferredName
+            ])}`
+          ),
+          { discard: true }
+        );
+      }
+    })
+  );
+  return {
+    deferredResult: Effect.fn("DeferredPersistence.deferredResult")(function* (deferred) {
+      const instance = yield* import_flow.FlowRuntime.FlowInstance;
+      const address = {
+        flowName: instance.flow._tag,
+        executionId: instance.executionId,
+        deferredName: deferred.name
+      };
+      const row = yield* state.deferred(address);
+      if (Option.isSome(row)) {
+        const consumedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+        yield* transactState(
+          Effect.flatMap(state.consumeDeferred(address, consumedAtMs), (consumed) => consumed ? journal.emitDurableUnfenced(
+            JournalRecords.deferredConsumed({
+              runId: address.executionId,
+              lineageId: import_engine.FlowEngine.Lineage.root(address.executionId),
+              sourceId: `${dependencies.journalSource}:deferred-consumed:${JSON.stringify([address.flowName, address.executionId, address.deferredName])}`,
+              sourceSeq: 0
+            }, { ...address, consumedAtMs })
+          ).pipe(Effect.asVoid) : Effect.void)
+        ).pipe(Effect.orDie);
+      }
+      return Option.map(row, (value) => value.exit);
+    }),
+    deferredDone: Effect.fn("DeferredPersistence.deferredDone")(completeDeferred),
+    deferredDoneIfWaiting: Effect.fn("DeferredPersistence.deferredDoneIfWaiting")(
+      (options) => persistDeferred(options, "deferred", {
+        reason: options.reason,
+        token: options.token
+      })
+    ),
+    scheduleClock,
+    sweepDue
+  };
+});
+//# sourceMappingURL=DeferredPersistence.js.map

package/dist/cjs/internal/DeferredPersistence.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/DeferredPersistence.ts"],
+  "sourcesContent": ["/**\n * Durable deferred delivery and absolute clock scheduling.\n *\n * @since 0.1.0\n */\n\nimport { FlowEngine } from \"@smthrs/engine\"\nimport { type DurableClock, type DurableDeferred, type Flow, FlowRuntime } from \"@smthrs/flow\"\nimport { Journal } from \"@smthrs/journal\"\nimport type { Ownership } from \"@smthrs/run-store\"\nimport * as Clock from \"effect/Clock\"\nimport * as Duration from \"effect/Duration\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as FiberMap from \"effect/FiberMap\"\nimport * as Option from \"effect/Option\"\nimport * as Schedule from \"effect/Schedule\"\nimport type * as Scope from \"effect/Scope\"\nimport * as DurableEngineState from \"../DurableEngineState.ts\"\nimport * as JournalRecords from \"./JournalRecords.ts\"\nimport * as StateTransaction from \"./StateTransaction.ts\"\n\n/**\n * Reasons passed to the single claim-gated resume scheduler.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ResumeReason = \"deferred\" | \"clock\"\n\n/**\n * Dependencies for durable deferred and clock persistence.\n *\n * `scheduleResume` must enter the run coordinator and ownership claim path. It\n * must never invoke a flow handler directly.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Dependencies {\n  readonly owner: Ownership.OwnerId\n  readonly journalSource: string\n  readonly scheduleResume: (\n    flowName: string,\n    executionId: string,\n    reason: ResumeReason,\n    sourceId?: string | undefined\n  ) => Effect.Effect<void>\n  /**\n   * Redispatch policy for a durable clock whose fire failed. Defaults to\n   * {@link defaultFireRetryPolicy}; a composition supplies its own the way\n   * the engine's `suspendedRetryPolicy` option is supplied, rather than\n   * editing the constant.\n   */\n  readonly fireRetryPolicy?: FireRetryPolicy | undefined\n}\n\n/**\n * Encoded deferred completion with optional opaque correlation metadata.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface DeferredDoneOptions {\n  readonly flowName: string\n  readonly executionId: string\n  readonly deferredName: string\n  readonly exit: Exit.Exit<unknown, unknown>\n  readonly metadata?: unknown\n}\n\n/**\n * Durable deferred and clock operations composed into the encoded engine.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Service {\n  readonly deferredResult: (\n    deferred: DurableDeferred.Any\n  ) => Effect.Effect<\n    Option.Option<Exit.Exit<unknown, unknown>>,\n    never,\n    FlowRuntime.FlowInstance\n  >\n  readonly deferredDone: (options: DeferredDoneOptions) => Effect.Effect<void>\n  readonly deferredDoneIfWaiting: (\n    options: DeferredDoneOptions & {\n      readonly reason: string\n      readonly token: string\n    }\n  ) => Effect.Effect<FlowRuntime.DeferredDoneIfWaitingOutcome>\n  readonly scheduleClock: (\n    flow: Flow.Any,\n    options: {\n      readonly executionId: string\n      readonly clock: DurableClock.DurableClock\n    }\n  ) => Effect.Effect<void>\n  readonly sweepDue: (flowName?: string) => Effect.Effect<void>\n}\n\nconst clockKey = (row: DurableEngineState.ClockAddress): string =>\n  JSON.stringify([row.flowName, row.executionId, row.clockName])\n\n/**\n * A clock-fire redispatch policy. The input is the sandboxed cause of a failed\n * fire, so any schedule that recurs on an arbitrary input fits.\n *\n * @since 0.1.0\n * @category models\n */\nexport type FireRetryPolicy = Schedule.Schedule<unknown, unknown>\n\n/**\n * The default redispatch policy for a durable clock whose fire failed.\n *\n * Temporal redispatches timer-queue tasks with backoff until they are acked\n * (`reference/temporal` `service/history` timer queue + `common/backoff`); we\n * mirror that here so one transient journal/flush error at fire time cannot\n * lose the timer until a process restart. Exponential from 100ms, capped at\n * 30s, forever \u2014 the fire is idempotent (first-writer deferred completion,\n * deduplicated journal admission, CAS clock completion), so retrying an\n * arbitrary prefix is safe.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const defaultFireRetryPolicy: FireRetryPolicy = Schedule.min([\n  Schedule.exponential(\"100 millis\"),\n  Schedule.spaced(\"30 seconds\")\n])\n\n/**\n * Constructs durable deferred and clock persistence.\n *\n * Delivery ordering is `durable state -> durable journal -> claim-gated\n * resume`. The delivery operation itself never invokes a flow handler.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (\n  dependencies: Dependencies\n): Effect.Effect<\n  Service,\n  never,\n  DurableEngineState.DurableEngineState | Journal.Journal | Scope.Scope\n> =>\n  Effect.gen(function*() {\n    const state = yield* DurableEngineState.DurableEngineState\n    const journal = yield* Journal.Journal\n    /**\n     * The package's ordered state-and-journal boundary: engine state first,\n     * the journal's write transaction inside it. See\n     * {@link StateTransaction.make} for the order and what it guarantees.\n     */\n    const transactState = StateTransaction.make(state, journal)\n    const timers = yield* FiberMap.make<string>()\n    const fireRetryPolicy = dependencies.fireRetryPolicy ?? defaultFireRetryPolicy\n\n    // The durable channel commits inside `emitDurable`; the flush that\n    // follows only pushes the *lossy* queue. Once the journal's lossy writer\n    // latches a `sink_failed` it stays latched for the process (issue #43),\n    // so treating a flush failure as a defect would turn every committed\n    // durable write into a permanent stall. Log and move on: durable\n    // delivery must never be coupled to lossy-channel health.\n    const flushLossy = journal.flush.pipe(\n      Effect.catchCause((cause) =>\n        Effect.logWarning(\n          \"engine-store: lossy journal flush failed after a committed durable write; continuing\",\n          cause\n        )\n      )\n    )\n\n    const persistDeferred = (\n      options: DeferredDoneOptions,\n      reason: ResumeReason = \"deferred\",\n      expectedWaiting?: { readonly reason: string; readonly token: string } | undefined,\n      alongside: Effect.Effect<void> = Effect.void\n    ): Effect.Effect<FlowRuntime.DeferredDoneIfWaitingOutcome> =>\n      Effect.gen(function*() {\n        const completedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor))\n        // The completion row and the record describing it commit as one unit:\n        // a crash between them left a resumable deferred the journal never\n        // announced. The lossy flush below stays outside \u2014 it waits on the\n        // journal's writer fiber, which would deadlock against the write\n        // transaction this holds.\n        const admission = yield* transactState(\n          Effect.gen(function*() {\n            if (expectedWaiting !== undefined) {\n              const waiting = yield* state.waiting(options.executionId)\n              if (\n                Option.isNone(waiting) ||\n                waiting.value.reason !== expectedWaiting.reason ||\n                waiting.value.token !== expectedWaiting.token\n              ) {\n                return { _tag: \"NotWaiting\" as const }\n              }\n            }\n            const completion = yield* state.completeDeferred({\n              flowName: options.flowName,\n              executionId: options.executionId,\n              deferredName: options.deferredName,\n              exit: options.exit,\n              ...(options.metadata === undefined ? {} : { metadata: options.metadata }),\n              completedAtMs\n            })\n            const row = completion.row\n\n            // Durable channel: a deferred completion is a lifecycle record and\n            // must never take the droppable lossy queue. It is unfenced by\n            // design \u2014 external-trigger admissions are first-writer-wins\n            // regardless of who owns the run (issue #10), which is exactly the\n            // admission `emitDurableUnfenced` exists for. The record names the\n            // row and the digests of its value; the value stays in the row,\n            // because the journal is redacted and replayed (issue #72).\n            yield* journal.emitDurableUnfenced(\n              JournalRecords.deferredCompleted({\n                runId: options.executionId,\n                lineageId: FlowEngine.Lineage.root(options.executionId),\n                sourceId: `${dependencies.journalSource}:deferred:${\n                  JSON.stringify([options.flowName, options.executionId, options.deferredName])\n                }`,\n                sourceSeq: 0\n              }, {\n                flowName: row.flowName,\n                executionId: row.executionId,\n                deferredName: row.deferredName,\n                completedAtMs: row.completedAtMs,\n                exitDigest: completion.digest.exit,\n                metadataDigest: completion.digest.metadata\n              })\n            ).pipe(Effect.orDie)\n            yield* alongside\n            return { _tag: \"Admitted\" as const, completion }\n          })\n        ).pipe(Effect.orDie)\n        if (admission._tag === \"NotWaiting\") return \"NotWaiting\"\n        const row = admission.completion.row\n        yield* flushLossy\n        yield* dependencies.scheduleResume(\n          row.flowName,\n          row.executionId,\n          reason\n        )\n        return admission.completion._tag\n      })\n\n    const completeDeferred = (\n      options: DeferredDoneOptions,\n      reason: ResumeReason = \"deferred\"\n    ): Effect.Effect<void> => persistDeferred(options, reason).pipe(Effect.asVoid)\n\n    const fireClock = (row: DurableEngineState.ClockRow): Effect.Effect<void> =>\n      Effect.gen(function*() {\n        const completedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor))\n        // The clock completes in the deferred's transaction, and its record\n        // with it: a completion the journal never recorded is a clock a\n        // rebuilt deadline index would arm again (issue #2037).\n        yield* persistDeferred(\n          {\n            flowName: row.flowName,\n            executionId: row.executionId,\n            deferredName: row.deferredName,\n            exit: Exit.void,\n            metadata: {\n              clockName: row.clockName,\n              dueAtMs: row.dueAtMs,\n              completedAtMs\n            }\n          },\n          \"clock\",\n          undefined,\n          Effect.flatMap(\n            state.completeClock(row, completedAtMs),\n            (completed) =>\n              completed._tag === \"Completed\" ? emitClockCompleted(completed.row, completedAtMs) : Effect.void\n          )\n        )\n      })\n\n    const armClock = (row: DurableEngineState.ClockRow): Effect.Effect<void> =>\n      // A replayed sleep re-schedules its clock and gets the existing row\n      // back. A fired clock whose completion stands is not armed again: firing\n      // it would re-admit that completion and wake the run, whose replay would\n      // re-schedule the clock again, re-driving the parked run forever. A\n      // rewind can drop the completion and keep the fired row; that clock\n      // still has to fire.\n      (row.completedAtMs === null\n        ? Effect.succeed(false)\n        : Effect.map(state.deferred(row), Option.isSome)).pipe(\n          Effect.flatMap((fired) => fired ? Effect.void : armTimer(row))\n        )\n\n    const armTimer = (row: DurableEngineState.ClockRow): Effect.Effect<void> =>\n      Clock.currentTimeMillis.pipe(Effect.map(Math.floor)).pipe(\n        Effect.flatMap((nowMs) =>\n          fireClock(row).pipe(\n            // A failed fire (journal emit/flush defect included) must not kill\n            // the one-shot timer fiber: expose the full cause and redispatch\n            // with backoff until the fire is durably acked.\n            Effect.sandbox,\n            Effect.retry(fireRetryPolicy),\n            Effect.orDie,\n            Effect.delay(Duration.millis(Math.max(0, row.dueAtMs - nowMs))),\n            FiberMap.run(timers, clockKey(row), { onlyIfMissing: true })\n          )\n        ),\n        Effect.asVoid\n      )\n\n    /** Records that a clock stopped being pending, in the caller's transaction. */\n    const emitClockCompleted = (\n      row: DurableEngineState.ClockAddress,\n      completedAtMs: number\n    ): Effect.Effect<void> =>\n      journal.emitDurableUnfenced(\n        JournalRecords.clockCompletedFor(\n          dependencies.journalSource,\n          FlowEngine.Lineage.root(row.executionId),\n          row,\n          completedAtMs\n        )\n      ).pipe(Effect.asVoid, Effect.orDie)\n\n    /**\n     * Durable channel: clock schedule records are lifecycle evidence and must\n     * never be droppable (issue #10). Unfenced: registration-time sweeps\n     * re-record clocks the current process does not own.\n     */\n    const emitClockScheduled = (\n      row: DurableEngineState.ClockRow\n    ): Effect.Effect<void> =>\n      journal.emitDurableUnfenced(\n        JournalRecords.clockScheduled({\n          runId: row.executionId,\n          lineageId: FlowEngine.Lineage.root(row.executionId),\n          sourceId: `${dependencies.journalSource}:clock:${\n            JSON.stringify([row.flowName, row.executionId, row.clockName])\n          }`,\n          sourceSeq: 0\n        }, {\n          flowName: row.flowName,\n          executionId: row.executionId,\n          clockName: row.clockName,\n          deferredName: row.deferredName,\n          dueAtMs: row.dueAtMs\n        })\n      ).pipe(Effect.asVoid, Effect.orDie)\n\n    /** Re-announces an already persisted clock row (the sweep path). */\n    const recordClockScheduled = (\n      row: DurableEngineState.ClockRow\n    ): Effect.Effect<void> => emitClockScheduled(row).pipe(Effect.andThen(flushLossy))\n\n    const scheduleClock: Service[\"scheduleClock\"] = Effect.fn(\"DeferredPersistence.scheduleClock\")((\n      flow,\n      options\n    ) =>\n      Effect.gen(function*() {\n        const nowMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor))\n        // The clock row and its schedule record commit as one unit, so a\n        // crash between them can no longer arm a durable timer the journal\n        // never announced (or announce one that was rolled back).\n        const scheduled = yield* transactState(\n          Effect.gen(function*() {\n            const scheduled = yield* state.scheduleClock({\n              flowName: flow._tag,\n              executionId: options.executionId,\n              clockName: options.clock.name,\n              deferredName: options.clock.deferred.name,\n              dueAtMs: nowMs + Duration.toMillis(options.clock.duration),\n              completedAtMs: null\n            }, dependencies.owner)\n            yield* emitClockScheduled(scheduled.row)\n            return scheduled\n          })\n        ).pipe(Effect.orDie)\n        yield* flushLossy\n        yield* armClock(scheduled.row)\n      })\n    )\n\n    const sweepDue: Service[\"sweepDue\"] = Effect.fn(\"DeferredPersistence.sweepDue\")((flowName) =>\n      Effect.gen(function*() {\n        const rows = yield* state.pendingClocks(flowName === undefined ? {} : { flowName })\n        yield* Effect.forEach(\n          rows,\n          (row) => recordClockScheduled(row).pipe(Effect.andThen(armClock(row))),\n          { discard: true }\n        )\n        if (flowName !== undefined) {\n          const completions = yield* state.completedDeferreds(flowName)\n          yield* Effect.forEach(\n            completions,\n            (address) =>\n              dependencies.scheduleResume(\n                address.flowName,\n                address.executionId,\n                \"deferred\",\n                `${dependencies.journalSource}:wake:${\n                  JSON.stringify([\n                    address.flowName,\n                    address.executionId,\n                    address.deferredName\n                  ])\n                }`\n              ),\n            { discard: true }\n          )\n        }\n      })\n    )\n\n    return {\n      deferredResult: Effect.fn(\"DeferredPersistence.deferredResult\")(function*(deferred) {\n        const instance = yield* FlowRuntime.FlowInstance\n        const address = {\n          flowName: instance.flow._tag,\n          executionId: instance.executionId,\n          deferredName: deferred.name\n        }\n        const row = yield* state.deferred(address)\n        if (Option.isSome(row)) {\n          // Keep the result for replay, but stop registration from waking a\n          // run that already observed it and may now be parked on another wait.\n          // The first consumption is recorded in the same transaction.\n          const consumedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor))\n          yield* transactState(\n            Effect.flatMap(state.consumeDeferred(address, consumedAtMs), (consumed) =>\n              consumed\n                ? journal.emitDurableUnfenced(\n                  JournalRecords.deferredConsumed({\n                    runId: address.executionId,\n                    lineageId: FlowEngine.Lineage.root(address.executionId),\n                    sourceId: `${dependencies.journalSource}:deferred-consumed:${\n                      JSON.stringify([address.flowName, address.executionId, address.deferredName])\n                    }`,\n                    sourceSeq: 0\n                  }, { ...address, consumedAtMs })\n                ).pipe(Effect.asVoid)\n                : Effect.void)\n          ).pipe(Effect.orDie)\n        }\n        return Option.map(row, (value) => value.exit as Exit.Exit<unknown, unknown>)\n      }),\n      deferredDone: Effect.fn(\"DeferredPersistence.deferredDone\")(completeDeferred),\n      deferredDoneIfWaiting: Effect.fn(\"DeferredPersistence.deferredDoneIfWaiting\")((options) =>\n        persistDeferred(options, \"deferred\", {\n          reason: options.reason,\n          token: options.token\n        })\n      ),\n      scheduleClock,\n      sweepDue\n    }\n  })\n"],
+  "mappings": "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",
+  "names": ["row", "scheduled"]
+}

package/dist/cjs/internal/EffectRecords.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Effect-boundary evidence, emitted by the engine at the point an irreversible
+ * action crosses into the outside world.
+ *
+ * Time travel (`packages/smithers/flows/time-travel/docs/README.md`) requires one durable
+ * journal entry recorded **before the adapter begins**, whose status then moves
+ * only forward (`intended` → `succeeded` | `unknown`). Rewind reads exactly
+ * these records to classify the doomed suffix as blocking, revertible, or
+ * warning; nothing else in the journal can answer that question, because an
+ * attempt row says an attempt happened, not that an effect left the machine.
+ *
+ * ## Why the shape lives here and not in `@smthrs/time-travel`
+ *
+ * `@smthrs/time-travel` depends on `@smthrs/engine-store` (it decodes
+ * `RunState`), so the arrow cannot be reversed without a cycle. The record is
+ * therefore a **wire contract**, not a shared type: this module writes the
+ * shape `EffectBoundary.decodeEntry` reads, under the event type that module
+ * owns, and `packages/smithers/flows/time-travel/test/EngineIntegration.test.ts` pins the two
+ * together by rewinding across a boundary record this module produced.
+ *
+ * ## One producer identity, two channels that must not double-count
+ *
+ * An irreversible dispatch now writes on two channels: the attempt lifecycle
+ * (`attempt-started` / `attempt-finished`), which says a durable attempt row
+ * moved, and this boundary (`intended` / terminal), which says an external
+ * effect was begun and how it settled. They are deliberately NOT merged —
+ * an attempt is retried under new numbers while an effect keeps one identity —
+ * and they cannot double-count, because a rewind's suffix scan matches only
+ * {@link eventType}. The two are tied by construction: the effect id IS the
+ * attempt identity (`runId:keyDigest:attempt`), so every boundary record names
+ * the attempt row that produced it and the audit reads as one story.
+ *
+ * @since 0.1.0
+ */
+import { JournalEvent } from "@smthrs/journal";
+/**
+ * The event type `@smthrs/time-travel` decodes boundary evidence from.
+ *
+ * Duplicated deliberately rather than imported: see the module note.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const eventType = "flows.time-travel.effect-boundary";
+/**
+ * Monotonic completion evidence recorded around an effect.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Status = "intended" | "succeeded" | "unknown";
+/**
+ * What the engine knows about an effect before it begins.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Descriptor {
+    readonly id: string;
+    readonly kind: string;
+    readonly tier: "sealed" | "compensable" | "irreversible";
+    readonly runId: string;
+    readonly lineageId: string;
+    readonly sourceId: string;
+    readonly attempt: number;
+    readonly idempotencyKey?: string | undefined;
+    readonly cacheKey?: string | undefined;
+    readonly changeId?: string | undefined;
+    /**
+     * The stable compensation descriptor the adapter owns, when it declares one.
+     * Time travel puts it in the entry so a
+     * rewind's handler resolution is a lookup over recorded evidence rather than
+     * a guess from the effect kind alone.
+     */
+    readonly compensation?: string | undefined;
+    readonly residue?: string | undefined;
+}
+/**
+ * Builds one boundary record for `descriptor` at `status`.
+ *
+ * Every effect and status pair gets its own producer identity: the status is
+ * appended to `descriptor.sourceId`, and every boundary record carries
+ * sourceSeq 0. Re-emitting the same status for the same effect therefore
+ * reuses that `(sourceId, sourceSeq)` pair, so a replay collapses into a
+ * journal `Duplicate` instead of appending a second boundary row, the same
+ * convergence the attempt lifecycle records rely on.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const boundary: (descriptor: Descriptor, status: Status, output?: unknown) => JournalEvent.Input;
+//# sourceMappingURL=EffectRecords.d.ts.map

package/dist/cjs/internal/EffectRecords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectRecords.d.ts","sourceRoot":"","sources":["../../../src/internal/EffectRecords.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,sCAAsC,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAA;AAEzD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAA;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACtC;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,GACnB,YAAY,UAAU,EACtB,QAAQ,MAAM,EACd,SAAS,OAAO,KACf,YAAY,CAAC,KAoCZ,CAAA"}

package/dist/cjs/internal/EffectRecords.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EffectRecords_exports = {};
+__export(EffectRecords_exports, {
+  boundary: () => boundary,
+  eventType: () => eventType
+});
+module.exports = __toCommonJS(EffectRecords_exports);
+var import_journal = require("@smthrs/journal");
+const eventType = "flows.time-travel.effect-boundary";
+const boundary = (descriptor, status, output) => new import_journal.JournalEvent.Input({
+  runId: descriptor.runId,
+  sourceId: `${descriptor.sourceId}:effect:${descriptor.id}:${status}`,
+  sourceSeq: 0,
+  eventType,
+  payload: {
+    version: 1,
+    effect: {
+      id: descriptor.id,
+      kind: descriptor.kind,
+      tier: descriptor.tier,
+      status,
+      runId: descriptor.runId,
+      lineageId: descriptor.lineageId,
+      attempt: descriptor.attempt,
+      durableBoundary: true,
+      providerStream: false,
+      ...output === void 0 ? {} : { output },
+      ...descriptor.idempotencyKey === void 0 ? {} : { idempotencyKey: descriptor.idempotencyKey },
+      ...descriptor.cacheKey === void 0 ? {} : { cacheKey: descriptor.cacheKey },
+      ...descriptor.changeId === void 0 ? {} : { changeId: descriptor.changeId },
+      ...descriptor.compensation === void 0 ? {} : { compensation: descriptor.compensation },
+      ...descriptor.residue === void 0 ? {} : { residue: descriptor.residue }
+    }
+  },
+  meta: {
+    lineageId: descriptor.lineageId,
+    ...descriptor.cacheKey === void 0 ? {} : { cacheKey: descriptor.cacheKey },
+    timeTravel: {
+      effectId: descriptor.id,
+      kind: descriptor.kind,
+      tier: descriptor.tier,
+      status
+    }
+  }
+});
+//# sourceMappingURL=EffectRecords.js.map

package/dist/cjs/internal/EffectRecords.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/EffectRecords.ts"],
+  "sourcesContent": ["/**\n * Effect-boundary evidence, emitted by the engine at the point an irreversible\n * action crosses into the outside world.\n *\n * Time travel (`packages/smithers/flows/time-travel/docs/README.md`) requires one durable\n * journal entry recorded **before the adapter begins**, whose status then moves\n * only forward (`intended` \u2192 `succeeded` | `unknown`). Rewind reads exactly\n * these records to classify the doomed suffix as blocking, revertible, or\n * warning; nothing else in the journal can answer that question, because an\n * attempt row says an attempt happened, not that an effect left the machine.\n *\n * ## Why the shape lives here and not in `@smthrs/time-travel`\n *\n * `@smthrs/time-travel` depends on `@smthrs/engine-store` (it decodes\n * `RunState`), so the arrow cannot be reversed without a cycle. The record is\n * therefore a **wire contract**, not a shared type: this module writes the\n * shape `EffectBoundary.decodeEntry` reads, under the event type that module\n * owns, and `packages/smithers/flows/time-travel/test/EngineIntegration.test.ts` pins the two\n * together by rewinding across a boundary record this module produced.\n *\n * ## One producer identity, two channels that must not double-count\n *\n * An irreversible dispatch now writes on two channels: the attempt lifecycle\n * (`attempt-started` / `attempt-finished`), which says a durable attempt row\n * moved, and this boundary (`intended` / terminal), which says an external\n * effect was begun and how it settled. They are deliberately NOT merged \u2014\n * an attempt is retried under new numbers while an effect keeps one identity \u2014\n * and they cannot double-count, because a rewind's suffix scan matches only\n * {@link eventType}. The two are tied by construction: the effect id IS the\n * attempt identity (`runId:keyDigest:attempt`), so every boundary record names\n * the attempt row that produced it and the audit reads as one story.\n *\n * @since 0.1.0\n */\n\nimport { JournalEvent } from \"@smthrs/journal\"\n\n/**\n * The event type `@smthrs/time-travel` decodes boundary evidence from.\n *\n * Duplicated deliberately rather than imported: see the module note.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const eventType = \"flows.time-travel.effect-boundary\"\n\n/**\n * Monotonic completion evidence recorded around an effect.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Status = \"intended\" | \"succeeded\" | \"unknown\"\n\n/**\n * What the engine knows about an effect before it begins.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Descriptor {\n  readonly id: string\n  readonly kind: string\n  readonly tier: \"sealed\" | \"compensable\" | \"irreversible\"\n  readonly runId: string\n  readonly lineageId: string\n  readonly sourceId: string\n  readonly attempt: number\n  readonly idempotencyKey?: string | undefined\n  readonly cacheKey?: string | undefined\n  readonly changeId?: string | undefined\n  /**\n   * The stable compensation descriptor the adapter owns, when it declares one.\n   * Time travel puts it in the entry so a\n   * rewind's handler resolution is a lookup over recorded evidence rather than\n   * a guess from the effect kind alone.\n   */\n  readonly compensation?: string | undefined\n  readonly residue?: string | undefined\n}\n\n/**\n * Builds one boundary record for `descriptor` at `status`.\n *\n * Every effect and status pair gets its own producer identity: the status is\n * appended to `descriptor.sourceId`, and every boundary record carries\n * sourceSeq 0. Re-emitting the same status for the same effect therefore\n * reuses that `(sourceId, sourceSeq)` pair, so a replay collapses into a\n * journal `Duplicate` instead of appending a second boundary row, the same\n * convergence the attempt lifecycle records rely on.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const boundary = (\n  descriptor: Descriptor,\n  status: Status,\n  output?: unknown\n): JournalEvent.Input =>\n  new JournalEvent.Input({\n    runId: descriptor.runId as JournalEvent.RunId,\n    sourceId: `${descriptor.sourceId}:effect:${descriptor.id}:${status}` as JournalEvent.SourceId,\n    sourceSeq: 0 as JournalEvent.SourceSeq,\n    eventType,\n    payload: {\n      version: 1,\n      effect: {\n        id: descriptor.id,\n        kind: descriptor.kind,\n        tier: descriptor.tier,\n        status,\n        runId: descriptor.runId,\n        lineageId: descriptor.lineageId,\n        attempt: descriptor.attempt,\n        durableBoundary: true,\n        providerStream: false,\n        ...(output === undefined ? {} : { output }),\n        ...(descriptor.idempotencyKey === undefined ? {} : { idempotencyKey: descriptor.idempotencyKey }),\n        ...(descriptor.cacheKey === undefined ? {} : { cacheKey: descriptor.cacheKey }),\n        ...(descriptor.changeId === undefined ? {} : { changeId: descriptor.changeId }),\n        ...(descriptor.compensation === undefined ? {} : { compensation: descriptor.compensation }),\n        ...(descriptor.residue === undefined ? {} : { residue: descriptor.residue })\n      }\n    },\n    meta: {\n      lineageId: descriptor.lineageId,\n      ...(descriptor.cacheKey === undefined ? {} : { cacheKey: descriptor.cacheKey }),\n      timeTravel: {\n        effectId: descriptor.id,\n        kind: descriptor.kind,\n        tier: descriptor.tier,\n        status\n      }\n    }\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmCA,qBAA6B;AAUtB,MAAM,YAAY;AAkDlB,MAAM,WAAW,CACtB,YACA,QACA,WAEA,IAAI,4BAAa,MAAM;AAAA,EACrB,OAAO,WAAW;AAAA,EAClB,UAAU,GAAG,WAAW,QAAQ,WAAW,WAAW,EAAE,IAAI,MAAM;AAAA,EAClE,WAAW;AAAA,EACX;AAAA,EACA,SAAS;AAAA,IACP,SAAS;AAAA,IACT,QAAQ;AAAA,MACN,IAAI,WAAW;AAAA,MACf,MAAM,WAAW;AAAA,MACjB,MAAM,WAAW;AAAA,MACjB;AAAA,MACA,OAAO,WAAW;AAAA,MAClB,WAAW,WAAW;AAAA,MACtB,SAAS,WAAW;AAAA,MACpB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,MAChB,GAAI,WAAW,SAAY,CAAC,IAAI,EAAE,OAAO;AAAA,MACzC,GAAI,WAAW,mBAAmB,SAAY,CAAC,IAAI,EAAE,gBAAgB,WAAW,eAAe;AAAA,MAC/F,GAAI,WAAW,aAAa,SAAY,CAAC,IAAI,EAAE,UAAU,WAAW,SAAS;AAAA,MAC7E,GAAI,WAAW,aAAa,SAAY,CAAC,IAAI,EAAE,UAAU,WAAW,SAAS;AAAA,MAC7E,GAAI,WAAW,iBAAiB,SAAY,CAAC,IAAI,EAAE,cAAc,WAAW,aAAa;AAAA,MACzF,GAAI,WAAW,YAAY,SAAY,CAAC,IAAI,EAAE,SAAS,WAAW,QAAQ;AAAA,IAC5E;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,WAAW,WAAW;AAAA,IACtB,GAAI,WAAW,aAAa,SAAY,CAAC,IAAI,EAAE,UAAU,WAAW,SAAS;AAAA,IAC7E,YAAY;AAAA,MACV,UAAU,WAAW;AAAA,MACrB,MAAM,WAAW;AAAA,MACjB,MAAM,WAAW;AAAA,MACjB;AAAA,IACF;AAAA,EACF;AACF,CAAC;",
+  "names": []
+}

package/dist/cjs/internal/EngineJj.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Engine-private Jujutsu authority.
+ *
+ * Action bodies resolve the public `Jj` tag from their guarded host context.
+ * Snapshot, restore, and diff bookkeeping resolve this distinct tag instead,
+ * so an engine operation never grants the same authority to user code.
+ *
+ * @since 1.0.0
+ */
+import { Jj } from "@smthrs/kernel";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+declare const EngineJj_base: Context.ServiceClass<EngineJj, "@smthrs/engine-store/internal/EngineJj", Jj.Jj>;
+/**
+ * Engine-owned repository operations, absent from public action context.
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare class EngineJj extends EngineJj_base {
+}
+/**
+ * Captures the current public Jj implementation under the private engine tag.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerFromJj: Layer.Layer<EngineJj, never, Jj.Jj>;
+export {};
+//# sourceMappingURL=EngineJj.d.ts.map