spawnfile 0.1.12 → 0.1.14

package/dist/compiler/upReceipt.js

@@ -0,0 +1,82 @@
+import { readDeploymentRecord, UP_RECEIPT_VERSION } from "../deployment/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { buildCompilePlan } from "./buildCompilePlan.js";
+/**
+ * Extracts the `{agent, cron}` pairs an up-receipt's `compiled_schedule` field carries
+ * (Decision 21 Piece 4) — the raw material for simfile's wake-diff denominator oracle.
+ * Only `kind: "cron"` schedules are represented; `every`/`disabled` schedules have no
+ * cron-fire cadence to diff against sim-time and are intentionally omitted, not zeroed.
+ */
+export const resolveCompiledSchedule = (plan) => plan.nodes
+    .filter((node) => node.kind === "agent")
+    .flatMap((node) => {
+    const schedule = node.value.schedule;
+    return schedule?.kind === "cron" ? [{ agent: node.id, cron: schedule.cron }] : [];
+})
+    .sort((left, right) => left.agent.localeCompare(right.agent));
+/**
+ * Extracts `{agent, engine}` pairs (Piece 5, Slice B) — disclosure ground truth for the
+ * run-manifest's `pinned-engine` field, so a `scripted` (or any non-default) pi engine is
+ * visibly disclosed rather than an invisible test-only branch. Reads
+ * `report.container.runtime_instances[].engine_by_node_id`, the single source of truth
+ * `containerArtifacts.ts` already stamps from the pi adapter's own resolved engine kinds
+ * (see `src/runtime/pi/adapter.ts`'s `createContainerTargets`) — deliberately not
+ * re-derived from a fresh `buildCompilePlan` walk (unlike `resolveCompiledSchedule` above),
+ * since that would recompute the exact same fact from pi-adapter-internal logic
+ * (`resolvePiEngine`) that compiler code has no business reaching into directly.
+ */
+export const resolveCompiledEngines = (report) => (report.container?.runtime_instances ?? [])
+    .flatMap((instance) => Object.entries(instance.engine_by_node_id ?? {}))
+    .map(([agent, engine]) => ({ agent, engine }))
+    .sort((left, right) => left.agent.localeCompare(right.agent));
+/**
+ * Builds `spawnfile.up-receipt.v1` from a project-path `upProject()` result. Reads back
+ * the deployment record `upProject` already wrote (for `run_id`/deployment name/container
+ * id — the same record `spawnfile artifacts export`/`spawnfile down` resolve), and
+ * re-derives `compiled_schedule` from the resolved graph, since `compileProject` does not
+ * retain its own `CompilePlan` past the compile step.
+ *
+ * `readiness` reuses whatever signal `upProject` already has — a bare `docker run -d`
+ * that returned a container id, not a new health probe: `up` has never polled
+ * application-level readiness, and this receipt does not invent one. `moltnet_base_url`
+ * comes straight from the compiled container report's own managed/external server plan;
+ * no credentials ever land on this contract (contracts.md).
+ */
+export const buildUpReceipt = async (inputPath, result) => {
+    const plan = await buildCompilePlan(inputPath);
+    const compiledSchedule = resolveCompiledSchedule(plan);
+    const compiledEngines = resolveCompiledEngines(result.report);
+    const record = result.deploymentRecordPath
+        ? await readDeploymentRecord(result.deploymentRecordPath)
+        : null;
+    const unit = record?.units[0] ?? null;
+    const containerIds = unit?.container_id ? [unit.container_id] : [];
+    const fingerprint = result.report.compile_fingerprint;
+    if (!fingerprint) {
+        throw new SpawnfileError("runtime_error", "Compiled output has no compile_fingerprint; cannot build an up-receipt");
+    }
+    return {
+        version: UP_RECEIPT_VERSION,
+        run_id: record?.run_id ?? null,
+        fingerprint,
+        deployment: {
+            name: record?.name ?? null,
+            container_ids: containerIds
+        },
+        readiness: {
+            state: containerIds.length > 0 ? "running" : "unknown",
+            moltnet_base_url: result.report.container?.moltnet?.server_plans?.[0]?.base_url ?? null
+        },
+        compiled_schedule: compiledSchedule,
+        engines: compiledEngines,
+        ...(result.report.container?.moltnet?.release
+            ? { moltnet_release: {
+                    ...result.report.container.moltnet.release,
+                    capabilities: ["pi-bridge"]
+                } }
+            : {}),
+        ...(record?.organization_handoff ? { organization_handoff: record.organization_handoff } : {}),
+        ...(record?.organization_handoff_handle ? { organization_handoff_handle: record.organization_handoff_handle } : {}),
+        ...(record?.organization_ready ? { organization_ready: record.organization_ready } : {})
+    };
+};

