spawnfile 0.1.13 → 0.1.14

package/dist/compiler/memoryArtifacts.js

@@ -0,0 +1,134 @@
+import path from "node:path/posix";
+import { resolveNoopolisRunId } from "../runtime/index.js";
+import { slugify } from "./helpers.js";
+import { createPersistentVolumeName } from "./moltnetArtifactPaths.js";
+const normalizePosixPath = (value) => path.normalize(value).replace(/\/+$/u, "") || "/";
+const safeSlug = (value) => slugify(value).trim() || "memory";
+const createMountId = (mountPath) => `memory-${safeSlug(mountPath)}`;
+const isFileBackedMemoryStore = (bank) => bank.store.kind === "sqlite" || bank.store.kind === "json";
+const transportFromRuntime = (runtimeName, bank) => {
+    switch (runtimeName) {
+        case "pi":
+        case "daimon":
+            return "direct";
+        case "picoclaw":
+        case "openclaw":
+            return isFileBackedMemoryStore(bank) ? "mcp" : "degraded_mcp";
+        default:
+            return "unsupported";
+    }
+};
+const memoryMountPath = (bank) => {
+    if (bank.store.kind !== "sqlite" && bank.store.kind !== "json") {
+        return null;
+    }
+    if (bank.store.persistence?.mode === "ephemeral") {
+        return null;
+    }
+    if (bank.store.persistence?.mount) {
+        return normalizePosixPath(bank.store.persistence.mount);
+    }
+    return bank.store.path
+        ? path.dirname(normalizePosixPath(bank.store.path))
+        : null;
+};
+const summarizeMemoryStore = (bank, mountId) => {
+    const persistenceMode = bank.store.kind === "sqlite" || bank.store.kind === "json"
+        ? (bank.store.persistence?.mode ?? "durable")
+        : undefined;
+    return {
+        kind: bank.store.kind,
+        ...(bank.store.path ? { path: bank.store.path } : {}),
+        ...(persistenceMode ? { persistence: persistenceMode } : {}),
+        ...(mountId ? { persistent_mount_id: mountId } : {}),
+        ...(bank.store.kind === "postgres" ? { dsn_secret: bank.store.dsn_secret } : {})
+    };
+};
+export const createMemoryArtifactBundle = (plan) => {
+    // Run-scoping key for every derived volume name below (see
+    // createPersistentVolumeName's doc comment in moltnetArtifactPaths.ts):
+    // present whenever this compile was driven by `spawnfile run`/`up`
+    // (which always call ensureNoopolisRunId() first), absent for a bare
+    // `spawnfile compile`/`spawnfile build`.
+    const runId = resolveNoopolisRunId(process.env);
+    const sourceToNode = new Map(plan.nodes.map((node) => [node.value.source, node]));
+    const groupedMemory = new Map();
+    for (const access of plan.memoryAccess ?? []) {
+        const key = `${access.source}::${access.bank.id}`;
+        const existing = groupedMemory.get(key);
+        if (existing) {
+            existing.accesses.push(access);
+        }
+        else {
+            groupedMemory.set(key, { bank: access.bank, source: access.source, accesses: [access] });
+        }
+    }
+    const mounts = [];
+    const mountPathMemoryMap = new Map();
+    const mountByPath = new Map();
+    const memories = [...groupedMemory.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, entry]) => {
+        const declaringNode = sourceToNode.get(entry.source);
+        if (!declaringNode) {
+            return null;
+        }
+        const transportByNodeId = {};
+        const accessibleNodeIds = new Set();
+        for (const access of entry.accesses) {
+            const agentNode = sourceToNode.get(access.agentSource);
+            if (!agentNode || agentNode.value.kind !== "agent") {
+                continue;
+            }
+            const transport = transportFromRuntime(agentNode.runtimeName, entry.bank);
+            transportByNodeId[agentNode.id] = transport;
+            accessibleNodeIds.add(agentNode.id);
+        }
+        const declaringNodeId = declaringNode.id;
+        const mountPath = memoryMountPath(entry.bank);
+        let persistentMountId;
+        if (mountPath !== null) {
+            const mountId = createMountId(mountPath);
+            // createPersistentVolumeName also folds in plan.root (previously
+            // missing here entirely), so two different projects that happen to
+            // share a mount-path convention no longer derive the same volume
+            // name — the same isolation moltnet's own persistent mounts already
+            // had before this change.
+            const volumeName = createPersistentVolumeName(plan.root, mountId, entry.bank.store.persistence?.name, runId);
+            const existingMount = mountByPath.get(mountPath);
+            if (existingMount && existingMount.volume_name !== volumeName) {
+                throw new Error(`Memory store mount ${mountPath} resolves to conflicting volume names`);
+            }
+            const mount = existingMount ?? {
+                id: mountId,
+                mount_path: mountPath,
+                reason: `durable memory stores under ${mountPath}`,
+                volume_name: volumeName
+            };
+            mountByPath.set(mountPath, mount);
+            if (!existingMount) {
+                mounts.push(mount);
+            }
+            persistentMountId = mount.id;
+            mountPathMemoryMap.set(persistentMountId, mountPath);
+        }
+        return {
+            id: entry.bank.id,
+            declaring_node_id: declaringNodeId,
+            accessible_node_ids: [...accessibleNodeIds].sort(),
+            store: summarizeMemoryStore(entry.bank, persistentMountId),
+            index: entry.bank.index,
+            consolidation: entry.bank.consolidation,
+            retention: entry.bank.retention,
+            transport_by_node_id: transportByNodeId
+        };
+    })
+        .filter((entry) => entry !== null)
+        .sort((left, right) => left.declaring_node_id.localeCompare(right.declaring_node_id)
+        || left.id.localeCompare(right.id));
+    return {
+        mountPathMemoryMap,
+        memories,
+        mounts: [...mounts].sort((left, right) => left.id.localeCompare(right.id) || left.mount_path.localeCompare(right.mount_path))
+    };
+};

