@a5c-ai/babysitter-sdk 0.0.16

package/dist/runner/nodeRunner.js

@@ -0,0 +1,354 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTaskRunnerError = void 0;
+exports.runNodeTask = runNodeTask;
+exports.commitNodeResult = commitNodeResult;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const tasks_1 = require("../storage/tasks");
+const commitEffectResult_1 = require("../runtime/commitEffectResult");
+const env_1 = require("./env");
+const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+class NodeTaskRunnerError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "NodeTaskRunnerError";
+    }
+}
+exports.NodeTaskRunnerError = NodeTaskRunnerError;
+async function runNodeTask(options) {
+    const task = options.task ?? (await loadNodeTask(options.runDir, options.effectId));
+    validateNodeTask(task, options.effectId);
+    const hydration = options.hydration ??
+        (0, env_1.resolveNodeTaskEnv)(task, {
+            baseEnv: options.baseEnv ?? process.env,
+            overrides: options.envOverrides,
+            inheritProcessEnv: options.cleanEnv ? false : options.inheritProcessEnv,
+        });
+    const entryPath = resolveWorkspacePath(options.workspaceRoot ?? options.runDir, task.node?.entry, "node.entry", options.effectId);
+    const cwdPath = resolveWorkspacePath(options.workspaceRoot ?? options.runDir, task.node?.cwd, "node.cwd", options.effectId);
+    const args = task.node?.args ? [...task.node.args] : [];
+    const timeoutMs = typeof options.timeoutMs === "number" ? options.timeoutMs : task.node?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const commandDetails = {
+        binary: options.nodeBinaryPath ?? process.execPath,
+        args: [entryPath, ...args],
+        cwd: cwdPath ?? options.runDir,
+    };
+    const envForProcess = { ...hydration.env };
+    const ioPaths = applyIoEnv(envForProcess, options.runDir, options.effectId, task.io);
+    if (options.dryRun) {
+        const nowIso = new Date().toISOString();
+        return {
+            task,
+            stdout: "",
+            stderr: "",
+            exitCode: null,
+            signal: null,
+            timedOut: false,
+            startedAt: nowIso,
+            finishedAt: nowIso,
+            durationMs: 0,
+            timeoutMs,
+            command: commandDetails,
+            io: ioPaths,
+            hydrated: hydration,
+        };
+    }
+    await ensureParentDir(ioPaths.inputJsonPath);
+    await ensureParentDir(ioPaths.outputJsonPath);
+    await ensureParentDir(ioPaths.stdoutPath);
+    await ensureParentDir(ioPaths.stderrPath);
+    await stageTaskInputs({
+        task,
+        runDir: options.runDir,
+        effectId: options.effectId,
+        inputJsonPath: ioPaths.inputJsonPath,
+    });
+    const startedAtMs = Date.now();
+    const startedAtIso = new Date(startedAtMs).toISOString();
+    const runResult = await spawnNodeProcess({
+        command: commandDetails.binary,
+        args: commandDetails.args,
+        cwd: commandDetails.cwd,
+        env: envForProcess,
+        timeoutMs,
+        stdoutPath: ioPaths.stdoutPath,
+        stderrPath: ioPaths.stderrPath,
+        onStdoutChunk: options.onStdoutChunk,
+        onStderrChunk: options.onStderrChunk,
+    });
+    const finishedAtMs = Date.now();
+    const finishedAtIso = new Date(finishedAtMs).toISOString();
+    let parsedOutput;
+    parsedOutput = await readOptionalJson(ioPaths.outputJsonPath);
+    return {
+        task,
+        stdout: runResult.stdout,
+        stderr: runResult.stderr,
+        exitCode: runResult.exitCode,
+        signal: runResult.signal,
+        timedOut: runResult.timedOut,
+        startedAt: startedAtIso,
+        finishedAt: finishedAtIso,
+        durationMs: finishedAtMs - startedAtMs,
+        timeoutMs,
+        output: parsedOutput,
+        command: commandDetails,
+        io: ioPaths,
+        hydrated: hydration,
+    };
+}
+async function commitNodeResult(options) {
+    const { runDir, effectId, invocationKey, logger, result } = options;
+    const stdoutRef = toRunRelativePosix(runDir, result.io.stdoutPath);
+    const stderrRef = toRunRelativePosix(runDir, result.io.stderrPath);
+    const outputJsonRef = toRunRelativePosix(runDir, result.io.outputJsonPath);
+    const status = !result.timedOut && (result.exitCode === null || result.exitCode === 0) ? "ok" : "error";
+    const metadata = {
+        durationMs: result.durationMs,
+        timeoutMs: result.timeoutMs,
+        exitCode: result.exitCode,
+        signal: result.signal ?? undefined,
+        timedOut: result.timedOut,
+        outputJsonRef,
+    };
+    return (0, commitEffectResult_1.commitEffectResult)({
+        runDir,
+        effectId,
+        invocationKey,
+        logger,
+        result: {
+            status,
+            value: status === "ok" ? result.output : undefined,
+            error: status === "error" ? buildNodeTaskErrorPayload(result, outputJsonRef) : undefined,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            stdoutRef,
+            stderrRef,
+            startedAt: result.startedAt,
+            finishedAt: result.finishedAt,
+            metadata,
+        },
+    });
+}
+async function loadNodeTask(runDir, effectId) {
+    const json = await (0, tasks_1.readTaskDefinition)(runDir, effectId);
+    if (!json) {
+        throw new NodeTaskRunnerError(`Task definition for effect ${effectId} is missing`, "missing_task");
+    }
+    return json;
+}
+function validateNodeTask(task, effectId) {
+    if (task.kind !== "node" || !task.node) {
+        throw new NodeTaskRunnerError(`Effect ${effectId} is not a node task`, "invalid_task_kind");
+    }
+    if (!task.node.entry || typeof task.node.entry !== "string") {
+        throw new NodeTaskRunnerError(`Effect ${effectId} node.entry is missing`, "missing_entry");
+    }
+}
+function resolveWorkspacePath(baseDir, value, field, effectId) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.replace(/\\/g, "/");
+    const isAbsolute = path_1.default.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized);
+    const resolved = isAbsolute ? normalized : path_1.default.join(baseDir, ...normalized.split("/"));
+    if (!resolved) {
+        throw new NodeTaskRunnerError(`Effect ${effectId} has an invalid ${field}`, "invalid_path");
+    }
+    return path_1.default.normalize(resolved);
+}
+function resolveRunRelativePath(runDir, relative) {
+    if (!relative)
+        return undefined;
+    if (path_1.default.isAbsolute(relative) || /^[A-Za-z]:[\\/]/.test(relative)) {
+        return path_1.default.normalize(relative);
+    }
+    const normalized = relative.replace(/\\/g, "/");
+    return path_1.default.join(runDir, ...normalized.split("/"));
+}
+function applyIoEnv(env, runDir, effectId, io) {
+    const normalizedIo = withDefaultIoHints(effectId, io);
+    const inputJsonPath = resolveRunRelativePath(runDir, normalizedIo.inputJsonPath);
+    const outputJsonPath = resolveRunRelativePath(runDir, normalizedIo.outputJsonPath);
+    const stdoutPath = resolveRunRelativePath(runDir, normalizedIo.stdoutPath);
+    const stderrPath = resolveRunRelativePath(runDir, normalizedIo.stderrPath);
+    env.BABYSITTER_INPUT_JSON = inputJsonPath;
+    env.BABYSITTER_OUTPUT_JSON = outputJsonPath;
+    env.BABYSITTER_STDOUT_PATH = stdoutPath;
+    env.BABYSITTER_STDERR_PATH = stderrPath;
+    env.BABYSITTER_EFFECT_ID = effectId;
+    return { inputJsonPath, outputJsonPath, stdoutPath, stderrPath };
+}
+async function readOptionalJson(filePath) {
+    try {
+        const contents = await fs_1.promises.readFile(filePath, "utf8");
+        if (!contents.trim()) {
+            return undefined;
+        }
+        return JSON.parse(contents);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function withDefaultIoHints(effectId, io) {
+    const defaulted = {
+        inputJsonPath: `tasks/${effectId}/inputs.json`,
+        outputJsonPath: `tasks/${effectId}/result.json`,
+        stdoutPath: `tasks/${effectId}/stdout.log`,
+        stderrPath: `tasks/${effectId}/stderr.log`,
+    };
+    return {
+        inputJsonPath: typeof io?.inputJsonPath === "string" && io.inputJsonPath.trim().length > 0
+            ? io.inputJsonPath
+            : defaulted.inputJsonPath,
+        outputJsonPath: typeof io?.outputJsonPath === "string" && io.outputJsonPath.trim().length > 0
+            ? io.outputJsonPath
+            : defaulted.outputJsonPath,
+        stdoutPath: typeof io?.stdoutPath === "string" && io.stdoutPath.trim().length > 0 ? io.stdoutPath : defaulted.stdoutPath,
+        stderrPath: typeof io?.stderrPath === "string" && io.stderrPath.trim().length > 0 ? io.stderrPath : defaulted.stderrPath,
+    };
+}
+async function spawnNodeProcess(options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(options.command, options.args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutStream = (0, fs_1.createWriteStream)(options.stdoutPath, { flags: "w" });
+        const stderrStream = (0, fs_1.createWriteStream)(options.stderrPath, { flags: "w" });
+        let streamsClosed = false;
+        const finishStreams = () => {
+            if (streamsClosed)
+                return;
+            streamsClosed = true;
+            stdoutStream.end();
+            stderrStream.end();
+        };
+        let settled = false;
+        const finishWithError = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            finishStreams();
+            reject(error);
+        };
+        const finishWithSuccess = (payload) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            finishStreams();
+            resolve(payload);
+        };
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+            stdoutStream.write(chunk);
+            options.onStdoutChunk?.(chunk);
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+            stderrStream.write(chunk);
+            options.onStderrChunk?.(chunk);
+        });
+        stdoutStream.on("error", (error) => {
+            child.kill();
+            finishWithError(new NodeTaskRunnerError(`Failed to write stdout log: ${error.message}`, "stdout_log_error"));
+        });
+        stderrStream.on("error", (error) => {
+            child.kill();
+            finishWithError(new NodeTaskRunnerError(`Failed to write stderr log: ${error.message}`, "stderr_log_error"));
+        });
+        const timeoutHandle = options.timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill();
+            }, options.timeoutMs)
+            : undefined;
+        child.on("error", (error) => {
+            finishWithError(new NodeTaskRunnerError(`Failed to spawn node task: ${error.message}`, "spawn_error"));
+        });
+        child.on("close", (code, signal) => {
+            finishWithSuccess({ stdout, stderr, exitCode: code, signal, timedOut });
+        });
+    });
+}
+async function ensureParentDir(filePath) {
+    await fs_1.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+}
+async function stageTaskInputs(options) {
+    const inlineInputs = options.task.inputs;
+    const hasInlineInputs = inlineInputs !== undefined;
+    const maybeInputsRef = options.task.inputsRef;
+    const inputsRef = typeof maybeInputsRef === "string" ? maybeInputsRef : undefined;
+    if (!hasInlineInputs && !inputsRef) {
+        return;
+    }
+    const payload = hasInlineInputs && inlineInputs !== undefined
+        ? inlineInputs
+        : await readInputsRefValue(options.runDir, inputsRef, options.effectId);
+    await fs_1.promises.writeFile(options.inputJsonPath, JSON.stringify(payload, null, 2) + "\n", "utf8");
+}
+async function readInputsRefValue(runDir, ref, effectId) {
+    const resolved = resolveRunRelativePath(runDir, ref);
+    if (!resolved) {
+        throw new NodeTaskRunnerError(`Effect ${effectId} has an invalid inputsRef path`, "invalid_inputs_ref");
+    }
+    try {
+        const contents = await fs_1.promises.readFile(resolved, "utf8");
+        if (!contents.trim()) {
+            throw new NodeTaskRunnerError(`Effect ${effectId} inputsRef file is empty`, "empty_inputs_ref");
+        }
+        return JSON.parse(contents);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            throw new NodeTaskRunnerError(`Effect ${effectId} inputsRef file is missing`, "missing_inputs_ref");
+        }
+        throw error;
+    }
+}
+function buildNodeTaskErrorPayload(result, outputJsonRef) {
+    const base = result.exitCode === null
+        ? "Node task exited without a code"
+        : `Node task exited with code ${result.exitCode}${result.signal ? ` (signal ${result.signal})` : ""}`;
+    const message = result.timedOut ? `Node task timed out after ${result.timeoutMs}ms` : base;
+    return {
+        message,
+        exitCode: result.exitCode,
+        signal: result.signal ?? undefined,
+        timedOut: result.timedOut,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        outputJsonRef,
+    };
+}
+function toRunRelativePosix(runDir, absolutePath) {
+    if (!absolutePath)
+        return undefined;
+    const relative = path_1.default.relative(runDir, absolutePath);
+    if (!relative || relative.startsWith(".."))
+        return undefined;
+    return relative.replace(/\\/g, "/");
+}

