spawnfile 0.1.13 → 0.1.17

package/dist/compiler/moltnetConfigLowering.js

@@ -1,9 +1,18 @@
+import { SpawnfileError } from "../shared/index.js";
 const pathSafeSegment = (value) => value.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "item";
 const isIpv6Literal = (value) => value.includes(":");
 const normalizePosixPath = (value) => value.replace(/\/+/g, "/").replace(/\/+$/u, "") || "/";
 export const createMoltnetOpenTokenDirectory = (agentSlug) => `/var/lib/spawnfile/agents/${pathSafeSegment(agentSlug)}/state/moltnet`;
 export const createMoltnetOpenTokenPath = (networkId, memberId, agentSlug = memberId) => `${createMoltnetOpenTokenDirectory(agentSlug)}/${pathSafeSegment(networkId)}-${pathSafeSegment(memberId)}.token`;
 export const createMoltnetNetworkStateDirectory = (networkId) => `/var/lib/spawnfile/moltnet/networks/${pathSafeSegment(networkId)}`;
+export const createMoltnetDaimonReceiptStorePath = (networkId, memberId) => {
+    const network = pathSafeSegment(networkId);
+    const member = pathSafeSegment(memberId);
+    if (network !== networkId || member !== memberId || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,254}$/u.test(memberId)) {
+        throw new SpawnfileError("validation_error", "invalid Daimon receipt-store path segment");
+    }
+    return `${createMoltnetNetworkStateDirectory(networkId)}/daimon-receipts/${member}.json`;
+};
 export const createDefaultMoltnetStorePath = (networkId, kind, mountPath) => {
     const directory = mountPath
         ? normalizePosixPath(mountPath)
@@ -30,6 +39,19 @@ export const resolveMoltnetStorePersistenceMountPath = (networkId, store) => {
     return storePath ? storePath.slice(0, storePath.lastIndexOf("/")) || "/" : null;
 };
 export const createMoltnetServerConfigPath = (serverId) => `container/rootfs/var/lib/spawnfile/moltnet/servers/${pathSafeSegment(serverId)}/Moltnet.json`;
+/**
+ * Dedicated causal-log subdirectory, a SIBLING of (never the same directory
+ * as) the server's own Moltnet.json config file. Deliberately kept separate
+ * so a persistent volume mounted here (to survive container teardown/
+ * restart, see moltnetArtifacts.ts's causal persistent mount) never masks a
+ * rebuilt image's freshly-baked Moltnet.json — which carries secrets
+ * patched in at container start via secretPatches — with a stale copy left
+ * over in a prior run's volume. Takes the already-container-absolute
+ * `configPath` (MoltnetServerPlan.configPath, post toContainerRootfsPath),
+ * not the rootfs-prefixed emit path.
+ */
+export const createMoltnetCausalDirectory = (configPath) => `${configPath.slice(0, configPath.lastIndexOf("/")) || "/"}/causal`;
+export const createMoltnetCausalEventsPath = (configPath) => `${createMoltnetCausalDirectory(configPath)}/causal.jsonl`;
 export const createMoltnetNodeConfigPath = (teamSlug, networkId, agentId) => `container/rootfs/var/lib/spawnfile/moltnet/nodes/${pathSafeSegment(teamSlug)}-${pathSafeSegment(networkId)}-${pathSafeSegment(agentId)}.json`;
 export const renderMoltnetListenAddr = (server) => {
     const bind = server.listen.bind;
@@ -50,10 +72,43 @@ export const resolveMoltnetBaseUrl = (server) => {
             : bind;
     return `http://${host}:${server.listen.port}`;
 };
-export const resolveMoltnetClientAuth = (server, networkId, memberId, agentSlug) => {
+export const resolveMoltnetClientAuth = (server, networkId, memberId, agentSlug, attachmentTokenId, runtimeName) => {
     if (server.auth.mode === "none") {
+        if (attachmentTokenId !== undefined) {
+            throw new SpawnfileError("validation_error", `Moltnet attachment ${networkId}/${memberId} cannot select token ${attachmentTokenId} when auth.mode is none`);
+        }
         return { mode: "none" };
     }
+    if (attachmentTokenId !== undefined) {
+        if (server.mode !== "managed" || server.auth.mode !== "bearer") {
+            throw new SpawnfileError("validation_error", `invalid Moltnet actor token ${attachmentTokenId} for ${memberId}: token_id is supported only for managed bearer servers`);
+        }
+        const tokens = server.auth.tokens?.filter((candidate) => candidate.id === attachmentTokenId) ?? [];
+        const token = tokens[0];
+        if (tokens.length === 0 || !token) {
+            throw new SpawnfileError("validation_error", `invalid Moltnet actor token ${attachmentTokenId} for ${memberId}: attachment ${networkId}/${memberId} references unknown token ${attachmentTokenId}`);
+        }
+        if (tokens.length !== 1) {
+            throw new SpawnfileError("validation_error", `invalid Moltnet actor token ${attachmentTokenId} for ${memberId}: token id must exist exactly once`);
+        }
+        const requiredScopes = runtimeName === "daimon"
+            ? ["attach", "observe", "write"]
+            : ["attach", "write"];
+        if (token.scopes.length !== requiredScopes.length
+            || token.scopes.some((scope, index) => scope !== requiredScopes[index])) {
+            throw new SpawnfileError("validation_error", `invalid Moltnet actor token ${attachmentTokenId} for ${memberId}: token must include ${requiredScopes.join(", ")} scopes exactly`);
+        }
+        if (token.agents?.length !== 1 || token.agents[0] !== memberId) {
+            throw new SpawnfileError("validation_error", `invalid Moltnet actor token ${attachmentTokenId} for ${memberId}: token must declare exactly agents: [${memberId}]`);
+        }
+        return {
+            credentialAgentId: memberId,
+            credentialId: token.id,
+            mode: "bearer",
+            ...(server.auth.agent_registration ? { registration: server.auth.agent_registration } : {}),
+            tokenEnv: token.secret
+        };
+    }
     const client = server.auth.client;
     const registrationOpen = server.auth.mode === "open" || server.auth.agent_registration === "open";
     if (registrationOpen && !client) {
@@ -69,11 +124,28 @@ export const resolveMoltnetClientAuth = (server, networkId, memberId, agentSlug)
             ...(server.auth.agent_registration ? { registration: server.auth.agent_registration } : {})
         };
     }
-    const tokenEnv = client.token_env
-        ?? (client.token_id && server.mode === "managed"
-            ? server.auth.tokens?.find((token) => token.id === client.token_id)?.secret
-            : undefined);
+    const selectedManagedToken = client.token_id && server.mode === "managed"
+        ? server.auth.tokens?.find((token) => token.id === client.token_id)
+        : undefined;
+    if (server.mode === "managed"
+        && server.auth.mode === "bearer"
+        && selectedManagedToken
+        && (!selectedManagedToken.scopes.includes("attach")
+            || !selectedManagedToken.scopes.includes("write"))) {
+        throw new SpawnfileError("validation_error", `Moltnet attachment ${networkId}/${memberId} must select its own attach+write token; auth.client token ${selectedManagedToken.id} is operator-only`);
+    }
+    if (selectedManagedToken
+        && (selectedManagedToken.agents?.length ?? 0) > 0
+        && !selectedManagedToken.agents?.includes(memberId)) {
+        throw new SpawnfileError("validation_error", `Moltnet attachment ${networkId}/${memberId} is not allowed by auth.client token ${selectedManagedToken.id}`);
+    }
+    const tokenEnv = client.token_env ?? selectedManagedToken?.secret;
+    const selectedAgents = selectedManagedToken
+        ? [...new Set((selectedManagedToken.agents ?? []).map((agent) => agent.trim()))].filter(Boolean)
+        : [];
     return {
+        ...(selectedAgents.length === 1 ? { credentialAgentId: selectedAgents[0] } : {}),
+        ...(client.token_id ? { credentialId: client.token_id } : {}),
         mode: server.auth.mode,
         ...(server.auth.agent_registration ? { registration: server.auth.agent_registration } : {}),
         ...(client.static_token ? { staticToken: true } : {}),
@@ -112,11 +184,20 @@ export const createMoltnetNativeServerConfig = ({ networkId, networkName, rooms,
             envName: pairing.token_secret,
             jsonPath: `pairings.${index}.token`
         });
+        if (pairing.relay) {
+            secretPatches.push({
+                envName: pairing.relay.token_secret,
+                jsonPath: `pairings.${index}.relay.token`
+            });
+        }
         return {
             id: pairing.id,
             remote_network_id: pairing.remote_network_id,
             remote_network_name: pairing.remote_network_name,
-            remote_base_url: pairing.remote_base_url,
+            ...(pairing.remote_base_url ? { remote_base_url: pairing.remote_base_url } : {}),
+            ...(pairing.relay
+                ? { relay: { room: pairing.relay.room, token: "", url: pairing.relay.url } }
+                : {}),
             token: ""
         };
     });
@@ -152,6 +233,11 @@ export const createMoltnetNativeServerConfig = ({ networkId, networkName, rooms,
             },
             storage: storageConfigFor(networkId, server.store),
             rooms: rooms.map((room) => ({
+                ...(room.federation !== undefined
+                    ? { federation: room.federation }
+                    : pairings.length > 0
+                        ? { federation: "none" }
+                        : {}),
                 id: room.id,
                 ...(room.name ? { name: room.name } : {}),
                 ...(room.visibility ? { visibility: room.visibility } : {}),

package/dist/compiler/moltnetExternalParticipantArtifact.d.ts

@@ -0,0 +1,38 @@
+import type { ResolvedExternalParticipant } from "./organizationIdentity.js";
+import type { EmittedFile } from "../runtime/index.js";
+import type { MoltnetExternalParticipantIntent } from "./types.js";
+export declare const MOLTNET_EXTERNAL_PARTICIPANT_ARTIFACT_VERSION: "spawnfile.moltnet-external-participant.v1";
+export interface MoltnetExternalParticipantArtifactV1 {
+    readonly version: typeof MOLTNET_EXTERNAL_PARTICIPANT_ARTIFACT_VERSION;
+    readonly participant: {
+        readonly authored_key: string;
+        readonly kind: "service";
+        readonly member_id: string;
+        readonly principal_id: string;
+    };
+    readonly network: {
+        readonly id: string;
+    };
+    readonly auth: {
+        readonly mode: "bearer";
+        readonly token_id: string;
+        readonly token_env: string;
+    };
+    readonly direct_messages: readonly {
+        readonly members: readonly [string, string];
+    }[];
+}
+export interface BuildMoltnetExternalParticipantArtifactInput {
+    readonly participant: ResolvedExternalParticipant;
+    readonly networkId: string;
+    readonly tokenId: string;
+    readonly tokenEnv: string;
+    readonly directMessagePeers: readonly string[];
+}
+export declare const buildMoltnetExternalParticipantArtifact: (input: BuildMoltnetExternalParticipantArtifactInput) => MoltnetExternalParticipantArtifactV1;
+export declare const parseMoltnetExternalParticipantArtifact: (raw: unknown) => MoltnetExternalParticipantArtifactV1;
+export declare const renderMoltnetExternalParticipantArtifact: (artifact: MoltnetExternalParticipantArtifactV1) => string;
+export declare const createMoltnetExternalParticipantArtifactFiles: (intents: readonly MoltnetExternalParticipantIntent[]) => {
+    artifacts: MoltnetExternalParticipantArtifactV1[];
+    files: EmittedFile[];
+};

package/dist/compiler/moltnetExternalParticipantArtifact.js

@@ -0,0 +1,188 @@
+import { types as nodeTypes } from "node:util";
+import { SpawnfileError } from "../shared/index.js";
+import { createMoltnetExternalParticipantArtifactPath } from "./moltnetArtifactPaths.js";
+export const MOLTNET_EXTERNAL_PARTICIPANT_ARTIFACT_VERSION = "spawnfile.moltnet-external-participant.v1";
+const idPattern = /^[a-z][a-z0-9-]{0,62}(?:\.[a-z][a-z0-9-]{0,62}){0,7}$/u;
+const segmentPattern = /^[a-z][a-z0-9-]{0,62}$/u;
+const envPattern = /^[A-Z_][A-Z0-9_]{0,127}$/u;
+const MAX_HOSTILE_DEPTH = 16;
+const MAX_HOSTILE_NODES = 512;
+const isCanonicalMemberId = (value) => idPattern.test(value) && Buffer.byteLength(value, "ascii") <= 255;
+const fail = (message) => { throw new SpawnfileError("validation_error", `invalid Moltnet external participant artifact: ${message}`); };
+const isCanonicalArray = (value) => Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
+const requireCanonicalArray = (value, label) => {
+    if (value && typeof value === "object" && nodeTypes.isProxy(value))
+        fail(`${label} proxy`);
+    if (!isCanonicalArray(value))
+        return fail(`${label} array prototype`);
+    const array = value;
+    if (array.length > 128)
+        fail(`${label} cardinality exceeds 128`);
+    return array;
+};
+const keys = (value, expected) => {
+    if (Object.getPrototypeOf(value) !== Object.prototype)
+        fail("object prototype");
+    if (Object.getOwnPropertySymbols(value).length > 0)
+        fail("symbol property");
+    const actual = Object.getOwnPropertyNames(value).filter((key) => key !== "length");
+    if (actual.length !== expected.length || Object.keys(value).length !== expected.length || actual.some((key, index) => key !== expected[index]))
+        fail(`keys must be ${expected.join(",")}`);
+    for (const key of actual) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true)
+            fail("accessor or non-enumerable property");
+    }
+};
+const stringValue = (value, label, pattern = idPattern) => {
+    if (typeof value !== "string" || !pattern.test(value) || value.length > 255)
+        fail(`${label} value`);
+    return value;
+};
+const freezeCopy = (value, seen = new WeakSet()) => {
+    if (!value || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        fail("alias or cycle");
+    seen.add(value);
+    for (const child of Object.values(value))
+        freezeCopy(child, seen);
+    return Object.freeze(value);
+};
+const rejectAliases = (value, state = { nodes: 0, seen: new WeakSet() }, depth = 0) => {
+    if (!value || typeof value !== "object")
+        return;
+    if (nodeTypes.isProxy(value))
+        fail("proxy");
+    if (depth > MAX_HOSTILE_DEPTH)
+        fail("object depth exceeds 16");
+    state.nodes += 1;
+    if (state.nodes > MAX_HOSTILE_NODES)
+        fail("object node count exceeds 512");
+    if (state.seen.has(value))
+        fail("alias or cycle");
+    state.seen.add(value);
+    if (Array.isArray(value)) {
+        requireCanonicalArray(value, "array");
+        if (Object.getOwnPropertySymbols(value).length > 0 || Object.getOwnPropertyNames(value).some((key) => key !== "length" && !/^\d+$/u.test(key)))
+            fail("extended array");
+        for (let index = 0; index < value.length; index += 1) {
+            if (!Object.hasOwn(value, index))
+                fail("sparse array");
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true)
+                fail("accessor or non-enumerable property");
+            rejectAliases(value[index], state, depth + 1);
+        }
+    }
+    else {
+        const ownNames = Object.getOwnPropertyNames(value);
+        if (ownNames.length > MAX_HOSTILE_NODES)
+            fail("object property count exceeds 512");
+        for (const key of ownNames) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor) {
+                fail("missing property descriptor");
+                return;
+            }
+            if (!("value" in descriptor)) {
+                fail("accessor property");
+                return;
+            }
+            const child = descriptor.value;
+            rejectAliases(child, state, depth + 1);
+        }
+    }
+};
+export const buildMoltnetExternalParticipantArtifact = (input) => {
+    const { participant, networkId, tokenId, tokenEnv, directMessagePeers } = input;
+    if (participant.kind !== "service" || !segmentPattern.test(participant.authoredParticipantKey) || participant.principalId !== `system:${participant.memberId}`)
+        fail("participant identity");
+    rejectAliases(directMessagePeers);
+    const peers = [...directMessagePeers];
+    if (peers.length === 0 || peers.length > 128 || new Set(peers).size !== peers.length)
+        fail("direct-message peer cardinality");
+    if (peers.some((peer) => !isCanonicalMemberId(peer) || peer === participant.memberId))
+        fail("direct-message peer identity");
+    const members = peers.sort().map((peer) => [peer, participant.memberId].sort());
+    const artifact = {
+        version: MOLTNET_EXTERNAL_PARTICIPANT_ARTIFACT_VERSION,
+        participant: { authored_key: participant.authoredParticipantKey, kind: "service", member_id: participant.memberId, principal_id: participant.principalId },
+        network: { id: stringValue(networkId, "network id", segmentPattern) },
+        auth: { mode: "bearer", token_id: stringValue(tokenId, "token id"), token_env: stringValue(tokenEnv, "token env", envPattern) },
+        direct_messages: members.map((members) => ({ members }))
+    };
+    return parseMoltnetExternalParticipantArtifact(artifact);
+};
+export const parseMoltnetExternalParticipantArtifact = (raw) => {
+    rejectAliases(raw);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        fail("root object");
+    const value = raw;
+    keys(value, ["version", "participant", "network", "auth", "direct_messages"]);
+    if (value.version !== MOLTNET_EXTERNAL_PARTICIPANT_ARTIFACT_VERSION)
+        fail("version");
+    const participant = value.participant;
+    const network = value.network;
+    const auth = value.auth;
+    if (!participant || typeof participant !== "object" || Array.isArray(participant))
+        fail("participant object");
+    if (!network || typeof network !== "object" || Array.isArray(network))
+        fail("network object");
+    if (!auth || typeof auth !== "object" || Array.isArray(auth))
+        fail("auth object");
+    keys(participant, ["authored_key", "kind", "member_id", "principal_id"]);
+    keys(network, ["id"]);
+    keys(auth, ["mode", "token_id", "token_env"]);
+    const member = stringValue(participant.member_id, "member id");
+    const authoredKey = stringValue(participant.authored_key, "authored key", segmentPattern);
+    if (participant.kind !== "service" || participant.principal_id !== `system:${member}` || authoredKey !== member)
+        fail("participant");
+    if (auth.mode !== "bearer")
+        fail("auth mode");
+    const messages = value.direct_messages;
+    const directMessages = requireCanonicalArray(messages, "direct messages");
+    if (directMessages.length === 0 || directMessages.length > 128 || directMessages.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry)))
+        fail("direct message cardinality");
+    const parsed = directMessages.map((entry) => {
+        const item = entry;
+        keys(item, ["members"]);
+        const members = requireCanonicalArray(item.members, "members");
+        if (members.length !== 2 || members.some((member) => typeof member !== "string"))
+            fail("members");
+        const pair = members;
+        if (!pair.every((entry) => isCanonicalMemberId(entry)) || pair[0] >= pair[1] || !pair.includes(member) || pair[0] === pair[1])
+            fail("member ordering");
+        return { members: [pair[0], pair[1]] };
+    });
+    const peerFor = (pair) => pair[0] === member ? pair[1] : pair[0];
+    if (parsed.some((entry, index) => index > 0 && peerFor(entry.members) <= peerFor(parsed[index - 1].members)))
+        fail("message ordering");
+    const result = { version: value.version, participant: { authored_key: participant.authored_key, kind: "service", member_id: member, principal_id: participant.principal_id }, network: { id: stringValue(network.id, "network id", segmentPattern) }, auth: { mode: "bearer", token_id: stringValue(auth.token_id, "token id", segmentPattern), token_env: stringValue(auth.token_env, "token env", envPattern) }, direct_messages: parsed };
+    return freezeCopy(structuredClone(result));
+};
+export const renderMoltnetExternalParticipantArtifact = (artifact) => `${JSON.stringify(parseMoltnetExternalParticipantArtifact(artifact), null, 2)}\n`;
+export const createMoltnetExternalParticipantArtifactFiles = (intents) => {
+    const ordered = [...intents].sort((left, right) => byArtifactKey(left, right));
+    const keys = new Set();
+    for (const intent of ordered) {
+        const key = `${intent.networkId}\u0000${intent.participant.memberId}`;
+        if (keys.has(key))
+            fail("duplicate external participant artifact");
+        keys.add(key);
+    }
+    const artifacts = ordered.map((intent) => buildMoltnetExternalParticipantArtifact(intent));
+    return {
+        artifacts,
+        files: artifacts.map((artifact) => ({
+            content: renderMoltnetExternalParticipantArtifact(artifact),
+            mode: 0o600,
+            path: createMoltnetExternalParticipantArtifactPath(artifact.network.id, artifact.participant.member_id)
+        }))
+    };
+};
+const byArtifactKey = (left, right) => {
+    const a = `${left.networkId}\u0000${left.participant.memberId}`;
+    const b = `${right.networkId}\u0000${right.participant.memberId}`;
+    return a < b ? -1 : a > b ? 1 : 0;
+};

