simfile 0.0.1

package/dist/schema/model.js

@@ -0,0 +1,222 @@
+import { z } from "zod";
+const identifierPattern = "[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*";
+export const simfileIdentifierSchema = z.string().regex(new RegExp(`^${identifierPattern}$`), {
+    message: "expected lowercase identifier with letters, numbers, dashes, or underscores"
+});
+const simfileDurationSchema = z.string().regex(/^(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:ms|s|m|h|d|w)$/u, {
+    message: "expected duration string (e.g. 20s, 1.5m, 2h)"
+});
+export const simfileRangeSchema = z.string().regex(new RegExp(`^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?\\.\\.-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?$`), { message: "expected range string like 0..1" }).superRefine((value, context) => {
+    const [start, end] = value.split("..");
+    if (Number.parseFloat(start) >= Number.parseFloat(end)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "range lower bound must be less than upper bound",
+            path: []
+        });
+    }
+});
+const scopeAgentPattern = new RegExp(`^agent:${identifierPattern}$`);
+const scopeTeamPattern = new RegExp(`^team:${identifierPattern}$`);
+const scopeRoomPattern = new RegExp(`^room:${identifierPattern}:${identifierPattern}$`);
+const scopePairPattern = new RegExp(`^pair:${identifierPattern}:${identifierPattern}$`);
+const simfileRoomScopeSchema = z.string().regex(scopeRoomPattern, {
+    message: "expected room scope (room:<network>:<room>)"
+});
+const simfileAgentScopeSchema = z.string().regex(scopeAgentPattern, {
+    message: "expected agent scope (agent:<id>)"
+});
+const simfileScopeSchema = z.string().refine((value) => {
+    return value === "global"
+        || scopeAgentPattern.test(value)
+        || scopeTeamPattern.test(value)
+        || scopeRoomPattern.test(value)
+        || scopePairPattern.test(value);
+}, {
+    message: "expected scope string global | agent:<id> | room:<network>:<room> | team:<id> | pair:<a>:<b>"
+});
+export const simfileEventKinds = [
+    "clock.sync",
+    "rule.fired",
+    "world.message",
+    "world.dm",
+    "world.act",
+    "wake.recommended",
+    "marker.seen"
+];
+const simfileEventKindSchema = z.enum(simfileEventKinds);
+const simfileWhenLeafSchema = z.union([
+    z.object({
+        variable: simfileIdentifierSchema,
+        above: z.number().optional(),
+        below: z.number().optional(),
+        for: simfileDurationSchema.optional()
+    }).strict().refine((value) => value.above !== undefined || value.below !== undefined, {
+        message: "variable condition requires above and/or below"
+    }),
+    z.object({
+        phase: simfileIdentifierSchema
+    }).strict(),
+    z.object({
+        event: simfileEventKindSchema,
+        target: z.string().optional(),
+        actor: z.string().optional(),
+        scope: simfileScopeSchema.optional()
+    }).strict()
+]);
+export const simfileWhenSchema = z.lazy(() => z.union([
+    simfileWhenLeafSchema,
+    z.object({
+        all: z.array(simfileWhenSchema).min(1)
+    }).strict(),
+    z.object({
+        any: z.array(simfileWhenSchema).min(1)
+    }).strict(),
+    z.object({
+        not: simfileWhenSchema
+    }).strict()
+]));
+export const simfileClockSchema = z.object({
+    seed: z.string().min(1),
+    tick: simfileDurationSchema,
+    sim_per_tick: simfileDurationSchema.optional(),
+    phases: z.record(simfileIdentifierSchema, z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/u)).default({})
+}).strict();
+const simfileMeasureSchema = z.object({
+    kind: z.enum(["messages_in", "token_mentions", "marker_violations", "distinct_speakers", "mentions_of", "ticks_since_last_message"]),
+    scope: simfileScopeSchema.optional(),
+    window: simfileDurationSchema
+}).strict();
+const simfileDerivedSchema = z.object({
+    eq: z.string().min(1)
+}).strict();
+const simfileVariableSchema = z.object({
+    scope: simfileScopeSchema,
+    initial: z.number().optional(),
+    range: simfileRangeSchema,
+    measure: simfileMeasureSchema.optional(),
+    derive: simfileDerivedSchema.optional(),
+    fed_by: simfileIdentifierSchema.optional()
+}).refine((value) => {
+    const sourceCount = Number(value.measure !== undefined) + Number(value.derive !== undefined) + Number(value.fed_by !== undefined);
+    return sourceCount <= 1;
+}, {
+    message: "variables must use at most one of measure, derive, or fed_by"
+}).strict();
+const simfileGeneratorDeterministicSchema = z.object({
+    kind: z.literal("deterministic"),
+    when: simfileWhenSchema.optional(),
+    variable: simfileIdentifierSchema,
+    delta: z.number().optional(),
+    delta_eq: z.string().optional(),
+    set_eq: z.string().optional()
+}).refine((value) => {
+    const writerCount = Number(value.delta !== undefined) + Number(value.delta_eq !== undefined) + Number(value.set_eq !== undefined);
+    return writerCount === 1;
+}, {
+    message: "deterministic generators require exactly one of delta, delta_eq, or set_eq"
+}).strict();
+const simfileGeneratorStochasticSchema = z.object({
+    kind: z.literal("stochastic"),
+    when: simfileWhenSchema.optional(),
+    variable: simfileIdentifierSchema,
+    uniform: z.tuple([z.number(), z.number()])
+}).strict();
+export const simfileGeneratorSchema = z.union([
+    simfileGeneratorDeterministicSchema,
+    simfileGeneratorStochasticSchema
+]);
+export const simfileRuleActionSchema = z.union([
+    z.object({
+        action: z.literal("moltnet:message"),
+        to: simfileRoomScopeSchema,
+        content: z.string().min(1)
+    }).strict(),
+    z.object({
+        action: z.literal("moltnet:dm"),
+        to: simfileAgentScopeSchema,
+        content: z.string().min(1)
+    }).strict(),
+    z.object({
+        action: z.literal("wake:recommend"),
+        to: simfileRoomScopeSchema
+    }).strict(),
+    z.object({
+        action: z.literal("variable:set"),
+        variable: simfileIdentifierSchema,
+        value: z.number()
+    }).strict(),
+    z.object({
+        action: z.literal("variable:delta"),
+        variable: simfileIdentifierSchema,
+        value: z.number()
+    }).strict()
+]);
+export const simfileRuleSchema = z.object({
+    fire: z.enum(["once", "per_crossing"]).default("per_crossing"),
+    when: simfileWhenSchema,
+    do: z.array(simfileRuleActionSchema).min(1)
+}).strict();
+export const simfileLedgerSchema = z.object({
+    store: z.object({
+        kind: z.enum(["jsonl", "sqlite", "postgres"]).default("jsonl"),
+        path: z.string().min(1).optional()
+    }).strict()
+}).strict();
+export const simfileTelemetrySchema = z.object({
+    snapshot_every: z.number().int().positive().optional()
+}).strict();
+export const simfileMarkerSchema = z.object({
+    text: z.array(z.string().min(1)).optional(),
+    mode: z.enum(["containment", "propagation"]),
+    scopes: z.array(simfileScopeSchema).min(1)
+}).strict();
+const simfileProbeExpectationSchema = z.union([
+    z.object({ at_least: z.number().int().nonnegative() }).strict(),
+    z.object({ at_most: z.number().int().nonnegative() }).strict(),
+    z.object({ always: z.literal(true) }).strict(),
+    z.object({ at_end: z.literal(true) }).strict()
+]).superRefine((expectation, context) => {
+    const keys = Object.keys(expectation);
+    if (keys.length !== 1) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "expect must contain one of at_least, at_most, always, or at_end",
+            path: []
+        });
+    }
+});
+export const simfileProbeSchema = z.object({
+    when: simfileWhenSchema,
+    expect: simfileProbeExpectationSchema,
+    after: simfileWhenSchema.optional(),
+    within: simfileDurationSchema.optional()
+}).superRefine((value, context) => {
+    if (value.within !== undefined && value.after === undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "within requires after",
+            path: ["within"]
+        });
+    }
+    if (value.after !== undefined && value.within === undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "after requires within",
+            path: ["after"]
+        });
+    }
+}).strict();
+export const simfileSchema = z.object({
+    simfile_version: z.literal("0.1"),
+    name: simfileIdentifierSchema,
+    spawnfile: z.string().optional(),
+    clock: simfileClockSchema,
+    variables: z.record(simfileIdentifierSchema, simfileVariableSchema).default({}),
+    generators: z.record(simfileIdentifierSchema, simfileGeneratorSchema).default({}),
+    rules: z.record(simfileIdentifierSchema, simfileRuleSchema).default({}),
+    ledger: simfileLedgerSchema.optional(),
+    telemetry: simfileTelemetrySchema.optional(),
+    markers: z.record(simfileIdentifierSchema, simfileMarkerSchema).default({}),
+    probes: z.record(simfileIdentifierSchema, simfileProbeSchema).default({})
+}).strict();