package/dist/compiler/memoryResolution.d.ts

@@ -0,0 +1,4 @@
+import type { CompilePlan, ResolvedMemoryBank } from "./types.js";
+import type { MemoryBank } from "../manifest/index.js";
+export declare const resolveDeclaredMemoryBanks: (memory: MemoryBank[] | undefined, source: string, declaredBy: "agent" | "team", manifestName: string) => ResolvedMemoryBank[];
+export declare const resolvePlanMemoryAccess: (plan: CompilePlan) => void;

package/dist/compiler/memoryResolution.js

@@ -0,0 +1,147 @@
+import { SpawnfileError } from "../shared/index.js";
+import { slugify } from "./helpers.js";
+const resolveMemoryIndex = (index) => ({
+    graph: {
+        enabled: index?.graph?.enabled ?? false,
+        ...(index?.graph?.kind ? { kind: index.graph.kind } : {})
+    },
+    lexical: {
+        enabled: index?.lexical?.enabled ?? true,
+        ...(index?.lexical?.engine ? { engine: index.lexical.engine } : {})
+    },
+    rerank: {
+        enabled: index?.rerank?.enabled ?? false
+    },
+    vector: {
+        ...(index?.vector?.base_url ? { base_url: index.vector.base_url } : {}),
+        dimensions: index?.vector?.dimensions,
+        enabled: index?.vector?.enabled ?? false,
+        ...(index?.vector?.model ? { model: index.vector.model } : {}),
+        ...(index?.vector?.provider ? { provider: index.vector.provider } : {}),
+        ...(index?.vector?.timeout_ms ? { timeout_ms: index.vector.timeout_ms } : {})
+    }
+});
+const resolveMemoryConsolidation = (consolidation) => ({
+    mode: consolidation?.mode ?? "disabled",
+    ...(consolidation?.schedule ? { schedule: consolidation.schedule } : {}),
+    ...(consolidation?.summarize_after_events
+        ? { summarize_after_events: consolidation.summarize_after_events }
+        : {})
+});
+const resolveMemoryRetention = (retention) => ({
+    forgetting: retention?.forgetting ?? "manual",
+    ...(retention?.ttl ? { ttl: retention.ttl } : {})
+});
+const resolveMemoryStore = (store, manifestName, bankId) => {
+    const manifestSlug = slugify(manifestName) || "memory";
+    const baseDirectory = `/var/lib/spawnfile/memory/${manifestSlug}/${bankId}`;
+    if (store.kind === "sqlite" || store.kind === "json") {
+        return {
+            kind: store.kind,
+            path: store.path ?? `${baseDirectory}/${store.kind === "sqlite" ? "memory.sqlite" : "memory.jsonl"}`,
+            ...(store.persistence
+                ? {
+                    persistence: {
+                        mode: store.persistence.mode,
+                        ...(store.persistence.mount ? { mount: store.persistence.mount } : {}),
+                        ...(store.persistence.name ? { name: store.persistence.name } : {})
+                    }
+                }
+                : {
+                    persistence: {
+                        mode: "durable"
+                    }
+                })
+        };
+    }
+    if (store.kind === "postgres") {
+        return {
+            kind: store.kind,
+            dsn_secret: store.dsn_secret
+        };
+    }
+    return { kind: "memory" };
+};
+export const resolveDeclaredMemoryBanks = (memory, source, declaredBy, manifestName) => (memory ?? []).map((entry) => ({
+    access: entry.access,
+    consolidation: resolveMemoryConsolidation(entry.consolidation),
+    declaredBy,
+    declaredName: manifestName,
+    id: entry.id,
+    index: resolveMemoryIndex(entry.index),
+    retention: resolveMemoryRetention(entry.retention),
+    source,
+    store: resolveMemoryStore(entry.store, manifestName, entry.id)
+}));
+const getAgentNodes = (plan) => new Map(plan.nodes
+    .filter((node) => node.value.kind === "agent")
+    .map((node) => [node.value.source, node.value]));
+const getTeamNodes = (plan) => new Map(plan.nodes
+    .filter((node) => node.value.kind === "team")
+    .map((node) => [node.value.source, node.value]));
+const resolveTeamMembersForBank = (team, members) => {
+    if (members !== undefined) {
+        return members;
+    }
+    return team.members.filter((member) => member.kind === "agent").map((member) => member.id);
+};
+export const resolvePlanMemoryAccess = (plan) => {
+    const agentBySource = getAgentNodes(plan);
+    const teamBySource = getTeamNodes(plan);
+    const memoryAccess = [];
+    for (const agent of agentBySource.values()) {
+        for (const bank of agent.memory ?? []) {
+            memoryAccess.push({
+                agentSource: agent.source,
+                declaringKind: "agent",
+                source: bank.source,
+                bank
+            });
+        }
+    }
+    for (const team of teamBySource.values()) {
+        for (const bank of team.memory ?? []) {
+            const allowedMembers = resolveTeamMembersForBank(team, bank.access?.members);
+            const validMemberIds = new Set(team.members.map((member) => member.id));
+            if (bank.access?.members) {
+                for (const memberId of bank.access.members) {
+                    if (!validMemberIds.has(memberId)) {
+                        throw new SpawnfileError("validation_error", `Team ${team.name} memory bank ${bank.id} references unknown member ${memberId}`);
+                    }
+                }
+            }
+            for (const memberId of allowedMembers) {
+                const member = team.members.find((memberRef) => memberRef.id === memberId);
+                if (!member || member.kind !== "agent") {
+                    continue;
+                }
+                const agentNode = agentBySource.get(member.nodeSource);
+                if (!agentNode) {
+                    throw new SpawnfileError("validation_error", `Unable to resolve agent member ${memberId} in team ${team.name} for memory bank ${bank.id}`);
+                }
+                memoryAccess.push({
+                    agentSource: agentNode.source,
+                    declaringKind: "team",
+                    slotId: memberId,
+                    source: team.source,
+                    bank
+                });
+            }
+        }
+    }
+    if (memoryAccess.length === 0) {
+        return;
+    }
+    const uniqueAccess = new Map();
+    for (const access of memoryAccess) {
+        const key = `${access.agentSource}::${access.declaringKind}::${access.source}::${access.bank.id}::${access.slotId ?? ""}`;
+        uniqueAccess.set(key, access);
+    }
+    plan.memoryAccess = [...uniqueAccess.values()].sort((left, right) => `${left.agentSource}:${left.bank.id}:${left.source}:${left.slotId ?? ""}`.localeCompare(`${right.agentSource}:${right.bank.id}:${right.source}:${right.slotId ?? ""}`));
+    for (const agent of agentBySource.values()) {
+        const access = plan.memoryAccess.filter((entry) => entry.agentSource === agent.source);
+        if (access.length > 0) {
+            agent.memoryAccess = access;
+        }
+    }
+};

