@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/projection/generation/model.js

@@ -1,256 +0,0 @@
-import { GENERATION_VERDICT_STATES, } from "../projection-life-protocol.js";
-import { OutcomeErrorValidationError, parseCurrentOutcomeError, } from "../../../agents/harness/index.js";
-export { GENERATION_VERDICT_STATES };
-export const VERDICTS = new Set(GENERATION_VERDICT_STATES);
-export class ProjectionGenerationStoreError extends Error {
-    code = "PROJECTION_GENERATION_STORE_ERROR";
-    /** Historical schemas/outcomes are not a current lifecycle observation. */
-    observation;
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionGenerationStoreError";
-        this.observation = options?.observation ?? "unknown";
-    }
-}
-export function isIncompatibleProjectionGenerationStoreError(error) {
-    return error instanceof ProjectionGenerationStoreError
-        && error.observation === "incompatible";
-}
-export function isPlainObject(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-export function assertJsonValue(value, location, ancestors) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return;
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw new ProjectionGenerationStoreError(`${location} contains a non-finite number`);
-        return;
-    }
-    if (typeof value !== "object") {
-        throw new ProjectionGenerationStoreError(`${location} contains a non-JSON value`);
-    }
-    if (ancestors.has(value))
-        throw new ProjectionGenerationStoreError(`${location} contains a cycle`);
-    ancestors.add(value);
-    try {
-        if (Array.isArray(value)) {
-            value.forEach((item, index) => assertJsonValue(item, `${location}[${index}]`, ancestors));
-            return;
-        }
-        if (!isPlainObject(value))
-            throw new ProjectionGenerationStoreError(`${location} must contain only plain JSON objects`);
-        for (const [key, item] of Object.entries(value)) {
-            assertJsonValue(item, `${location}.${key}`, ancestors);
-        }
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}
-export function cloneFacts(value, location) {
-    if (!isPlainObject(value))
-        throw new ProjectionGenerationStoreError(`${location} must be a JSON object`);
-    assertJsonValue(value, location, new Set());
-    return JSON.parse(JSON.stringify(value));
-}
-export function assertExecutionId(executionId) {
-    if (typeof executionId !== "string" || executionId.trim() === "") {
-        throw new ProjectionGenerationStoreError("executionId must be a non-blank string");
-    }
-    return executionId;
-}
-export function assertNonNegativeSafeInteger(value, location) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new ProjectionGenerationStoreError(`${location} must be a non-negative safe integer`);
-    }
-    return value;
-}
-export function assertPositiveSafeInteger(value, location) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new ProjectionGenerationStoreError(`${location} must be a positive safe integer`);
-    }
-    return value;
-}
-export function assertIsoTimestamp(value, location) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new ProjectionGenerationStoreError(`${location} must be an ISO-8601 timestamp`);
-    }
-    const milliseconds = Date.parse(value);
-    if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== value) {
-        throw new ProjectionGenerationStoreError(`${location} must be a canonical ISO-8601 timestamp`);
-    }
-    return value;
-}
-export function validateTellFence(value, location) {
-    if (!Array.isArray(value))
-        throw new ProjectionGenerationStoreError(`${location} must be an array`);
-    const seen = new Set();
-    return value.map((tellId, index) => {
-        if (typeof tellId !== "string" || tellId.trim() === "") {
-            throw new ProjectionGenerationStoreError(`${location}[${index}] must be a non-blank string`);
-        }
-        if (seen.has(tellId))
-            throw new ProjectionGenerationStoreError(`${location} contains duplicate tell '${tellId}'`);
-        seen.add(tellId);
-        return tellId;
-    });
-}
-export function validateLaunchFacts(value, location) {
-    const facts = cloneFacts(value, location);
-    facts.createdAt = assertIsoTimestamp(facts.createdAt, `${location}.createdAt`);
-    if (facts.tellFence !== undefined)
-        facts.tellFence = validateTellFence(facts.tellFence, `${location}.tellFence`);
-    if ("state" in facts)
-        throw new ProjectionGenerationStoreError(`${location}.state is reserved for verdict records`);
-    return facts;
-}
-export function validateAdoptionFacts(value, location) {
-    const facts = cloneFacts(value, location);
-    if ("state" in facts)
-        throw new ProjectionGenerationStoreError(`${location}.state is reserved for verdict records`);
-    return facts;
-}
-export function validateKillIntentFacts(value, location) {
-    const facts = cloneFacts(value, location);
-    if (facts.operatorAction !== "kill") {
-        throw new ProjectionGenerationStoreError(`${location}.operatorAction must be exactly 'kill'`);
-    }
-    facts.killedAt = assertIsoTimestamp(facts.killedAt, `${location}.killedAt`);
-    if ("state" in facts)
-        throw new ProjectionGenerationStoreError(`${location}.state is reserved for verdict records`);
-    return facts;
-}
-export function validateInterruptIntentFacts(value, location) {
-    const facts = cloneFacts(value, location);
-    facts.interruptedAt = assertIsoTimestamp(facts.interruptedAt, `${location}.interruptedAt`);
-    if ("operatorAction" in facts) {
-        throw new ProjectionGenerationStoreError(`${location}.operatorAction is not part of interrupt-intent`);
-    }
-    if ("state" in facts)
-        throw new ProjectionGenerationStoreError(`${location}.state is reserved for verdict records`);
-    return facts;
-}
-export function validateVerdictFacts(value, location) {
-    const facts = cloneFacts(value, location);
-    if (typeof facts.state !== "string" || !VERDICTS.has(facts.state)) {
-        throw new ProjectionGenerationStoreError(`${location}.state is not in the closed verdict vocabulary`);
-    }
-    if (facts.terminalAt !== undefined) {
-        facts.terminalAt = assertIsoTimestamp(facts.terminalAt, `${location}.terminalAt`);
-    }
-    if (facts.state === "failed") {
-        try {
-            facts.error = parseCurrentOutcomeError(facts.error, `${location}.error`);
-        }
-        catch (error) {
-            if (error instanceof OutcomeErrorValidationError) {
-                throw new ProjectionGenerationStoreError(error.message, {
-                    observation: error.incompatible ? "incompatible" : "unknown",
-                });
-            }
-            throw error;
-        }
-    }
-    return facts;
-}
-export function parseStoredRow(row) {
-    const seq = typeof row.seq === "bigint" ? Number(row.seq) : row.seq;
-    if (!Number.isSafeInteger(seq) || seq <= 0) {
-        throw new ProjectionGenerationStoreError(`generation row has invalid seq '${String(row.seq)}'`);
-    }
-    if (row.kind !== "launch"
-        && row.kind !== "adoption"
-        && row.kind !== "kill-intent"
-        && row.kind !== "interrupt-intent"
-        && row.kind !== "verdict") {
-        throw new ProjectionGenerationStoreError(`generation row ${seq} has unknown kind '${row.kind}'`);
-    }
-    const executionId = assertExecutionId(row.execution_id);
-    let decoded;
-    try {
-        decoded = JSON.parse(row.facts_json);
-    }
-    catch (error) {
-        throw new ProjectionGenerationStoreError(`generation row ${seq} contains malformed facts JSON`, { cause: error, observation: "incompatible" });
-    }
-    const location = `generation row ${seq} facts`;
-    const facts = row.kind === "launch"
-        ? validateLaunchFacts(decoded, location)
-        : row.kind === "adoption"
-            ? validateAdoptionFacts(decoded, location)
-            : row.kind === "kill-intent"
-                ? validateKillIntentFacts(decoded, location)
-                : row.kind === "interrupt-intent"
-                    ? validateInterruptIntentFacts(decoded, location)
-                    : validateVerdictFacts(decoded, location);
-    return { seq, kind: row.kind, executionId, facts };
-}
-export function validateHistory(records) {
-    let current = null;
-    const launchIds = new Set();
-    for (let index = 0; index < records.length; index += 1) {
-        const record = records[index];
-        const expectedSeq = index + 1;
-        if (record.seq !== expectedSeq) {
-            throw new ProjectionGenerationStoreError(`generation history is not dense: expected seq ${expectedSeq}, found ${record.seq}`);
-        }
-        if (record.kind === "launch") {
-            if (current && !current.verdict) {
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} launches before execution '${current.launch.executionId}' is terminal`);
-            }
-            if (launchIds.has(record.executionId)) {
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} reuses executionId '${record.executionId}'`);
-            }
-            launchIds.add(record.executionId);
-            current = { launch: record };
-            continue;
-        }
-        if (!current)
-            throw new ProjectionGenerationStoreError(`generation row ${record.seq} appears before any launch`);
-        if (record.executionId !== current.launch.executionId) {
-            throw new ProjectionGenerationStoreError(`generation row ${record.seq} does not join the current launch`);
-        }
-        if (record.kind === "adoption") {
-            if (current.adoption)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates adoption`);
-            if (current.verdict)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} adopts a terminal execution`);
-            current.adoption = record;
-            continue;
-        }
-        if (record.kind === "kill-intent") {
-            if (current.killIntent || current.interruptIntent)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates generation stop intent`);
-            if (current.verdict)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} records kill-intent after verdict`);
-            current.killIntent = record;
-            continue;
-        }
-        if (record.kind === "interrupt-intent") {
-            if (current.killIntent || current.interruptIntent)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates generation stop intent`);
-            if (current.verdict)
-                throw new ProjectionGenerationStoreError(`generation row ${record.seq} records interrupt-intent after verdict`);
-            current.interruptIntent = record;
-            continue;
-        }
-        if (current.verdict)
-            throw new ProjectionGenerationStoreError(`generation row ${record.seq} duplicates verdict`);
-        current.verdict = record;
-    }
-    return current;
-}
-export function extractTerminalTimestamp(facts) {
-    if (!facts)
-        return undefined;
-    for (const key of ["terminalAt", "completedAt", "failedAt", "dismissedAt", "killedAt"]) {
-        const value = facts[key];
-        if (typeof value === "string" && Number.isFinite(Date.parse(value)))
-            return value;
-    }
-    return undefined;
-}

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

@@ -1,84 +0,0 @@
-import { ProjectionStateError } from "../../atomic-publish.js";
-import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../../../agents/launch-snapshot/model.js";
-import { listTellMetadataFromDatabase, readPendingTellWindowFromDatabase, } from "../tell/store.js";
-import { PENDING_PROJECTION_TELL_STATES } from "../tell/model.js";
-import { readValidatedHistory, withGenerationReadSnapshot } from "./database.js";
-function snapshotTells(database, layers, admit) {
-    const pending = listTellMetadataFromDatabase(database, layers)
-        .filter((item) => admit?.({
-        layer: item.state,
-        tellId: item.tellId,
-        ...(item.executionId ? { executionId: item.executionId } : {}),
-    }) ?? true);
-    const effort = pending.reduce((selected, item) => {
-        return item.effort ?? selected;
-    }, undefined);
-    return {
-        tellIds: pending.map((item) => item.tellId),
-        ...(effort ? { effort } : {}),
-    };
-}
-/** All non-consumed tells remain eligible for an ordinary successor. */
-export function snapshotPendingTells(projectionDirectory) {
-    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
-}
-/** Interrupt successors replay every non-consumed tell. */
-export function snapshotInterruptTells(projectionDirectory, executionId) {
-    void executionId;
-    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
-}
-/** Failed launch recovery retains every non-consumed tell. */
-export function snapshotRetainedSuccessorTells(projectionDirectory, retainedFence) {
-    void retainedFence;
-    return withGenerationReadSnapshot(projectionDirectory, (database) => snapshotTells(database, PENDING_PROJECTION_TELL_STATES));
-}
-/** Build the durable successor fence only after continuation is admitted. */
-export function snapshotProjectionContinuationTells(projectionDirectory, current) {
-    const snapshot = readProjectionGenerationContinuationSnapshot(projectionDirectory, 0);
-    if (snapshot.current?.launch.executionId !== current?.launch.executionId) {
-        throw new ProjectionStateError("projection generation changed while selecting continuation tells");
-    }
-    return snapshot.successor;
-}
-function readContinuationFromDatabase(database, limit = 10) {
-    const tells = readPendingTellWindowFromDatabase(database, limit);
-    const successor = snapshotTells(database, PENDING_PROJECTION_TELL_STATES);
-    return {
-        tells,
-        successor,
-        requiresWake: successor.tellIds.length > 0,
-    };
-}
-/** One heart snapshot owns generation selection and all continuation facts. */
-export function readProjectionGenerationContinuationSnapshot(projectionDirectory, limit = 10) {
-    return withGenerationReadSnapshot(projectionDirectory, (database) => {
-        const { records, current } = readValidatedHistory(database);
-        const continuation = readContinuationFromDatabase(database, limit);
-        return {
-            records,
-            current,
-            generationSequence: records.at(-1)?.seq ?? 0,
-            ...continuation,
-        };
-    });
-}
-/** One continuation eligibility fact shared by tell, wait, and wake. */
-export function readProjectionContinuation(projectionDirectory, current, limit = 10) {
-    const snapshot = readProjectionGenerationContinuationSnapshot(projectionDirectory, limit);
-    if (snapshot.current?.launch.executionId !== current?.launch.executionId) {
-        throw new ProjectionStateError("projection generation changed while reading continuation");
-    }
-    return snapshot;
-}
-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) };
-}

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

@@ -1,217 +0,0 @@
-import { initializeConfig } from "../../../config/env.js";
-import { buildCallTerms } from "../../../agents/call-terms.js";
-import { parseResolvedAkumaLaunchSnapshot } from "../../../agents/launch-snapshot/model.js";
-import { revive, call, } from "../../../agents/harness/index.js";
-import { claimAndReserveFencedTells, readTellOriginal, readProjectionEvents, } from "../projection-core.js";
-import { createProjectionExecutionObserver, renderProjectionTellFrame, } from "../projection-execution-observer.js";
-import { readProjectionIdentity } from "../projection-identity.js";
-import { selectValidStoredAgentEvents } from "../../stored-agent-event.js";
-import { persistResponseHistory } from "../../transcripts.js";
-import { attachProviderLoaderPorts, } from "../../provider-loader-ports.js";
-function isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function requireString(value, field) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`generation launch ${field} must be a non-blank string`);
-    }
-    return value;
-}
-function optionalString(value, field) {
-    return value === undefined ? undefined : requireString(value, field);
-}
-function requirePositiveSafeInteger(value, field) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-        throw new Error(`generation launch ${field} must be a positive safe integer`);
-    }
-    return value;
-}
-function requireNonNegativeSafeInteger(value, field) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-        throw new Error(`generation launch ${field} must be a non-negative safe integer`);
-    }
-    return value;
-}
-function parseLaunchInputs(launch) {
-    const raw = launch.facts.inputs;
-    if (!isObject(raw))
-        throw new Error("generation launch inputs must be an object");
-    let launchSnapshot;
-    try {
-        launchSnapshot = parseResolvedAkumaLaunchSnapshot(raw.launchSnapshot);
-    }
-    catch (error) {
-        throw new Error(`generation launch launchSnapshot is invalid: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-    if (raw.persistProjectionResponse !== true && raw.persistProjectionResponse !== false) {
-        throw new Error("generation launch persistProjectionResponse must be boolean");
-    }
-    if (raw.session !== undefined && !isObject(raw.session)) {
-        throw new Error("generation launch session must be an object");
-    }
-    const evidenceCwd = optionalString(raw.evidenceCwd, "evidenceCwd");
-    const title = optionalString(raw.title, "title");
-    const context = optionalString(raw.context, "context");
-    const resumePath = optionalString(raw.resumePath, "resumePath");
-    const sourceArtifactId = optionalString(raw.sourceArtifactId, "sourceArtifactId");
-    return {
-        prompt: requireString(raw.prompt, "prompt"),
-        cwd: requireString(raw.cwd, "cwd"),
-        task: requireString(raw.task, "task"),
-        historyCwd: requireString(raw.historyCwd, "historyCwd"),
-        ...(evidenceCwd ? { evidenceCwd } : {}),
-        ...(title ? { title } : {}),
-        ...(context ? { context } : {}),
-        launchSnapshot,
-        idleTimeoutMs: requirePositiveSafeInteger(raw.idleTimeoutMs, "idleTimeoutMs"),
-        executionTimeoutMs: requireNonNegativeSafeInteger(raw.executionTimeoutMs, "executionTimeoutMs"),
-        persistProjectionResponse: raw.persistProjectionResponse,
-        ...(raw.session ? { session: raw.session } : {}),
-        ...(resumePath ? { resumePath } : {}),
-        ...(sourceArtifactId ? { sourceArtifactId } : {}),
-    };
-}
-function persistenceError(error) {
-    return (error instanceof Error ? error.message : String(error))
-        .replace(/[\r\n]+/g, " ")
-        .trim() || "response persistence failed";
-}
-function responseTitle(executionId, title) {
-    return `${executionId.slice(-16)}-${title ?? "call"}-${executionId}`;
-}
-function asJsonObject(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function maximumValidEnvelopeTurn(projectionDirectory) {
-    const { events } = selectValidStoredAgentEvents(readProjectionEvents(projectionDirectory));
-    let maximum = 0;
-    for (const event of events) {
-        if (event.turn > maximum)
-            maximum = event.turn;
-    }
-    return maximum;
-}
-async function completionFacts(projectionDirectory, executionId, inputs, outcome) {
-    const providerUnavailable = outcome.error?.code === "SUBAGENT_PROVIDER_UNAVAILABLE";
-    let persistence = {};
-    if (inputs.persistProjectionResponse && !providerUnavailable) {
-        try {
-            if (!inputs.evidenceCwd) {
-                throw new Error("projection response persistence is missing evidenceCwd");
-            }
-            const pact = readProjectionIdentity(projectionDirectory);
-            persistence = await persistResponseHistory({
-                tool: "call",
-                cwd: inputs.historyCwd,
-                provenance: {
-                    authority: pact.authority,
-                    binding: pact.binding,
-                    evidenceCwd: inputs.evidenceCwd,
-                },
-                task: inputs.task,
-                response: outcome.finalMessage,
-                ...(outcome.error ? { terminalFailure: outcome.error } : {}),
-                session: outcome.session,
-                launchSnapshot: inputs.launchSnapshot,
-                effectivePolicy: inputs.launchSnapshot.akuma.policy,
-                subagentName: inputs.launchSnapshot.akuma.name,
-                title: responseTitle(executionId, inputs.title),
-                ...(inputs.context ? { context: inputs.context } : {}),
-            });
-        }
-        catch (error) {
-            persistence = { responsePersistError: persistenceError(error) };
-        }
-    }
-    return asJsonObject({
-        completedAt: new Date().toISOString(),
-        finalMessage: outcome.finalMessage,
-        output: outcome.output,
-        diagnostics: outcome.diagnostics,
-        session: outcome.session,
-        warnings: outcome.warnings,
-        launchSnapshot: inputs.launchSnapshot,
-        effectivePolicy: inputs.launchSnapshot.akuma.policy,
-        ...(outcome.error ? { error: outcome.error } : {}),
-        ...(providerUnavailable && inputs.sourceArtifactId
-            ? { sourceArtifactId: inputs.sourceArtifactId }
-            : {}),
-        ...persistence,
-    });
-}
-/**
- * Construct the public Projection once and expose a provider-neutral execution
- * handle. Provider adapters and harness public types are unchanged.
- */
-export function prepareProjectionGenerationExecution(projectionDirectory, launch, providerLoaderPorts = {}) {
-    const inputs = parseLaunchInputs(launch);
-    initializeConfig(process.env, inputs.cwd);
-    const executionId = launch.executionId;
-    const initialTellIds = claimAndReserveFencedTells(projectionDirectory, launch.facts.tellFence ?? [], executionId);
-    const tellPrompt = initialTellIds.map((tellId) => {
-        const tell = readTellOriginal(projectionDirectory, "inflight", tellId);
-        return renderProjectionTellFrame(tellId, tell.text);
-    }).join("\n\n");
-    const prompt = tellPrompt === ""
-        ? inputs.prompt
-        : inputs.session
-            ? tellPrompt
-            : `${inputs.prompt}\n\n${tellPrompt}`;
-    const terms = attachProviderLoaderPorts(buildCallTerms(inputs.launchSnapshot, prompt, inputs.cwd, {
-        idleTimeoutMs: inputs.idleTimeoutMs,
-        executionTimeoutMs: inputs.executionTimeoutMs,
-        initialTurn: maximumValidEnvelopeTurn(projectionDirectory),
-    }), providerLoaderPorts);
-    const observerController = createProjectionExecutionObserver({
-        projectionDirectory,
-        executionId,
-        reservedLaunchTellIds: initialTellIds,
-    });
-    return {
-        start() {
-            let projection;
-            try {
-                projection = inputs.session
-                    ? revive({
-                        ...terms,
-                        session: inputs.session,
-                        resumePath: inputs.resumePath ?? projectionDirectory,
-                    }, { observer: observerController.observer, launchTellIds: initialTellIds })
-                    : call(terms, { observer: observerController.observer, launchTellIds: initialTellIds });
-            }
-            catch (error) {
-                void observerController.close();
-                throw error;
-            }
-            const outcome = projection.outcome.then(async (result) => {
-                try {
-                    return {
-                        verdict: result.status === "completed"
-                            ? "completed"
-                            : result.status === "dismissed"
-                                ? "dismissed"
-                                : result.status === "interrupted"
-                                    ? "interrupted"
-                                    : "failed",
-                        facts: await completionFacts(projectionDirectory, executionId, inputs, result),
-                    };
-                }
-                finally {
-                    await observerController.close();
-                }
-            }, async (error) => {
-                await observerController.close();
-                throw error;
-            });
-            return {
-                events: projection.events,
-                outcome,
-                abort: (mode) => projection.abort(mode),
-            };
-        },
-        dispose: () => observerController.close(),
-    };
-}
-export function executeProjectionGeneration(projectionDirectory, launch, providerLoaderPorts = {}) {
-    return prepareProjectionGenerationExecution(projectionDirectory, launch, providerLoaderPorts).start();
-}

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

@@ -1,17 +0,0 @@
-import { randomBytes } from "node:crypto";
-import * as path from "node:path";
-import { ProjectionStateError } from "../../atomic-publish.js";
-import { createUlid } from "../../ids.js";
-const EXECUTION_ID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
-export function createProjectionExecutionId(nowMs = Date.now()) {
-    return createUlid(nowMs, [...randomBytes(10)]);
-}
-export function assertProjectionExecutionId(executionId) {
-    if (!EXECUTION_ID_PATTERN.test(executionId)) {
-        throw new ProjectionStateError(`invalid projection execution id: ${executionId}`);
-    }
-}
-export function executionStdioLogPath(projectionDirectory, executionId) {
-    assertProjectionExecutionId(executionId);
-    return path.join(projectionDirectory, `${executionId}.stdio.log`);
-}