spawnfile 0.1.0

package/dist/runtime/picoclaw/adapter.js

@@ -0,0 +1,204 @@
+import { listEffectiveExecutionModelTargets, listExecutionModelSecretNames, resolveModelProviderEnvName } from "../../compiler/modelEnv.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
+import { preparePicoClawRuntimeAuth } from "./runAuth.js";
+import { createPicoClawAgentScaffold } from "./scaffold.js";
+import { assertSupportedPicoClawSurfaces, buildPicoClawChannelConfig, buildPicoClawSurfaceEnvBindings } from "./surfaces.js";
+const formatModelName = (node) => {
+    const primary = node.execution?.model?.primary;
+    if (!primary)
+        return null;
+    return primary.name;
+};
+const resolveDefaultTemperature = (node) => {
+    const primary = node.execution?.model?.primary;
+    if (!primary)
+        return null;
+    if (primary.provider === "openai" && primary.name === "gpt-5") {
+        return 1;
+    }
+    return null;
+};
+const MODEL_PROVIDER_ENV_VARS = new Map([
+    ["anthropic", "ANTHROPIC_API_KEY"],
+    ["google", "GOOGLE_API_KEY"],
+    ["groq", "GROQ_API_KEY"],
+    ["mistral", "MISTRAL_API_KEY"],
+    ["openai", "OPENAI_API_KEY"],
+    ["openrouter", "OPENROUTER_API_KEY"],
+    ["xai", "XAI_API_KEY"]
+]);
+const formatProviderEnvName = (provider) => MODEL_PROVIDER_ENV_VARS.get(provider) ??
+    `${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
+const createProviderSecretPath = (provider) => createSecretPath(formatProviderEnvName(provider));
+const createSecretPath = (envName) => `secrets/${envName}`;
+const buildModelList = (node) => {
+    return listEffectiveExecutionModelTargets(node.execution).map((target) => {
+        if (target.endpoint) {
+            return {
+                ...(target.auth.method === "api_key"
+                    ? { api_key: `file://${createSecretPath(target.auth.key)}` }
+                    : {}),
+                api_base: target.endpoint.base_url,
+                model: target.endpoint.compatibility === "anthropic"
+                    ? `anthropic-messages/${target.name}`
+                    : `openai/${target.name}`,
+                model_name: target.name
+            };
+        }
+        return {
+            ...(target.auth.method === "api_key"
+                ? {
+                    api_key: `file://${createSecretPath(target.auth.key ?? resolveModelProviderEnvName(target.provider))}`
+                }
+                : {}),
+            model: `${target.provider}/${target.name}`,
+            model_name: target.name
+        };
+    });
+};
+const buildMcpServers = (servers) => {
+    const result = {};
+    for (const server of servers) {
+        const entry = { enabled: true };
+        if (server.transport === "stdio") {
+            entry.command = server.command;
+            if (server.args)
+                entry.args = server.args;
+            if (server.env)
+                entry.env = server.env;
+        }
+        else {
+            entry.type = server.transport === "streamable_http" ? "http" : server.transport;
+            entry.url = server.url;
+        }
+        if (server.auth) {
+            entry.headers = { [server.auth.secret]: "" };
+        }
+        result[server.name] = entry;
+    }
+    return result;
+};
+const buildPicoClawConfig = (node) => {
+    const modelName = formatModelName(node);
+    const restrictToWorkspace = node.runtime.options.restrict_to_workspace ?? true;
+    const temperature = resolveDefaultTemperature(node);
+    const config = {
+        agents: {
+            defaults: {
+                workspace: "<workspace-path>",
+                restrict_to_workspace: restrictToWorkspace,
+                ...(modelName ? { model_name: modelName } : {}),
+                ...(temperature !== null ? { temperature } : {})
+            }
+        },
+        model_list: buildModelList(node)
+    };
+    const channels = buildPicoClawChannelConfig(node.surfaces);
+    if (Object.keys(channels).length > 0) {
+        config.channels = channels;
+    }
+    if (node.mcpServers.length > 0) {
+        config.tools = {
+            mcp: {
+                enabled: true,
+                servers: buildMcpServers(node.mcpServers)
+            }
+        };
+    }
+    return `${JSON.stringify(config, null, 2)}\n`;
+};
+const createContainerTargets = async (inputs) => inputs.map((input) => {
+    const agent = input.value;
+    const envFiles = listExecutionModelSecretNames(agent.execution).map((secretName) => ({
+        envName: secretName,
+        relativePath: createSecretPath(secretName)
+    }));
+    const configEnvBindings = buildPicoClawSurfaceEnvBindings(agent.surfaces);
+    return {
+        configEnvBindings,
+        envFiles,
+        files: input.emittedFiles,
+        id: `${input.kind}-${input.slug}`,
+        sourceIds: [input.id]
+    };
+});
+export const picoClawAdapter = {
+    assertSupportedModelTarget(target) {
+        if (target.endpoint) {
+            if (target.endpoint.compatibility === "anthropic" &&
+                target.auth.method === "none") {
+                throw new SpawnfileError("validation_error", "PicoClaw anthropic-compatible custom or local models require api_key auth");
+            }
+            if (target.auth.method === "claude-code" || target.auth.method === "codex") {
+                throw new SpawnfileError("validation_error", `PicoClaw custom or local models do not support ${target.auth.method} auth`);
+            }
+            return;
+        }
+        if (target.provider === "anthropic") {
+            if (target.auth.method === "api_key" || target.auth.method === "claude-code") {
+                return;
+            }
+        }
+        else if (target.provider === "openai") {
+            if (target.auth.method === "api_key" || target.auth.method === "codex") {
+                return;
+            }
+        }
+        else if (target.auth.method === "api_key" || target.auth.method === "none") {
+            return;
+        }
+        throw new SpawnfileError("validation_error", `PicoClaw does not support model auth method ${target.auth.method} for provider ${target.provider}`);
+    },
+    assertSupportedSurfaces(surfaces) {
+        assertSupportedPicoClawSurfaces(surfaces);
+    },
+    container: {
+        configFileName: "config.json",
+        configPathEnv: "PICOCLAW_CONFIG",
+        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex"],
+        homeEnv: "PICOCLAW_HOME",
+        instancePaths: {
+            configPathTemplate: "<instance-root>/picoclaw/<config-file>",
+            homePathTemplate: "<instance-root>/picoclaw",
+            workspacePathTemplate: "<instance-root>/picoclaw/workspace"
+        },
+        port: 18790,
+        portEnv: "PICOCLAW_GATEWAY_PORT",
+        standaloneBaseImage: "debian:bookworm-slim",
+        startCommand: ["picoclaw", "gateway", "--allow-empty"],
+        staticEnv: {
+            PICOCLAW_GATEWAY_HOST: "0.0.0.0"
+        },
+        systemDeps: ["bash", "ca-certificates", "curl", "nodejs", "npm", "tar"]
+    },
+    async compileAgent(node) {
+        return {
+            capabilities: createAgentCapabilities(node),
+            diagnostics: [],
+            files: [
+                ...createDocumentFiles("workspace", node.docs),
+                ...createSkillFiles("workspace/skills", node.skills),
+                {
+                    content: buildPicoClawConfig(node),
+                    path: "config.json"
+                }
+            ]
+        };
+    },
+    async createContainerTargets(inputs) {
+        return createContainerTargets(inputs);
+    },
+    name: "picoclaw",
+    prepareRuntimeAuth: preparePicoClawRuntimeAuth,
+    scaffoldAgentProject: createPicoClawAgentScaffold,
+    validateRuntimeOptions(options) {
+        if ("restrict_to_workspace" in options &&
+            typeof options.restrict_to_workspace !== "boolean") {
+            return [
+                createDiagnostic("error", "PicoClaw runtime option restrict_to_workspace must be a boolean")
+            ];
+        }
+        return [];
+    }
+};