package/dist/schema/parse.d.ts

@@ -0,0 +1,10 @@
+import { type Simfile } from "./model.js";
+export interface ParseSimfileOptions {
+    path?: string;
+}
+export interface ParseSimfileResult {
+    simfile: Simfile;
+    warnings: string[];
+}
+export declare const parseSimfileSource: (source: string, options?: ParseSimfileOptions) => ParseSimfileResult;
+//# sourceMappingURL=parse.d.ts.map

package/dist/schema/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/schema/parse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAGzD,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAUD,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,MAAM,EACd,UAAS,mBAAwB,KAChC,kBAKF,CAAC"}

package/dist/schema/parse.js

@@ -0,0 +1,15 @@
+import YAML from "yaml";
+import { simfileSchema } from "./model.js";
+import { validateSimfileSemantics } from "./semantic.js";
+const parseRawDocument = (source, path) => {
+    if (path?.endsWith(".json")) {
+        return JSON.parse(source);
+    }
+    return YAML.parse(source);
+};
+export const parseSimfileSource = (source, options = {}) => {
+    const raw = parseRawDocument(source, options.path);
+    const simfile = simfileSchema.parse(raw);
+    const warnings = validateSimfileSemantics(simfile);
+    return { simfile, warnings };
+};

package/dist/schema/semantic.d.ts