package/dist/compiler/moltnetNodeConfig.js

@@ -1,7 +1,7 @@
 import { resolveMoltnetClientAuth } from "./moltnetConfigLowering.js";
 import { resolveRuntimeConfig } from "./moltnetRuntimeConfig.js";
 export const createMoltnetNodeConfigContent = ({ agentNode, attachment, networkServer, nodeSlug, plan, serverPlan }) => {
-    const clientAuth = resolveMoltnetClientAuth(networkServer, attachment.network, attachment.memberId, nodeSlug);
+    const clientAuth = resolveMoltnetClientAuth(networkServer, attachment.network, attachment.memberId, nodeSlug, attachment.auth?.tokenId, agentNode.runtime.name);
     const usesPerAttachmentOpenToken = clientAuth.mode === "open" &&
         clientAuth.staticToken !== true &&
         Boolean(clientAuth.tokenEnv || clientAuth.tokenPath);
@@ -56,7 +56,12 @@ export const createMoltnetNodeConfigContent = ({ agentNode, attachment, networkS
                         ? {
                             dms: {
                                 enabled: attachment.dms.enabled,
-                                ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {})
+                                ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {}),
+                                ...(attachment.dms.allowedWakeSenders !== undefined
+                                    ? {
+                                        allowed_wake_senders: [...attachment.dms.allowedWakeSenders]
+                                    }
+                                    : {})
                             }
                         }
                         : {})

