spawnfile 0.1.12 → 0.1.14

package/dist/compiler/buildProject.js

@@ -1,8 +1,14 @@
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { execFile as execFileCallback, spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+import { promisify } from "node:util";
+import { BUILD_IMAGE_CACHE_VERSION, readBuildImageCacheEntry, writeBuildImageCacheEntry } from "../deployment/buildImageCacheStore.js";
 import { SpawnfileError } from "../shared/index.js";
 import { compileProject } from "./compileProject.js";
+import { createDockerBuildContextDigest, listDockerBuildContextFiles } from "./dockerBuildContext.js";
+import { inspectDockerImage, shouldSkipDockerBuild } from "./dockerBuildSkip.js";
 import { slugify } from "./helpers.js";
+const execFile = promisify(execFileCallback);
 export const createDefaultImageTag = (projectRoot) => {
     const baseName = slugify(path.basename(projectRoot));
     return `spawnfile-${baseName || "project"}`;
@@ -13,12 +19,44 @@ const resolveImageTagRoot = (inputPath) => {
         ? path.dirname(resolvedPath)
         : resolvedPath;
 };
-export const createDockerBuildInvocation = (outputDirectory, imageTag, dockerCommand = "docker") => ({
-    args: ["build", "-t", imageTag, "."],
-    command: dockerCommand,
+export const createDockerBuildInvocation = (outputDirectory, imageTag, options = "docker") => ({
+    args: typeof options === "string" || !options.dockerContext
+        ? ["build", "-t", imageTag, "."]
+        : ["--context", options.dockerContext, "build", "-t", imageTag, "."],
+    command: typeof options === "string" ? options : options.dockerCommand ?? "docker",
     cwd: outputDirectory,
+    dockerContext: typeof options === "string" ? null : options.dockerContext ?? null,
     imageTag
 });
+export const normalizeDockerArchitecture = (architecture) => {
+    switch (architecture.trim()) {
+        case "amd64":
+        case "x64":
+        case "x86_64":
+            return "amd64";
+        case "aarch64":
+        case "arm64":
+            return "arm64";
+        default:
+            throw new SpawnfileError("compile_error", `Docker target architecture ${architecture.trim() || "unknown"} is not supported by staged Moltnet binaries`);
+    }
+};
+export const resolveDockerBuildArchitecture = async (options) => {
+    if (!options.dockerContext) {
+        return undefined;
+    }
+    try {
+        const { stdout } = await execFile(options.dockerCommand ?? "docker", ["--context", options.dockerContext, "info", "--format", "{{.Architecture}}"], { timeout: 10_000 });
+        return normalizeDockerArchitecture(stdout);
+    }
+    catch (error) {
+        if (error instanceof SpawnfileError) {
+            throw error;
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to resolve Docker context ${options.dockerContext} architecture: ${reason}`);
+    }
+};
 export const runDockerBuild = async (invocation) => new Promise((resolve, reject) => {
     const child = spawn(invocation.command, invocation.args, {
         cwd: invocation.cwd,
@@ -38,15 +76,91 @@ export const runDockerBuild = async (invocation) => new Promise((resolve, reject
     });
 });
 export const buildProject = async (inputPath, options = {}) => {
+    const targetArchitecture = options.containerArchitecture ?? await resolveDockerBuildArchitecture(options);
     const compileResult = await compileProject(inputPath, {
         clean: options.clean,
-        outputDirectory: options.outputDirectory
+        containerArchitecture: targetArchitecture,
+        outputDirectory: options.outputDirectory,
+        runtimePackageOverrides: options.runtimePackageOverrides,
+        ...(options.worldBindingsPath !== undefined
+            ? { worldBindingsPath: options.worldBindingsPath }
+            : {})
     });
     const imageTag = options.imageTag ?? createDefaultImageTag(resolveImageTagRoot(inputPath));
-    const invocation = createDockerBuildInvocation(compileResult.outputDirectory, imageTag, options.dockerCommand);
-    await (options.buildRunner ?? runDockerBuild)(invocation);
+    const invocation = createDockerBuildInvocation(compileResult.outputDirectory, imageTag, {
+        dockerCommand: options.dockerCommand,
+        dockerContext: options.dockerContext
+    });
+    const compileFingerprint = compileResult.report.compile_fingerprint ?? "";
+    const projectRoot = compileResult.report.root;
+    const contextDigestStartedAt = performance.now();
+    const [contextFiles, contextDigest] = await Promise.all([
+        listDockerBuildContextFiles(compileResult.outputDirectory),
+        createDockerBuildContextDigest(compileResult.outputDirectory)
+    ]);
+    const contextDigestMs = performance.now() - contextDigestStartedAt;
+    let probeMs = 0;
+    let skipped = false;
+    if (!options.buildRunner) {
+        const probeStartedAt = performance.now();
+        const cacheEntry = await readBuildImageCacheEntry({
+            dockerContext: options.dockerContext,
+            imageTag,
+            projectRoot
+        });
+        skipped = await shouldSkipDockerBuild({
+            cacheEntry,
+            compileFingerprint,
+            contextDigest,
+            dockerCommand: options.dockerCommand,
+            dockerContext: options.dockerContext,
+            imageInspector: options.imageInspector,
+            imageTag
+        });
+        probeMs = performance.now() - probeStartedAt;
+    }
+    let buildMs = null;
+    if (!skipped) {
+        const buildStartedAt = performance.now();
+        await (options.buildRunner ?? runDockerBuild)(invocation);
+        buildMs = performance.now() - buildStartedAt;
+        if (!options.buildRunner) {
+            try {
+                const inspection = await (options.imageInspector ?? inspectDockerImage)({
+                    dockerCommand: options.dockerCommand,
+                    dockerContext: options.dockerContext,
+                    imageTag
+                });
+                if (inspection
+                    && inspection.labels["com.spawnfile.compile_fingerprint"] === compileFingerprint) {
+                    await writeBuildImageCacheEntry({
+                        compileFingerprint,
+                        contextDigest,
+                        dockerContext: options.dockerContext ?? null,
+                        imageId: inspection.id,
+                        imageTag,
+                        projectRoot,
+                        version: BUILD_IMAGE_CACHE_VERSION,
+                        writtenAt: new Date().toISOString()
+                    });
+                }
+            }
+            catch {
+                // A post-build cache probe is best-effort and never changes build success.
+            }
+        }
+    }
     return {
         ...compileResult,
+        imageBuild: {
+            buildMs,
+            contextBytes: contextFiles.reduce((total, file) => total + file.size, 0),
+            contextDigest,
+            contextDigestMs,
+            contextFileCount: contextFiles.length,
+            probeMs,
+            skipped
+        },
         imageTag
     };
 };

package/dist/compiler/compilePlanHelpers.js

@@ -14,6 +14,7 @@ export const validateEffectiveSkillRequirements = (nodeName, mcpNames, skills) =
 export const getAgentFingerprint = (node) => stableStringify({
     env: node.env,
     execution: node.execution,
+    memory: node.memory,
     mcpServers: node.mcpServers,
     runtime: node.runtime,
     schedule: node.schedule,
@@ -30,6 +31,7 @@ export const getAgentFingerprint = (node) => stableStringify({
 export const getTeamFingerprint = (node) => stableStringify({
     members: node.members,
     mode: node.mode,
+    memory: node.memory,
     lead: node.lead,
     external: node.external,
     networks: node.networks ?? [],

package/dist/compiler/compileProject.d.ts

@@ -1,9 +1,24 @@
 import { CompileReport } from "../report/index.js";
+import { type RuntimePackageOverrideRequest } from "./containerPackageOverrides.js";
+import { type MoltnetTargetArchitecture } from "./moltnetBinaries.js";
+import { type OrganizationReadinessEvidence } from "./organizationReadyEvidence.js";
+export { createOrganizationReadinessEvidence, ORGANIZATION_READINESS_EVIDENCE_VERSION } from "./organizationReadyEvidence.js";
+export type { CreateOrganizationReadinessEvidenceInput, OrganizationReadinessEvidence } from "./organizationReadyEvidence.js";
 export interface CompileProjectOptions {
     clean?: boolean;
+    containerArchitecture?: MoltnetTargetArchitecture;
     outputDirectory?: string;
+    /** Compile-time-only local overrides for runtime install npm packages
+     * (see src/compiler/containerPackageOverrides.ts). Only opt-in
+     * local/E2E callers set this; a standard compile leaves it undefined and
+     * every runtime install package resolves to its pinned registry
+     * version, unchanged. */
+    runtimePackageOverrides?: RuntimePackageOverrideRequest;
+    /** Runner-owned path to a bounded, secret-free simfile.world-bindings.v1 artifact. */
+    worldBindingsPath?: string;
 }
 export interface CompileProjectResult {
+    organizationReadinessEvidence: OrganizationReadinessEvidence;
     outputDirectory: string;
     report: CompileReport;
     reportPath: string;

package/dist/compiler/compileProject.js

@@ -3,12 +3,18 @@ import { chmod } from "node:fs/promises";
 import { ensureDirectory, removeDirectory } from "../filesystem/index.js";
 import { createCompileReport, createDiagnostic, writeCompileReport } from "../report/index.js";
 import { DEFAULT_OUTPUT_DIRECTORY } from "../shared/index.js";
-import { assertRuntimeCanCompile, createRuntimeLifecycleDiagnostics, getRuntimeAdapter } from "../runtime/index.js";
+import { assertRuntimeCanCompile, createRuntimeLifecycleDiagnostics, getRuntimeAdapter, resolveNoopolisRunId } from "../runtime/index.js";
 import { buildCompilePlan } from "./buildCompilePlan.js";
 import { createContainerArtifacts } from "./containerArtifacts.js";
+import { stageRuntimePackageOverrides } from "./containerPackageOverrides.js";
+import { augmentNodeReports } from "./compileProjectReports.js";
+import { enforcePolicy } from "./compileProjectPolicy.js";
 import { injectMoltnetWorkspaceFiles, injectTeamCompileSupportFiles, prepareTeamCompileSupport, writeEmittedFiles } from "./compileProjectSupport.js";
 import { generateMoltnetArtifacts } from "./moltnetArtifacts.js";
 import { stageMoltnetBinaries } from "./moltnetBinaries.js";
+import { loadWorldBindingsForCompile } from "./worldBindingsFile.js";
+import { createOrganizationReadinessEvidence } from "./organizationReadyEvidence.js";
+export { createOrganizationReadinessEvidence, ORGANIZATION_READINESS_EVIDENCE_VERSION } from "./organizationReadyEvidence.js";
 const createTeamCapabilities = (outcome, message) => [
     { key: "team.members", message, outcome },
     { key: "team.mode", message, outcome },
@@ -132,76 +138,11 @@ const compileTeamNode = async (baseDirectory, node) => {
         value: node.value
     };
 };
-const enforcePolicy = (nodeReport, policyMode, onDegrade) => {
-    for (const capability of nodeReport.capabilities) {
-        if (capability.outcome === "unsupported") {
-            if (policyMode === "strict") {
-                throw new Error(`Policy violation: ${capability.key} is unsupported for ${nodeReport.id} (strict mode)${capability.message ? `: ${capability.message}` : ""}`);
-            }
-            if (policyMode === "warn") {
-                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is unsupported for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
-            }
-        }
-        if (capability.outcome === "degraded") {
-            if (onDegrade === "error") {
-                throw new Error(`Policy violation: ${capability.key} is degraded for ${nodeReport.id} (on_degrade: error)${capability.message ? `: ${capability.message}` : ""}`);
-            }
-            if (onDegrade === "warn") {
-                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is degraded for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
-            }
-        }
-    }
-};
-const createIdentityCapabilities = (node) => [
-    ...(node.surfaces?.slack?.identity
-        ? [{
-                key: "surfaces.slack.identity",
-                message: "Declared Slack identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : []),
-    ...(node.surfaces?.discord?.identity
-        ? [{
-                key: "surfaces.discord.identity",
-                message: "Declared Discord identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : []),
-    ...(node.surfaces?.telegram?.identity
-        ? [{
-                key: "surfaces.telegram.identity",
-                message: "Declared Telegram identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : []),
-    ...(node.surfaces?.whatsapp?.identity
-        ? [{
-                key: "surfaces.whatsapp.identity",
-                message: "Declared WhatsApp identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : [])
-];
-const createWorkspaceResourceCapabilities = (node) => (node.workspaceResources?.length ?? 0) > 0
-    ? [{
-            key: "workspace.resources",
-            message: `${node.workspaceResources?.length ?? 0} workspace resource(s) will be prepared at startup`,
-            outcome: "supported"
-        }]
-    : [];
-const augmentNodeReports = (compiledNodes, support) => {
-    for (const compiled of compiledNodes) {
-        compiled.report.capabilities.push(...createWorkspaceResourceCapabilities(compiled.value));
-        if (compiled.value.kind === "team") {
-            compiled.report.capabilities.push(...(support.capabilitiesByTeamSource.get(compiled.value.source) ?? []));
-            compiled.report.diagnostics.push(...(support.diagnosticsByTeamSource.get(compiled.value.source) ?? []));
-            continue;
-        }
-        compiled.report.capabilities.push(...createIdentityCapabilities(compiled.value));
-    }
-};
 export const compileProject = async (inputPath, options = {}) => {
     const plan = await buildCompilePlan(inputPath);
+    const worldBindings = options.worldBindingsPath === undefined
+        ? undefined
+        : await loadWorldBindingsForCompile(plan, options.worldBindingsPath, resolveNoopolisRunId(process.env));
     // The default output directory lives under the resolved project root, not the
     // process working directory, so `spawnfile compile ./org` writes ./org/.spawn.
     const outputDirectory = options.outputDirectory
@@ -231,15 +172,21 @@ export const compileProject = async (inputPath, options = {}) => {
         enforcePolicy(compiled.report, compiled.value.policyMode, compiled.value.policyOnDegrade);
     }
     const moltnetArtifacts = await generateMoltnetArtifacts(plan);
-    const hasStagedMoltnetBinaries = moltnetArtifacts
-        ? await stageMoltnetBinaries(outputDirectory)
-        : false;
+    const moltnetRelease = moltnetArtifacts
+        ? await stageMoltnetBinaries(outputDirectory, {
+            architecture: options.containerArchitecture
+        })
+        : undefined;
     await injectMoltnetWorkspaceFiles(outputDirectory, compiledNodes, moltnetArtifacts);
+    const resolvedRuntimePackageOverrides = await stageRuntimePackageOverrides(outputDirectory, options.runtimePackageOverrides);
     const generatedAt = new Date().toISOString();
     const containerArtifacts = await createContainerArtifacts(plan, compiledNodes, {
         generatedAt,
-        hasStagedMoltnetBinaries,
-        moltnet: moltnetArtifacts
+        hasStagedMoltnetBinaries: Boolean(moltnetRelease),
+        moltnet: moltnetArtifacts,
+        moltnetRelease,
+        runtimePackageOverrides: resolvedRuntimePackageOverrides,
+        ...(worldBindings ? { worldBindings } : {})
     });
     await writeEmittedFiles(outputDirectory, containerArtifacts.files);
     await Promise.all(containerArtifacts.executablePaths.map((filePath) => chmod(path.join(outputDirectory, filePath), 0o755)));
@@ -250,5 +197,12 @@ export const compileProject = async (inputPath, options = {}) => {
         projectName: containerArtifacts.distribution.report.organization.project
     });
     const reportPath = await writeCompileReport(outputDirectory, report);
-    return { outputDirectory, report, reportPath };
+    const organizationReadinessEvidence = createOrganizationReadinessEvidence({
+        compileVersion: report.spawnfile_version,
+        containerArtifacts,
+        moltnetArtifacts,
+        plan,
+        ...(worldBindings ? { worldBindings } : {})
+    });
+    return { organizationReadinessEvidence, outputDirectory, report, reportPath };
 };

package/dist/compiler/compileProjectPolicy.d.ts

@@ -0,0 +1,5 @@
+import type { Manifest } from "../manifest/index.js";
+import { type NodeReport } from "../report/index.js";
+export type PolicyMode = NonNullable<Manifest["policy"]>["mode"];
+export type OnDegrade = NonNullable<Manifest["policy"]>["on_degrade"];
+export declare const enforcePolicy: (nodeReport: NodeReport, policyMode: PolicyMode | null, onDegrade: OnDegrade | null) => void;

package/dist/compiler/compileProjectPolicy.js

@@ -0,0 +1,21 @@
+import { createDiagnostic } from "../report/index.js";
+export const enforcePolicy = (nodeReport, policyMode, onDegrade) => {
+    for (const capability of nodeReport.capabilities) {
+        if (capability.outcome === "unsupported") {
+            if (policyMode === "strict") {
+                throw new Error(`Policy violation: ${capability.key} is unsupported for ${nodeReport.id} (strict mode)${capability.message ? `: ${capability.message}` : ""}`);
+            }
+            if (policyMode === "warn") {
+                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is unsupported for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
+            }
+        }
+        if (capability.outcome === "degraded") {
+            if (onDegrade === "error") {
+                throw new Error(`Policy violation: ${capability.key} is degraded for ${nodeReport.id} (on_degrade: error)${capability.message ? `: ${capability.message}` : ""}`);
+            }
+            if (onDegrade === "warn") {
+                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is degraded for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
+            }
+        }
+    }
+};

package/dist/compiler/compileProjectReports.d.ts

@@ -0,0 +1,9 @@
+import type { NodeReport } from "../report/index.js";
+import type { TeamCompileSupport } from "./compileProjectSupport.js";
+import type { ResolvedAgentNode, ResolvedTeamNode } from "./types.js";
+interface ReportTarget {
+    report: NodeReport;
+    value: ResolvedAgentNode | ResolvedTeamNode;
+}
+export declare const augmentNodeReports: (compiledNodes: ReportTarget[], support: TeamCompileSupport) => void;
+export {};

package/dist/compiler/compileProjectReports.js

@@ -0,0 +1,52 @@
+const createIdentityCapabilities = (node) => [
+    ...(node.surfaces?.slack?.identity
+        ? [{
+                key: "surfaces.slack.identity",
+                message: "Declared Slack identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.discord?.identity
+        ? [{
+                key: "surfaces.discord.identity",
+                message: "Declared Discord identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.telegram?.identity
+        ? [{
+                key: "surfaces.telegram.identity",
+                message: "Declared Telegram identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.whatsapp?.identity
+        ? [{
+                key: "surfaces.whatsapp.identity",
+                message: "Declared WhatsApp identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : [])
+];
+const createWorkspaceResourceCapabilities = (node) => (node.workspaceResources?.length ?? 0) > 0
+    ? [{
+            key: "workspace.resources",
+            message: `${node.workspaceResources?.length ?? 0} workspace resource(s) will be prepared at startup`,
+            outcome: "supported"
+        }]
+    : [];
+export const augmentNodeReports = (compiledNodes, support) => {
+    for (const compiled of compiledNodes) {
+        compiled.report.capabilities.push(...createWorkspaceResourceCapabilities(compiled.value));
+        if (compiled.value.kind === "team") {
+            compiled.report.capabilities.push(...(support.capabilitiesByTeamSource.get(compiled.value.source) ?? []));
+            compiled.report.diagnostics.push(...(support.diagnosticsByTeamSource.get(compiled.value.source) ?? []));
+            continue;
+        }
+        const activeEnvironments = support.activeEnvironmentsByAgentSource.get(compiled.value.source);
+        if (activeEnvironments) {
+            compiled.report.active_environments = activeEnvironments;
+        }
+        compiled.report.capabilities.push(...createIdentityCapabilities(compiled.value));
+    }
+};

package/dist/compiler/containerArtifactSummaries.d.ts

@@ -0,0 +1,7 @@
+import type { DistributionOrganizationSummary } from "../distribution/index.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { MoltnetReleaseIdentity } from "./moltnetBinaries.js";
+import type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
+import type { CompilePlan } from "./types.js";
+export declare const createOrganizationSummary: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[]) => DistributionOrganizationSummary;
+export declare const createMoltnetSummary: (moltnet: MoltnetArtifacts | undefined | null, release: MoltnetReleaseIdentity | undefined) => GeneratedContainerArtifacts["report"]["moltnet"] | undefined;

package/dist/compiler/containerArtifactSummaries.js

@@ -0,0 +1,138 @@
+import { SpawnfileError } from "../shared/index.js";
+export const createOrganizationSummary = (plan, compiledNodes) => {
+    const nodes = compiledNodes.map((node) => ({
+        id: node.id ?? `${node.kind}:${node.slug}`,
+        kind: node.kind,
+        name: node.value.name,
+        runtimeName: node.runtimeName,
+        source: node.value.source
+    }));
+    const rootNode = nodes.find((node) => node.source === plan.root)
+        ?? nodes.find((node) => !plan.edges.some((edge) => edge.to === node.id))
+        ?? nodes[0];
+    if (!rootNode) {
+        throw new SpawnfileError("compile_error", `Unable to resolve the root node for ${plan.root}`);
+    }
+    const memberEdges = plan.edges.filter((edge) => edge.kind === "team_member");
+    const teamsByAgent = new Map();
+    for (const edge of memberEdges) {
+        teamsByAgent.set(edge.to, [...(teamsByAgent.get(edge.to) ?? []), edge.from]);
+    }
+    const agentNodes = nodes.filter((node) => node.kind === "agent");
+    const teamNodes = nodes.filter((node) => node.kind === "team");
+    const agentIds = new Set(agentNodes.map((node) => node.id));
+    return {
+        agents: agentNodes
+            .map((node) => ({
+            id: node.id,
+            name: node.name,
+            runtime: node.runtimeName,
+            teams: [...(teamsByAgent.get(node.id) ?? [])].sort()
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id)),
+        project: rootNode.name,
+        teams: teamNodes
+            .map((node) => ({
+            agents: memberEdges
+                .filter((edge) => edge.from === node.id && agentIds.has(edge.to))
+                .map((edge) => edge.to)
+                .sort(),
+            id: node.id,
+            name: node.name
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id))
+    };
+};
+const resolveMoltnetOperatorCredential = (plan) => {
+    const client = plan.server.auth.client;
+    if (!client) {
+        return {};
+    }
+    if (client.token_env) {
+        return { secret: client.token_env };
+    }
+    if (client.token_path) {
+        return { secret: client.token_path };
+    }
+    if (!client.token_id) {
+        return {};
+    }
+    const token = plan.server.auth.tokens?.find((candidate) => candidate.id === client.token_id);
+    const agents = [...new Set((token?.agents ?? []).map((agent) => agent.trim()))].filter(Boolean);
+    return {
+        ...(agents.length === 1 ? { agentId: agents[0] } : {}),
+        id: client.token_id,
+        ...(token?.secret ? { secret: token.secret } : {})
+    };
+};
+export const createMoltnetSummary = (moltnet, release) => {
+    if (!moltnet) {
+        return undefined;
+    }
+    return {
+        node_plans: moltnet.nodePlans.map((plan) => ({
+            config_path: plan.configPath,
+            ...(plan.credentialAgentId ? { credential_agent_id: plan.credentialAgentId } : {}),
+            ...(plan.credentialId ? { credential_id: plan.credentialId } : {}),
+            ...(plan.credentialSecret ? { credential_secret: plan.credentialSecret } : {}),
+            ...(plan.memberId ? { member_id: plan.memberId } : {}),
+            network_id: plan.networkId
+        })),
+        release,
+        server_plans: moltnet.serverPlans.map((plan) => {
+            const operatorCredential = resolveMoltnetOperatorCredential(plan);
+            return {
+                ...(plan.server.auth.agent_registration
+                    ? { agent_registration: plan.server.auth.agent_registration }
+                    : {}),
+                auth_mode: plan.server.auth.mode,
+                ...(plan.server.mode === "managed" && plan.server.auth.tokens
+                    ? {
+                        auth_tokens: plan.server.auth.tokens.map((token) => ({
+                            agents: [...new Set((token.agents ?? []).map((agent) => agent.trim()))]
+                                .filter(Boolean)
+                                .sort(),
+                            id: token.id,
+                            scopes: [...token.scopes].sort(),
+                            secret: token.secret
+                        }))
+                    }
+                    : {}),
+                base_url: plan.baseUrl,
+                ...(plan.configPath ? { config_path: plan.configPath } : {}),
+                ...(plan.server.mode === "managed"
+                    ? {
+                        debug_events: plan.server.debug_events,
+                        direct_messages: plan.server.direct_messages,
+                        human_ingress: plan.server.human_ingress,
+                        trust_forwarded_proto: plan.server.trust_forwarded_proto
+                    }
+                    : {}),
+                id: plan.id,
+                mode: plan.mode,
+                network_id: plan.networkId,
+                network_name: plan.name,
+                ...(operatorCredential.agentId
+                    ? { operator_agent_id: operatorCredential.agentId }
+                    : {}),
+                ...(operatorCredential.id ? { operator_token_id: operatorCredential.id } : {}),
+                ...(operatorCredential.secret
+                    ? { operator_token_secret: operatorCredential.secret }
+                    : {}),
+                ...(plan.port ? { port: plan.port } : {}),
+                ...(plan.server.auth.public_read !== undefined
+                    ? { public_read: plan.server.auth.public_read }
+                    : {}),
+                rooms: plan.rooms.map((room) => ({
+                    id: room.id,
+                    members: [...room.members],
+                    ...(room.visibility ? { visibility: room.visibility } : {}),
+                    ...(room.write_policy ? { write_policy: room.write_policy } : {})
+                })),
+                ...(plan.server.mode === "managed"
+                    ? { store_kind: plan.server.store.kind }
+                    : {})
+            };
+        })
+    };
+};

package/dist/compiler/containerArtifacts.d.ts

@@ -1,10 +1,20 @@
+import type { RuntimeContainerPackageOverrides } from "../runtime/index.js";
 import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { MoltnetReleaseIdentity } from "./moltnetBinaries.js";
 import type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
 import type { CompilePlan } from "./types.js";
+import { type ResolvedWorldBindings } from "./worldBindings.js";
 export type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
 export interface ContainerArtifactOptions {
     generatedAt?: string;
     hasStagedMoltnetBinaries?: boolean;
     moltnet?: MoltnetArtifacts | null;
+    moltnetRelease?: MoltnetReleaseIdentity;
+    worldBindings?: ResolvedWorldBindings;
+    /** Resolved local overrides for runtime install npm packages, produced by
+     * stageRuntimePackageOverrides.ts from a compile-time-only
+     * RuntimePackageOverrideRequest (see compileProject.ts). Undefined for a
+     * standard compile. */
+    runtimePackageOverrides?: RuntimeContainerPackageOverrides;
 }
 export declare const createContainerArtifacts: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[], options?: ContainerArtifactOptions) => Promise<GeneratedContainerArtifacts>;