package/dist/runtime/picoclaw/runAuth.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAuthPreparationInput, RuntimeAuthPreparationResult } from "../types.js";
+export declare const preparePicoClawRuntimeAuth: (input: RuntimeAuthPreparationInput) => Promise<RuntimeAuthPreparationResult>;

package/dist/runtime/picoclaw/runAuth.js

@@ -0,0 +1,117 @@
+import path from "node:path";
+import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../../auth/index.js";
+import { copyDirectory, ensureDirectory, readUtf8File, writeUtf8File } from "../../filesystem/index.js";
+const resolveRootfsSourcePath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", ...path.posix.relative("/", containerPath).split("/"));
+const createMountArgs = (hostPath, containerPath) => [
+    "-v",
+    `${hostPath}:${containerPath}`
+];
+const createMountedHomeDirectory = async (input, patchedConfig, authStore) => {
+    const sourceHomePath = resolveRootfsSourcePath(input.outputDirectory, input.instance.home_path);
+    const mountedHomePath = path.join("runtime-auth", "picoclaw", input.instance.id, "home");
+    const hostHomePath = path.join(input.tempRoot, mountedHomePath);
+    await ensureDirectory(path.dirname(hostHomePath));
+    await copyDirectory(sourceHomePath, hostHomePath);
+    const relativeConfigPath = path.posix.relative(input.instance.home_path, input.instance.config_path);
+    const hostConfigPath = path.join(hostHomePath, ...relativeConfigPath.split("/"));
+    const hostAuthPath = path.join(hostHomePath, "auth.json");
+    await ensureDirectory(path.dirname(hostConfigPath));
+    await writeUtf8File(hostConfigPath, `${JSON.stringify(patchedConfig, null, 2)}\n`);
+    if (authStore) {
+        await writeUtf8File(hostAuthPath, `${JSON.stringify(authStore, null, 2)}\n`);
+    }
+    return hostHomePath;
+};
+const createPicoClawCredential = (provider, credential) => ({
+    access_token: credential.access,
+    ...("type" in credential && credential.type === "oauth" && credential.refresh
+        ? { refresh_token: credential.refresh }
+        : !("type" in credential)
+            ? { refresh_token: credential.refresh }
+            : {}),
+    ...("accountId" in credential && credential.accountId ? { account_id: credential.accountId } : {}),
+    auth_method: "oauth",
+    expires_at: new Date(credential.expires).toISOString(),
+    provider
+});
+const normalizeClaudeCliModelName = (modelName) => modelName.replaceAll(".", "-");
+const patchPicoClawConfig = (config, options) => {
+    const agents = config.agents ?? {};
+    const defaults = agents.defaults ?? {};
+    const providers = (config.providers ?? {});
+    const modelList = Array.isArray(config.model_list) ? config.model_list : [];
+    const nextProviders = { ...providers };
+    const nextModelList = modelList.map((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return entry;
+        }
+        const record = { ...entry };
+        const model = record.model;
+        const modelName = typeof record.model_name === "string" ? record.model_name : null;
+        if (options.useClaudeCode && typeof model === "string" && model.startsWith("anthropic/")) {
+            delete record.api_key;
+            delete record.auth_method;
+            if (modelName) {
+                record.model = `claude-cli/${normalizeClaudeCliModelName(modelName)}`;
+            }
+        }
+        if (options.useCodex && typeof model === "string" && model.startsWith("openai/")) {
+            delete record.api_key;
+            record.auth_method = "oauth";
+        }
+        return record;
+    });
+    if (options.useClaudeCode) {
+        delete nextProviders.anthropic;
+    }
+    if (options.useCodex) {
+        nextProviders.openai = {
+            ...(nextProviders.openai ?? {}),
+            auth_method: "oauth"
+        };
+    }
+    return {
+        ...config,
+        agents: {
+            ...agents,
+            defaults
+        },
+        model_list: nextModelList,
+        providers: nextProviders
+    };
+};
+export const preparePicoClawRuntimeAuth = async (input) => {
+    if (!input.instance.home_path) {
+        return { coveredModelSecrets: [], mountArgs: [] };
+    }
+    const claudeCode = input.authProfile.imports["claude-code"]
+        ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
+        : null;
+    const codex = input.authProfile.imports.codex
+        ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
+        : null;
+    const useClaudeCode = input.instance.model_auth_methods.anthropic === "claude-code" && claudeCode;
+    const useCodex = input.instance.model_auth_methods.openai === "codex" && codex;
+    if (!useClaudeCode && !useCodex) {
+        return { coveredModelSecrets: [], mountArgs: [] };
+    }
+    const credentials = {};
+    const coveredModelSecrets = [];
+    if (useCodex) {
+        credentials.openai = createPicoClawCredential("openai", codex);
+        coveredModelSecrets.push("OPENAI_API_KEY");
+    }
+    if (useClaudeCode) {
+        coveredModelSecrets.push("ANTHROPIC_API_KEY");
+    }
+    const sourceConfig = JSON.parse(await readUtf8File(resolveRootfsSourcePath(input.outputDirectory, input.instance.config_path)));
+    const patchedConfig = patchPicoClawConfig(sourceConfig, {
+        useClaudeCode: Boolean(useClaudeCode),
+        useCodex: Boolean(useCodex)
+    });
+    const mountedHomePath = await createMountedHomeDirectory(input, patchedConfig, Object.keys(credentials).length > 0 ? { credentials } : null);
+    return {
+        coveredModelSecrets,
+        mountArgs: createMountArgs(mountedHomePath, input.instance.home_path)
+    };
+};