package/dist/compiler/moltnetReleaseAuthority.d.ts

@@ -0,0 +1,40 @@
+export declare const MOLTNET_RELEASE_AUTHORITY_VERSION: "spawnfile.moltnet-release-authority.v1";
+export type MoltnetTargetArchitecture = "amd64" | "arm64";
+/**
+ * The bridge capabilities a Moltnet build can advertise.
+ *
+ * CANONICAL ORDERING: `daimon-bridge` before `pi-bridge`. Several places
+ * compare this list by exact equality (`upReceipt.ts`, `localMoltnetAuthority.ts`)
+ * rather than as a set, so a differently ordered but equivalent list is
+ * rejected as a different release. The local builder
+ * (`scripts/build-local-moltnet.ts`) already writes this order; every producer
+ * must match it, and `moltnetReleaseAuthority.test.ts` asserts it.
+ *
+ * This is a UNION, never a replacement: an older pi-only release must keep
+ * pinning cleanly after a dual-capability one is published.
+ */
+export declare const MOLTNET_PI_ONLY_CAPABILITIES: readonly ["pi-bridge"];
+export declare const MOLTNET_DUAL_BRIDGE_CAPABILITIES: readonly ["daimon-bridge", "pi-bridge"];
+export type MoltnetBridgeCapabilities = typeof MOLTNET_PI_ONLY_CAPABILITIES | typeof MOLTNET_DUAL_BRIDGE_CAPABILITIES;
+/**
+ * The single runtime check for an advertised capability list. Every producer
+ * and parser funnels through this so the type and the runtime check can never
+ * drift apart — widening one without the other is precisely how a release
+ * becomes typecheck-green and runtime-rejected.
+ */
+export declare const parseMoltnetBridgeCapabilities: (value: unknown) => MoltnetBridgeCapabilities | null;
+export interface TrustedMoltnetReleaseAsset {
+    readonly architecture: MoltnetTargetArchitecture;
+    readonly asset: string;
+    readonly asset_sha256: `sha256:${string}`;
+}
+export interface TrustedMoltnetReleaseAuthority {
+    readonly version: typeof MOLTNET_RELEASE_AUTHORITY_VERSION;
+    readonly release_version: string;
+    readonly source_revision: string;
+    readonly capabilities: MoltnetBridgeCapabilities;
+    readonly assets: readonly TrustedMoltnetReleaseAsset[];
+}
+export declare const parseTrustedMoltnetReleaseAuthority: (raw: unknown) => TrustedMoltnetReleaseAuthority;
+export declare const readTrustedMoltnetReleaseAuthority: () => Promise<TrustedMoltnetReleaseAuthority>;
+export declare const trustedMoltnetReleaseAsset: (authority: TrustedMoltnetReleaseAuthority, architecture: MoltnetTargetArchitecture) => TrustedMoltnetReleaseAsset;

