spawnfile 0.1.1 → 0.1.3

package/dist/compiler/moltnetArtifacts.js

@@ -0,0 +1,208 @@
+import { getRuntimeAdapter } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { listConcreteMoltnetRoomMemberIds } from "./moltnetRoomMemberships.js";
+const DEFAULT_MOLTNET_PORT = 8787;
+const DEFAULT_TINYCLAW_PORT = 3777;
+const ROOTFS_PREFIX = "container/rootfs";
+const INSTANCE_ROOT_PLACEHOLDER = "<instance-root>";
+const CONFIG_FILE_PLACEHOLDER = "<config-file>";
+const createServerKey = (networkId) => networkId;
+const createBridgeConfigPath = (teamSlug, networkId, agentId) => `${ROOTFS_PREFIX}/var/lib/spawnfile/moltnet/bridges/${teamSlug}-${networkId}-${agentId}.json`;
+const resolveSequentialRuntimePort = (plan, runtimeName, slug) => {
+    const adapter = getRuntimeAdapter(runtimeName);
+    const basePort = adapter.container.port;
+    if (basePort === undefined) {
+        return undefined;
+    }
+    const runtimeAgents = plan.nodes.filter((node) => node.kind === "agent" && node.runtimeName === runtimeName);
+    const index = runtimeAgents.findIndex((node) => node.slug === slug);
+    if (index < 0) {
+        return undefined;
+    }
+    return basePort + (index * (adapter.container.portStride ?? 1));
+};
+const createTinyClawChannel = (networkId, agentId) => `moltnet:${networkId}:${agentId}`;
+const replaceContainerPathTemplate = (template, instanceRoot, configFileName) => template
+    .replaceAll(INSTANCE_ROOT_PLACEHOLDER, instanceRoot)
+    .replaceAll(CONFIG_FILE_PLACEHOLDER, configFileName);
+const resolveRuntimeInstancePaths = (runtimeName, slug) => {
+    const adapter = getRuntimeAdapter(runtimeName);
+    const instanceRoot = `/var/lib/spawnfile/instances/${runtimeName}/agent-${slug}`;
+    return {
+        configPath: replaceContainerPathTemplate(adapter.container.instancePaths.configPathTemplate, instanceRoot, adapter.container.configFileName),
+        homePath: adapter.container.instancePaths.homePathTemplate
+            ? replaceContainerPathTemplate(adapter.container.instancePaths.homePathTemplate, instanceRoot, adapter.container.configFileName)
+            : undefined
+    };
+};
+const resolveRuntimeConfig = (plan, agentNode, nodeSlug, networkId, agentId) => {
+    switch (agentNode.runtime.name) {
+        case "openclaw": {
+            const port = resolveSequentialRuntimePort(plan, "openclaw", nodeSlug);
+            if (!port) {
+                throw new SpawnfileError("compile_error", `Unable to resolve OpenClaw gateway port for Moltnet agent ${agentNode.name}`);
+            }
+            const instancePaths = resolveRuntimeInstancePaths("openclaw", nodeSlug);
+            return {
+                gateway_url: `ws://127.0.0.1:${port}`,
+                ...(instancePaths.homePath ? { home_path: instancePaths.homePath } : {}),
+                kind: "openclaw",
+            };
+        }
+        case "picoclaw": {
+            const instancePaths = resolveRuntimeInstancePaths("picoclaw", nodeSlug);
+            return {
+                command: "/usr/local/bin/picoclaw",
+                config_path: instancePaths.configPath,
+                ...(instancePaths.homePath ? { home_path: instancePaths.homePath } : {}),
+                kind: "picoclaw",
+            };
+        }
+        case "tinyclaw": {
+            const channel = createTinyClawChannel(networkId, agentId);
+            return {
+                ack_url: `http://127.0.0.1:${DEFAULT_TINYCLAW_PORT}/api/responses`,
+                channel,
+                inbound_url: `http://127.0.0.1:${DEFAULT_TINYCLAW_PORT}/api/message`,
+                kind: "tinyclaw",
+                outbound_url: `http://127.0.0.1:${DEFAULT_TINYCLAW_PORT}/api/responses/pending?channel=${encodeURIComponent(channel)}`
+            };
+        }
+        default:
+            throw new SpawnfileError("compile_error", `Moltnet does not know how to attach runtime ${agentNode.runtime.name} directly`);
+    }
+};
+export const generateMoltnetArtifacts = async (plan) => {
+    const teamNodes = plan.nodes
+        .filter((node) => node.kind === "team")
+        .filter((node) => (node.value.networks?.length ?? 0) > 0);
+    if (teamNodes.length === 0) {
+        return null;
+    }
+    const serverPlans = new Map();
+    let nextPort = DEFAULT_MOLTNET_PORT;
+    for (const teamNode of teamNodes) {
+        for (const network of teamNode.value.networks ?? []) {
+            const serverKey = createServerKey(network.id);
+            const existingPlan = serverPlans.get(serverKey);
+            if (existingPlan) {
+                for (const room of network.rooms) {
+                    const concreteMembers = listConcreteMoltnetRoomMemberIds(plan, teamNode.value, network.id, room);
+                    const existingRoom = existingPlan.rooms.find((entry) => entry.id === room.id);
+                    if (existingRoom) {
+                        existingRoom.members = [
+                            ...new Set([...existingRoom.members, ...concreteMembers])
+                        ].sort();
+                    }
+                    else {
+                        existingPlan.rooms.push({
+                            id: room.id,
+                            members: concreteMembers
+                        });
+                    }
+                }
+                existingPlan.rooms.sort((left, right) => left.id.localeCompare(right.id));
+            }
+            else {
+                serverPlans.set(serverKey, {
+                    id: `${teamNode.slug}-${network.id}`,
+                    name: network.name,
+                    networkId: network.id,
+                    port: nextPort,
+                    rooms: network.rooms.map((room) => ({
+                        id: room.id,
+                        members: listConcreteMoltnetRoomMemberIds(plan, teamNode.value, network.id, room)
+                    })),
+                    teamSource: teamNode.value.source
+                });
+                nextPort += 1;
+            }
+        }
+    }
+    const bridgePlans = [];
+    const bridgePlanKeys = new Set();
+    const configFiles = [];
+    for (const node of plan.nodes) {
+        if (node.kind !== "agent") {
+            continue;
+        }
+        const agentNode = node.value;
+        if (!agentNode.surfaces?.moltnet || agentNode.surfaces.moltnet.length === 0) {
+            continue;
+        }
+        for (const attachment of agentNode.surfaces.moltnet) {
+            if (!attachment.teamSource || !attachment.memberId) {
+                throw new SpawnfileError("validation_error", `Agent ${agentNode.name} Moltnet attachments require a team-bound network context`);
+            }
+            const teamNode = teamNodes.find((team) => team.value.source === attachment.teamSource);
+            if (!teamNode) {
+                throw new SpawnfileError("validation_error", `Unable to find team context for Moltnet attachment ${attachment.network} on ${agentNode.name}`);
+            }
+            const serverPlan = serverPlans.get(createServerKey(attachment.network));
+            if (!serverPlan) {
+                throw new SpawnfileError("validation_error", `Unable to find Moltnet network ${attachment.network} for ${agentNode.name}`);
+            }
+            const configPath = createBridgeConfigPath(teamNode.slug, attachment.network, attachment.memberId);
+            const bridgePlanKey = `${attachment.network}::${attachment.memberId}`;
+            if (bridgePlanKeys.has(bridgePlanKey)) {
+                throw new SpawnfileError("validation_error", `Duplicate Moltnet bridge attachment for ${attachment.network}/${attachment.memberId}`);
+            }
+            bridgePlanKeys.add(bridgePlanKey);
+            configFiles.push({
+                content: `${JSON.stringify({
+                    version: "moltnet.bridge.v1",
+                    agent: {
+                        id: attachment.memberId,
+                        name: agentNode.name
+                    },
+                    moltnet: {
+                        base_url: `http://127.0.0.1:${serverPlan.port}`,
+                        network_id: attachment.network
+                    },
+                    runtime: resolveRuntimeConfig(plan, agentNode, node.slug, attachment.network, attachment.memberId),
+                    ...(attachment.rooms
+                        ? {
+                            rooms: Object.entries(attachment.rooms)
+                                .sort(([left], [right]) => left.localeCompare(right))
+                                .map(([roomId, policy]) => ({
+                                id: roomId,
+                                ...(policy.read ? { read: policy.read } : {}),
+                                ...(policy.reply ? { reply: policy.reply } : {})
+                            }))
+                        }
+                        : {}),
+                    ...(attachment.dms
+                        ? {
+                            dms: {
+                                enabled: attachment.dms.enabled,
+                                ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
+                                ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                            }
+                        }
+                        : {})
+                }, null, 2)}\n`,
+                mode: 0o600,
+                path: configPath
+            });
+            bridgePlans.push({
+                agentId: attachment.memberId,
+                configPath: `/${configPath.replace(`${ROOTFS_PREFIX}/`, "")}`,
+                networkId: attachment.network,
+                runtime: agentNode.runtime.name
+            });
+        }
+    }
+    return {
+        bridgePlans: bridgePlans.sort((left, right) => left.configPath.localeCompare(right.configPath)),
+        files: configFiles,
+        ports: [...new Set([...serverPlans.values()].map((plan) => plan.port))].sort((left, right) => left - right),
+        publishedPorts: [
+            ...new Set(teamNodes
+                .flatMap((teamNode) => (teamNode.value.networks ?? []).map((network) => network.expose
+                ? serverPlans.get(createServerKey(network.id))?.port
+                : undefined))
+                .filter((port) => port !== undefined))
+        ].sort((left, right) => left - right),
+        serverPlans: [...serverPlans.values()].sort((left, right) => left.port - right.port)
+    };
+};

package/dist/compiler/moltnetBinaries.d.ts

@@ -0,0 +1,4 @@
+export declare const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
+export declare const MOLTNET_BINARY_NAMES: readonly ["moltnet"];
+export declare const resolveMoltnetCliCommand: () => Promise<string>;
+export declare const stageMoltnetBinaries: (outputDirectory: string) => Promise<boolean>;

package/dist/compiler/moltnetBinaries.js

@@ -0,0 +1,103 @@
+import { execFile as execFileCallback } from "node:child_process";
+import path from "node:path";
+import { chmod } from "node:fs/promises";
+import { promisify } from "node:util";
+import { ensureDirectory, fileExists } from "../filesystem/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const execFile = promisify(execFileCallback);
+const MOLTNET_CLI_ENV = "SPAWNFILE_MOLTNET_CLI";
+const MOLTNET_RELEASE_DIR_ENV = "SPAWNFILE_MOLTNET_RELEASE_DIR";
+const LOCAL_MOLTNET_CLI_PATH = path.resolve(process.cwd(), "moltnet", "bin", "moltnet");
+const MOLTNET_TARGET_OS = "linux";
+export const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
+export const MOLTNET_BINARY_NAMES = ["moltnet"];
+const resolveTargetArchitecture = () => {
+    switch (process.arch) {
+        case "arm64":
+            return "arm64";
+        case "x64":
+            return "amd64";
+        default:
+            throw new SpawnfileError("compile_error", `Moltnet container installs do not support host architecture ${process.arch}`);
+    }
+};
+const createReleaseAssetName = (architecture) => `moltnet_${MOLTNET_TARGET_OS}_${architecture}.tar.gz`;
+const isCommandNotFoundError = (error) => typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "ENOENT";
+const validateMoltnetCli = async (command, sourceLabel) => {
+    try {
+        await execFile(command, ["version"]);
+        return command;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to execute compiled Moltnet CLI from ${sourceLabel}: ${reason}. Install Moltnet with \`curl -fsSL https://moltnet.dev/install.sh | sh\` or set ${MOLTNET_CLI_ENV}.`);
+    }
+};
+const resolveConfiguredReleaseDirectory = async () => {
+    const configuredDirectory = process.env[MOLTNET_RELEASE_DIR_ENV]?.trim();
+    if (!configuredDirectory) {
+        return null;
+    }
+    if (!(await fileExists(configuredDirectory))) {
+        throw new SpawnfileError("compile_error", `Moltnet release directory ${configuredDirectory} does not exist`);
+    }
+    return configuredDirectory;
+};
+const findPathMoltnetCli = async () => {
+    try {
+        await execFile("moltnet", ["version"]);
+        return "moltnet";
+    }
+    catch (error) {
+        if (isCommandNotFoundError(error)) {
+            return null;
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to execute compiled Moltnet CLI from PATH: ${reason}. Install Moltnet with \`curl -fsSL https://moltnet.dev/install.sh | sh\` or set ${MOLTNET_CLI_ENV}.`);
+    }
+};
+export const resolveMoltnetCliCommand = async () => {
+    const configuredCli = process.env[MOLTNET_CLI_ENV]?.trim();
+    if (configuredCli) {
+        return validateMoltnetCli(configuredCli, configuredCli);
+    }
+    const pathCli = await findPathMoltnetCli();
+    if (pathCli) {
+        return pathCli;
+    }
+    if (await fileExists(LOCAL_MOLTNET_CLI_PATH)) {
+        return validateMoltnetCli(LOCAL_MOLTNET_CLI_PATH, LOCAL_MOLTNET_CLI_PATH);
+    }
+    return validateMoltnetCli("moltnet", "PATH");
+};
+export const stageMoltnetBinaries = async (outputDirectory) => {
+    const releaseDirectory = await resolveConfiguredReleaseDirectory();
+    if (!releaseDirectory) {
+        return false;
+    }
+    const architecture = resolveTargetArchitecture();
+    const releaseAssetPath = path.join(releaseDirectory, createReleaseAssetName(architecture));
+    if (!(await fileExists(releaseAssetPath))) {
+        throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} does not exist. Build it with \`cd moltnet && make release-assets\` or set ${MOLTNET_RELEASE_DIR_ENV}.`);
+    }
+    const installDirectory = path.join(outputDirectory, MOLTNET_BIN_DIRECTORY);
+    await ensureDirectory(installDirectory);
+    try {
+        await execFile("tar", ["-C", installDirectory, "-xzf", releaseAssetPath]);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to extract Moltnet release asset ${releaseAssetPath}: ${reason}`);
+    }
+    for (const binaryName of MOLTNET_BINARY_NAMES) {
+        const binaryPath = path.join(installDirectory, binaryName);
+        if (!(await fileExists(binaryPath))) {
+            throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} did not contain ${binaryName}`);
+        }
+        await chmod(binaryPath, 0o755);
+    }
+    return true;
+};