package/dist/runtime/picoclaw/scaffold-assets/AGENTS.md

@@ -0,0 +1,3 @@
+# AGENTS.md
+
+PicoClaw reads this from the workspace.

package/dist/runtime/picoclaw/scaffold-assets/CLAUDE.md

@@ -0,0 +1,5 @@
+# PicoClaw Scaffold Assets
+
+This folder contains the bundled markdown starter files used by `spawnfile init --runtime picoclaw`.
+
+These files are copied into `dist/runtime/picoclaw/scaffold-assets/` during `npm run build` so the installed CLI can scaffold projects without depending on `blueprints/` or `runtimes/`.

package/dist/runtime/picoclaw/scaffold-assets/IDENTITY.md

@@ -0,0 +1,3 @@
+# IDENTITY.md
+
+PicoClaw reads this from the workspace.

package/dist/runtime/picoclaw/scaffold-assets/SOUL.md

@@ -0,0 +1,3 @@
+# SOUL.md
+
+PicoClaw reads this from the workspace.

package/dist/runtime/picoclaw/scaffold.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAgentScaffold } from "../types.js";
+export declare const createPicoClawAgentScaffold: () => RuntimeAgentScaffold;

package/dist/runtime/picoclaw/scaffold.js

@@ -0,0 +1,28 @@
+import { createAgentScaffoldManifest } from "../../manifest/index.js";
+import { loadRuntimeScaffoldAsset } from "../scaffoldAssets.js";
+export const createPicoClawAgentScaffold = () => ({
+    files: [
+        {
+            content: loadRuntimeScaffoldAsset(import.meta.url, "IDENTITY.md"),
+            path: "IDENTITY.md"
+        },
+        {
+            content: loadRuntimeScaffoldAsset(import.meta.url, "SOUL.md"),
+            path: "SOUL.md"
+        },
+        {
+            content: loadRuntimeScaffoldAsset(import.meta.url, "AGENTS.md"),
+            path: "AGENTS.md"
+        }
+    ],
+    manifest: createAgentScaffoldManifest({
+        docs: {
+            identity: "IDENTITY.md",
+            soul: "SOUL.md",
+            system: "AGENTS.md"
+        },
+        modelName: "claude-sonnet-4-6",
+        provider: "anthropic",
+        runtime: "picoclaw"
+    })
+});

