simfile 0.0.1

package/dist/view/runWorldTrace.d.ts

@@ -0,0 +1,97 @@
+import type { RunTimeline, RunTimelineMembrane } from "./runTimelineTypes.js";
+/**
+ * Adapts a run-replay `RunTimeline` into the same `viewer.trace.v1` shape
+ * `web/src/viewer/worldModel.ts`'s `buildViewerWorld` already consumes, so
+ * the existing `AsciiMap`/`worldModel`/`renderSettings` render this run's
+ * map unchanged (`docs/VIEW_DESIGN.md`'s two-layer rule). This type is a
+ * structural mirror of `web/src/viewer/types.ts`'s `ViewerContractTrace` —
+ * a deliberate duplicate, not a cross-package import, matching this
+ * package's existing src/web boundary: the contract is the JSON shape on
+ * the wire, not a shared TS type.
+ *
+ * These moltnet-room runs have no place-bearing world (Space Module has not
+ * landed): there is exactly one informational room anchor per room in the
+ * `rooms` list, no corridors, no presence stream. Agents render with
+ * `label_hint: "heuristic"`, which is the same "no presence stream yet"
+ * treatment `worldModel.ts` already gives any agent lacking presence events
+ * — nothing new to teach the renderer.
+ */
+export interface RunWorldTraceRoom {
+    id: string;
+    label: string;
+    scope: string;
+    members: string[];
+    scene: [number, number, number];
+    access_hint?: string;
+}
+export interface RunWorldTraceAgent {
+    id: string;
+    label?: string;
+    scope: string;
+    label_hint?: string;
+    detail?: string;
+}
+export type RunWorldTraceLedgerFactType = "clock.sync" | "world.message" | "world.dm" | "wake.recommended" | "rule.fired" | "marker.seen" | "probe" | "other";
+export interface RunWorldTraceLedgerFact {
+    type: RunWorldTraceLedgerFactType;
+    tick: number;
+    event_id: string;
+    kind: string;
+    sim_time: number;
+    provenance: "mechanical" | "agentic" | "external";
+    actor: string;
+    target: string;
+    detail: string;
+    scope?: string;
+    payload: unknown;
+}
+export interface RunWorldTrace {
+    version: "viewer.trace.v1";
+    run_id: string;
+    run_name: string;
+    rooms: RunWorldTraceRoom[];
+    corridors: never[];
+    agents: RunWorldTraceAgent[];
+    presence: never[];
+    ledger_facts: RunWorldTraceLedgerFact[];
+    signals: never[];
+}
+export declare const NO_PLACE_CAPTION = "no place-bearing world in this run \u2014 a chat-only room, rendered as an informational anchor";
+/** One explicit room to render as an anchor — the generalized replacement for the old single-room `world` shape. */
+export interface BuildRunWorldTraceRoomInput {
+    networkId: string;
+    roomId: string;
+    members?: string[];
+}
+export interface BuildRunWorldTraceParams {
+    runId: string;
+    runName: string;
+    /** Legacy single-room shape, kept for callers that only ever had one anchor. Ignored when `rooms` is given. */
+    world?: {
+        networkId?: string;
+        roomId?: string;
+        members?: string[];
+    };
+    /**
+     * Explicit room list — the parameterization the recursive membrane portal
+     * needs (`docs/VIEW_DESIGN.md` rule 5): the outer map's rooms (every
+     * `manifest.world` room that is NOT some membrane's interior room) and a
+     * membrane's own `interiorRooms` both go through this same param, laid out
+     * side by side (`ROOM_SPACING` apart) rather than stacked at one origin.
+     */
+    rooms?: BuildRunWorldTraceRoomInput[];
+    timeline: RunTimeline;
+}
+export declare const buildRunWorldTrace: ({ runId, runName, world, rooms: roomInputs, timeline }: BuildRunWorldTraceParams) => RunWorldTrace;
+/**
+ * Builds a `viewer.trace.v1` mini-map for every membrane, scoped to exactly
+ * its own `interiorRooms` — the recursive membrane portal's interior map
+ * (`docs/VIEW_DESIGN.md` rule 5, "descend into a mind"). Called once by
+ * `server.ts` after the full `RunTimeline` (interior events included)
+ * exists; membranes with no parseable interior room ref pass through
+ * unchanged rather than throwing (defensive — every membrane
+ * `deriveMembranes` emits today always has at least one, but a future
+ * shape should degrade, not crash the server).
+ */
+export declare const buildMembraneInteriorWorlds: (membranes: readonly RunTimelineMembrane[], timeline: RunTimeline) => RunTimelineMembrane[];
+//# sourceMappingURL=runWorldTrace.d.ts.map