@@ -0,0 +1,3 @@
+import { type Simfile } from "./model.js";
+export declare const validateSimfileSemantics: (simfile: Simfile) => string[];
+//# sourceMappingURL=semantic.d.ts.map

package/dist/schema/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../src/schema/semantic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAsG7D,eAAO,MAAM,wBAAwB,GAAI,SAAS,OAAO,KAAG,MAAM,EA6DjE,CAAC"}

package/dist/schema/semantic.js

@@ -0,0 +1,135 @@
+import { simfileEventKinds } from "./model.js";
+const EXPRESSION_IDENTIFIER_PATTERN = /[a-zA-Z_][a-zA-Z0-9_-]*/gu;
+const PLACEHOLDER_PATTERN = /\{([a-z][a-z0-9_-]*)\}/gu;
+const RESERVED_EXPRESSION_NAMES = new Set(["abs", "ceil", "clamp", "cos", "e", "exp", "floor", "lerp", "log", "max", "min", "mod", "pi", "pow", "sin", "smoothstep", "sqrt", "step", "t", "tick"]);
+const SIMFILE_EVENT_KIND_SET = new Set(simfileEventKinds);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringValue = (value) => typeof value === "string" ? value : undefined;
+const validateWhenNode = (node, location, variableIds, phaseIds) => {
+    if (!isRecord(node)) {
+        throw new Error(`${location} must be a condition object`);
+    }
+    if ("all" in node) {
+        if (!Array.isArray(node.all))
+            throw new Error(`${location}.all must be a list`);
+        node.all.forEach((child) => validateWhenNode(child, location, variableIds, phaseIds));
+        return;
+    }
+    if ("any" in node) {
+        if (!Array.isArray(node.any))
+            throw new Error(`${location}.any must be a list`);
+        node.any.forEach((child) => validateWhenNode(child, location, variableIds, phaseIds));
+        return;
+    }
+    if ("not" in node) {
+        validateWhenNode(node.not, location, variableIds, phaseIds);
+        return;
+    }
+    if ("variable" in node) {
+        const variableId = stringValue(node.variable);
+        if (variableId === undefined || !variableIds.has(variableId)) {
+            throw new Error(`${location} references unknown variable ${String(node.variable)}`);
+        }
+        return;
+    }
+    if ("phase" in node) {
+        const phaseId = stringValue(node.phase);
+        if (phaseId === undefined || !phaseIds.has(phaseId)) {
+            throw new Error(`${location} references unknown phase ${String(node.phase)}`);
+        }
+        return;
+    }
+    if ("event" in node) {
+        const eventKind = stringValue(node.event);
+        if (eventKind === undefined || !SIMFILE_EVENT_KIND_SET.has(eventKind)) {
+            throw new Error(`${location} references unknown event ${String(node.event)}`);
+        }
+    }
+};
+const validatePlaceholders = (content, location, variableIds) => {
+    for (const match of content.matchAll(PLACEHOLDER_PATTERN)) {
+        const variableId = match[1];
+        if (!variableIds.has(variableId)) {
+            throw new Error(`${location} placeholder references unknown variable ${variableId}`);
+        }
+    }
+};
+const expressionDependencies = (expression) => {
+    const dependencies = new Set();
+    for (const match of expression.matchAll(EXPRESSION_IDENTIFIER_PATTERN)) {
+        const name = match[0];
+        const index = match.index ?? 0;
+        const previous = expression[index - 1] ?? "";
+        if (/[0-9.]/u.test(previous)) {
+            continue;
+        }
+        const suffix = expression.slice(index + name.length).trimStart();
+        if (RESERVED_EXPRESSION_NAMES.has(name) || suffix.startsWith("(")) {
+            continue;
+        }
+        dependencies.add(name);
+    }
+    return [...dependencies];
+};
+const validateExpressionDependencies = (expression, location, variableIds) => {
+    expressionDependencies(expression).forEach((dependency) => {
+        if (!variableIds.has(dependency)) {
+            throw new Error(`${location} references unknown variable ${dependency}`);
+        }
+    });
+};
+export const validateSimfileSemantics = (simfile) => {
+    const warnings = [];
+    const variableIds = new Set(Object.keys(simfile.variables));
+    const phaseIds = new Set(Object.keys(simfile.clock.phases));
+    const fedVariableIds = new Set(Object.entries(simfile.variables)
+        .filter(([, variable]) => variable.fed_by !== undefined)
+        .map(([variableId]) => variableId));
+    for (const [variableId, variable] of Object.entries(simfile.variables)) {
+        if (variable.derive) {
+            validateExpressionDependencies(variable.derive.eq, `variable ${variableId} derive.eq`, variableIds);
+        }
+    }
+    for (const [generatorId, generator] of Object.entries(simfile.generators)) {
+        if (!variableIds.has(generator.variable)) {
+            throw new Error(`generator ${generatorId} references unknown variable ${generator.variable}`);
+        }
+        if (fedVariableIds.has(generator.variable)) {
+            throw new Error(`generator ${generatorId} targets fed variable ${generator.variable}; fed variables have exactly one writer (fed_by)`);
+        }
+        if (generator.when) {
+            validateWhenNode(generator.when, `generator ${generatorId} when`, variableIds, phaseIds);
+        }
+        if (generator.kind === "deterministic") {
+            if (generator.delta_eq) {
+                validateExpressionDependencies(generator.delta_eq, `generator ${generatorId} delta_eq`, variableIds);
+            }
+            if (generator.set_eq) {
+                validateExpressionDependencies(generator.set_eq, `generator ${generatorId} set_eq`, variableIds);
+            }
+        }
+    }
+    for (const [ruleId, rule] of Object.entries(simfile.rules)) {
+        validateWhenNode(rule.when, `rule ${ruleId} when`, variableIds, phaseIds);
+        for (const action of rule.do) {
+            if ((action.action === "variable:set" || action.action === "variable:delta")
+                && !variableIds.has(action.variable)) {
+                throw new Error(`rule ${ruleId} action ${action.action} references unknown variable ${action.variable}`);
+            }
+            if ((action.action === "variable:set" || action.action === "variable:delta")
+                && fedVariableIds.has(action.variable)) {
+                throw new Error(`rule ${ruleId} action ${action.action} targets fed variable ${action.variable}; fed variables have exactly one writer (fed_by)`);
+            }
+            if ("content" in action) {
+                validatePlaceholders(action.content, `rule ${ruleId} action ${action.action}`, variableIds);
+            }
+        }
+    }
+    for (const [probeId, probe] of Object.entries(simfile.probes)) {
+        validateWhenNode(probe.when, `probe ${probeId} when`, variableIds, phaseIds);
+        if (probe.after) {
+            validateWhenNode(probe.after, `probe ${probeId} after`, variableIds, phaseIds);
+        }
+    }
+    return warnings;
+};