package/dist/runtime/commitEffectResult.d.ts

@@ -0,0 +1,3 @@
+import { CommitEffectResultArtifacts, CommitEffectResultOptions } from "./types";
+export declare function commitEffectResult(options: CommitEffectResultOptions): Promise<CommitEffectResultArtifacts>;
+//# sourceMappingURL=commitEffectResult.d.ts.map

package/dist/runtime/commitEffectResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commitEffectResult.d.ts","sourceRoot":"","sources":["../../src/runtime/commitEffectResult.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,EAG1B,MAAM,SAAS,CAAC;AAOjB,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAoEjH"}

package/dist/runtime/commitEffectResult.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitEffectResult = commitEffectResult;
+const journal_1 = require("../storage/journal");
+const effectIndex_1 = require("./replay/effectIndex");
+const exceptions_1 = require("./exceptions");
+const errorUtils_1 = require("./errorUtils");
+const instrumentation_1 = require("./instrumentation");
+const registry_1 = require("../tasks/registry");
+const serializer_1 = require("../tasks/serializer");
+async function commitEffectResult(options) {
+    guardResultPayload(options);
+    const effectIndex = await (0, effectIndex_1.buildEffectIndex)({ runDir: options.runDir });
+    const record = effectIndex.getByEffectId(options.effectId);
+    if (!record) {
+        logCommitFailure(options, "unknown_effect");
+        throw new exceptions_1.RunFailedError(`Unknown effectId ${options.effectId}`);
+    }
+    if (record.status !== "requested") {
+        logCommitFailure(options, "already_resolved", { currentStatus: record.status });
+        throw new exceptions_1.RunFailedError(`Effect ${options.effectId} is already resolved`);
+    }
+    ensureInvocationKeyMatches(options, record);
+    const resultPayload = buildResultPayload(options);
+    const { resultRef, stdoutRef: writtenStdoutRef, stderrRef: writtenStderrRef } = await (0, serializer_1.serializeAndWriteTaskResult)({
+        runDir: options.runDir,
+        effectId: options.effectId,
+        taskId: requireTaskId(record),
+        invocationKey: record.invocationKey,
+        payload: resultPayload,
+    });
+    const stdoutRef = resultPayload.stdoutRef ?? writtenStdoutRef;
+    const stderrRef = resultPayload.stderrRef ?? writtenStderrRef;
+    const eventError = resultPayload.status === "error" ? resultPayload.error : undefined;
+    const resolvedEvent = await (0, journal_1.appendEvent)({
+        runDir: options.runDir,
+        eventType: "EFFECT_RESOLVED",
+        event: {
+            effectId: options.effectId,
+            status: options.result.status,
+            resultRef,
+            error: eventError,
+            stdoutRef,
+            stderrRef,
+            startedAt: resultPayload.startedAt,
+            finishedAt: resultPayload.finishedAt,
+        },
+    });
+    registry_1.globalTaskRegistry.resolveEffect(options.effectId, {
+        status: options.result.status === "ok" ? "resolved_ok" : "resolved_error",
+        resultRef,
+        stdoutRef,
+        stderrRef,
+        resolvedAt: resolvedEvent.recordedAt,
+    });
+    (0, instrumentation_1.emitRuntimeMetric)(options.logger, "commit.effect", {
+        effectId: options.effectId,
+        invocationKey: record.invocationKey,
+        status: options.result.status,
+        runDir: options.runDir,
+        hasStdout: Boolean(stdoutRef),
+        hasStderr: Boolean(stderrRef),
+    });
+    return {
+        resultRef,
+        stdoutRef: stdoutRef ?? undefined,
+        stderrRef: stderrRef ?? undefined,
+        startedAt: resultPayload.startedAt,
+        finishedAt: resultPayload.finishedAt,
+    };
+}
+function ensureInvocationKeyMatches(options, record) {
+    if (!options.invocationKey)
+        return;
+    if (options.invocationKey === record.invocationKey) {
+        return;
+    }
+    logCommitFailure(options, "invocation_mismatch", {
+        expectedInvocationKey: record.invocationKey,
+        providedInvocationKey: options.invocationKey,
+    });
+    throw new exceptions_1.RunFailedError(`Invocation key mismatch for effect ${options.effectId}`, {
+        effectId: options.effectId,
+        expectedInvocationKey: record.invocationKey,
+        providedInvocationKey: options.invocationKey,
+    });
+}
+function serializeEffectError(error) {
+    return (0, errorUtils_1.toSerializedEffectError)(error);
+}
+function guardResultPayload(options) {
+    try {
+        validateResultPayload(options);
+    }
+    catch (error) {
+        logCommitFailure(options, "invalid_payload", {
+            message: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+function validateResultPayload(options) {
+    if (options.result.status === "ok" && options.result.error !== undefined) {
+        throw new exceptions_1.RunFailedError("Cannot provide an error payload when result status is 'ok'");
+    }
+    if (options.result.status === "error" && options.result.error === undefined) {
+        throw new exceptions_1.RunFailedError("Missing error payload for result status 'error'");
+    }
+    if (options.result.stdout !== undefined && typeof options.result.stdout !== "string") {
+        throw new exceptions_1.RunFailedError("stdout must be a string when provided");
+    }
+    if (options.result.stderr !== undefined && typeof options.result.stderr !== "string") {
+        throw new exceptions_1.RunFailedError("stderr must be a string when provided");
+    }
+    if (options.result.stdoutRef !== undefined && typeof options.result.stdoutRef !== "string") {
+        throw new exceptions_1.RunFailedError("stdoutRef must be a string when provided");
+    }
+    if (options.result.stderrRef !== undefined && typeof options.result.stderrRef !== "string") {
+        throw new exceptions_1.RunFailedError("stderrRef must be a string when provided");
+    }
+    if (options.result.startedAt !== undefined && typeof options.result.startedAt !== "string") {
+        throw new exceptions_1.RunFailedError("startedAt must be an ISO timestamp string when provided");
+    }
+    if (options.result.finishedAt !== undefined && typeof options.result.finishedAt !== "string") {
+        throw new exceptions_1.RunFailedError("finishedAt must be an ISO timestamp string when provided");
+    }
+    if (options.result.metadata !== undefined &&
+        (options.result.metadata === null || typeof options.result.metadata !== "object" || Array.isArray(options.result.metadata))) {
+        throw new exceptions_1.RunFailedError("metadata must be a JsonRecord when provided");
+    }
+}
+function logCommitFailure(options, reason, extra = {}) {
+    (0, instrumentation_1.emitRuntimeMetric)(options.logger, "commit.effect", {
+        effectId: options.effectId,
+        status: "rejected",
+        reason,
+        runDir: options.runDir,
+        invocationKey: options.invocationKey,
+        ...extra,
+    });
+}
+function buildResultPayload(options) {
+    const base = {
+        stdout: options.result.stdout,
+        stderr: options.result.stderr,
+        stdoutRef: options.result.stdoutRef,
+        stderrRef: options.result.stderrRef,
+        startedAt: options.result.startedAt,
+        finishedAt: options.result.finishedAt,
+        metadata: options.result.metadata,
+    };
+    if (options.result.status === "ok") {
+        return {
+            status: "ok",
+            result: options.result.value,
+            ...base,
+        };
+    }
+    return {
+        status: "error",
+        error: serializeEffectError(options.result.error),
+        ...base,
+    };
+}
+function requireTaskId(record) {
+    if (record.taskId) {
+        return record.taskId;
+    }
+    throw new exceptions_1.RunFailedError(`Effect ${record.effectId} is missing task id metadata`, {
+        effectId: record.effectId,
+    });
+}

package/dist/runtime/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const replaySchemaVersion = "2026.01-storage-preview";
+//# sourceMappingURL=constants.d.ts.map

package/dist/runtime/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,4BAAyB,CAAC"}

package/dist/runtime/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaySchemaVersion = void 0;
+const paths_1 = require("../storage/paths");
+exports.replaySchemaVersion = paths_1.DEFAULT_LAYOUT_VERSION;

package/dist/runtime/createRun.d.ts

@@ -0,0 +1,3 @@
+import type { CreateRunOptions, CreateRunResult } from "./types";
+export declare function createRun(options: CreateRunOptions): Promise<CreateRunResult>;
+//# sourceMappingURL=createRun.d.ts.map

package/dist/runtime/createRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRun.d.ts","sourceRoot":"","sources":["../../src/runtime/createRun.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEjE,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAkDnF"}

package/dist/runtime/createRun.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRun = createRun;
+const path_1 = __importDefault(require("path"));
+const createRunDir_1 = require("../storage/createRunDir");
+const journal_1 = require("../storage/journal");
+const lock_1 = require("../storage/lock");
+const paths_1 = require("../storage/paths");
+const ulids_1 = require("../storage/ulids");
+async function createRun(options) {
+    const runId = options.runId ?? (0, ulids_1.nextUlid)();
+    validateRunId(runId);
+    const runDir = (0, paths_1.getRunDir)(options.runsDir, runId);
+    const normalizedEntrypoint = normalizeEntrypoint(runDir, options.process.importPath, options.process.exportName);
+    const requestId = options.request ?? options.process.processId ?? runId;
+    const { metadata } = await (0, createRunDir_1.createRunDir)({
+        runsRoot: options.runsDir,
+        runId,
+        request: requestId,
+        processId: options.process.processId,
+        processRevision: options.processRevision,
+        layoutVersion: options.layoutVersion,
+        inputs: options.inputs,
+        entrypoint: normalizedEntrypoint,
+        processPath: normalizedEntrypoint.importPath,
+        extraMetadata: options.metadata,
+    });
+    let lockAcquired = false;
+    try {
+        await (0, lock_1.acquireRunLock)(runDir, options.lockOwner ?? "runtime:createRun");
+        lockAcquired = true;
+        const eventPayload = {
+            runId,
+            processId: metadata.processId,
+            entrypoint: metadata.entrypoint,
+        };
+        if (metadata.processRevision) {
+            eventPayload.processRevision = metadata.processRevision;
+        }
+        if (options.inputs !== undefined) {
+            eventPayload.inputsRef = paths_1.INPUTS_FILE;
+        }
+        await (0, journal_1.appendEvent)({
+            runDir,
+            eventType: "RUN_CREATED",
+            event: eventPayload,
+        });
+    }
+    finally {
+        if (lockAcquired) {
+            await (0, lock_1.releaseRunLock)(runDir);
+        }
+    }
+    return {
+        runId,
+        runDir,
+        metadata,
+    };
+}
+function validateRunId(runId) {
+    if (typeof runId !== "string" || runId.trim() === "") {
+        throw new Error("runId must be a non-empty string");
+    }
+}
+function normalizeEntrypoint(runDir, importPath, exportName) {
+    const entryImport = toRunRelativePosix(runDir, importPath);
+    return {
+        importPath: entryImport,
+        exportName: exportName ?? "process",
+    };
+}
+function toRunRelativePosix(runDir, importPath) {
+    const relative = path_1.default.isAbsolute(importPath) ? path_1.default.relative(runDir, importPath) : importPath;
+    if (!relative || relative === ".") {
+        throw new Error("Entrypoint import path must reference a file");
+    }
+    return path_1.default.posix.normalize(relative.replace(/\\/g, "/"));
+}

package/dist/runtime/errorUtils.d.ts

@@ -0,0 +1,10 @@
+import { SerializedEffectError } from "./types";
+export interface SerializedRuntimeError {
+    name: string;
+    message: string;
+    stack?: string;
+    data?: unknown;
+}
+export declare function serializeUnknownError(error: unknown): SerializedRuntimeError;
+export declare function toSerializedEffectError(error: unknown): SerializedEffectError;
+//# sourceMappingURL=errorUtils.d.ts.map

package/dist/runtime/errorUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorUtils.d.ts","sourceRoot":"","sources":["../../src/runtime/errorUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAqB5E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB,CAkB7E"}