package/dist/compiler/modelEnv.d.ts

@@ -1,6 +1,8 @@
 import type { ExecutionBlock, ModelTarget } from "../manifest/index.js";
 import { type ModelAuthMethod } from "../shared/index.js";
 import type { EffectiveModelTarget } from "./types.js";
+export declare const CLI_CREDENTIAL_SECRET_NAME = "SPAWNFILE_CLI_AUTH_JSON";
+export declare const modelAuthMethodNeedsCliCredential: (method: ModelAuthMethod) => boolean;
 export declare const resolveModelProviderEnvName: (provider: string) => string;
 export declare const listExecutionModelTargets: (execution: ExecutionBlock | undefined) => ModelTarget[];
 export declare const resolveEffectiveModelTarget: (target: ModelTarget, execution: ExecutionBlock | undefined) => EffectiveModelTarget;

package/dist/compiler/modelEnv.js

@@ -8,6 +8,8 @@ const MODEL_PROVIDER_ENV_VARS = new Map([
     ["openrouter", "OPENROUTER_API_KEY"],
     ["xai", "XAI_API_KEY"]
 ]);
+export const CLI_CREDENTIAL_SECRET_NAME = "SPAWNFILE_CLI_AUTH_JSON";
+export const modelAuthMethodNeedsCliCredential = (method) => method !== "api_key" && method !== "none";
 const resolveLegacyModelAuthMethod = (execution, provider) => {
     const auth = execution?.model?.auth;
     if (!auth) {
@@ -88,6 +90,10 @@ export const resolveExecutionModelAuthMethods = (execution) => {
 export const listExecutionModelSecretNames = (execution) => {
     const secretNames = new Set();
     for (const target of listEffectiveExecutionModelTargets(execution)) {
+        if (modelAuthMethodNeedsCliCredential(target.auth.method)) {
+            secretNames.add(CLI_CREDENTIAL_SECRET_NAME);
+            continue;
+        }
         if (target.auth.method !== "api_key") {
             continue;
         }

package/dist/compiler/moltnetAllowedWakeSendersValidation.d.ts

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

package/dist/compiler/moltnetAllowedWakeSendersValidation.js

@@ -0,0 +1,42 @@
+import { SpawnfileError } from "../shared/index.js";
+const rootTeamNode = (plan) => {
+    const rootNodes = plan.nodes
+        .map((entry) => entry.kind === "team" &&
+        entry.value.kind === "team" &&
+        entry.value.source === plan.root
+        ? entry.value
+        : undefined)
+        .filter((team) => Boolean(team));
+    if (rootNodes.length !== 1) {
+        throw new SpawnfileError("validation_error", `Moltnet attachment validation requires exactly one source-root team; found ${rootNodes.length}`);
+    }
+    return rootNodes[0];
+};
+const describeAttachment = (network, memberId) => `${network}/${memberId ?? "unknown"}`;
+export const validateAllowedWakeSenders = (plan) => {
+    let rootTeam;
+    const rootParticipants = () => {
+        if (!rootTeam) {
+            rootTeam = rootTeamNode(plan);
+        }
+        return rootTeam.externalParticipants ?? [];
+    };
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "agent")
+            continue;
+        const attachments = node.value.surfaces?.moltnet ?? [];
+        for (const attachment of attachments) {
+            if (!attachment.dms?.allowedWakeSenders?.length) {
+                continue;
+            }
+            const rootNodeParticipants = rootParticipants();
+            for (const authorId of attachment.dms.allowedWakeSenders) {
+                const compatible = rootNodeParticipants.filter((service) => service.id === authorId &&
+                    service.surfaces.moltnet.some((entry) => entry.network === attachment.network && entry.dms.enabled === true));
+                if (compatible.length !== 1) {
+                    throw new SpawnfileError("validation_error", `Moltnet attachment ${node.value.name}/${describeAttachment(attachment.network, attachment.memberId)} has ${compatible.length} root matches for allowed_wake_senders entry ${authorId}`);
+                }
+            }
+        }
+    }
+};

package/dist/compiler/moltnetArtifactPaths.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedTeamNode } from "./types.js";
+export declare const createMoltnetExternalParticipantArtifactPath: (networkId: string, memberId: string) => string;
+/**
+ * Derives the host-mounted docker volume name for a durable mount.
+ *
+ * `runId` (the compiling process's resolved NOOPOLIS_RUN_ID, see
+ * src/runtime/common.ts) is the run-scoping key: `spawnfile run`/`spawnfile
+ * up` always call `ensureNoopolisRunId()` before compiling, so a fresh
+ * invocation with no host-pinned run id gets a fresh generated one and
+ * therefore a fresh volume — two concurrent/successive runs (e.g. two
+ * memetics replicates) never share durable state. A cold restart that wants
+ * to recall the same run's memory sets the SAME `NOOPOLIS_RUN_ID` before
+ * re-running, which reproduces this same volume name and remounts it.
+ * Omitted (a bare `spawnfile compile`/`spawnfile build` with no run id in
+ * the host env) reproduces the pre-run-scoping name exactly, so standard
+ * compiles stay byte-identical.
+ *
+ * `explicitName` (an author-declared `persistence.name`) always wins over
+ * both project/id and run scoping — an explicit name is opt-in shared/
+ * reused state by author intent, not something this helper should silently
+ * fragment across runs.
+ */
+export declare const createPersistentVolumeName: (planRoot: string, id: string, explicitName?: string, runId?: string) => string;
+export declare const toContainerRootfsPath: (rootfsPath: string) => string;
+export declare const isNetworkHttpEnabled: (network: NonNullable<ResolvedTeamNode["networks"]>[number]) => boolean;
+export declare const resolveNetworkPort: (network: NonNullable<ResolvedTeamNode["networks"]>[number], fallbackPort: number) => number;

package/dist/compiler/moltnetArtifactPaths.js

@@ -0,0 +1,49 @@
+import { SpawnfileError } from "../shared/index.js";
+import { createShortHash, slugify } from "./helpers.js";
+const ROOTFS_PREFIX = "container/rootfs";
+const ARTIFACT_SEGMENT = /^[a-z][a-z0-9-]{0,62}$/u;
+export const createMoltnetExternalParticipantArtifactPath = (networkId, memberId) => {
+    if (!ARTIFACT_SEGMENT.test(networkId) ||
+        !/^[a-z][a-z0-9-]{0,62}(?:\.[a-z][a-z0-9-]{0,62}){0,7}$/u.test(memberId) ||
+        Buffer.byteLength(memberId, "ascii") > 255) {
+        throw new SpawnfileError("validation_error", "invalid Moltnet external participant artifact path segment");
+    }
+    return `moltnet/external-participants/${networkId}/${memberId}.json`;
+};
+const truncateSegment = (value, maxLength) => value.length > maxLength ? value.slice(0, maxLength).replace(/[-_.]+$/u, "") : value;
+/**
+ * Derives the host-mounted docker volume name for a durable mount.
+ *
+ * `runId` (the compiling process's resolved NOOPOLIS_RUN_ID, see
+ * src/runtime/common.ts) is the run-scoping key: `spawnfile run`/`spawnfile
+ * up` always call `ensureNoopolisRunId()` before compiling, so a fresh
+ * invocation with no host-pinned run id gets a fresh generated one and
+ * therefore a fresh volume — two concurrent/successive runs (e.g. two
+ * memetics replicates) never share durable state. A cold restart that wants
+ * to recall the same run's memory sets the SAME `NOOPOLIS_RUN_ID` before
+ * re-running, which reproduces this same volume name and remounts it.
+ * Omitted (a bare `spawnfile compile`/`spawnfile build` with no run id in
+ * the host env) reproduces the pre-run-scoping name exactly, so standard
+ * compiles stay byte-identical.
+ *
+ * `explicitName` (an author-declared `persistence.name`) always wins over
+ * both project/id and run scoping — an explicit name is opt-in shared/
+ * reused state by author intent, not something this helper should silently
+ * fragment across runs.
+ */
+export const createPersistentVolumeName = (planRoot, id, explicitName, runId) => {
+    if (explicitName && explicitName.trim().length > 0) {
+        return explicitName.trim();
+    }
+    const project = truncateSegment(slugify(planRoot.split("/").slice(-2, -1)[0] ?? "project") || "project", 32);
+    const suffix = truncateSegment(slugify(id) || "state", 48);
+    const trimmedRunId = runId?.trim();
+    if (!trimmedRunId) {
+        return `spawnfile-${project}-${suffix}-${createShortHash(`${planRoot}:${id}`)}`;
+    }
+    const runSegment = truncateSegment(slugify(trimmedRunId) || "run", 24);
+    return `spawnfile-${project}-${suffix}-${runSegment}-${createShortHash(`${planRoot}:${id}:${trimmedRunId}`)}`;
+};
+export const toContainerRootfsPath = (rootfsPath) => `/${rootfsPath.replace(`${ROOTFS_PREFIX}/`, "")}`;
+export const isNetworkHttpEnabled = (network) => network.server?.mode === "managed" && network.server.human_ingress === true;
+export const resolveNetworkPort = (network, fallbackPort) => network.server?.mode === "managed" ? network.server.listen.port : fallbackPort;

package/dist/compiler/moltnetArtifactTypes.d.ts

@@ -0,0 +1,46 @@
+import type { EmittedFile } from "../runtime/index.js";
+import type { TeamNetworkServer } from "../manifest/index.js";
+import type { MoltnetSecretPatch } from "./moltnetConfigLowering.js";
+import type { MoltnetExternalParticipantArtifactV1 } from "./moltnetExternalParticipantArtifact.js";
+export interface MoltnetServerPlan {
+    baseUrl: string;
+    configPath?: string;
+    id: string;
+    mode: "external" | "managed";
+    name: string;
+    networkId: string;
+    port?: number;
+    rooms: Array<{
+        id: string;
+        members: string[];
+        name?: string;
+        visibility?: "public" | "private";
+        write_policy?: "members" | "operators" | "registered_agents";
+    }>;
+    server: TeamNetworkServer;
+    secretPatches: MoltnetSecretPatch[];
+    teamSource: string;
+}
+export interface MoltnetNodePlan {
+    configPath: string;
+    credentialAgentId?: string;
+    credentialId?: string;
+    credentialSecret?: string;
+    memberId?: string;
+    networkId: string;
+}
+export interface MoltnetPersistentMount {
+    id: string;
+    mountPath: string;
+    reason: string;
+    volumeName: string;
+}
+export interface MoltnetArtifacts {
+    externalParticipantArtifacts?: MoltnetExternalParticipantArtifactV1[];
+    files: EmittedFile[];
+    nodePlans: MoltnetNodePlan[];
+    persistentMounts: MoltnetPersistentMount[];
+    ports: number[];
+    publishedPorts: number[];
+    serverPlans: MoltnetServerPlan[];
+}

package/dist/compiler/moltnetArtifactTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/moltnetArtifacts.d.ts

@@ -1,42 +1,4 @@
-import type { EmittedFile } from "../runtime/index.js";
-import type { TeamNetworkServer } from "../manifest/index.js";
-import { type MoltnetSecretPatch } from "./moltnetConfigLowering.js";
+import type { MoltnetArtifacts } from "./moltnetArtifactTypes.js";
 import type { CompilePlan } from "./types.js";
-export interface MoltnetServerPlan {
-    baseUrl: string;
-    configPath?: string;
-    id: string;
-    mode: "external" | "managed";
-    name: string;
-    networkId: string;
-    port?: number;
-    rooms: Array<{
-        id: string;
-        members: string[];
-        name?: string;
-        visibility?: "public" | "private";
-        write_policy?: "members" | "operators" | "registered_agents";
-    }>;
-    server: TeamNetworkServer;
-    secretPatches: MoltnetSecretPatch[];
-    teamSource: string;
-}
-export interface MoltnetNodePlan {
-    configPath: string;
-    networkId: string;
-}
-export interface MoltnetPersistentMount {
-    id: string;
-    mountPath: string;
-    reason: string;
-    volumeName: string;
-}
-export interface MoltnetArtifacts {
-    files: EmittedFile[];
-    nodePlans: MoltnetNodePlan[];
-    persistentMounts: MoltnetPersistentMount[];
-    ports: number[];
-    publishedPorts: number[];
-    serverPlans: MoltnetServerPlan[];
-}
+export type { MoltnetArtifacts, MoltnetNodePlan, MoltnetPersistentMount, MoltnetServerPlan } from "./moltnetArtifactTypes.js";
 export declare const generateMoltnetArtifacts: (plan: CompilePlan) => Promise<MoltnetArtifacts | null>;