package/dist/sims/composeRunManifest.d.ts

@@ -0,0 +1,54 @@
+import { type RunManifestArtifactEntry, type SeedDeclaration, type SimfileRunManifest } from "../observe/manifest.js";
+export declare const sha256HexOfBuffer: (buffer: Buffer) => string;
+/** A type alias (not an interface) so it stays assignable to the manifest's
+ * genre-neutral `Record<string, unknown>` world slot. */
+export type ComposeRunManifestWorld = {
+    network_id: string;
+    room_id: string;
+    members: string[];
+};
+export interface ComposeRunManifestInput {
+    runId: string;
+    /** ISO 8601 timestamp, passed in rather than generated here so the
+     * composer stays a pure function of its arguments (deterministic, no
+     * hidden `Date.now()` read). */
+    createdAt: string;
+    /** `spawnfile.up-receipt.v1`'s fingerprint, when available. */
+    fingerprint?: string | null;
+    /** Disclosed engine kind (Piece 5) — this composed office-sim always runs
+     * every agent on the `scripted` engine, so callers pass a single string
+     * (e.g. derived by collapsing the up-receipt's `engines[]` to its one
+     * distinct value). */
+    engine: string;
+    /**
+     * The run's declared world. A single-network run passes a
+     * `ComposeRunManifestWorld` (`{network_id, room_id, members}`); a
+     * multi-network composed run (the jungian psyche) passes `{rooms: [...]}`.
+     * Stored verbatim on the manifest (the schema's `world` is genre-neutral
+     * free-form), so either shape is accepted.
+     */
+    world: Record<string, unknown>;
+    /** `{path, sha256}` entries folded straight from `spawnfile artifacts
+     * export --json`'s `index.files` (per that contract's own docstring: "so
+     * a future `simfile.run-manifest.v1` can fold `files` straight into its
+     * own `artifacts` array ... without re-deriving anything"). */
+    exportedArtifacts: readonly RunManifestArtifactEntry[];
+    /** Artifacts this driver itself writes after export (e.g.
+     * `raw/moltnet/transcript.json`), each already hashed by the caller. */
+    extraArtifacts?: readonly RunManifestArtifactEntry[];
+    /** Decision-13 ground truth for a doc-seeded memetics secret (memetics
+     * increment (a) — the world-driven driver). Omitted for a plain office-sim
+     * run, which has no seeded secret. */
+    seedDeclaration?: SeedDeclaration;
+}
+/**
+ * Writes `simfile.run-manifest.v1` for a composed run (Piece 5 step 3's
+ * "writes `manifest.json` LAST" driver step). Pure and deterministic given
+ * its inputs: no filesystem, no clock read, no network — artifact hashing
+ * happens before this is called, and `createdAt` is threaded in rather than
+ * generated here. Artifacts are sorted by path for a stable byte-identical
+ * manifest across two structurally-identical runs (the parity gate's
+ * determinism check).
+ */
+export declare const composeRunManifest: (input: ComposeRunManifestInput) => SimfileRunManifest;
+//# sourceMappingURL=composeRunManifest.d.ts.map

