@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/core/projection-core.js

@@ -1,16 +1,15 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomBytes } from "node:crypto";
 import { isErrnoException } from "../errno.js";
-import { createUlid } from "./ids.js";
-import { atomicPublishFile, ProjectionStateError, randomHex8, } from "./atomic-publish.js";
+import { projectionCoordinateRoot } from "./projection-coordinate.js";
+import { ProjectionStateError, } from "./atomic-publish.js";
+import { readProjectionIdentity } from "./projection-identity.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "./atomic-publish.js";
+export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, isTellCausallyConsumed, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./projection-tells.js";
 /** Relative segments for `.keiyaku/projection`. */
 export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
-/** Tell layer directories created at mint (and only these five). */
-export const PROJECTION_LAYER_DIRS = ["inbox", "inflight", "submitted", "consumed", "delivered"];
 export function projectionRoot(cwd) {
-    return path.join(cwd, ...PROJECTION_ROOT_SEGMENTS);
+    return path.join(projectionCoordinateRoot(cwd), ...PROJECTION_ROOT_SEGMENTS);
 }
 export function projectionDir(cwd, id) {
     return path.join(projectionRoot(cwd), id);
@@ -24,21 +23,17 @@ export function isoFromNowMs(nowMs) {
     }
     return new Date(nowMs).toISOString();
 }