package/dist/compiler/moltnetReleaseAuthority.js

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { SpawnfileError } from "../shared/index.js";
+export const MOLTNET_RELEASE_AUTHORITY_VERSION = "spawnfile.moltnet-release-authority.v1";
+/**
+ * The bridge capabilities a Moltnet build can advertise.
+ *
+ * CANONICAL ORDERING: `daimon-bridge` before `pi-bridge`. Several places
+ * compare this list by exact equality (`upReceipt.ts`, `localMoltnetAuthority.ts`)
+ * rather than as a set, so a differently ordered but equivalent list is
+ * rejected as a different release. The local builder
+ * (`scripts/build-local-moltnet.ts`) already writes this order; every producer
+ * must match it, and `moltnetReleaseAuthority.test.ts` asserts it.
+ *
+ * This is a UNION, never a replacement: an older pi-only release must keep
+ * pinning cleanly after a dual-capability one is published.
+ */
+export const MOLTNET_PI_ONLY_CAPABILITIES = ["pi-bridge"];
+export const MOLTNET_DUAL_BRIDGE_CAPABILITIES = ["daimon-bridge", "pi-bridge"];
+/**
+ * The single runtime check for an advertised capability list. Every producer
+ * and parser funnels through this so the type and the runtime check can never
+ * drift apart — widening one without the other is precisely how a release
+ * becomes typecheck-green and runtime-rejected.
+ */
+export const parseMoltnetBridgeCapabilities = (value) => {
+    if (!Array.isArray(value))
+        return null;
+    const joined = value.join("\0");
+    if (joined === MOLTNET_PI_ONLY_CAPABILITIES.join("\0"))
+        return MOLTNET_PI_ONLY_CAPABILITIES;
+    if (joined === MOLTNET_DUAL_BRIDGE_CAPABILITIES.join("\0"))
+        return MOLTNET_DUAL_BRIDGE_CAPABILITIES;
+    return null;
+};
+const SHA256 = /^sha256:[a-f0-9]{64}$/u;
+const REVISION = /^[a-f0-9]{40}$/u;
+const VERSION = /^v?\d+\.\d+\.\d+(?:-\d+-g[a-f0-9]{7,40})?$/u;
+const exactKeys = (value, keys) => Object.keys(value).sort().join("\0") === [...keys].sort().join("\0");
+const fail = () => {
+    throw new SpawnfileError("compile_error", "Trusted Moltnet release authority is invalid");
+};
+export const parseTrustedMoltnetReleaseAuthority = (raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return fail();
+    const value = raw;
+    if (!exactKeys(value, [
+        "assets", "capabilities", "release_version", "source_revision", "version"
+    ])
+        || value.version !== MOLTNET_RELEASE_AUTHORITY_VERSION
+        || typeof value.release_version !== "string"
+        || !VERSION.test(value.release_version)
+        || typeof value.source_revision !== "string"
+        || !REVISION.test(value.source_revision)
+        || parseMoltnetBridgeCapabilities(value.capabilities) === null
+        || !Array.isArray(value.assets)
+        || value.assets.length !== 2)
+        return fail();
+    const assets = [];
+    for (const rawAsset of value.assets) {
+        if (!rawAsset || typeof rawAsset !== "object" || Array.isArray(rawAsset))
+            return fail();
+        const asset = rawAsset;
+        if (!exactKeys(asset, ["architecture", "asset", "asset_sha256"])
+            || asset.architecture !== "amd64" && asset.architecture !== "arm64"
+            || asset.asset !== `moltnet_linux_${asset.architecture}.tar.gz`
+            || typeof asset.asset_sha256 !== "string"
+            || !SHA256.test(asset.asset_sha256))
+            return fail();
+        assets.push(Object.freeze({
+            architecture: asset.architecture,
+            asset: asset.asset,
+            asset_sha256: asset.asset_sha256
+        }));
+    }
+    if (assets[0]?.architecture !== "amd64" || assets[1]?.architecture !== "arm64")
+        return fail();
+    const describedRevision = value.release_version.match(/-g([a-f0-9]{7,40})$/u)?.[1];
+    if (describedRevision && !value.source_revision.startsWith(describedRevision))
+        return fail();
+    return Object.freeze({
+        version: MOLTNET_RELEASE_AUTHORITY_VERSION,
+        release_version: value.release_version,
+        source_revision: value.source_revision,
+        capabilities: parseMoltnetBridgeCapabilities(value.capabilities),
+        assets: Object.freeze(assets)
+    });
+};
+export const readTrustedMoltnetReleaseAuthority = async () => {
+    try {
+        return parseTrustedMoltnetReleaseAuthority(JSON.parse(await readFile(new URL("../../moltnet-releases.json", import.meta.url), "utf8")));
+    }
+    catch (error) {
+        if (error instanceof SpawnfileError)
+            throw error;
+        return fail();
+    }
+};
+export const trustedMoltnetReleaseAsset = (authority, architecture) => {
+    const parsed = parseTrustedMoltnetReleaseAuthority(authority);
+    const asset = parsed.assets.find((candidate) => candidate.architecture === architecture);
+    return asset ?? fail();
+};