package/dist/compiler/moltnetClientConfig.d.ts

@@ -0,0 +1,11 @@
+import type { EmittedFile } from "../runtime/index.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { ResolvedAgentNode } from "./types.js";
+export interface MoltnetWorkspaceLayout {
+    clientConfigPath: string;
+    cliRuntime: string;
+    skillPaths: string[];
+    workspaceRootPath: string;
+}
+export declare const resolveMoltnetWorkspaceLayout: (runtimeName: string, agentName: string) => MoltnetWorkspaceLayout;
+export declare const createMoltnetClientConfigFiles: (node: ResolvedAgentNode, artifacts: MoltnetArtifacts) => EmittedFile[];

package/dist/compiler/moltnetClientConfig.js

@@ -0,0 +1,89 @@
+import { SpawnfileError } from "../shared/index.js";
+const GENERATED_SKILL_NAME = "moltnet";
+const GENERATED_CONFIG_PATH = ".moltnet/config.json";
+const createConfigContent = (node, attachments) => `${JSON.stringify({
+    version: "moltnet.client.v1",
+    agent: {
+        name: node.name,
+        runtime: node.runtime.name
+    },
+    attachments
+}, null, 2)}\n`;
+const findServerPlan = (artifacts, attachment) => {
+    const exactPlan = artifacts.serverPlans.find((serverPlan) => serverPlan.networkId === attachment.network &&
+        serverPlan.teamSource === attachment.teamSource);
+    const plan = exactPlan ?? artifacts.serverPlans.find((serverPlan) => serverPlan.networkId === attachment.network);
+    if (!plan) {
+        throw new SpawnfileError("compile_error", `Unable to resolve Moltnet server plan for ${attachment.network} on ${attachment.memberId ?? "unknown-agent"}`);
+    }
+    return plan;
+};
+const createAttachmentConfig = (node, artifacts, attachment) => {
+    if (!attachment.memberId) {
+        throw new SpawnfileError("compile_error", `Moltnet client config requires a resolved member id for ${node.name}`);
+    }
+    const serverPlan = findServerPlan(artifacts, attachment);
+    return {
+        agent_name: node.name,
+        auth: { mode: "none" },
+        base_url: `http://127.0.0.1:${serverPlan.port}`,
+        ...(attachment.dms
+            ? {
+                dms: {
+                    enabled: attachment.dms.enabled,
+                    ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
+                    ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                }
+            }
+            : {}),
+        member_id: attachment.memberId,
+        network_id: attachment.network,
+        runtime: node.runtime.name,
+        ...(attachment.rooms
+            ? {
+                rooms: Object.entries(attachment.rooms)
+                    .sort(([left], [right]) => left.localeCompare(right))
+                    .map(([roomId, policy]) => ({
+                    id: roomId,
+                    ...(policy.read ? { read: policy.read } : {}),
+                    ...(policy.reply ? { reply: policy.reply } : {})
+                }))
+            }
+            : {})
+    };
+};
+export const resolveMoltnetWorkspaceLayout = (runtimeName, agentName) => {
+    if (runtimeName === "openclaw" || runtimeName === "picoclaw") {
+        return {
+            clientConfigPath: `workspace/${GENERATED_CONFIG_PATH}`,
+            cliRuntime: runtimeName,
+            skillPaths: [`workspace/skills/${GENERATED_SKILL_NAME}/SKILL.md`],
+            workspaceRootPath: "workspace"
+        };
+    }
+    if (runtimeName === "tinyclaw") {
+        return {
+            clientConfigPath: `workspace/${agentName}/${GENERATED_CONFIG_PATH}`,
+            cliRuntime: runtimeName,
+            skillPaths: [
+                `workspace/${agentName}/.agents/skills/${GENERATED_SKILL_NAME}/SKILL.md`,
+                `workspace/${agentName}/.claude/skills/${GENERATED_SKILL_NAME}/SKILL.md`
+            ],
+            workspaceRootPath: `workspace/${agentName}`
+        };
+    }
+    throw new SpawnfileError("compile_error", `Moltnet client config does not know how to emit files for runtime ${runtimeName}`);
+};
+export const createMoltnetClientConfigFiles = (node, artifacts) => {
+    const attachments = node.surfaces?.moltnet;
+    if (!attachments || attachments.length === 0) {
+        return [];
+    }
+    const layout = resolveMoltnetWorkspaceLayout(node.runtime.name, node.name);
+    return [
+        {
+            content: createConfigContent(node, attachments.map((attachment) => createAttachmentConfig(node, artifacts, attachment))),
+            path: layout.clientConfigPath
+        }
+    ];
+};