package/dist/view/runWorldTrace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runWorldTrace.d.ts","sourceRoot":"","sources":["../../src/view/runWorldTrace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG9E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,2BAA2B,GACnC,YAAY,GACZ,eAAe,GACf,UAAU,GACV,kBAAkB,GAClB,YAAY,GACZ,aAAa,GACb,OAAO,GACP,OAAO,CAAC;AAEZ,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,2BAA2B,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,YAAY,GAAG,SAAS,GAAG,UAAU,CAAC;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,SAAS,EAAE,KAAK,EAAE,CAAC;IACnB,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC,OAAO,EAAE,KAAK,EAAE,CAAC;CAClB;AAED,eAAO,MAAM,gBAAgB,oGACiE,CAAC;AAW/F,oHAAoH;AACpH,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,+GAA+G;IAC/G,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACpE;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,2BAA2B,EAAE,CAAC;IACtC,QAAQ,EAAE,WAAW,CAAC;CACvB;AAKD,eAAO,MAAM,kBAAkB,GAAI,wDAAwD,wBAAwB,KAAG,aAyDrH,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,GACtC,WAAW,SAAS,mBAAmB,EAAE,EACzC,UAAU,WAAW,KACpB,mBAAmB,EAalB,CAAC"}

package/dist/view/runWorldTrace.js