package/dist/runtime/picoclaw/surfaces.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedAgentSurfaces } from "../../compiler/types.js";
+import type { RuntimeContainerConfigEnvBinding } from "../types.js";
+export declare const buildPicoClawChannelConfig: (surfaces: ResolvedAgentSurfaces | undefined) => Record<string, unknown>;
+export declare const buildPicoClawSurfaceEnvBindings: (surfaces: ResolvedAgentSurfaces | undefined) => RuntimeContainerConfigEnvBinding[] | undefined;
+export declare const assertSupportedPicoClawSurfaces: (surfaces: ResolvedAgentSurfaces | undefined) => void;

package/dist/runtime/picoclaw/surfaces.js

@@ -0,0 +1,111 @@
+import { SpawnfileError } from "../../shared/index.js";
+export const buildPicoClawChannelConfig = (surfaces) => {
+    if (!surfaces) {
+        return {};
+    }
+    const channels = {};
+    if (surfaces.discord) {
+        channels.discord = {
+            ...(surfaces.discord.access?.mode === "allowlist"
+                ? { allow_from: surfaces.discord.access.users }
+                : {}),
+            enabled: true,
+            mention_only: true
+        };
+    }
+    if (surfaces.telegram) {
+        channels.telegram = {
+            ...(surfaces.telegram.access?.mode === "allowlist"
+                ? { allow_from: surfaces.telegram.access.users }
+                : {}),
+            enabled: true
+        };
+    }
+    if (surfaces.whatsapp) {
+        channels.whatsapp = {
+            ...(surfaces.whatsapp.access?.mode === "allowlist"
+                ? { allow_from: surfaces.whatsapp.access.users }
+                : {}),
+            enabled: true,
+            use_native: true
+        };
+    }
+    if (surfaces.slack) {
+        channels.slack = {
+            ...(surfaces.slack.access?.mode === "allowlist"
+                ? { allow_from: surfaces.slack.access.users }
+                : {}),
+            enabled: true,
+            group_trigger: {
+                mention_only: true
+            }
+        };
+    }
+    return channels;
+};
+export const buildPicoClawSurfaceEnvBindings = (surfaces) => {
+    if (!surfaces) {
+        return undefined;
+    }
+    const bindings = [];
+    if (surfaces.discord) {
+        bindings.push({
+            envName: surfaces.discord.botTokenSecret,
+            jsonPath: "channels.discord.token"
+        });
+    }
+    if (surfaces.telegram) {
+        bindings.push({
+            envName: surfaces.telegram.botTokenSecret,
+            jsonPath: "channels.telegram.token"
+        });
+    }
+    if (surfaces.slack) {
+        bindings.push({
+            envName: surfaces.slack.botTokenSecret,
+            jsonPath: "channels.slack.bot_token"
+        }, {
+            envName: surfaces.slack.appTokenSecret,
+            jsonPath: "channels.slack.app_token"
+        });
+    }
+    return bindings.length > 0 ? bindings : undefined;
+};
+export const assertSupportedPicoClawSurfaces = (surfaces) => {
+    const discordAccess = surfaces?.discord?.access;
+    if (discordAccess) {
+        if (discordAccess.mode === "pairing") {
+            throw new SpawnfileError("validation_error", "PicoClaw Discord does not support pairing access");
+        }
+        if (discordAccess.guilds.length > 0 || discordAccess.channels.length > 0) {
+            throw new SpawnfileError("validation_error", "PicoClaw Discord only supports user allowlists in Spawnfile v0.1");
+        }
+    }
+    const telegramAccess = surfaces?.telegram?.access;
+    if (telegramAccess) {
+        if (telegramAccess.mode === "pairing") {
+            throw new SpawnfileError("validation_error", "PicoClaw Telegram does not support pairing access");
+        }
+        if (telegramAccess.chats.length > 0) {
+            throw new SpawnfileError("validation_error", "PicoClaw Telegram only supports user allowlists in Spawnfile v0.1");
+        }
+    }
+    const whatsappAccess = surfaces?.whatsapp?.access;
+    if (whatsappAccess) {
+        if (whatsappAccess.mode === "pairing") {
+            throw new SpawnfileError("validation_error", "PicoClaw WhatsApp does not support pairing access");
+        }
+        if (whatsappAccess.groups.length > 0) {
+            throw new SpawnfileError("validation_error", "PicoClaw WhatsApp only supports user allowlists in Spawnfile v0.1");
+        }
+    }
+    const slackAccess = surfaces?.slack?.access;
+    if (slackAccess) {
+        if (slackAccess.mode === "pairing") {
+            throw new SpawnfileError("validation_error", "PicoClaw Slack does not support pairing access");
+        }
+        if (slackAccess.channels.length > 0) {
+            throw new SpawnfileError("validation_error", "PicoClaw Slack only supports user allowlists in Spawnfile v0.1");
+        }
+    }
+};

