@a5c-ai/babysitter-sdk 0.0.16

package/dist/runtime/replay/stateCache.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_CACHE_SCHEMA_VERSION = void 0;
+exports.readStateCache = readStateCache;
+exports.writeStateCache = writeStateCache;
+exports.journalHeadsEqual = journalHeadsEqual;
+exports.createStateCacheSnapshot = createStateCacheSnapshot;
+exports.normalizeJournalHead = normalizeJournalHead;
+exports.normalizeSnapshot = normalizeSnapshot;
+exports.rebuildStateCache = rebuildStateCache;
+const fs_1 = require("fs");
+const paths_1 = require("../../storage/paths");
+const atomic_1 = require("../../storage/atomic");
+const effectIndex_1 = require("./effectIndex");
+const clock_1 = require("../../storage/clock");
+exports.STATE_CACHE_SCHEMA_VERSION = "2026.01.state-cache";
+async function readStateCache(runDir) {
+    const stateFile = (0, paths_1.getStateFile)(runDir);
+    try {
+        const raw = await fs_1.promises.readFile(stateFile, "utf8");
+        const parsed = JSON.parse(raw);
+        return normalizeSnapshot(parsed);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeStateCache(runDir, snapshot) {
+    const stateDir = (0, paths_1.getStateDir)(runDir);
+    await fs_1.promises.mkdir(stateDir, { recursive: true });
+    const stateFile = (0, paths_1.getStateFile)(runDir);
+    await (0, atomic_1.writeFileAtomic)(stateFile, JSON.stringify(snapshot, null, 2) + "\n");
+}
+function journalHeadsEqual(a, b) {
+    if (!a && !b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.seq !== b.seq || a.ulid !== b.ulid)
+        return false;
+    if (a.checksum && b.checksum && a.checksum !== b.checksum)
+        return false;
+    return true;
+}
+function createStateCacheSnapshot(journalHeadOrOptions) {
+    const options = journalHeadOrOptions && isJournalHeadLike(journalHeadOrOptions)
+        ? { journalHead: journalHeadOrOptions }
+        : journalHeadOrOptions ?? {};
+    return {
+        schemaVersion: options.schemaVersion ?? exports.STATE_CACHE_SCHEMA_VERSION,
+        savedAt: options.savedAt ?? (0, clock_1.getClockIsoString)(),
+        journalHead: options.journalHead ?? null,
+        stateVersion: options.stateVersion ?? 0,
+        effectsByInvocation: options.effectsByInvocation ?? {},
+        pendingEffectsByKind: options.pendingEffectsByKind ?? {},
+        rebuildReason: options.rebuildReason ?? null,
+    };
+}
+function normalizeJournalHead(raw) {
+    if (raw === null || raw === undefined)
+        return raw;
+    if (!isPlainObject(raw))
+        return undefined;
+    const seq = Number(raw.seq);
+    const ulid = raw.ulid;
+    if (!Number.isFinite(seq) || typeof ulid !== "string" || !ulid) {
+        return undefined;
+    }
+    const checksum = typeof raw.checksum === "string" && raw.checksum ? raw.checksum : undefined;
+    return { seq, ulid, checksum };
+}
+function normalizeSnapshot(raw) {
+    if (!isPlainObject(raw)) {
+        throw new Error("Invalid state cache snapshot");
+    }
+    const journalHead = raw.journalHead === null ? null : normalizeJournalHead(raw.journalHead ?? undefined) ?? null;
+    const effectsByInvocation = normalizeEffectSummaryMap(raw.effectsByInvocation);
+    const pendingEffectsByKind = normalizePendingEffects(raw.pendingEffectsByKind);
+    const savedAt = typeof raw.savedAt === "string" ? raw.savedAt : (0, clock_1.getClockIsoString)();
+    const rebuildReason = raw.rebuildReason === null
+        ? null
+        : typeof raw.rebuildReason === "string"
+            ? raw.rebuildReason
+            : null;
+    const stateVersion = typeof raw.stateVersion === "number" && Number.isFinite(raw.stateVersion) ? raw.stateVersion : 0;
+    return createStateCacheSnapshot({
+        schemaVersion: typeof raw.schemaVersion === "string" ? raw.schemaVersion : exports.STATE_CACHE_SCHEMA_VERSION,
+        savedAt,
+        journalHead,
+        stateVersion,
+        effectsByInvocation,
+        pendingEffectsByKind,
+        rebuildReason,
+    });
+}
+async function rebuildStateCache(runDir, opts) {
+    const effectIndex = opts?.effectIndex ??
+        (await (0, effectIndex_1.buildEffectIndex)({
+            runDir,
+        }));
+    const journalHead = effectIndex.getJournalHead() ?? null;
+    const stateVersion = journalHead?.seq ?? 0;
+    const effectsByInvocation = deriveEffectsByInvocation(effectIndex);
+    const pendingEffectsByKind = derivePendingByKind(effectIndex);
+    const snapshot = createStateCacheSnapshot({
+        journalHead,
+        stateVersion,
+        effectsByInvocation,
+        pendingEffectsByKind,
+        rebuildReason: opts?.reason ?? null,
+    });
+    await writeStateCache(runDir, snapshot);
+    return snapshot;
+}
+function deriveEffectsByInvocation(effectIndex) {
+    const summaries = {};
+    effectIndex.listEffects().forEach((record) => {
+        summaries[record.invocationKey] = summarizeEffect(record);
+    });
+    return summaries;
+}
+function summarizeEffect(record) {
+    const summary = {
+        effectId: record.effectId,
+        invocationKey: record.invocationKey,
+        status: record.status,
+    };
+    if (record.kind)
+        summary.kind = record.kind;
+    if (record.label)
+        summary.label = record.label;
+    if (record.taskId)
+        summary.taskId = record.taskId;
+    if (record.stepId)
+        summary.stepId = record.stepId;
+    if (record.requestedAt)
+        summary.requestedAt = record.requestedAt;
+    if (record.resolvedAt)
+        summary.resolvedAt = record.resolvedAt;
+    return summary;
+}
+function derivePendingByKind(effectIndex) {
+    const totals = {};
+    effectIndex.listPendingEffects().forEach((record) => {
+        const key = record.kind ?? "unknown";
+        totals[key] = (totals[key] ?? 0) + 1;
+    });
+    return totals;
+}
+function normalizeEffectSummaryMap(raw) {
+    if (!isPlainObject(raw))
+        return {};
+    const summaries = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const summary = normalizeDerivedEffectSummary(value);
+        if (summary) {
+            summaries[key] = summary;
+        }
+    }
+    return summaries;
+}
+function normalizeDerivedEffectSummary(raw) {
+    if (!isPlainObject(raw))
+        return undefined;
+    const effectId = typeof raw.effectId === "string" ? raw.effectId : undefined;
+    const invocationKey = typeof raw.invocationKey === "string" ? raw.invocationKey : undefined;
+    const status = isEffectStatus(raw.status) ? raw.status : undefined;
+    if (!effectId || !invocationKey || !status) {
+        return undefined;
+    }
+    const summary = { effectId, invocationKey, status };
+    if (typeof raw.kind === "string")
+        summary.kind = raw.kind;
+    if (typeof raw.label === "string")
+        summary.label = raw.label;
+    if (typeof raw.taskId === "string")
+        summary.taskId = raw.taskId;
+    if (typeof raw.stepId === "string")
+        summary.stepId = raw.stepId;
+    if (typeof raw.requestedAt === "string")
+        summary.requestedAt = raw.requestedAt;
+    if (typeof raw.resolvedAt === "string")
+        summary.resolvedAt = raw.resolvedAt;
+    return summary;
+}
+function normalizePendingEffects(raw) {
+    if (!isPlainObject(raw))
+        return {};
+    const totals = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            totals[key] = value;
+        }
+    }
+    return totals;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEffectStatus(value) {
+    return value === "requested" || value === "resolved_ok" || value === "resolved_error";
+}
+function isJournalHeadLike(value) {
+    if (!isPlainObject(value))
+        return false;
+    return Number.isFinite(value.seq) && typeof value.ulid === "string" && value.ulid.length > 0;
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,147 @@
+import type { JsonRecord, RunMetadata } from "../storage/types";
+import type { DefinedTask, TaskDef, TaskInvokeOptions } from "../tasks/types";
+import type { StateCacheJournalHead } from "./replay/stateCache";
+export type { DefinedTask, TaskBuildContext, TaskDef, TaskInvokeOptions } from "../tasks/types";
+export type { StateCacheJournalHead } from "./replay/stateCache";
+export type ProcessLogger = (...args: any[]) => void;
+export type EffectStatus = "requested" | "resolved_ok" | "resolved_error";
+export interface SerializedEffectError {
+    name?: string;
+    message?: string;
+    stack?: string;
+    data?: unknown;
+}
+export interface EffectRecord {
+    effectId: string;
+    invocationKey: string;
+    invocationHash?: string;
+    stepId: string;
+    taskId: string;
+    status: EffectStatus;
+    kind?: string;
+    label?: string;
+    labels?: string[];
+    taskDefRef?: string;
+    inputsRef?: string;
+    resultRef?: string;
+    error?: SerializedEffectError;
+    stdoutRef?: string;
+    stderrRef?: string;
+    requestedAt?: string;
+    resolvedAt?: string;
+}
+export interface EffectSchedulerHints {
+    pendingCount?: number;
+    parallelGroupId?: string;
+    sleepUntilEpochMs?: number;
+}
+export interface EffectAction {
+    effectId: string;
+    invocationKey: string;
+    kind: string;
+    label?: string;
+    labels?: string[];
+    taskDef: TaskDef;
+    taskId?: string;
+    stepId?: string;
+    taskDefRef?: string;
+    inputsRef?: string;
+    requestedAt?: string;
+    schedulerHints?: EffectSchedulerHints;
+}
+export interface CreateRunOptions {
+    runsDir: string;
+    runId?: string;
+    process: {
+        processId: string;
+        importPath: string;
+        exportName?: string;
+    };
+    request?: string;
+    inputs?: unknown;
+    processRevision?: string;
+    layoutVersion?: string;
+    metadata?: JsonRecord;
+    lockOwner?: string;
+}
+export interface CreateRunResult {
+    runId: string;
+    runDir: string;
+    metadata: RunMetadata;
+}
+export interface ParallelHelpers {
+    all<T>(thunks: Array<() => T | Promise<T>>): Promise<T[]>;
+    map<TItem, TOut>(items: TItem[], fn: (item: TItem) => TOut | Promise<TOut>): Promise<TOut[]>;
+}
+export interface ProcessContext {
+    now(): Date;
+    task<TArgs, TResult>(task: DefinedTask<TArgs, TResult>, args: TArgs, options?: TaskInvokeOptions): Promise<TResult>;
+    breakpoint<T = unknown>(payload: T, options?: {
+        label?: string;
+    }): Promise<void>;
+    sleepUntil(target: string | number, options?: {
+        label?: string;
+    }): Promise<void>;
+    orchestratorTask<TArgs = unknown, TResult = unknown>(payload: TArgs, options?: {
+        label?: string;
+    }): Promise<TResult>;
+    parallel: ParallelHelpers;
+    log?: ProcessLogger;
+}
+export interface OrchestrateOptions {
+    runDir: string;
+    process?: {
+        importPath: string;
+        exportName?: string;
+    };
+    inputs?: unknown;
+    now?: Date | (() => Date);
+    context?: Record<string, unknown>;
+    logger?: ProcessLogger;
+}
+export interface IterationMetadata {
+    stateVersion?: number;
+    stateRebuilt?: boolean;
+    stateRebuildReason?: string | null;
+    pendingEffectsByKind?: Record<string, number>;
+    journalHead?: StateCacheJournalHead | null;
+}
+export type IterationResult = {
+    status: "completed";
+    output: unknown;
+    metadata?: IterationMetadata;
+} | {
+    status: "waiting";
+    nextActions: EffectAction[];
+    metadata?: IterationMetadata;
+} | {
+    status: "failed";
+    error: unknown;
+    metadata?: IterationMetadata;
+};
+export interface CommitEffectResultOptions {
+    runDir: string;
+    effectId: string;
+    invocationKey?: string;
+    logger?: ProcessLogger;
+    result: {
+        status: "ok" | "error";
+        value?: unknown;
+        error?: unknown;
+        stdout?: string;
+        stderr?: string;
+        stdoutRef?: string;
+        stderrRef?: string;
+        startedAt?: string;
+        finishedAt?: string;
+        metadata?: JsonRecord;
+    };
+}
+export interface CommitEffectResultArtifacts {
+    resultRef: string;
+    stdoutRef?: string;
+    stderrRef?: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/runtime/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/atomic.d.ts

@@ -0,0 +1,2 @@
+export declare function writeFileAtomic(targetPath: string, data: string | Buffer, retries?: number): Promise<void>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/storage/atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../../src/storage/atomic.ts"],"names":[],"mappings":"AAcA,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,SAAI,iBAiC3F"}

package/dist/storage/atomic.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileAtomic = writeFileAtomic;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const RETRYABLE_ERRORS = new Set(["EBUSY", "ETXTBSY", "EPERM", "EACCES"]);
+async function fsyncPath(targetPath) {
+    const handle = await fs_1.promises.open(targetPath, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function writeFileAtomic(targetPath, data, retries = 3) {
+    await fs_1.promises.mkdir(path_1.default.dirname(targetPath), { recursive: true });
+    const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+    const handle = await fs_1.promises.open(tempPath, "w");
+    try {
+        if (typeof data === "string") {
+            await handle.writeFile(data, "utf8");
+        }
+        else {
+            await handle.writeFile(data);
+        }
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            await fs_1.promises.rename(tempPath, targetPath);
+            await fsyncPath(path_1.default.dirname(targetPath));
+            return;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                await fs_1.promises.writeFile(targetPath, data);
+                return;
+            }
+            if (attempt === retries || !err.code || !RETRYABLE_ERRORS.has(err.code)) {
+                await fs_1.promises.rm(tempPath, { force: true });
+                throw err;
+            }
+            await new Promise((resolve) => setTimeout(resolve, (attempt + 1) * 25));
+        }
+    }
+}

package/dist/storage/cleanup.d.ts

@@ -0,0 +1,4 @@
+import { DiskUsageReport, OrphanedBlobInfo } from "./types";
+export declare function getDiskUsage(runsRoot: string, runId: string): Promise<DiskUsageReport>;
+export declare function findOrphanedBlobs(runsRoot: string, runId: string): Promise<OrphanedBlobInfo[]>;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/storage/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../src/storage/cleanup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAwB5D,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAU5F;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6CpG"}

package/dist/storage/cleanup.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiskUsage = getDiskUsage;
+exports.findOrphanedBlobs = findOrphanedBlobs;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+async function dirSize(dir) {
+    try {
+        const entries = await fs_1.promises.readdir(dir, { withFileTypes: true });
+        let total = 0;
+        for (const entry of entries) {
+            const full = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                total += await dirSize(full);
+            }
+            else if (entry.isFile()) {
+                const stat = await fs_1.promises.stat(full);
+                total += stat.size;
+            }
+        }
+        return total;
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT")
+            return 0;
+        throw error;
+    }
+}
+async function getDiskUsage(runsRoot, runId) {
+    const runDir = (0, paths_1.getRunDir)(runsRoot, runId);
+    const [journal, tasks, blobs, state] = await Promise.all([
+        dirSize((0, paths_1.getJournalDir)(runDir)),
+        dirSize((0, paths_1.getTasksDir)(runDir)),
+        dirSize((0, paths_1.getBlobsDir)(runDir)),
+        dirSize((0, paths_1.getStateDir)(runDir)),
+    ]);
+    const total = journal + tasks + blobs + state;
+    return { totalBytes: total, journalBytes: journal, tasksBytes: tasks, blobsBytes: blobs, stateBytes: state };
+}
+async function findOrphanedBlobs(runsRoot, runId) {
+    const runDir = (0, paths_1.getRunDir)(runsRoot, runId);
+    const blobsDir = (0, paths_1.getBlobsDir)(runDir);
+    const referenced = new Set();
+    const tasksDir = (0, paths_1.getTasksDir)(runDir);
+    try {
+        const effects = await fs_1.promises.readdir(tasksDir, { withFileTypes: true });
+        for (const effectEntry of effects) {
+            if (!effectEntry.isDirectory())
+                continue;
+            const artifactsPath = path_1.default.join(tasksDir, effectEntry.name, "artifacts.json");
+            try {
+                const data = await fs_1.promises.readFile(artifactsPath, "utf8");
+                const artifacts = JSON.parse(data);
+                for (const artifact of artifacts) {
+                    if (artifact.storedAt.startsWith("blobs/")) {
+                        referenced.add(path_1.default.basename(artifact.storedAt));
+                    }
+                }
+            }
+            catch (err) {
+                const error = err;
+                if (error.code !== "ENOENT")
+                    throw err;
+            }
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (error.code !== "ENOENT")
+            throw err;
+    }
+    const orphaned = [];
+    try {
+        const blobs = await fs_1.promises.readdir(blobsDir, { withFileTypes: true });
+        for (const blob of blobs) {
+            if (!blob.isFile())
+                continue;
+            if (!referenced.has(blob.name)) {
+                const full = path_1.default.join(blobsDir, blob.name);
+                const stat = await fs_1.promises.stat(full);
+                orphaned.push({ hash: blob.name, bytes: stat.size, path: `blobs/${blob.name}` });
+            }
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (error.code !== "ENOENT")
+            throw err;
+    }
+    return orphaned;
+}

package/dist/storage/clock.d.ts

@@ -0,0 +1,6 @@
+export type ClockProvider = () => Date;
+export declare function getClockDate(): Date;
+export declare function getClockIsoString(): string;
+export declare function setClockForTests(provider: ClockProvider): void;
+export declare function resetClock(): void;
+//# sourceMappingURL=clock.d.ts.map

package/dist/storage/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../src/storage/clock.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC;AAQvC,wBAAgB,YAAY,IAAI,IAAI,CAMnC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,QAKvD;AAED,wBAAgB,UAAU,SAEzB"}

package/dist/storage/clock.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClockDate = getClockDate;
+exports.getClockIsoString = getClockIsoString;
+exports.setClockForTests = setClockForTests;
+exports.resetClock = resetClock;
+function systemClock() {
+    return new Date();
+}
+let activeClock = systemClock;
+function getClockDate() {
+    const current = activeClock();
+    if (!(current instanceof Date)) {
+        throw new Error("Clock provider must return a Date instance");
+    }
+    return new Date(current.getTime());
+}
+function getClockIsoString() {
+    return getClockDate().toISOString();
+}
+function setClockForTests(provider) {
+    if (typeof provider !== "function") {
+        throw new Error("setClockForTests requires a function");
+    }
+    activeClock = provider;
+}
+function resetClock() {
+    activeClock = systemClock;
+}

package/dist/storage/createRunDir.d.ts

@@ -0,0 +1,6 @@
+import { CreateRunDirOptions, RunMetadata } from "./types";
+export declare function createRunDir(options: CreateRunDirOptions): Promise<{
+    runDir: string;
+    metadata: RunMetadata;
+}>;
+//# sourceMappingURL=createRunDir.d.ts.map

package/dist/storage/createRunDir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRunDir.d.ts","sourceRoot":"","sources":["../../src/storage/createRunDir.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAyB,WAAW,EAAE,MAAM,SAAS,CAAC;AAkBlF,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB;;;GAkC9D"}

package/dist/storage/createRunDir.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunDir = createRunDir;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+const atomic_1 = require("./atomic");
+const clock_1 = require("./clock");
+const GITIGNORE_CONTENT = `state/\ntasks/*/artifacts/\nblobs/\norphaned/\n`;
+async function createRunDir(options) {
+    const runDir = (0, paths_1.getRunDir)(options.runsRoot, options.runId);
+    await fs_1.promises.mkdir(runDir, { recursive: true });
+    await Promise.all([
+        fs_1.promises.mkdir((0, paths_1.getJournalDir)(runDir), { recursive: true }),
+        fs_1.promises.mkdir((0, paths_1.getTasksDir)(runDir), { recursive: true }),
+        fs_1.promises.mkdir((0, paths_1.getBlobsDir)(runDir), { recursive: true }),
+        fs_1.promises.mkdir((0, paths_1.getStateDir)(runDir), { recursive: true }),
+        fs_1.promises.mkdir(path_1.default.join(runDir, paths_1.ORPHANED_DIR), { recursive: true }),
+        fs_1.promises.mkdir(path_1.default.join(runDir, paths_1.PROCESS_DIR), { recursive: true }),
+    ]);
+    await (0, atomic_1.writeFileAtomic)(path_1.default.join(runDir, ".gitignore"), GITIGNORE_CONTENT);
+    const layoutVersion = options.layoutVersion ?? paths_1.DEFAULT_LAYOUT_VERSION;
+    const entrypoint = resolveEntrypoint(options);
+    const createdAt = (0, clock_1.getClockIsoString)();
+    const metadata = {
+        runId: options.runId,
+        request: options.request,
+        processId: options.processId ?? options.request ?? options.runId,
+        entrypoint,
+        processPath: entrypoint.importPath,
+        processRevision: options.processRevision,
+        layoutVersion,
+        createdAt,
+    };
+    if (options.extraMetadata) {
+        Object.assign(metadata, options.extraMetadata);
+    }
+    await (0, atomic_1.writeFileAtomic)(path_1.default.join(runDir, paths_1.RUN_METADATA_FILE), JSON.stringify(metadata, null, 2) + "\n");
+    if (options.inputs !== undefined) {
+        await (0, atomic_1.writeFileAtomic)(path_1.default.join(runDir, paths_1.INPUTS_FILE), JSON.stringify(options.inputs, null, 2) + "\n");
+    }
+    return { runDir, metadata };
+}
+function resolveEntrypoint(options) {
+    if (options.entrypoint?.importPath) {
+        return {
+            importPath: options.entrypoint.importPath,
+            exportName: options.entrypoint.exportName ?? "process",
+        };
+    }
+    const importPath = options.processPath ?? "./process.js";
+    return {
+        importPath,
+        exportName: "process",
+    };
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,9 @@
+export { createRunDir } from "./createRunDir";
+export { appendEvent, loadJournal } from "./journal";
+export { snapshotState } from "./snapshotState";
+export { storeTaskArtifacts } from "./storeTaskArtifacts";
+export { getDiskUsage, findOrphanedBlobs } from "./cleanup";
+export { acquireRunLock, releaseRunLock, readRunLock } from "./lock";
+export { readRunMetadata, readRunInputs, writeRunOutput } from "./runFiles";
+export { writeTaskDefinition, readTaskDefinition, readTaskResult, writeTaskResult, } from "./tasks";
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,eAAe,GAChB,MAAM,SAAS,CAAC"}