-/** Projection execution IDs share the repository's ULID family. */
-export function createProjectionExecutionId(nowMs = Date.now()) {
-    return createUlid(nowMs, [...randomBytes(10)]);
-}
-export function isReadyProjection(dir) {
+/** A published projection is any visible non-dot real directory under the projection root. */
+export function isPublishedProjection(dir) {
     try {
-        fs.accessSync(path.join(dir, "ready"));
-        return true;
+        return !path.basename(dir).startsWith(".") && fs.lstatSync(dir).isDirectory();
     }
     catch {
         return false;
     }
 }
-/** readdir-based prefix resolution. Only ready projections are candidates. Ambiguity lists candidates; never guesses. */
-export function resolveProjectionPrefix(cwd, prefix) {
+/** readdir-based address resolution. Atomic mint rename makes every visible non-dot directory published. */
+export function resolveProjectionPrefix(cwd, prefix, commissionId) {
     const needle = prefix.trim();
     if (!needle) {
         return { status: "none" };
@@ -54,19 +49,26 @@ export function resolveProjectionPrefix(cwd, prefix) {
         }
         throw error;
     }
-    const candidates = entries
+    const publishedIds = entries
         .filter((id) => {
         if (id.startsWith("."))
             return false;
-        try {
-            return fs.statSync(path.join(root, id)).isDirectory() && isReadyProjection(path.join(root, id));
-        }
-        catch {
-            return false;
-        }
+        const directory = path.join(root, id);
+        return isPublishedProjection(directory);
     })
-        .filter((id) => id === needle || id.startsWith(needle))
         .sort();
+    const addressed = publishedIds.filter((id) => {
+        if (id === needle || id.startsWith(needle))
+            return true;
+        const suffix = /-([0-9a-f]{8})$/.exec(id)?.[1];
+        return suffix === needle;
+    });
+    const candidates = commissionId === undefined
+        ? addressed
+        : addressed.filter((id) => {
+            const identity = readProjectionIdentity(path.join(root, id));
+            return identity.binding.kind === "commission" && identity.binding.commissionId === commissionId;
+        });
     if (candidates.length === 1) {
         return { status: "resolved", id: candidates[0] };
     }
@@ -75,467 +77,71 @@ export function resolveProjectionPrefix(cwd, prefix) {
     }
     return { status: "ambiguous", candidates };
 }
-export function listTellIds(projectionDirectory, layer) {
-    const dir = path.join(projectionDirectory, layer);
-    try {
-        return fs
-            .readdirSync(dir)
-            .filter((name) => !name.startsWith("."))
-            .sort();
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return [];
-        }
-        throw error;
-    }
-}
-export function readTellOriginal(projectionDirectory, layer, tellId) {
-    const raw = fs.readFileSync(path.join(projectionDirectory, layer, tellId), "utf8");
-    return JSON.parse(raw);
-}
-export function readTellSubmitted(projectionDirectory, tellId) {
-    const raw = fs.readFileSync(path.join(projectionDirectory, "submitted", tellId), "utf8");
-    return JSON.parse(raw);
-}
-function assertTellIdRandomHex(randomHex) {
-    if (!/^[0-9a-f]{8}$/.test(randomHex)) {
-        throw new ProjectionStateError(`tell id random segment must be 8 lowercase hex chars, got ${randomHex}`);
-    }
-    return randomHex;
-}
-function assertTellExecutionId(executionId) {
-    if (typeof executionId !== "string" || executionId.length === 0) {
-        throw new ProjectionStateError("submitted tell executionId must be a non-empty string");
-    }
-    return executionId;
-}
-function assertTellFence(fence) {
-    if (!fence || typeof fence !== "object")
-        throw new ProjectionStateError("tell fence is required");
-    const value = fence;
-    if (value.kind === "turn" && typeof value.turnId === "string" && value.turnId.length > 0) {
-        return { kind: "turn", turnId: value.turnId };
-    }
-    if (value.kind === "ordinal" && typeof value.ordinal === "number" && Number.isSafeInteger(value.ordinal) && value.ordinal >= 0) {
-        return { kind: "ordinal", ordinal: value.ordinal };
-    }
-    throw new ProjectionStateError("tell fence must be turn(string) or ordinal(non-negative integer)");
-}
-/** The only tell-consumption predicate. */
-export function isTellCausallyConsumed(submitted, checkpoint) {
-    if (submitted.kind !== checkpoint.kind) {
-        throw new ProjectionStateError(`tell fence kind mismatch: ${submitted.kind} vs ${checkpoint.kind}`);
-    }
-    if (submitted.kind === "ordinal" && checkpoint.kind === "ordinal")
-        return checkpoint.ordinal > submitted.ordinal;
-    if (submitted.kind === "turn" && checkpoint.kind === "turn")
-        return checkpoint.turnId === submitted.turnId;
-    throw new ProjectionStateError("unreachable tell fence comparison");
-}
-/** Write immutable tell original into inbox. Filename `<timestamp-ms>-<8hex>`. */
-export function writeInboxTell(projectionDirectory, text, nowMs, options) {
-    const tellId = `${nowMs}-${assertTellIdRandomHex((options?.randomHex ?? randomHex8)())}`;
-    const document = {
-        version: 1,
-        text,
-        createdAt: isoFromNowMs(nowMs),
-        ...(options?.effort ? { effort: options.effort } : {}),
-    };
-    const target = path.join(projectionDirectory, "inbox", tellId);
-    try {
-        fs.writeFileSync(target, encodeProjectionJson(document), { flag: "wx" });
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "EEXIST") {
-            throw new ProjectionStateError(`tell id already exists in inbox: ${tellId}`);
-        }
-        throw error;
-    }
-    return tellId;
-}
-/** inbox → inflight pure rename (claim). Admission-lock serialization makes the corrupt-state presence check coherent. */
-export function claimTellToInflight(projectionDirectory, tellId) {
-    const from = path.join(projectionDirectory, "inbox", tellId);
-    const to = path.join(projectionDirectory, "inflight", tellId);
-    if (fs.readdirSync(path.dirname(to)).includes(tellId)) {
-        throw new ProjectionStateError(`inflight tell already exists before claim: ${tellId}`);
-    }
-    try {
-        fs.renameSync(from, to);
-        return true;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return false;
-        }
-        throw error;
+const PROJECTION_EXECUTION_ID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+function assertProjectionExecutionId(executionId) {
+    if (!PROJECTION_EXECUTION_ID_PATTERN.test(executionId)) {
+        throw new ProjectionStateError(`invalid projection execution id: ${executionId}`);
     }
 }
-/** Claim every current inbox tell in filename order. */
-export function claimAllInbox(projectionDirectory) {
-    const claimed = [];
-    for (const tellId of listTellIds(projectionDirectory, "inbox")) {
-        if (claimTellToInflight(projectionDirectory, tellId)) {
-            claimed.push(tellId);
-        }
-    }
-    return claimed;
+export function executionEventsPath(projectionDirectory, executionId) {
+    assertProjectionExecutionId(executionId);
+    return path.join(projectionDirectory, `${executionId}.events.jsonl`);
 }
-/** Claim exactly one immutable generation fence in its recorded order. */
-export function claimFencedTells(projectionDirectory, fence, executionId) {
-    const claimed = [];
-    const seen = new Set();
-    for (const tellId of fence) {
-        if (seen.has(tellId))
-            throw new ProjectionStateError(`duplicate tell in generation fence: ${tellId}`);
-        seen.add(tellId);
-        if (listTellIds(projectionDirectory, "inflight").includes(tellId)) {
-            claimed.push(tellId);
-            continue;
-        }
-        if (listTellIds(projectionDirectory, "inbox").includes(tellId) && claimTellToInflight(projectionDirectory, tellId)) {
-            claimed.push(tellId);
-            continue;
-        }
-        const consumedPath = path.join(projectionDirectory, "consumed", tellId);
-        if (fs.existsSync(consumedPath)) {
-            const consumed = JSON.parse(fs.readFileSync(consumedPath, "utf8"));
-            if (consumed.executionId === executionId)
-                continue;
-        }
-        throw new ProjectionStateError(`generation tell fence member is missing: ${tellId}`);
-    }
-    return claimed;
+export function appendGenerationEvent(projectionDirectory, executionId, event) {
+    const filePath = executionEventsPath(projectionDirectory, executionId);
+    fs.appendFileSync(filePath, encodeProjectionJson(event), "utf8");
 }
 /**
- * inflight → submitted enriched rewrite via atomicPublishFile + unlink inflight.
- * If submitted already exists (crash mid-transition), clear inflight and keep submitted.
+ * Read one generation's event ledger. A writer may be interrupted while
+ * appending its final line, so only an unterminated final residue is ignored.
+ * Earlier complete lines remain strict ledger records.
  */
-export function markTellSubmitted(projectionDirectory, tellId, fields) {
-    const executionId = assertTellExecutionId(fields.executionId);
-    const legacy = !fields.fence;
-    if (legacy && (fields.submittedAtTurn === undefined) === (fields.submittedAfterResultOrdinal === undefined)) {
-        throw new ProjectionStateError("submitted tell must contain exactly one legacy fence field");
-    }
-    const fence = fields.fence
-        ? assertTellFence(fields.fence)
-        : fields.submittedAtTurn !== undefined
-            ? assertTellFence({ kind: "ordinal", ordinal: fields.submittedAtTurn })
-            : assertTellFence({ kind: "ordinal", ordinal: fields.submittedAfterResultOrdinal });
-    const inflightPath = path.join(projectionDirectory, "inflight", tellId);
-    const submittedPath = path.join(projectionDirectory, "submitted", tellId);
-    if (fs.existsSync(submittedPath)) {
-        try {
-            fs.unlinkSync(inflightPath);
-        }
-        catch (error) {
-            if (!(isErrnoException(error) && error.code === "ENOENT")) {
-                throw error;
-            }
-        }
-        return;
-    }
-    const original = JSON.parse(fs.readFileSync(inflightPath, "utf8"));
-    const submitted = {
-        version: 1,
-        text: original.text,
-        createdAt: original.createdAt,
-        ...(original.effort ? { effort: original.effort } : {}),
-        executionId,
-        ...(!legacy ? { fence } : {}),
-        ...(legacy && fields.submittedAtTurn !== undefined ? { submittedAtTurn: fields.submittedAtTurn } : {}),
-        ...(legacy && fields.submittedAfterResultOrdinal !== undefined ? { submittedAfterResultOrdinal: fields.submittedAfterResultOrdinal } : {}),
-        ...((fields.replayedFrom ?? original.replayedFrom)?.length ? { replayedFrom: [...(fields.replayedFrom ?? original.replayedFrom)] } : {}),
-    };
-    const result = atomicPublishFile(submittedPath, encodeProjectionJson(submitted));
-    if (result === "taken") {
-        try {
-            fs.unlinkSync(inflightPath);
-        }
-        catch (error) {
-            if (!(isErrnoException(error) && error.code === "ENOENT")) {
-                throw error;
-            }
-        }
-        return;
-    }
-    try {
-        fs.unlinkSync(inflightPath);
-    }
-    catch (error) {
-        if (!(isErrnoException(error) && error.code === "ENOENT")) {
-            throw error;
-        }
-    }
-}
-/** submitted → consumed pure rename; unlink delivered marker if present (ledger hygiene). */
-export function markTellConsumed(projectionDirectory, tellId) {
-    const from = path.join(projectionDirectory, "submitted", tellId);
-    const to = path.join(projectionDirectory, "consumed", tellId);
-    fs.renameSync(from, to);
-    clearDeliveredMarker(projectionDirectory, tellId);
-}
-export function publishDeliveredMarker(projectionDirectory, tellId, nowMs) {
-    const document = {
-        version: 1,
-        at: isoFromNowMs(nowMs),
-    };
-    return atomicPublishFile(path.join(projectionDirectory, "delivered", tellId), encodeProjectionJson(document));
-}
-export function clearDeliveredMarker(projectionDirectory, tellId) {
-    try {
-        fs.unlinkSync(path.join(projectionDirectory, "delivered", tellId));
-    }
-    catch (error) {
-        if (!(isErrnoException(error) && error.code === "ENOENT")) {
-            throw error;
-        }
-    }
-}
-/** Clear delivered markers for the given tell ids (crash replay prep). */
-export function clearDeliveredMarkers(projectionDirectory, tellIds) {
-    for (const tellId of tellIds) {
-        clearDeliveredMarker(projectionDirectory, tellId);
-    }
-}
-/** Replace an existing JSON ledger atomically.  Publish-once remains atomicPublishFile's law. */
-export function atomicReplaceFile(target, content) {
-    const directory = path.dirname(target);
-    const temporary = path.join(directory, `.${path.basename(target)}.${process.pid}.${randomHex8()}.tmp`);
-    let fd;
-    try {
-        fd = fs.openSync(temporary, "wx", 0o600);
-        fs.writeFileSync(fd, content, "utf8");
-        fs.fsyncSync(fd);
-        fs.closeSync(fd);
-        fd = undefined;
-        fs.renameSync(temporary, target);
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
-        try {
-            fs.unlinkSync(temporary);
-        }
-        catch (error) {
-            if (!(isErrnoException(error) && error.code === "ENOENT"))
-                throw error;
-        }
-    }
-}
-export function acquireAdmissionLock(projectionDirectory, pid, nowMs, executionId, parentExecutionId) {
-    const document = {
-        version: 1,
-        pid,
-        createdAt: isoFromNowMs(nowMs),
-        ...(executionId ? { executionId } : {}),
-        ...(parentExecutionId ? { parentExecutionId } : {}),
-    };
-    return atomicPublishFile(path.join(projectionDirectory, ".admission-lock"), encodeProjectionJson(document));
-}
-export function releaseAdmissionLock(projectionDirectory) {
-    try {
-        fs.unlinkSync(path.join(projectionDirectory, ".admission-lock"));
-    }
-    catch (error) {
-        if (!(isErrnoException(error) && error.code === "ENOENT")) {
-            throw error;
-        }
-    }
-}
-/** Release only the admission record owned by this generation. */
-export function releaseAdmissionLockOwned(projectionDirectory, executionId) {
-    const admission = readAdmissionLock(projectionDirectory);
-    if (!admission)
-        return false;
-    if (admission.executionId !== executionId) {
-        throw new ProjectionStateError(`admission ownership mismatch: expected ${executionId}, found ${admission.executionId ?? "none"}`);
-    }
-    releaseAdmissionLock(projectionDirectory);
-    return true;
-}
-export function readAdmissionLock(projectionDirectory) {
-    try {
-        const raw = fs.readFileSync(path.join(projectionDirectory, ".admission-lock"), "utf8");
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-export function acquireResumeLock(projectionDirectory, childId, pid, nowMs) {
-    const document = {
-        version: 1,
-        childId,
-        pid,
-        createdAt: isoFromNowMs(nowMs),
-    };
-    return atomicPublishFile(path.join(projectionDirectory, ".resume-lock"), encodeProjectionJson(document));
-}
-export function releaseResumeLock(projectionDirectory) {
-    try {
-        fs.unlinkSync(path.join(projectionDirectory, ".resume-lock"));
-    }
-    catch (error) {
-        if (!(isErrnoException(error) && error.code === "ENOENT")) {
-            throw error;
-        }
-    }
-}
-/** Release only a resume lock created by this launcher. */
-export function releaseResumeLockOwned(projectionDirectory, childId) {
-    const lock = readResumeLock(projectionDirectory);
-    if (!lock)
-        return false;
-    if (lock.childId !== childId) {
-        throw new ProjectionStateError(`resume ownership mismatch: expected ${childId}, found ${lock.childId}`);
-    }
-    releaseResumeLock(projectionDirectory);
-    return true;
-}
-export function readResumeLock(projectionDirectory) {
-    try {
-        const raw = fs.readFileSync(path.join(projectionDirectory, ".resume-lock"), "utf8");
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-/** Publish terminal verdict. Dead is observational and never written. */
-export function publishVerdict(projectionDirectory, state, nowMs, detail) {
-    const document = {
-        version: 1,
-        state,
-        at: isoFromNowMs(nowMs),
-        ...(detail ? { detail } : {}),
-    };
-    atomicReplaceFile(path.join(projectionDirectory, "verdict.json"), encodeProjectionJson(document));
-    return "published";
-}
-export function generationLaunchPath(projectionDirectory, executionId) {
-    return path.join(projectionDirectory, `generation-${executionId}.json`);
-}
-export function generationResultPath(projectionDirectory, executionId) {
-    return path.join(projectionDirectory, `generation-${executionId}.result.json`);
-}
-export function generationLogPath(projectionDirectory, executionId) {
-    return path.join(projectionDirectory, `generation-${executionId}.log`);
-}
-export function publishGenerationLaunch(projectionDirectory, document) {
-    return atomicPublishFile(generationLaunchPath(projectionDirectory, document.executionId), encodeProjectionJson(document));
-}
-export function publishGenerationResult(projectionDirectory, document) {
-    return atomicPublishFile(generationResultPath(projectionDirectory, document.executionId), encodeProjectionJson(document));
-}
-export function readGenerationLaunch(projectionDirectory, executionId) {
-    return JSON.parse(fs.readFileSync(generationLaunchPath(projectionDirectory, executionId), "utf8"));
-}
-/** Lineage tip is launch time, not lexical UUID order. A dirty tip is never skipped. */
-export function latestGenerationLaunch(projectionDirectory) {
-    const launches = fs.readdirSync(projectionDirectory)
-        .filter((name) => /^generation-[^.]+\.json$/.test(name))
-        .map((name) => JSON.parse(fs.readFileSync(path.join(projectionDirectory, name), "utf8")))
-        .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt) || left.executionId.localeCompare(right.executionId));
-    return launches.at(-1) ?? null;
-}
-export function latestGenerationResult(projectionDirectory) {
-    const launch = latestGenerationLaunch(projectionDirectory);
-    if (!launch)
-        return null;
+export function readGenerationEvents(projectionDirectory, executionId) {
+    let content;
     try {
-        return JSON.parse(fs.readFileSync(generationResultPath(projectionDirectory, launch.executionId), "utf8"));
+        content = fs.readFileSync(executionEventsPath(projectionDirectory, executionId), "utf8");
     }
     catch (error) {
         if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
+            return [];
         throw error;
     }
-}
-/** Shared status/tell/wake phase authority. */
-export function deriveProjectionPhase(projectionDirectory, nowMs, probePid = (pid) => { process.kill(pid, 0); }) {
-    const admission = readAdmissionLock(projectionDirectory);
-    const verdict = readVerdict(projectionDirectory);
-    if (admission) {
-        let alive = true;
+    const lines = content.split("\n");
+    const terminated = content.endsWith("\n");
+    const completeLines = lines.slice(0, -1);
+    const events = [];
+    for (const line of completeLines) {
+        events.push(JSON.parse(line));
+    }
+    if (!terminated && lines.at(-1)) {
         try {
-            probePid(admission.pid);
+            events.push(JSON.parse(lines.at(-1)));
         }
         catch {
-            alive = false;
-        }
-        let fresh = false;
-        try {
-            fresh = nowMs - fs.statSync(path.join(projectionDirectory, "heartbeat")).mtimeMs <= 15_000;
+            // A concurrent append can leave only this final record incomplete.
         }
-        catch { /* stale */ }
-        if (alive && fresh)
-            return "active";
-        if (!latestGenerationResult(projectionDirectory))
-            return "lost";
     }
-    if (verdict?.state === "dismissed")
-        return "dismissed";
-    if (verdict?.state === "failed")
-        return "failed";
-    if (verdict?.state === "done")
-        return "done";
-    return "quiescent";
+    return events;
 }
-/** The only wake eligibility predicate. */
-export function isProjectionWakeEligible(projectionDirectory) {
-    return latestGenerationResult(projectionDirectory) !== null &&
-        readAdmissionLock(projectionDirectory) === null &&
-        (readVerdict(projectionDirectory) === null || readVerdict(projectionDirectory)?.state === "done");
-}
-/** New executions replay all predecessor submissions exactly once through inflight. */
-export function demoteSubmittedTellsForReplay(projectionDirectory, executionId) {
-    const replayed = [];
-    for (const tellId of listTellIds(projectionDirectory, "submitted")) {
-        const submitted = readTellSubmitted(projectionDirectory, tellId);
-        if (submitted.executionId === executionId)
-            throw new ProjectionStateError(`submitted tell belongs to current execution: ${tellId}`);
-        const target = path.join(projectionDirectory, "inflight", tellId);
-        if (fs.existsSync(target))
-            throw new ProjectionStateError(`inflight tell already exists before replay: ${tellId}`);
-        fs.renameSync(path.join(projectionDirectory, "submitted", tellId), target);
-        atomicReplaceFile(target, encodeProjectionJson({
-            version: 1,
-            text: submitted.text,
-            createdAt: submitted.createdAt,
-            ...(submitted.effort ? { effort: submitted.effort } : {}),
-            replayedFrom: [...(submitted.replayedFrom ?? []), { executionId: submitted.executionId, fence: submitted.fence }],
-        }));
-        replayed.push(tellId);
-    }
-    return replayed;
-}
-export function readVerdict(projectionDirectory) {
+export function readProjectionEvents(projectionDirectory) {
+    let entries;
     try {
-        const raw = fs.readFileSync(path.join(projectionDirectory, "verdict.json"), "utf8");
-        return JSON.parse(raw);
+        entries = fs.readdirSync(projectionDirectory, { withFileTypes: true });
     }
     catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return null;
-        }
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return [];
         throw error;
     }
-}
-export function readPact(projectionDirectory) {
-    const raw = fs.readFileSync(path.join(projectionDirectory, "pact.json"), "utf8");
-    return JSON.parse(raw);
-}
-/** Touch heartbeat mtime with injected nowMs (empty file created at mint). */
-export function touchHeartbeat(projectionDirectory, nowMs) {
-    const heartbeatPath = path.join(projectionDirectory, "heartbeat");
-    const at = new Date(nowMs);
-    fs.utimesSync(heartbeatPath, at, at);
+    const names = entries
+        .filter((entry) => (entry.isFile()
+        && /^[0-9A-HJKMNP-TV-Z]{26}\.events\.jsonl$/.test(entry.name)))
+        .map((entry) => entry.name)
+        .sort();
+    const events = [];
+    for (const name of names) {
+        const executionId = name.slice(0, -".events.jsonl".length);
+        events.push(...readGenerationEvents(projectionDirectory, executionId));
+    }
+    return events;
 }

package/build/core/projection-generation-continuation.js

@@ -0,0 +1,31 @@
+import { ProjectionStateError } from "./atomic-publish.js";
+import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot_v2.js";
+import { listTellIds, readTellOriginal, readTellSubmitted, } from "./projection-core.js";
+export function snapshotPendingTells(projectionDirectory) {
+    const pending = ["inbox", "inflight", "submitted"]
+        .flatMap((layer) => listTellIds(projectionDirectory, layer)
+        .map((tellId) => ({ layer, tellId })))
+        .sort((left, right) => left.tellId.localeCompare(right.tellId));
+    const effort = pending.reduce((selected, item) => {
+        const tell = item.layer === "submitted"
+            ? readTellSubmitted(projectionDirectory, item.tellId)
+            : readTellOriginal(projectionDirectory, item.layer, item.tellId);
+        return tell.effort ?? selected;
+    }, undefined);
+    return {
+        tellIds: pending.map((item) => item.tellId),
+        ...(effort ? { effort } : {}),
+    };
+}
+export function applyContinuationEffort(inputs, effort) {
+    if (!effort)
+        return inputs;
+    let launchSnapshot;
+    try {
+        launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
+    }
+    catch (error) {
+        throw new ProjectionStateError("generation launch has an invalid immutable launchSnapshot", { cause: error });
+    }
+    return { ...inputs, launchSnapshot: applySnapshotEffort(launchSnapshot, effort) };
+}