package/dist/compiler/updateProjectModels.js

@@ -1,8 +1,9 @@
 import path from "node:path";
-import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
+import { getManifestPath, writeUtf8File } from "../filesystem/index.js";
 import { loadManifest, renderSpawnfile } from "../manifest/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { resolveEffectiveModelTarget } from "./modelEnv.js";
+import { collectProjectManifestPaths, createInlineAgentSource, rewriteInlineAgentMembers } from "./projectManifestGraph.js";
 const TEAM_MODEL_COMMAND_ERROR = "spawnfile model commands only write agent manifests; use --recursive to update descendant agents of a team project";
 const AUTH_METHOD_PROVIDER_HINTS = {
     "api_key": "use a model provider like openai or anthropic, then pass --auth api_key",
@@ -74,22 +75,6 @@ const buildModelTarget = (options) => {
         provider: options.provider
     };
 };
-const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
-    const canonicalPath = getCanonicalManifestPath(manifestPath);
-    if (visited.has(canonicalPath)) {
-        return [];
-    }
-    visited.add(canonicalPath);
-    if (!recursive) {
-        return [canonicalPath];
-    }
-    const loadedManifest = await loadManifest(canonicalPath);
-    const childRefs = loadedManifest.manifest.kind === "team"
-        ? loadedManifest.manifest.members.map((member) => member.ref)
-        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
-    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
-    return [canonicalPath, ...nestedPaths.flat()];
-};
 const updateManifestExecution = (manifest, model) => ({
     ...manifest,
     execution: {
@@ -98,14 +83,14 @@ const updateManifestExecution = (manifest, model) => ({
     }
 });
 const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
-const assertModelMutationAllowed = (manifest, recursive) => {
+const mutateAgentDeclarations = (manifest, manifestPath, recursive, mutate) => {
     if (manifest.kind === "agent") {
-        return true;
+        return mutate(manifest, manifestPath);
     }
-    if (recursive) {
-        return false;
+    if (!recursive) {
+        throw new SpawnfileError("validation_error", TEAM_MODEL_COMMAND_ERROR);
     }
-    throw new SpawnfileError("validation_error", TEAM_MODEL_COMMAND_ERROR);
+    return rewriteInlineAgentMembers(manifest, (member) => mutate(member, createInlineAgentSource(manifestPath, member.id)) ?? member);
 };
 const rewriteTouchedManifests = async (manifestPaths, mutate) => {
     const updatedFiles = [];
@@ -123,59 +108,56 @@ const rewriteTouchedManifests = async (manifestPaths, mutate) => {
 export const setProjectPrimaryModel = async (options) => {
     const modelTarget = buildModelTarget(options);
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
-    return rewriteTouchedManifests(manifestPaths, (manifest) => {
-        if (!assertModelMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const normalizedModel = normalizeExecutionModel(manifest.execution);
-        return updateManifestExecution(manifest, {
-            ...(normalizedModel?.fallback ? { fallback: normalizedModel.fallback } : {}),
-            primary: modelTarget
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration) => {
+            const normalizedModel = normalizeExecutionModel(declaration.execution);
+            return updateManifestExecution(declaration, {
+                ...(normalizedModel?.fallback ? { fallback: normalizedModel.fallback } : {}),
+                primary: modelTarget
+            });
         });
     });
 };
 export const addProjectModelFallback = async (options) => {
     const modelTarget = buildModelTarget(options);
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
-        if (!assertModelMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const normalizedModel = normalizeExecutionModel(manifest.execution);
-        if (!normalizedModel) {
-            if (recursive) {
-                return null;
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration, source) => {
+            const normalizedModel = normalizeExecutionModel(declaration.execution);
+            if (!normalizedModel) {
+                if (recursive) {
+                    return null;
+                }
+                throw new SpawnfileError("validation_error", `Manifest at ${source} must declare a primary model before adding fallback models`);
             }
-            throw new SpawnfileError("validation_error", `Manifest at ${manifestPath} must declare a primary model before adding fallback models`);
-        }
-        const existingFallback = normalizedModel.fallback ?? [];
-        const nextFallback = existingFallback.some((entry) => JSON.stringify(entry) === JSON.stringify(modelTarget))
-            ? existingFallback
-            : [...existingFallback, modelTarget];
-        return updateManifestExecution(manifest, {
-            fallback: nextFallback,
-            primary: normalizedModel.primary
+            const existingFallback = normalizedModel.fallback ?? [];
+            const nextFallback = existingFallback.some((entry) => JSON.stringify(entry) === JSON.stringify(modelTarget))
+                ? existingFallback
+                : [...existingFallback, modelTarget];
+            return updateManifestExecution(declaration, {
+                fallback: nextFallback,
+                primary: normalizedModel.primary
+            });
         });
     });
 };
 export const clearProjectModelFallbacks = async (options = {}) => {
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
-        if (!assertModelMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const normalizedModel = normalizeExecutionModel(manifest.execution);
-        if (!normalizedModel) {
-            if (recursive) {
-                return null;
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration, source) => {
+            const normalizedModel = normalizeExecutionModel(declaration.execution);
+            if (!normalizedModel) {
+                if (recursive) {
+                    return null;
+                }
+                throw new SpawnfileError("validation_error", `Manifest at ${source} does not declare any execution model`);
             }
-            throw new SpawnfileError("validation_error", `Manifest at ${manifestPath} does not declare any execution model`);
-        }
-        return updateManifestExecution(manifest, {
-            primary: normalizedModel.primary
+            return updateManifestExecution(declaration, {
+                primary: normalizedModel.primary
+            });
         });
     });
 };

package/dist/compiler/updateProjectRuntime.js

@@ -1,38 +1,14 @@
 import path from "node:path";
-import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
-import { loadManifest, renderSpawnfile } from "../manifest/index.js";
+import { getManifestPath, writeUtf8File } from "../filesystem/index.js";
+import { loadManifest, materializeInlineAgentManifest, renderSpawnfile } from "../manifest/index.js";
 import { assertRuntimeCanCompile } from "../runtime/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
+import { collectProjectManifestPaths, rewriteInlineAgentMembers } from "./projectManifestGraph.js";
 import { validateAgentSurfaceSupport } from "./surfaceDefinitions.js";
 const TEAM_RUNTIME_COMMAND_ERROR = "spawnfile runtime commands only write agent manifests; use --recursive to update descendant agents of a team project";
 const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
-const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
-    const canonicalPath = getCanonicalManifestPath(manifestPath);
-    if (visited.has(canonicalPath)) {
-        return [];
-    }
-    visited.add(canonicalPath);
-    if (!recursive) {
-        return [canonicalPath];
-    }
-    const loadedManifest = await loadManifest(canonicalPath);
-    const childRefs = loadedManifest.manifest.kind === "team"
-        ? loadedManifest.manifest.members.map((member) => member.ref)
-        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
-    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
-    return [canonicalPath, ...nestedPaths.flat()];
-};
 const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
-const assertRuntimeMutationAllowed = (manifest, recursive) => {
-    if (manifest.kind === "agent") {
-        return true;
-    }
-    if (recursive) {
-        return false;
-    }
-    throw new SpawnfileError("validation_error", TEAM_RUNTIME_COMMAND_ERROR);
-};
 const validateAgentRuntimeMutation = (manifest) => {
     validateAgentSurfaceSupport(manifest);
     const runtimeName = typeof manifest.runtime === "string" ? manifest.runtime : manifest.runtime?.name;
@@ -41,22 +17,33 @@ const validateAgentRuntimeMutation = (manifest) => {
     }
     assertRuntimeSupportsExecutionModelAuth(runtimeName, manifest.execution, manifest.name);
 };
+const setInlineRuntime = (team, member, runtime) => {
+    const nextMember = { ...member, runtime };
+    validateAgentRuntimeMutation(materializeInlineAgentManifest(team, nextMember));
+    return nextMember;
+};
 export const setProjectRuntime = async (options) => {
     await assertRuntimeCanCompile(options.runtime);
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     const updatedFiles = [];
     for (const manifestPath of manifestPaths) {
         const loadedManifest = await loadManifest(manifestPath);
         const manifest = loadedManifest.manifest;
-        if (!assertRuntimeMutationAllowed(manifest, recursive)) {
-            continue;
+        let nextManifest;
+        if (manifest.kind === "agent") {
+            nextManifest = {
+                ...manifest,
+                runtime: options.runtime
+            };
+            validateAgentRuntimeMutation(nextManifest);
+        }
+        else {
+            if (!recursive) {
+                throw new SpawnfileError("validation_error", TEAM_RUNTIME_COMMAND_ERROR);
+            }
+            nextManifest = rewriteInlineAgentMembers(manifest, (member) => setInlineRuntime(manifest, member, options.runtime));
         }
-        const nextManifest = {
-            ...manifest,
-            runtime: options.runtime
-        };
-        validateAgentRuntimeMutation(nextManifest);
         if (!manifestChanged(manifest, nextManifest)) {
             continue;
         }

package/dist/compiler/updateProjectSurfaces.js

@@ -1,25 +1,20 @@
 import path from "node:path";
-import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
-import { loadManifest, renderSpawnfile } from "../manifest/index.js";
+import { getManifestPath, writeUtf8File } from "../filesystem/index.js";
+import { isReferencedMember, loadManifest, materializeInlineAgentManifest, renderSpawnfile } from "../manifest/index.js";
 import { assertSurfaceMutationAllowed, removeSurface, updateSurfaceAccess, upsertSurface, validateAgentSurfaceSupport } from "./surfaceDefinitions.js";
+import { collectProjectManifestPaths, createInlineAgentSource, rewriteInlineAgentMembers } from "./projectManifestGraph.js";
 const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
-const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
-    const canonicalPath = getCanonicalManifestPath(manifestPath);
-    if (visited.has(canonicalPath)) {
-        return [];
+const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
+const mutateAgentDeclarations = (manifest, manifestPath, recursive, mutate) => {
+    if (manifest.kind === "agent") {
+        return mutate(manifest, manifestPath);
     }
-    visited.add(canonicalPath);
     if (!recursive) {
-        return [canonicalPath];
+        assertSurfaceMutationAllowed(manifest, recursive);
+        return null;
     }
-    const loadedManifest = await loadManifest(canonicalPath);
-    const childRefs = loadedManifest.manifest.kind === "team"
-        ? loadedManifest.manifest.members.map((member) => member.ref)
-        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
-    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
-    return [canonicalPath, ...nestedPaths.flat()];
+    return rewriteInlineAgentMembers(manifest, (member) => mutate(member, createInlineAgentSource(manifestPath, member.id)) ?? member);
 };
-const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
 const rewriteTouchedManifests = async (manifestPaths, mutate) => {
     const rewrites = [];
     for (const manifestPath of manifestPaths) {
@@ -31,6 +26,13 @@ const rewriteTouchedManifests = async (manifestPaths, mutate) => {
         if (nextManifest.kind === "agent") {
             validateAgentSurfaceSupport(nextManifest);
         }
+        else {
+            for (const member of nextManifest.members) {
+                if (!isReferencedMember(member)) {
+                    validateAgentSurfaceSupport(materializeInlineAgentManifest(nextManifest, member));
+                }
+            }
+        }
         rewrites.push({
             manifest: nextManifest,
             manifestPath
@@ -46,53 +48,57 @@ const rewriteTouchedManifests = async (manifestPaths, mutate) => {
 export { resolvePortableSurfaceName } from "./surfaceDefinitions.js";
 export const addProjectSurface = async (options) => {
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
-    return rewriteTouchedManifests(manifestPaths, (manifest) => {
-        if (!assertSurfaceMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        return {
-            ...manifest,
-            surfaces: upsertSurface(manifest.surfaces, options)
-        };
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration) => ({
+            ...declaration,
+            surfaces: upsertSurface(declaration.surfaces, options)
+        }));
     });
 };
 export const setProjectSurfaceAccess = async (options) => {
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
-        if (!assertSurfaceMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const nextSurfaces = updateSurfaceAccess(manifest.surfaces, options, manifestPath, recursive);
-        if (!nextSurfaces) {
-            return null;
-        }
-        return {
-            ...manifest,
-            surfaces: nextSurfaces
-        };
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration, source) => {
+            const nextSurfaces = updateSurfaceAccess(declaration.surfaces, options, source, recursive);
+            if (!nextSurfaces) {
+                return null;
+            }
+            return {
+                ...declaration,
+                surfaces: nextSurfaces
+            };
+        });
     });
 };
 export const removeProjectSurface = async (options) => {
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
-    return rewriteTouchedManifests(manifestPaths, (manifest) => {
-        if (!assertSurfaceMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        return {
-            ...manifest,
-            surfaces: removeSurface(manifest.surfaces, options.surface)
-        };
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration) => ({
+            ...declaration,
+            surfaces: removeSurface(declaration.surfaces, options.surface)
+        }));
     });
 };
 export const showProjectSurfaces = async (options = {}) => {
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), options.recursive ?? false);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), options.recursive ?? false);
     const entries = [];
     for (const manifestPath of manifestPaths) {
         const loadedManifest = await loadManifest(manifestPath);
-        if (options.recursive && loadedManifest.manifest.kind !== "agent") {
+        if (options.recursive && loadedManifest.manifest.kind === "team") {
+            for (const member of loadedManifest.manifest.members) {
+                if (isReferencedMember(member)) {
+                    continue;
+                }
+                entries.push({
+                    kind: "agent",
+                    manifestPath: createInlineAgentSource(manifestPath, member.id),
+                    name: member.id,
+                    surfaces: member.surfaces
+                });
+            }
             continue;
         }
         entries.push({

package/dist/compiler/worldBindings.d.ts

@@ -0,0 +1,39 @@
+import type { CompilePlan } from "./types.js";
+export declare const SIMFILE_WORLD_BINDINGS_VERSION: "simfile.world-bindings.v1";
+export declare const WORLD_BINDINGS_OUTPUT_FILE = "world-bindings.json";
+export interface SimfileWorldBindingV1 {
+    readonly member: {
+        readonly id: string;
+        readonly principal_id: string;
+    };
+    readonly run_id: string;
+    readonly world_instance_id: string;
+    readonly capability_manifest_digest: string;
+    readonly token_env: string;
+    readonly json: {
+        readonly auth: "bearer";
+        readonly url: string;
+    };
+    readonly mcp: {
+        readonly auth: "bearer";
+        readonly transport: "streamable_http";
+        readonly url: string;
+    };
+}
+export interface SimfileWorldBindingsV1 {
+    readonly schema: typeof SIMFILE_WORLD_BINDINGS_VERSION;
+    readonly bindings: readonly SimfileWorldBindingV1[];
+}
+export interface ResolvedWorldBindingAssignment {
+    readonly binding: SimfileWorldBindingV1;
+    readonly nodeId: string;
+}
+export interface ResolvedWorldBindings {
+    readonly artifact: SimfileWorldBindingsV1;
+    readonly assignments: readonly ResolvedWorldBindingAssignment[];
+    readonly canonicalBytes: string;
+}
+export declare const parseSimfileWorldBindings: (raw: unknown) => SimfileWorldBindingsV1;
+export declare const renderSimfileWorldBindings: (artifact: SimfileWorldBindingsV1) => string;
+export declare const resolveWorldBindings: (plan: CompilePlan, raw: unknown) => ResolvedWorldBindings;
+export declare const findWorldBindingForNode: (resolved: ResolvedWorldBindings | undefined, nodeId: string) => SimfileWorldBindingV1 | undefined;