package/dist/compiler/moltnetRepresentativeResolution.d.ts

@@ -0,0 +1,16 @@
+import type { CompilePlan, ResolvedMoltnetAttachment, ResolvedTeamNetwork, ResolvedTeamNode } from "./types.js";
+export interface MoltnetTeamContext {
+    memberId: string;
+    teamName: string;
+    teamSource: string;
+    networks: ResolvedTeamNetwork[];
+}
+export interface TeamRepresentativeResolution {
+    agentSource: string;
+    memberId: string;
+    path: string[];
+    sourceTeamName: string;
+    sourceTeamSource: string;
+}
+export declare const resolveTeamRepresentatives: (plan: CompilePlan, teamNode: ResolvedTeamNode, seen?: string[]) => TeamRepresentativeResolution[];
+export declare const resolveMoltnetAttachments: (attachments: ResolvedMoltnetAttachment[] | undefined, context: MoltnetTeamContext | undefined, nodeName: string) => ResolvedMoltnetAttachment[] | undefined;

package/dist/compiler/moltnetRepresentativeResolution.js

@@ -0,0 +1,86 @@
+import { SpawnfileError } from "../shared/index.js";
+const cloneAttachment = (attachment, context) => ({
+    ...(attachment.dms ? { dms: { ...attachment.dms } } : {}),
+    memberId: context.memberId,
+    network: attachment.network,
+    ...(attachment.rooms
+        ? {
+            rooms: Object.fromEntries(Object.entries(attachment.rooms).map(([roomId, policy]) => [
+                roomId,
+                { ...policy }
+            ]))
+        }
+        : {}),
+    teamSource: context.teamSource
+});
+const findTeamBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "team" && entry.value.source === source);
+    if (!node || node.value.kind !== "team") {
+        throw new SpawnfileError("compile_error", `Unable to find team node at ${source}`);
+    }
+    return node.value;
+};
+export const resolveTeamRepresentatives = (plan, teamNode, seen = []) => {
+    if (seen.includes(teamNode.source)) {
+        throw new SpawnfileError("compile_error", `Cycle detected while resolving representatives for ${teamNode.name}`);
+    }
+    const selectedMemberIds = teamNode.externalExplicit
+        ? teamNode.external
+        : teamNode.mode === "hierarchical" && teamNode.lead
+            ? [teamNode.lead]
+            : teamNode.members.map((member) => member.id);
+    const nextSeen = [...seen, teamNode.source];
+    const representatives = [];
+    for (const memberId of selectedMemberIds) {
+        const member = teamNode.members.find((entry) => entry.id === memberId);
+        if (!member) {
+            throw new SpawnfileError("validation_error", `Team ${teamNode.name} representative interface references unknown member ${memberId}`);
+        }
+        if (member.kind === "agent") {
+            representatives.push({
+                agentSource: member.nodeSource,
+                memberId: member.id,
+                path: [member.id],
+                sourceTeamName: teamNode.name,
+                sourceTeamSource: teamNode.source
+            });
+            continue;
+        }
+        const childTeam = findTeamBySource(plan, member.nodeSource);
+        const childRepresentatives = resolveTeamRepresentatives(plan, childTeam, nextSeen);
+        if (childRepresentatives.length === 0) {
+            throw new SpawnfileError("validation_error", `Team ${childTeam.name} does not resolve to a concrete representative for ${teamNode.name}`);
+        }
+        for (const representative of childRepresentatives) {
+            representatives.push({
+                ...representative,
+                path: [member.id, ...representative.path]
+            });
+        }
+    }
+    return representatives;
+};
+export const resolveMoltnetAttachments = (attachments, context, nodeName) => {
+    if (!attachments || attachments.length === 0) {
+        return undefined;
+    }
+    if (!context) {
+        throw new SpawnfileError("validation_error", `Agent ${nodeName} declares Moltnet surfaces but is not attached to a team network`);
+    }
+    return attachments.map((attachment) => {
+        const network = context.networks.find((entry) => entry.id === attachment.network);
+        if (!network) {
+            throw new SpawnfileError("validation_error", `Agent ${nodeName} references unknown Moltnet network ${attachment.network} on team ${context.teamName}`);
+        }
+        for (const roomId of Object.keys(attachment.rooms ?? {})) {
+            const room = network.rooms.find((entry) => entry.id === roomId);
+            if (!room) {
+                throw new SpawnfileError("validation_error", `Agent ${nodeName} references unknown Moltnet room ${roomId} on network ${network.id}`);
+            }
+            if (!room.members.includes(context.memberId)) {
+                throw new SpawnfileError("validation_error", `Agent ${nodeName} cannot attach to Moltnet room ${roomId} because member ${context.memberId} is not in that room`);
+            }
+        }
+        return cloneAttachment(attachment, context);
+    });
+};

package/dist/compiler/moltnetResolution.d.ts

@@ -0,0 +1,3 @@
+import type { CompilePlan } from "./types.js";
+export { resolveMoltnetAttachments, resolveTeamRepresentatives, type MoltnetTeamContext, type TeamRepresentativeResolution } from "./moltnetRepresentativeResolution.js";
+export declare const resolvePlanMoltnetAttachments: (plan: CompilePlan) => void;