@@ -0,0 +1,88 @@
+import { parseRoomRef, stripRefPrefix } from "./runTimelineRefs.js";
+export const NO_PLACE_CAPTION = "no place-bearing world in this run — a chat-only room, rendered as an informational anchor";
+const ledgerFactType = (viewClass) => {
+    if (viewClass === "message")
+        return "world.message";
+    if (viewClass === "wake")
+        return "wake.recommended";
+    return "other";
+};
+const provenanceFor = (authority) => authority === "moltnet" || authority === "daimon" ? "agentic" : "mechanical";
+/** Deterministic x-offset between room anchors when more than one room is rendered — presentation only, never fed back into the schema (rule 4). */
+const ROOM_SPACING = 3.2;
+export const buildRunWorldTrace = ({ runId, runName, world, rooms: roomInputs, timeline }) => {
+    const inputs = roomInputs?.length
+        ? roomInputs
+        : [{ networkId: world?.networkId ?? "run", roomId: world?.roomId ?? "run-room", members: world?.members }];
+    const allAgentLabels = timeline.elements.filter((element) => element.kind === "agent").map((element) => element.label);
+    const rooms = inputs.map((input, index) => {
+        // The "fall back to every agent in the timeline" rule only makes sense
+        // for the single-anchor legacy shape; an explicit multi-room list always
+        // states its own membership (an empty interior/outer room legitimately
+        // has no members rather than borrowing every other room's agents).
+        const members = input.members?.length ? input.members : inputs.length === 1 ? allAgentLabels : [];
+        return {
+            id: input.roomId,
+            label: input.roomId,
+            scope: `room:${input.networkId}:${input.roomId}`,
+            members,
+            scene: [index * ROOM_SPACING, 0, 0],
+            access_hint: NO_PLACE_CAPTION,
+        };
+    });
+    const memberIds = new Set(rooms.flatMap((room) => room.members));
+    const agents = [...memberIds].map((id) => ({
+        id,
+        label: id,
+        scope: `agent:${id}`,
+        label_hint: "heuristic",
+        detail: "Placeless chat participant in this run — open its storyline portal for its own timeline.",
+    }));
+    const ledgerFacts = timeline.events.map((event) => ({
+        type: ledgerFactType(event.viewClass),
+        tick: event.t,
+        event_id: event.eventId,
+        kind: event.type,
+        sim_time: event.t,
+        provenance: provenanceFor(event.authority),
+        actor: event.actor ?? event.authority,
+        target: event.subjects[0] ?? "",
+        detail: event.text ?? event.type,
+        scope: event.subjects[0],
+        payload: event.payload,
+    }));
+    return {
+        version: "viewer.trace.v1",
+        run_id: runId,
+        run_name: runName,
+        rooms,
+        corridors: [],
+        agents,
+        presence: [],
+        ledger_facts: ledgerFacts,
+        signals: [],
+    };
+};
+/**
+ * Builds a `viewer.trace.v1` mini-map for every membrane, scoped to exactly
+ * its own `interiorRooms` — the recursive membrane portal's interior map
+ * (`docs/VIEW_DESIGN.md` rule 5, "descend into a mind"). Called once by
+ * `server.ts` after the full `RunTimeline` (interior events included)
+ * exists; membranes with no parseable interior room ref pass through
+ * unchanged rather than throwing (defensive — every membrane
+ * `deriveMembranes` emits today always has at least one, but a future
+ * shape should degrade, not crash the server).
+ */
+export const buildMembraneInteriorWorlds = (membranes, timeline) => membranes.map((membrane) => {
+    const memberIds = membrane.members.map(stripRefPrefix);
+    const rooms = membrane.interiorRooms
+        .map(parseRoomRef)
+        .filter((room) => room !== undefined)
+        .map((room) => ({ ...room, members: memberIds }));
+    if (rooms.length === 0)
+        return membrane;
+    return {
+        ...membrane,
+        interiorWorld: buildRunWorldTrace({ runId: timeline.runId, runName: timeline.runId, rooms, timeline }),
+    };
+});

package/dist/view/server.d.ts

@@ -0,0 +1,12 @@
+export interface ViewerServerConfig {
+    port: number;
+    sourcePath: string;
+    statePath?: string;
+    mode: "live" | "replay";
+}
+export interface ViewerServerHandle {
+    close: () => Promise<void>;
+    url: string;
+}
+export declare const createViewerServer: (config: ViewerServerConfig) => Promise<ViewerServerHandle>;
+//# sourceMappingURL=server.d.ts.map

package/dist/view/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/view/server.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb;AAqPD,eAAO,MAAM,kBAAkB,GAAU,QAAQ,kBAAkB,KAAG,OAAO,CAAC,kBAAkB,CA+F/F,CAAC"}

package/dist/view/server.js