package/dist/compiler/moltnetReleaseDownload.d.ts

@@ -0,0 +1,12 @@
+import { type MoltnetTargetArchitecture, type TrustedMoltnetReleaseAuthority } from "./moltnetReleaseAuthority.js";
+type ReleaseResponse = Pick<Response, "body" | "headers" | "ok" | "status" | "statusText">;
+export interface MoltnetReleaseDownloadDependencies {
+    readonly fetchRelease?: (input: string, init: RequestInit) => Promise<ReleaseResponse>;
+}
+export interface DownloadedMoltnetReleaseAsset {
+    readonly assetPath: string;
+    readonly cleanup: () => Promise<void>;
+}
+export declare const trustedMoltnetReleaseDownloadUrl: (authority: TrustedMoltnetReleaseAuthority, architecture: MoltnetTargetArchitecture) => string;
+export declare const downloadTrustedMoltnetReleaseAsset: (authority: TrustedMoltnetReleaseAuthority, architecture: MoltnetTargetArchitecture, dependencies?: MoltnetReleaseDownloadDependencies) => Promise<DownloadedMoltnetReleaseAsset>;
+export {};

package/dist/compiler/moltnetReleaseDownload.js

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SpawnfileError } from "../shared/index.js";
+import { parseTrustedMoltnetReleaseAuthority, trustedMoltnetReleaseAsset } from "./moltnetReleaseAuthority.js";
+const MAX_RELEASE_BYTES = 64 * 1024 * 1024;
+const DOWNLOAD_TIMEOUT_MS = 120_000;
+export const trustedMoltnetReleaseDownloadUrl = (authority, architecture) => {
+    const parsed = parseTrustedMoltnetReleaseAuthority(authority);
+    const asset = trustedMoltnetReleaseAsset(parsed, architecture);
+    return `https://github.com/noopolis/moltnet/releases/download/${parsed.release_version}/${asset.asset}`;
+};
+const responseBytes = async (response) => {
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength !== null) {
+        const bytes = Number(declaredLength);
+        if (!Number.isSafeInteger(bytes) || bytes < 1 || bytes > MAX_RELEASE_BYTES) {
+            throw new SpawnfileError("compile_error", "Pinned Moltnet release has an invalid content length");
+        }
+    }
+    if (response.body === null) {
+        throw new SpawnfileError("compile_error", "Pinned Moltnet release response has no body");
+    }
+    const chunks = [];
+    let total = 0;
+    const reader = response.body.getReader();
+    try {
+        for (;;) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            total += item.value.byteLength;
+            if (total > MAX_RELEASE_BYTES) {
+                await reader.cancel();
+                throw new SpawnfileError("compile_error", "Pinned Moltnet release exceeds the download limit");
+            }
+            chunks.push(item.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (total === 0)
+        throw new SpawnfileError("compile_error", "Pinned Moltnet release is empty");
+    return Buffer.concat(chunks, total);
+};
+export const downloadTrustedMoltnetReleaseAsset = async (authority, architecture, dependencies = {}) => {
+    const parsed = parseTrustedMoltnetReleaseAuthority(authority);
+    const asset = trustedMoltnetReleaseAsset(parsed, architecture);
+    const url = trustedMoltnetReleaseDownloadUrl(parsed, architecture);
+    const fetchRelease = dependencies.fetchRelease ?? fetch;
+    let response;
+    try {
+        response = await fetchRelease(url, {
+            redirect: "follow",
+            signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to download pinned Moltnet release: ${reason}`);
+    }
+    if (!response.ok) {
+        throw new SpawnfileError("compile_error", `Unable to download pinned Moltnet release: HTTP ${response.status} ${response.statusText}`);
+    }
+    const bytes = await responseBytes(response);
+    const sha256 = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+    if (sha256 !== asset.asset_sha256) {
+        throw new SpawnfileError("compile_error", "Downloaded Moltnet release digest does not match trusted authority");
+    }
+    const directory = await mkdtemp(path.join(os.tmpdir(), "spawnfile-moltnet-release-"));
+    try {
+        const assetPath = path.join(directory, asset.asset);
+        await writeFile(assetPath, bytes, { flag: "wx" });
+        return Object.freeze({
+            assetPath,
+            cleanup: () => rm(directory, { force: true, recursive: true })
+        });
+    }
+    catch (error) {
+        await rm(directory, { force: true, recursive: true });
+        throw error;
+    }
+};

package/dist/compiler/moltnetRepresentativeResolution.d.ts

@@ -4,6 +4,7 @@ export interface MoltnetTeamContext {
     teamName: string;
     teamSource: string;
     networks: ResolvedTeamNetwork[];
+    resolvedMemberId?: string;
 }
 export interface TeamRepresentativeResolution {
     agentSource: string;
@@ -13,4 +14,4 @@ export interface TeamRepresentativeResolution {
     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;
+export declare const resolveMoltnetAttachments: (attachments: ResolvedMoltnetAttachment[] | undefined, context: MoltnetTeamContext | undefined, nodeName: string, runtimeName?: string) => ResolvedMoltnetAttachment[] | undefined;