package/dist/runtime/registry.d.ts

@@ -0,0 +1,41 @@
+import type { DiagnosticReport } from "../report/index.js";
+import type { RuntimeLifecycleStatus } from "../shared/index.js";
+import type { RuntimeAdapter } from "./types.js";
+export type RuntimeRegistryInstall = {
+    image: string;
+    kind: "container_image";
+    tag: string;
+} | {
+    kind: "github_release_archive";
+    assets: Record<string, string>;
+    binary: string;
+    repository: string;
+    tag: string;
+} | {
+    kind: "github_release_bundle";
+    asset: string;
+    repository: string;
+    tag: string;
+} | {
+    kind: "npm";
+    package: string;
+    version: string;
+} | {
+    kind: "source_repo";
+};
+export interface RuntimeRegistryEntry {
+    defaultBranch: string;
+    install?: RuntimeRegistryInstall;
+    name: string;
+    ref: string;
+    remote: string;
+    status: RuntimeLifecycleStatus;
+}
+export declare const parseRuntimeRegistry: (source: string) => RuntimeRegistryEntry[];
+export declare const loadRuntimeRegistry: () => Promise<RuntimeRegistryEntry[]>;
+export declare const getRegisteredRuntime: (runtimeName: string) => Promise<RuntimeRegistryEntry | undefined>;
+export declare const hasRuntimeAdapter: (runtimeName: string) => boolean;
+export declare const assertRuntimeCanCompile: (runtimeName: string) => Promise<RuntimeRegistryEntry>;
+export declare const createRuntimeLifecycleDiagnostics: (runtime: Pick<RuntimeRegistryEntry, "name" | "ref" | "status">) => DiagnosticReport[];
+export declare const getRuntimeAdapter: (runtimeName: string) => RuntimeAdapter;
+export declare const listRuntimeAdapters: () => string[];

