@goah/cli 0.13.0 → 0.13.2

package/dist/index.js

@@ -1,385 +1,84 @@
-import { accessSync, chmodSync, constants, existsSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { CONTRACT_VERSION } from "goah-ledger-contract";
-import { SQLITE_SCHEMA_VERSION, SqliteLedger } from "goah-ledger-sqlite";
-import { createPiModel, piWorkerPath, ProcessRunner, resolveEnvSpec } from "goah-runner-pi";
-import { RunnerRouter, Supervisor } from "goah-supervisor";
-import { runnerPlugin } from "./runner-registry.js";
-const configRoots = new WeakMap();
-export function loadConfig(path = "goah.config.json") {
-    recoverProfileTransaction();
-    const absolute = resolve(path);
-    const config = JSON.parse(readFileSync(absolute, "utf8"));
-    if (config.version !== 1 && config.version !== 2)
-        throw new Error(`unsupported goah config version: ${String(config.version)}`);
-    const base = dirname(absolute);
-    const root = config.workspace ? absolutePath(base, config.workspace) : base;
-    delete config.workspace;
-    delete config.limits;
-    delete config.heartbeatPolicies;
-    delete config.progressPolicies;
-    configRoots.set(config, root);
-    config.stateDir = absolutePath(base, config.stateDir);
-    if (config.runner) {
-        config.runner.command = resolveCommand(config.runner.command);
-        config.runner.args = config.runner.args.map((arg) => arg === "$GOAH_PI_WORKER" ? piWorkerPath() : arg);
-    }
-    if (!config.runnerProfiles?.length && config.runner?.env?.GOAH_PI_PROVIDER && config.runner.env.GOAH_PI_MODEL) {
-        const env = config.runner.env;
-        const provider = env.GOAH_PI_PROVIDER;
-        const model = env.GOAH_PI_MODEL;
-        const keyRef = Object.entries(env).find(([key, value]) => key.endsWith("API_KEY") && value.startsWith("env:"));
-        config.runnerProfiles = [{ id: "default", runner: "pi", config: { provider, model, ...(keyRef ? { apiKeyEnv: keyRef[1].slice(4) } : {}), ...(env.GOAH_PI_BASE_URL ? { baseUrl: env.GOAH_PI_BASE_URL } : {}) } }];
-        if (config.profiles)
-            config.profiles = config.profiles.map((profile) => ({ ...profile, runnerProfile: profile.runnerProfile ?? "default" }));
-    }
-    return config;
-}
-export function createRuntime(config) {
-    mkdirSync(config.stateDir, { recursive: true });
-    const ledger = new SqliteLedger(join(config.stateDir, "ledger.sqlite"));
-    const runner = config.runnerProfiles?.length
-        ? new RunnerRouter(new Map(config.runnerProfiles.map((profile) => [profile.id, runnerPlugin(profile.runner).create(profile.config, configRoot(config))])))
-        : legacyRunner(config);
-    const supervisor = new Supervisor(ledger, runner, new class {
-        now() { return new Date(); }
-    }(), {
-        ...(config.profiles ? { profiles: config.profiles } : {}),
-        ...(config.runnerProfiles ? { runnerProfiles: config.runnerProfiles } : {}),
-        ...(config.retryPolicy ? { retryPolicy: config.retryPolicy } : {}),
-    });
-    return { ledger, supervisor };
-}
-export function defaultConfig(directory, options = {}) {
-    const provider = options.provider ?? "faux";
-    const model = options.model ?? defaultModel(provider);
-    const runnerProfile = { id: "default", runner: "pi", config: { provider, model, thinking: "medium", ...(options.apiKeyEnv ? { apiKeyEnv: options.apiKeyEnv } : {}), ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}), ...(options.contextWindowTokens ? { contextWindowTokens: options.contextWindowTokens } : {}), ...(options.maxOutputTokensPerTurn ? { maxOutputTokens: options.maxOutputTokensPerTurn } : {}) } };
-    return {
-        version: 2,
-        stateDir: defaultStateDir(directory),
-        runnerProfiles: [runnerProfile],
-        profiles: [{ agent: "ceo", role: "ceo", runnerProfile: "default" }, { agent: options.agent ?? "worker", role: "child", runnerProfile: "default" }],
-    };
-}
-export class SupervisorLock {
-    path;
-    #owned = false;
-    constructor(stateDir) { this.path = join(stateDir, "supervisor.lock"); }
-    acquire() {
-        mkdirSync(dirname(this.path), { recursive: true });
-        if (existsSync(this.path)) {
-            const pid = Number(readFileSync(this.path, "utf8"));
-            if (Number.isInteger(pid) && alive(pid))
-                throw new Error(`supervisor already running with pid ${pid}`);
-            rmSync(this.path);
-        }
-        const fd = openSync(this.path, "wx");
-        writeFileSync(fd, String(process.pid));
-        closeSync(fd);
-        this.#owned = true;
-    }
-    release() { if (this.#owned) {
-        rmSync(this.path, { force: true });
-        this.#owned = false;
-    } }
-}
-export function writeDefaultConfig(path = "goah.config.json", options = {}, overwrite = false) {
-    const absolute = resolve(path);
-    if (existsSync(absolute) && !overwrite)
-        throw new Error(`${absolute} already exists`);
-    writeFileSync(absolute, `${JSON.stringify(defaultConfig(dirname(absolute), options), null, 2)}\n`);
-}
-export function profilePath() { return join(process.env.GOAH_STATE_HOME ?? join(homedir(), ".goah"), "profile.json"); }
-export function readDefaultRunnerProfile() {
-    recoverProfileTransaction();
-    try {
-        const raw = JSON.parse(readFileSync(profilePath(), "utf8"));
-        if (typeof raw.id === "string" && typeof raw.runner === "string" && raw.config && typeof raw.config === "object")
-            return raw;
-        if (typeof raw.provider === "string" && typeof raw.model === "string") {
-            const { provider, model, apiKeyEnv, baseUrl, contextWindowTokens, maxOutputTokensPerTurn } = raw;
-            return { id: "default", runner: "pi", config: { provider, model, ...(typeof apiKeyEnv === "string" ? { apiKeyEnv } : {}), ...(typeof baseUrl === "string" ? { baseUrl } : {}), ...(typeof contextWindowTokens === "number" ? { contextWindowTokens } : {}), ...(typeof maxOutputTokensPerTurn === "number" ? { maxOutputTokens: maxOutputTokensPerTurn } : {}) } };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export function writeDefaultRunnerProfile(profile) {
-    withProfileLock(() => { recoverProfileTransactionUnlocked(); writeDefaultRunnerProfileUnlocked(profile); });
-}
-function writeDefaultRunnerProfileUnlocked(profile) {
-    mkdirSync(dirname(profilePath()), { recursive: true });
-    const temporary = `${profilePath()}.${process.pid}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(profile, null, 2)}\n`, { mode: 0o600 });
-    renameSync(temporary, profilePath());
-    chmodSync(profilePath(), 0o600);
-}
-export function updateWorkspaceRunnerProfile(path, profile) {
-    withProfileLock(() => { recoverProfileTransactionUnlocked(); updateWorkspaceRunnerProfileUnlocked(path, profile); });
-}
-function updateWorkspaceRunnerProfileUnlocked(path, profile) {
-    const absolute = resolve(path);
-    const current = existsSync(absolute) ? JSON.parse(readFileSync(absolute, "utf8")) : defaultConfig(dirname(absolute));
-    current.runnerProfiles = [...(current.runnerProfiles ?? []).filter((item) => item.id !== profile.id), profile];
-    current.profiles = (current.profiles ?? [{ agent: "ceo", role: "ceo" }, { agent: "worker", role: "child" }]).map((agent) => ({ ...agent, runnerProfile: agent.runnerProfile ?? profile.id }));
-    const temporary = `${absolute}.${process.pid}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(current, null, 2)}\n`);
-    renameSync(temporary, absolute);
-}
-/** Persist default + workspace profile with a crash-recoverable rollback journal. */
-export function persistRunnerProfile(profile, workspacePath) {
-    withProfileLock(() => {
-        recoverProfileTransactionUnlocked();
-        const targets = [profilePath(), ...(workspacePath ? [resolve(workspacePath)] : [])];
-        const before = targets.map((path) => ({ path, content: existsSync(path) ? readFileSync(path) : null }));
-        writeProfileTransaction(before);
-        try {
-            writeDefaultRunnerProfileUnlocked(profile);
-            if (workspacePath)
-                updateWorkspaceRunnerProfileUnlocked(workspacePath, profile);
-            rmSync(profileTransactionPath(), { force: true });
-        }
-        catch (error) {
-            restoreProfileSnapshots(before);
-            rmSync(profileTransactionPath(), { force: true });
-            throw error;
-        }
-    });
-}
-function withProfileLock(operation) {
-    const lock = `${profilePath()}.lock`;
-    const ownerPath = join(lock, "owner.json");
-    const token = randomUUID();
-    mkdirSync(dirname(lock), { recursive: true });
-    acquireProfileLock(lock, ownerPath, token);
-    try {
-        return operation();
-    }
-    finally {
-        if (readProfileLockOwner(ownerPath)?.token === token)
-            rmSync(lock, { recursive: true, force: true });
-    }
-}
-function acquireProfileLock(lock, ownerPath, token) {
-    while (true) {
-        try {
-            mkdirSync(lock);
-            try {
-                writeFileSync(ownerPath, JSON.stringify({ pid: process.pid, token }), { mode: 0o600 });
-            }
-            catch (error) {
-                rmSync(lock, { recursive: true, force: true });
-                throw error;
-            }
-            return;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-        }
-        const owner = readProfileLockOwner(ownerPath);
-        let oldUnownedLock = false;
-        try {
-            oldUnownedLock = !owner && Date.now() - statSync(lock).mtimeMs > 5_000;
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                continue;
-            throw error;
-        }
-        if (owner && processIsAlive(owner.pid) || !owner && !oldUnownedLock)
-            throw new Error("Another Goah process is updating Runner Profiles; try again.");
-        const stale = `${lock}.stale.${token}`;
-        try {
-            renameSync(lock, stale);
-            rmSync(stale, { recursive: true, force: true });
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-}
-function profileTransactionPath() { return join(dirname(profilePath()), "profile-transaction.json"); }
-function writeProfileTransaction(snapshots) {
-    const path = profileTransactionPath();
-    const temporary = `${path}.${process.pid}.tmp`;
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(temporary, `${JSON.stringify({ version: 1, snapshots: snapshots.map((snapshot) => ({ path: snapshot.path, content: snapshot.content?.toString("base64") ?? null })) })}\n`, { mode: 0o600 });
-    renameSync(temporary, path);
-    chmodSync(path, 0o600);
-}
-function restoreProfileSnapshots(snapshots) {
-    for (const snapshot of snapshots) {
-        if (snapshot.content === null)
-            rmSync(snapshot.path, { force: true });
-        else {
-            mkdirSync(dirname(snapshot.path), { recursive: true });
-            const temporary = `${snapshot.path}.${process.pid}.rollback.tmp`;
-            writeFileSync(temporary, snapshot.content, snapshot.path === profilePath() ? { mode: 0o600 } : undefined);
-            renameSync(temporary, snapshot.path);
-            if (snapshot.path === profilePath())
-                chmodSync(snapshot.path, 0o600);
-        }
-    }
-}
-function recoverProfileTransaction() { if (existsSync(profileTransactionPath()))
-    withProfileLock(recoverProfileTransactionUnlocked); }
-function recoverProfileTransactionUnlocked() {
-    const path = profileTransactionPath();
-    if (!existsSync(path))
-        return;
-    const value = JSON.parse(readFileSync(path, "utf8"));
-    if (value.version !== 1 || !Array.isArray(value.snapshots))
-        throw new Error("Goah Runner Profile transaction journal is invalid");
-    const snapshots = value.snapshots.map((snapshot) => {
-        if (typeof snapshot.path !== "string" || snapshot.content !== null && typeof snapshot.content !== "string")
-            throw new Error("Goah Runner Profile transaction journal is invalid");
-        return { path: snapshot.path, content: snapshot.content === null ? null : Buffer.from(snapshot.content, "base64") };
-    });
-    restoreProfileSnapshots(snapshots);
-    rmSync(path, { force: true });
-}
-function readProfileLockOwner(path) {
-    try {
-        const value = JSON.parse(readFileSync(path, "utf8"));
-        return Number.isInteger(value.pid) && Number(value.pid) > 0 && typeof value.token === "string" ? value : null;
-    }
-    catch (error) {
-        if (error.code === "ENOENT" || error instanceof SyntaxError)
-            return null;
-        throw error;
-    }
-}
-function processIsAlive(pid) { try {
-    process.kill(pid, 0);
-    return true;
-}
-catch (error) {
-    return error.code === "EPERM";
-} }
-export function diagnoseConfig(config) {
-    const checks = [];
-    const check = (name, fn) => {
-        try {
-            checks.push({ name, ok: true, detail: fn() });
-        }
-        catch (error) {
-            checks.push({ name, ok: false, detail: error instanceof Error ? error.message : String(error) });
-        }
-    };
-    check("node", () => {
-        if (Number(process.versions.node.split(".")[0]) < 24)
-            throw new Error(`Node ${process.versions.node} is unsupported; require >=24`);
-        return process.versions.node;
-    });
-    check("root", () => {
-        const root = configRoot(config);
-        accessSync(root, constants.R_OK | constants.W_OK);
-        return `${root} (runner-owned local execution)`;
-    });
-    check("state", () => {
-        const existing = nearestExisting(config.stateDir);
-        accessSync(existing, constants.W_OK);
-        const database = join(config.stateDir, "ledger.sqlite");
-        if (!existsSync(database))
-            return `${config.stateDir} (will create)`;
-        const db = new DatabaseSync(database, { readOnly: true });
-        try {
-            const version = db.prepare("PRAGMA user_version").get().user_version;
-            if (version > SQLITE_SCHEMA_VERSION)
-                throw new Error(`ledger schema ${version} is newer than supported schema ${SQLITE_SCHEMA_VERSION}`);
-            if (version > 0 && version < SQLITE_SCHEMA_VERSION)
-                throw new Error(`ledger schema ${version} predates runtime schema ${SQLITE_SCHEMA_VERSION}; recreate this development workspace`);
-            return `${database} (schema ${version})`;
-        }
-        finally {
-            db.close();
-        }
-    });
-    check("runner", () => {
-        if (config.runnerProfiles?.length) {
-            for (const profile of config.runnerProfiles)
-                runnerPlugin(profile.runner);
-            return config.runnerProfiles.map((profile) => `${profile.id}:${profile.runner}`).join(", ");
-        }
-        if (!config.runner)
-            throw new Error("no runner is configured");
-        accessSync(config.runner.command, constants.X_OK);
-        const workerArg = config.runner.args[0];
-        if (workerArg && isAbsolute(workerArg))
-            accessSync(workerArg, constants.R_OK);
-        const env = resolveEnvSpec(config.runner.env, { root: configRoot(config) });
-        const provider = requiredEnv(env, "GOAH_PI_PROVIDER");
-        const modelId = requiredEnv(env, "GOAH_PI_MODEL");
-        const model = createPiModel(provider, modelId, env).model;
-        return `${provider}/${modelId} context=${model.contextWindow} output=${model.maxTokens}; auth is checked when the wake starts`;
-    });
-    return { ok: checks.every((item) => item.ok || item.severity === "warning"), checks };
-}
-export function statusSnapshot(ledger) {
-    const events = ledger.events();
-    const wakes = ledger.wakes().map((wake) => {
-        const turn = wake.turnId ? ledger.turn(wake.turnId) : null;
-        const turnEvents = turn ? ledger.readStream(`turn:${turn.id}`) : [];
-        const tokensUsed = turnEvents.reduce((total, event) => total + assistantTokens(event.data), 0);
-        return { ...wake, tokensUsed, abnormalReason: turn?.status === "failed" ? field(turn.error, "message") : null };
-    });
-    const goals = ledger.goals();
-    const handoffs = events.filter((event) => event.type === "handoff.recorded").slice(-20).map((event) => ({ seq: event.seq, ts: event.ts, agent: event.actor, streamId: event.streamId, handoff: event.data }));
-    const modelCapabilitiesByAgent = Object.fromEntries(ledger.threads().flatMap((thread) => { const turnIds = new Set(ledger.turns(thread.id).map((turn) => turn.id)); const capability = [...events].reverse().find((event) => event.type === "transcript.started" && event.streamId.startsWith("turn:") && turnIds.has(event.streamId.slice("turn:".length)))?.data; return capability ? [[thread.agent, capability]] : []; }));
-    const modelCapabilities = modelCapabilitiesByAgent.ceo ?? [...events].reverse().find((event) => event.type === "transcript.started")?.data ?? null;
-    return { seq: events.at(-1)?.seq ?? 0, threads: ledger.threads(), turns: ledger.turns().map((turn) => ({ ...turn, leaseToken: null })), goals, wakes, wakeTriggers: wakes.flatMap((wake) => ledger.wakeTriggers(wake.id)), schedules: ledger.schedules(), modelCapabilities, modelCapabilitiesByAgent, recentHandoffs: handoffs };
-}
-function defaultModel(provider) {
-    if (provider === "faux")
-        return "faux-goah";
-    throw new Error(`--model is required for ${provider}; interactive setup discovers models through the selected Runner.`);
-}
-function legacyRunner(config) {
-    if (!config.runner)
-        throw new Error("no runner profiles are configured");
-    const { env, ...spec } = config.runner;
-    return new ProcessRunner({ ...spec, envSpec: env, cwd: configRoot(config) });
-}
-function requiredEnv(env, name) { const value = env[name]; if (!value)
-    throw new Error(`${name} is missing`); return value; }
-function nearestExisting(path) { let current = resolve(path); while (!existsSync(current)) {
-    const parent = dirname(current);
-    if (parent === current)
-        break;
-    current = parent;
-} return current; }
-function defaultStateDir(directory) {
-    const id = createHash("sha256").update(resolve(directory)).digest("hex").slice(0, 16);
-    return join(process.env.GOAH_STATE_HOME ?? join(homedir(), ".goah", "state"), id);
-}
-function field(value, key) { return typeof value === "object" && value !== null && !Array.isArray(value) ? value[key] : undefined; }
-function assistantTokens(value) {
-    const message = field(value, "message");
-    if (field(message, "role") !== "assistant")
-        return 0;
-    const usage = field(message, "usage");
-    const total = field(usage, "totalTokens");
-    return typeof total === "number" ? total : 0;
-}
-function resolveCommand(command) { return command === "$NODE" ? process.execPath : command; }
-function absolutePath(base, value) { return isAbsolute(value) ? value : resolve(base, value); }
-function alive(pid) { try {
-    process.kill(pid, 0);
-    return true;
-}
-catch {
-    return false;
-} }
-export function configRoot(config) { return configRoots.get(config) ?? process.cwd(); }
-export { exportThread, listThreads, redactValue, replayThread, showThread, showTurnContext, streamEvents } from "./thread-inspect.js";
-export { controlAvailable, controlEndpoint, requestControl, runControlServer, streamControl } from "./control.js";
-export { consoleMetadataPath, consoleSnapshot, organizationTrajectory, readConsoleMetadata, runWebConsole } from "./web-console.js";
-export { CONTRACT_VERSION };
-//# sourceMappingURL=index.js.map
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  SupervisorLock,
+  configRoot,
+  consoleMetadataPath,
+  consoleSnapshot,
+  controlAvailable,
+  controlEndpoint,
+  createRuntime,
+  defaultConfig,
+  diagnoseConfig,
+  exportThread,
+  listThreads,
+  loadConfig,
+  organizationTrajectory,
+  persistRunnerProfile,
+  profilePath,
+  readConsoleMetadata,
+  readDefaultRunnerProfile,
+  redactValue,
+  replayThread,
+  requestControl,
+  runControlServer,
+  runWebConsole,
+  showThread,
+  showTurnContext,
+  statusSnapshot,
+  streamControl,
+  streamEvents,
+  updateWorkspaceRunnerProfile,
+  writeDefaultConfig,
+  writeDefaultRunnerProfile
+} from "./chunk-KJ4HJCTK.js";
+import "./chunk-D2DVAH37.js";
+import "./chunk-YH6YJ2IB.js";
+import "./chunk-QBD6EJ2Z.js";
+import "./chunk-7E7V6OIU.js";
+import "./chunk-6M3OOCKO.js";
+import "./chunk-K26BVR6O.js";
+import "./chunk-IIJQ3DW4.js";
+import "./chunk-2ZP2NBW3.js";
+import "./chunk-MPXK7QBL.js";
+import "./chunk-2QBQZGXF.js";
+import "./chunk-4KA63VNZ.js";
+import {
+  CONTRACT_VERSION
+} from "./chunk-KAO7WIXG.js";
+import "./chunk-R6I3VKME.js";
+import "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+export {
+  CONTRACT_VERSION,
+  SupervisorLock,
+  configRoot,
+  consoleMetadataPath,
+  consoleSnapshot,
+  controlAvailable,
+  controlEndpoint,
+  createRuntime,
+  defaultConfig,
+  diagnoseConfig,
+  exportThread,
+  listThreads,
+  loadConfig,
+  organizationTrajectory,
+  persistRunnerProfile,
+  profilePath,
+  readConsoleMetadata,
+  readDefaultRunnerProfile,
+  redactValue,
+  replayThread,
+  requestControl,
+  runControlServer,
+  runWebConsole,
+  showThread,
+  showTurnContext,
+  statusSnapshot,
+  streamControl,
+  streamEvents,
+  updateWorkspaceRunnerProfile,
+  writeDefaultConfig,
+  writeDefaultRunnerProfile
+};

package/dist/kernel.d.ts

@@ -1,2 +1,39 @@
-export * from "goah-ledger-contract/kernel";
-//# sourceMappingURL=kernel.d.ts.map
+declare const CONTRACT_VERSION: "0.13.0";
+declare const CONTRACT_STABILITY: "experimental";
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** One append request. Sequence numbers are assigned by the ledger. */
+interface EventInput {
+    streamId: string;
+    ts: string;
+    actor: string;
+    type: string;
+    data: JsonValue;
+    /** An unfamiliar reader may skip this event without changing replay semantics. */
+    ignorable?: true;
+}
+/** One immutable fact in the global ledger and in one logical stream. */
+interface EventRecord extends EventInput {
+    seq: number;
+    streamSeq: number;
+}
+interface EventStore {
+    appendEvent(input: EventInput): EventRecord;
+    appendEvents(inputs: EventInput[]): EventRecord[];
+    readStream(streamId: string, fromStreamSeq?: number): EventRecord[];
+    eventsSince(seq: number, types?: string[]): EventRecord[];
+    events(): EventRecord[];
+}
+interface Clock {
+    now(): Date;
+}
+declare function wakeStream(wakeId: string): string;
+declare function controlStream(actor?: string): string;
+declare function goalStream(goalId: string): string;
+declare function workRecordStream(goalId: string): string;
+declare function memoryStream(agent: string): string;
+
+export { CONTRACT_STABILITY, CONTRACT_VERSION, controlStream, goalStream, memoryStream, wakeStream, workRecordStream };
+export type { Clock, EventInput, EventRecord, EventStore, JsonPrimitive, JsonValue };

package/dist/kernel.js

@@ -1,2 +1,21 @@
-export * from "goah-ledger-contract/kernel";
-//# sourceMappingURL=kernel.js.map
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  CONTRACT_STABILITY,
+  CONTRACT_VERSION,
+  controlStream,
+  goalStream,
+  memoryStream,
+  wakeStream,
+  workRecordStream
+} from "./chunk-KAO7WIXG.js";
+import "./chunk-XPQKM3L7.js";
+export {
+  CONTRACT_STABILITY,
+  CONTRACT_VERSION,
+  controlStream,
+  goalStream,
+  memoryStream,
+  wakeStream,
+  workRecordStream
+};