package/dist/sims/composeRunManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeRunManifest.d.ts","sourceRoot":"","sources":["../../src/sims/composeRunManifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAahC,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,KAAG,MAA2D,CAAC;AAE/G;yDACyD;AACzD,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd;;oCAEgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;0BAGsB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B;;;mEAG+D;IAC/D,iBAAiB,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACvD;4EACwE;IACxE,cAAc,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACrD;;0CAEsC;IACtC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,uBAAuB,KAAG,kBAkBnE,CAAC"}

package/dist/sims/composeRunManifest.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+import { RUN_MANIFEST_VERSION } from "../observe/manifest.js";
+import { OBSERVE_REPORT_VERSION } from "../observe/report.js";
+/** The one fixed `contract_versions` map every composed run stamps —
+ * mirrors the golden fixture's manifest.json exactly (same three keys, same
+ * literal `causal-event.v1` value) so a composed run and the golden capture
+ * are structurally comparable. */
+const CONTRACT_VERSIONS = {
+    "causal-event.v1": "noopolis.causal-event.v1",
+    "simfile.observe.v1": OBSERVE_REPORT_VERSION,
+    "simfile.run-manifest.v1": RUN_MANIFEST_VERSION
+};
+export const sha256HexOfBuffer = (buffer) => createHash("sha256").update(buffer).digest("hex");
+/**
+ * Writes `simfile.run-manifest.v1` for a composed run (Piece 5 step 3's
+ * "writes `manifest.json` LAST" driver step). Pure and deterministic given
+ * its inputs: no filesystem, no clock read, no network — artifact hashing
+ * happens before this is called, and `createdAt` is threaded in rather than
+ * generated here. Artifacts are sorted by path for a stable byte-identical
+ * manifest across two structurally-identical runs (the parity gate's
+ * determinism check).
+ */
+export const composeRunManifest = (input) => {
+    const artifacts = [...input.exportedArtifacts, ...(input.extraArtifacts ?? [])]
+        .map((artifact) => ({ path: artifact.path, sha256: artifact.sha256 }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        version: RUN_MANIFEST_VERSION,
+        run_id: input.runId,
+        created_at: input.createdAt,
+        contract_versions: CONTRACT_VERSIONS,
+        ...(input.fingerprint ? { spawnfile: { fingerprint: input.fingerprint } } : {}),
+        artifacts,
+        engine: input.engine,
+        ...(input.seedDeclaration ? { seed_declaration: input.seedDeclaration } : {}),
+        // `SimfileRunManifest.world` is a free-form `Record<string, unknown>`
+        // (genre-neutral schema); the driver's world shape is stored verbatim.
+        world: input.world
+    };
+};

package/dist/sims/composedJungianSimDriver.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The MULTI-NETWORK composed-run driver: the jungian psyche generalization of
+ * `composedOfficeSimDriver.ts`. It runs a recursive Spawnfile org — a psyche
+ * floor whose members are self-teams, each owning its OWN inner Moltnet council
+ * network — as one composed sim, then assembles a run-dir `simfile observe`
+ * reconciles and `simfile view` descends into. Same charter as the office
+ * driver: shells `spawnfile up/artifacts export/down --json` only, seeds the
+ * floor exactly ONCE, and every other step is a read-only poll. The interior
+ * deliberation (representative -> inner council -> back to the floor) is driven
+ * entirely by the agents' own wake-across-membranes plumbing, never coaxed
+ * here.
+ */
+export interface RunComposedJungianSimOptions {
+    spawnfileBin: string;
+    /** Path to the composed jungian org (`fixtures/sims/jungian-daimon-org/org`). */
+    orgPath: string;
+    containerName: string;
+    deploymentName: string;
+    /** Scratch dir for spawnfile's compile output + deployment record — the compile report is read from here. */
+    compiledOutputDirectory: string;
+    /** Parent directory under which `runs/<run_id>/` is assembled. */
+    runsRootDirectory: string;
+    /** The floor network the operator seed is posted into. */
+    seedNetworkId?: string;
+    seedRoomId?: string;
+    /** The representative agent the seed @mentions to wake it. */
+    seedTargetAgentId?: string;
+    seedMessageText?: string;
+    /** Substring the representative's floor-facing SYNTHESIS carries — the run's completion gate. */
+    synthesisMarker?: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    removeVolumesOnDown?: boolean;
+    now?: () => Date;
+}
+export interface RunComposedJungianSimResult {
+    runDir: string;
+    runId: string;
+    /** The representative's floor-facing synthesis message text (proof the whole membrane chain closed). */
+    synthesis: string;
+}
+/**
+ * Runs the composed jungian psyche end to end: up -> poll every network ready
+ * -> seed the floor ONCE -> wait for the representative's synthesis to reappear
+ * on the floor (proof the interior council deliberated and answered across the
+ * membrane) -> export per-network transcripts + causal artifacts + the compile
+ * report -> down -> write `manifest.json` (with `world.rooms[]`) LAST.
+ */
+export declare const runComposedJungianSim: (options: RunComposedJungianSimOptions) => Promise<RunComposedJungianSimResult>;
+//# sourceMappingURL=composedJungianSimDriver.d.ts.map

package/dist/sims/composedJungianSimDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composedJungianSimDriver.d.ts","sourceRoot":"","sources":["../../src/sims/composedJungianSimDriver.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,6GAA6G;IAC7G,uBAAuB,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iGAAiG;IACjG,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,wGAAwG;IACxG,SAAS,EAAE,MAAM,CAAC;CACnB;AAsHD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,4BAA4B,KACpC,OAAO,CAAC,2BAA2B,CA2GrC,CAAC"}