package/dist/runtime/registry.js

@@ -0,0 +1,134 @@
+import { readFile } from "node:fs/promises";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { SpawnfileError } from "../shared/index.js";
+import { openClawAdapter } from "./openclaw/adapter.js";
+import { picoClawAdapter } from "./picoclaw/adapter.js";
+import { tinyClawAdapter } from "./tinyclaw/adapter.js";
+const runtimeAdapters = new Map([
+    [openClawAdapter.name, openClawAdapter],
+    [picoClawAdapter.name, picoClawAdapter],
+    [tinyClawAdapter.name, tinyClawAdapter]
+]);
+const runtimeInstallSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        image: z.string().min(1),
+        kind: z.literal("container_image"),
+        tag: z.string().min(1)
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("npm"),
+        package: z.string().min(1),
+        version: z.string().min(1)
+    })
+        .strict(),
+    z
+        .object({
+        assets: z.record(z.string(), z.string().min(1)),
+        binary: z.string().min(1),
+        kind: z.literal("github_release_archive"),
+        repository: z.string().min(1),
+        tag: z.string().min(1)
+    })
+        .strict(),
+    z
+        .object({
+        asset: z.string().min(1),
+        kind: z.literal("github_release_bundle"),
+        repository: z.string().min(1),
+        tag: z.string().min(1)
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("source_repo")
+    })
+        .strict()
+]);
+const runtimeRegistrySchema = z
+    .object({
+    runtimes: z.record(z.string(), z
+        .object({
+        default_branch: z.string().min(1),
+        install: runtimeInstallSchema.optional(),
+        ref: z.string().min(1),
+        remote: z.string().min(1),
+        status: z.enum(["active", "deprecated", "exploratory"])
+    })
+        .strict())
+})
+    .strict();
+const runtimeRegistryUrl = new URL("../../runtimes.yaml", import.meta.url);
+let runtimeRegistryPromise;
+export const parseRuntimeRegistry = (source) => {
+    try {
+        const parsed = runtimeRegistrySchema.parse(parseYaml(source));
+        return Object.entries(parsed.runtimes)
+            .map(([name, entry]) => ({
+            defaultBranch: entry.default_branch,
+            install: entry.install,
+            name,
+            ref: entry.ref,
+            remote: entry.remote,
+            status: entry.status
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const issue = error.issues[0];
+            throw new SpawnfileError("runtime_error", `Invalid runtime registry: ${issue.message}`);
+        }
+        throw error;
+    }
+};
+const readRuntimeRegistry = async () => {
+    try {
+        const source = await readFile(runtimeRegistryUrl, "utf8");
+        return parseRuntimeRegistry(source);
+    }
+    catch (error) {
+        if (error instanceof SpawnfileError) {
+            throw error;
+        }
+        throw new SpawnfileError("runtime_error", `Unable to read runtime registry at ${runtimeRegistryUrl.pathname}`);
+    }
+};
+export const loadRuntimeRegistry = async () => {
+    runtimeRegistryPromise ??= readRuntimeRegistry();
+    return runtimeRegistryPromise;
+};
+export const getRegisteredRuntime = async (runtimeName) => (await loadRuntimeRegistry()).find((entry) => entry.name === runtimeName);
+export const hasRuntimeAdapter = (runtimeName) => runtimeAdapters.has(runtimeName);
+export const assertRuntimeCanCompile = async (runtimeName) => {
+    const registeredRuntime = await getRegisteredRuntime(runtimeName);
+    if (!registeredRuntime) {
+        throw new SpawnfileError("runtime_error", `Unknown runtime binding: ${runtimeName}`);
+    }
+    if (registeredRuntime.status === "exploratory") {
+        throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} is exploratory and cannot be compiled in v0.1`);
+    }
+    if (!hasRuntimeAdapter(runtimeName)) {
+        throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} is marked ${registeredRuntime.status} in runtimes.yaml but has no bundled adapter`);
+    }
+    return registeredRuntime;
+};
+export const createRuntimeLifecycleDiagnostics = (runtime) => runtime.status === "deprecated"
+    ? [
+        {
+            level: "warn",
+            message: `Runtime ${runtime.name} is deprecated in Spawnfile and pinned at ${runtime.ref}`
+        }
+    ]
+    : [];
+export const getRuntimeAdapter = (runtimeName) => {
+    const adapter = runtimeAdapters.get(runtimeName);
+    if (!adapter) {
+        throw new SpawnfileError("runtime_error", `Unknown runtime adapter: ${runtimeName}`);
+    }
+    return adapter;
+};
+export const listRuntimeAdapters = () => [...runtimeAdapters.keys()].sort();

package/dist/runtime/scaffoldAssets.d.ts

@@ -0,0 +1 @@
+export declare const loadRuntimeScaffoldAsset: (moduleUrl: string, assetName: string) => string;

package/dist/runtime/scaffoldAssets.js

@@ -0,0 +1,2 @@
+import { readFileSync } from "node:fs";
+export const loadRuntimeScaffoldAsset = (moduleUrl, assetName) => readFileSync(new URL(`./scaffold-assets/${assetName}`, moduleUrl), "utf8");