@@ -0,0 +1,306 @@
+import { createServer } from "node:http";
+import { createReadStream, existsSync } from "node:fs";
+import { access, readFile, stat } from "node:fs/promises";
+import { dirname, resolve, relative, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isObserveRunDir } from "./runDetect.js";
+import { buildRunViewModel } from "./runViewModel.js";
+import { buildRunTimeline, readWorldRooms } from "./runTimeline.js";
+import { buildMembraneInteriorWorlds, buildRunWorldTrace } from "./runWorldTrace.js";
+const mimeTypes = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+};
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const webDistRoot = resolve(packageRoot, "web", "dist");
+const webSourceRoot = resolve(packageRoot, "web");
+const webRoot = existsSync(resolve(webDistRoot, "index.html")) ? webDistRoot : webSourceRoot;
+const replayRequiredArtifacts = ["manifest.yaml", "viewer-trace.json"];
+const sendJson = (res, body, status = 200) => {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(body));
+};
+const safeJoin = (base, target) => {
+    const absolute = resolve(base, target);
+    const rel = relative(base, absolute);
+    if (rel.startsWith("..") || rel.includes("../")) {
+        throw new Error("Invalid path");
+    }
+    return absolute;
+};
+const streamFile = async (res, requestedPath) => {
+    try {
+        const path = safeJoin(webRoot, requestedPath);
+        await access(path);
+        const stats = await stat(path);
+        if (stats.isDirectory()) {
+            res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+            res.end("Forbidden");
+            return;
+        }
+        const contentType = mimeTypes[extname(path)] || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": contentType });
+        createReadStream(path).pipe(res);
+    }
+    catch {
+        res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Not found");
+    }
+};
+const sendState = (req, res, config, effectiveMode) => {
+    if (req.url === undefined)
+        return;
+    sendJson(res, {
+        mode: effectiveMode,
+        sourcePath: config.sourcePath,
+        statePath: config.statePath,
+        now: new Date().toISOString(),
+    });
+};
+const sendSkins = (_req, res) => {
+    sendJson(res, {
+        selected: "default",
+        options: [
+            { id: "default", label: "Default (No Skin)" },
+            { id: "office", label: "Office Floor" },
+            { id: "night", label: "Night Shift" },
+        ],
+    });
+};
+const loadViewerTrace = async (path) => {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+};
+const resolveReplayArtifacts = async (basePath) => {
+    const base = resolve(basePath);
+    const missing = await Promise.all(replayRequiredArtifacts.map(async (artifact) => {
+        try {
+            await access(join(base, artifact));
+            return undefined;
+        }
+        catch {
+            return artifact;
+        }
+    }));
+    return missing.filter((artifact) => artifact !== undefined);
+};
+const isViewerTrace = (value) => typeof value === "object" && value !== null;
+const sendWorld = async (_req, res, config) => {
+    const sourcePath = resolve(config.statePath ?? config.sourcePath);
+    if (config.mode === "replay") {
+        const missingArtifacts = await resolveReplayArtifacts(sourcePath);
+        if (missingArtifacts.length > 0) {
+            sendJson(res, {
+                error: "viewer-trace.json requires a sealed replay directory",
+                mode: "replay",
+                source_path: sourcePath,
+                required_artifacts: [...replayRequiredArtifacts],
+                missing_artifacts: missingArtifacts,
+            }, 404);
+            return;
+        }
+    }
+    const trace = await loadViewerTrace(join(sourcePath, "viewer-trace.json"));
+    if (!isViewerTrace(trace)) {
+        sendJson(res, { error: "viewer-trace.json not found" }, 404);
+        return;
+    }
+    sendJson(res, {
+        now: new Date().toISOString(),
+        run_id: trace.run_id,
+        run_name: trace.run_name,
+        trace
+    });
+};
+const maxTraceTick = (trace) => {
+    const facts = Array.isArray(trace?.ledger_facts) ? trace.ledger_facts : [];
+    const presence = Array.isArray(trace?.presence) ? trace.presence : [];
+    return [...facts, ...presence].reduce((max, entry) => {
+        if (typeof entry === "object" && entry !== null && typeof entry.tick === "number") {
+            return Math.max(max, entry.tick);
+        }
+        return max;
+    }, 0);
+};
+const sendEvents = async (_req, res, config) => {
+    const tracePath = join(resolve(config.statePath ?? config.sourcePath), "viewer-trace.json");
+    const trace = await loadViewerTrace(tracePath);
+    const maxTick = Math.max(1, maxTraceTick(trace));
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
+    res.write(": viewer heartbeat stream\n\n");
+    let tick = 0;
+    const pushEvent = (payload) => {
+        res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    };
+    pushEvent({ type: "connected", at: new Date().toISOString() });
+    const timer = setInterval(() => {
+        tick = tick >= maxTick ? 0 : tick + 1;
+        pushEvent({
+            type: "sim.tick",
+            tick,
+            at: new Date().toISOString(),
+            message: `tick ${tick}`,
+        });
+    }, 2500);
+    const cleanup = () => {
+        clearInterval(timer);
+    };
+    res.on("close", cleanup);
+};
+/**
+ * `simfile view <dir>` picks run-replay mode over the world/3D replay mode
+ * purely from the run directory's shape: a sealed compose-and-observe run
+ * directory (`manifest.json` @ `simfile.run-manifest.v1` +
+ * `raw/moltnet/transcript.json`, see `runDetect.ts`) never has `--state`
+ * set, so this only applies in replay mode. Built once at server start (the
+ * run directory is sealed, not tailed) rather than per-request. Run-replay
+ * mode serves the same React shell as world/live mode, fed by
+ * `/api/timeline`, the `runWorldTrace` adapter's `/api/world`, and
+ * `/api/run-meta` (verdict + provenance, reusing `computeVerdict`/
+ * `computeProvenance` from `runViewModelCompute.ts` unchanged; increment 3
+ * additionally carries `seedSpread`/`spreadSummary`/`variableSamples` when
+ * the run has them). The bespoke
+ * run-reader page (`runPage.ts`/`runPageScript.ts`/`runPageStyles.ts`) and
+ * its `/api/run-view-model.json` endpoint are retired as of increment 2: the
+ * React shell now renders verdict/provenance at parity, so `GET
+ * /api/run-view-model.json` 404s (falls through to the static-asset
+ * handler, same as any other unknown path).
+ */
+const loadRunReplay = async (config) => {
+    if (config.mode !== "replay" || config.statePath)
+        return null;
+    const runDir = resolve(config.sourcePath);
+    if (!(await isObserveRunDir(runDir)))
+        return null;
+    const [model, timeline, worldRooms] = await Promise.all([
+        buildRunViewModel(runDir),
+        buildRunTimeline(runDir),
+        readWorldRooms(runDir),
+    ]);
+    // The outer map renders every declared room that is NOT some membrane's own
+    // interior council room — for a recursive-psyche run that is the parent
+    // floor (`commons`) alone; for a flat run (no membranes) it is every room
+    // the manifest declares, unchanged from before this parameterization
+    // (`runWorldTrace.ts`'s `rooms` param, `docs/VIEW_DESIGN.md` rule 5).
+    const interiorRoomRefs = new Set(timeline.membranes?.flatMap((membrane) => membrane.interiorRooms) ?? []);
+    const outerRooms = worldRooms.filter((room) => !interiorRoomRefs.has(room.ref));
+    const world = buildRunWorldTrace({
+        runId: model.runId,
+        runName: model.runId,
+        world: model.world,
+        rooms: outerRooms.map((room) => ({ networkId: room.networkId, roomId: room.roomId, members: room.members })),
+        timeline,
+    });
+    // Each membrane's own "descend into a mind" mini map — populated here,
+    // once the full timeline (interior events included) exists; `deriveMembranes`
+    // itself never sees a completed `RunTimeline` (increment's ordering: the
+    // report-derived membrane shape comes first, the interior world trace after).
+    const timelineWithInteriorWorlds = {
+        ...timeline,
+        membranes: buildMembraneInteriorWorlds(timeline.membranes ?? [], timeline),
+    };
+    return { model, timeline: timelineWithInteriorWorlds, world };
+};
+export const createViewerServer = async (config) => {
+    const runReplay = await loadRunReplay(config);
+    const server = createServer(async (req, res) => {
+        const path = req.url?.split("?")[0] ?? "/";
+        if (path === "/api/state") {
+            sendState(req, res, config, runReplay ? "run-replay" : config.mode);
+            return;
+        }
+        if (path === "/api/skins") {
+            sendSkins(req, res);
+            return;
+        }
+        if (runReplay) {
+            if (path === "/api/timeline") {
+                sendJson(res, runReplay.timeline);
+                return;
+            }
+            if (path === "/api/world") {
+                sendJson(res, {
+                    now: new Date().toISOString(),
+                    run_id: runReplay.world.run_id,
+                    run_name: runReplay.world.run_name,
+                    trace: runReplay.world,
+                });
+                return;
+            }
+            if (path === "/api/run-meta") {
+                sendJson(res, {
+                    runId: runReplay.model.runId,
+                    verdict: runReplay.model.verdict,
+                    provenance: runReplay.model.provenance,
+                    // Honesty-critical disclosure (never omitted): scripted vs
+                    // real-engine vs mixed vs unknown, badged unmissably by the
+                    // React shell's topbar (`EngineProvenanceBadge`).
+                    engineProvenance: runReplay.model.engineProvenance,
+                    // Passthrough context for the spread readout's "reach/total"
+                    // denominator (never spread math itself — that stays in
+                    // `spreadSummary`, computed once by `computeSeedSpread`).
+                    participants: runReplay.model.participants,
+                    // Increment 3: undefined on a run with no `manifest.seed_declaration`
+                    // (JSON.stringify drops an undefined-valued key outright — the
+                    // React shell's graceful-absence path, not an empty array/object).
+                    seedSpread: runReplay.model.seedSpread,
+                    spreadSummary: runReplay.model.spreadSummary,
+                    variableSamples: runReplay.model.variableSamples,
+                });
+                return;
+            }
+            // No `/api/events`: run-replay's cursor is scrubbed by the client
+            // store, never a live/synthetic tick that would fight it.
+            // No `/api/run-view-model.json`: retired in increment 2 — the React
+            // shell's `RunMetaPanels` renders `/api/run-meta` (a subset of the
+            // same computed model) instead of the bespoke `runPage.ts` page.
+        }
+        else {
+            if (path === "/api/world") {
+                await sendWorld(req, res, config);
+                return;
+            }
+            if (path === "/api/events") {
+                await sendEvents(req, res, config);
+                return;
+            }
+        }
+        const assetPath = path === "/" || path === "/index.html" ? "index.html" : path.replace(/^\//, "");
+        await streamFile(res, assetPath);
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(config.port, "127.0.0.1", () => resolve());
+        server.once("error", reject);
+    });
+    const address = server.address();
+    if (address === null || address === ":0" || typeof address === "string") {
+        throw new Error("Unable to bind viewer server");
+    }
+    return {
+        close: () => new Promise((resolveClose, rejectClose) => {
+            server.close((error) => {
+                if (error) {
+                    rejectClose(error);
+                    return;
+                }
+                resolveClose();
+            });
+        }),
+        url: `http://127.0.0.1:${address.port}`,
+    };
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "simfile",
+  "version": "0.0.1",
+  "description": "Declarative simulation world mechanics for agentic organizations.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "simfile": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "web/dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/noopolis/simfile.git"
+  },
+  "scripts": {
+    "build": "rm -rf dist web/dist && tsc --project tsconfig.build.json && npm run build:web && chmod +x dist/cli/index.js",
+    "build:web": "vite build --config web/vite.config.ts",
+    "build:website": "npm --prefix website run build",
+    "clean": "rm -rf dist web/dist",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test",
+    "typecheck": "tsc --project tsconfig.json --noEmit && tsc --project tsconfig.web.json --noEmit",
+    "test": "node --import tsx --test \"src/**/*.test.ts\" \"web/src/**/*.test.ts\"",
+    "coverage:render": "node --import tsx scripts/render-coverage.ts",
+    "emit-causal-fixture": "tsx src/runtime/emit-causal-fixture.ts"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@noopolis/stele": "^0.0.1",
+    "yaml": "^2.8.2",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@glyphcss/core": "^0.1.0",
+    "@glyphcss/react": "^0.1.0",
+    "@types/node": "^24.12.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.4",
+    "glyphcss": "^0.1.0",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^6.0.0"
+  }
+}