spawnfile 0.1.12 → 0.1.14

package/dist/dev/index.js

@@ -0,0 +1,2 @@
+export * from "./activity.js";
+export * from "./project.js";

package/dist/dev/project.d.ts

@@ -0,0 +1,35 @@
+import { type UpProjectOptions, type UpProjectResult } from "../compiler/index.js";
+import { type DeploymentRecord } from "../deployment/index.js";
+import { type DevExecFile } from "./docker.js";
+export declare const PI_CONTROL_URL = "http://127.0.0.1:19690";
+export interface DevProjectOptions {
+    deploymentName?: string;
+    dockerCommand?: string;
+    outputDirectory?: string;
+}
+export interface DevApplyProjectOptions extends DevProjectOptions {
+    agent: string;
+    execFile?: DevExecFile;
+    restart?: boolean;
+}
+export interface DevApplyProjectResult {
+    agentId: string;
+    bridgeStarted: boolean;
+    containerName: string;
+    deploymentName: string;
+    existingAgent: boolean;
+    outputDirectory: string;
+}
+export interface DevStopProjectResult {
+    containerName: string;
+    deploymentName: string;
+    outputDirectory: string;
+}
+export declare const resolveDevOutputDirectory: (inputPath: string, outputDirectory?: string) => Promise<string>;
+export declare const devUpProject: (inputPath: string, options?: UpProjectOptions) => Promise<UpProjectResult>;
+export declare const selectDeploymentRecord: (outputDirectory: string, deploymentName?: string) => Promise<DeploymentRecord>;
+export declare const devApplyProject: (inputPath: string, options: DevApplyProjectOptions) => Promise<DevApplyProjectResult>;
+export declare const devRestartProject: (inputPath: string, options: DevApplyProjectOptions) => Promise<DevApplyProjectResult>;
+export declare const devStopProject: (inputPath: string, options?: DevProjectOptions & {
+    execFile?: DevExecFile;
+}) => Promise<DevStopProjectResult>;

package/dist/dev/project.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { buildCompilePlan, upProject } from "../compiler/index.js";
+import { listDeploymentRecords, normalizeDeploymentName } from "../deployment/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { chownContainerPaths, compileForDevApply, copyIntoContainer, defaultExecFile, dockerArgsForRecord, ensureContainerDirectories, firstContainerName, runDocker } from "./docker.js";
+const DEV_OUTPUT_DIRECTORY = ".spawn-dev";
+export const PI_CONTROL_URL = "http://127.0.0.1:19690";
+export const resolveDevOutputDirectory = async (inputPath, outputDirectory) => {
+    if (outputDirectory) {
+        return path.resolve(outputDirectory);
+    }
+    const plan = await buildCompilePlan(inputPath);
+    return path.join(path.dirname(plan.root), DEV_OUTPUT_DIRECTORY);
+};
+export const devUpProject = async (inputPath, options = {}) => upProject(inputPath, {
+    ...options,
+    detach: true,
+    outputDirectory: await resolveDevOutputDirectory(inputPath, options.outputDirectory)
+});
+export const selectDeploymentRecord = async (outputDirectory, deploymentName) => {
+    const records = await listDeploymentRecords(outputDirectory);
+    if (records.length === 0) {
+        throw new SpawnfileError("validation_error", `No dev deployment records found in ${outputDirectory}; run spawnfile dev up first`);
+    }
+    if (deploymentName) {
+        const normalized = normalizeDeploymentName(deploymentName);
+        const selected = records.find((entry) => entry.record.name === normalized);
+        if (!selected) {
+            throw new SpawnfileError("validation_error", `Unknown dev deployment "${normalized}". Valid deployments: ${records.map((entry) => entry.record.name).join(", ")}`);
+        }
+        return selected.record;
+    }
+    if (records.length > 1) {
+        throw new SpawnfileError("validation_error", `--deployment is required: ${records.map((entry) => entry.record.name).join(", ")}`);
+    }
+    return records[0].record;
+};
+const readJson = async (filePath) => JSON.parse(await readFile(filePath, "utf8"));
+const rootfsPath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", containerPath.replace(/^\/+/u, ""));
+const matchesAgent = (agent, input) => agent.slug === input || agent.id === input || agent.name === input || agent.id === `agent:${input}`;
+const selectPiAgent = async (compileResult, agentInput) => {
+    const instance = compileResult.report.container?.runtime_instances.find((candidate) => candidate.id === "pi-app" && ["daimon", "pi"].includes(candidate.runtime));
+    if (!instance?.config_path || !instance.workspace_path || !instance.home_path) {
+        throw new SpawnfileError("runtime_error", "Compiled output does not contain a generated Daimon runtime instance");
+    }
+    const configPath = rootfsPath(compileResult.outputDirectory, instance.config_path);
+    const config = await readJson(configPath);
+    const agent = (config.agents ?? []).find((candidate) => matchesAgent(candidate, agentInput));
+    if (!agent) {
+        throw new SpawnfileError("validation_error", `Daimon agent "${agentInput}" was not found in compiled output`);
+    }
+    return {
+        agent,
+        configPath,
+        instanceRoot: path.posix.dirname(instance.home_path),
+        remoteConfigPath: instance.config_path,
+        remoteWorkspaceRoot: `${instance.workspace_path}/agents`,
+        workspacePath: rootfsPath(compileResult.outputDirectory, `${instance.workspace_path}/agents/${agent.slug}`)
+    };
+};
+const selectMoltnetNodes = async (result, agent) => {
+    const nodePlans = result.report.container?.moltnet?.node_plans ?? [];
+    const matches = [];
+    for (const plan of nodePlans) {
+        const configPath = rootfsPath(result.outputDirectory, plan.config_path);
+        const config = await readJson(configPath);
+        const attachment = (config.attachments ?? []).find((candidate) => {
+            const id = candidate.agent?.id ?? "";
+            const name = candidate.agent?.name ?? "";
+            return id === agent.slug || id === agent.id || name === agent.name;
+        });
+        if (attachment?.agent?.id) {
+            matches.push({
+                configPath,
+                remotePath: plan.config_path,
+                ...(attachment.moltnet?.token_path
+                    ? { tokenDirectory: path.posix.dirname(attachment.moltnet.token_path) }
+                    : {})
+            });
+        }
+    }
+    return matches;
+};
+const selectManagedMoltnetServers = (result) => (result.report.container?.moltnet?.server_plans ?? [])
+    .filter((plan) => plan.mode === "managed" && Boolean(plan.config_path))
+    .map((plan) => ({
+    configPath: rootfsPath(result.outputDirectory, plan.config_path),
+    remotePath: plan.config_path
+}));
+const shellQuote = (value) => `'${value.replaceAll("'", "'\"'\"'")}'`;
+const listRunningPiAgents = async (dockerCommand, dockerPrefix, containerName, execFileImpl) => {
+    const stdout = await runDocker(dockerCommand, [...dockerPrefix, "exec", containerName, "curl", "-fsS", `${PI_CONTROL_URL}/spawnfile/agents`], execFileImpl);
+    const parsed = JSON.parse(stdout);
+    return parsed.agents ?? [];
+};
+const loadPiAgent = async (dockerCommand, dockerPrefix, containerName, slug, action, execFileImpl) => {
+    await runDocker(dockerCommand, [
+        ...dockerPrefix,
+        "exec",
+        containerName,
+        "curl",
+        "-fsS",
+        "-X",
+        "POST",
+        "-H",
+        "content-type: application/json",
+        "--data",
+        JSON.stringify({ slug }),
+        `${PI_CONTROL_URL}/spawnfile/agents/${action}`
+    ], execFileImpl, 120_000);
+};
+export const devApplyProject = async (inputPath, options) => {
+    const outputDirectory = await resolveDevOutputDirectory(inputPath, options.outputDirectory);
+    const record = await selectDeploymentRecord(outputDirectory, options.deploymentName);
+    const dockerCommand = options.dockerCommand ?? "docker";
+    const dockerPrefix = dockerArgsForRecord(record);
+    const containerName = firstContainerName(record);
+    const execFileImpl = options.execFile ?? defaultExecFile;
+    const existingAgents = await listRunningPiAgents(dockerCommand, dockerPrefix, containerName, execFileImpl);
+    const compileResult = await compileForDevApply(inputPath, outputDirectory, record, dockerCommand, execFileImpl);
+    const { agent, configPath, instanceRoot, remoteConfigPath, remoteWorkspaceRoot, workspacePath } = await selectPiAgent(compileResult, options.agent);
+    const nodes = await selectMoltnetNodes(compileResult, agent);
+    const serverConfigs = selectManagedMoltnetServers(compileResult);
+    const existingAgent = existingAgents.some((candidate) => matchesAgent(candidate, agent.slug));
+    await copyIntoContainer(dockerCommand, dockerPrefix, configPath, `${containerName}:${remoteConfigPath}`, execFileImpl);
+    await copyIntoContainer(dockerCommand, dockerPrefix, workspacePath, `${containerName}:${remoteWorkspaceRoot}`, execFileImpl);
+    for (const node of nodes) {
+        await copyIntoContainer(dockerCommand, dockerPrefix, node.configPath, `${containerName}:${node.remotePath}`, execFileImpl);
+    }
+    for (const serverConfig of serverConfigs) {
+        await copyIntoContainer(dockerCommand, dockerPrefix, serverConfig.configPath, `${containerName}:${serverConfig.remotePath}`, execFileImpl);
+    }
+    const tokenDirectories = nodes
+        .map((node) => node.tokenDirectory)
+        .filter((directory) => Boolean(directory));
+    await ensureContainerDirectories(dockerCommand, dockerPrefix, containerName, tokenDirectories, execFileImpl);
+    await chownContainerPaths(dockerCommand, dockerPrefix, containerName, [
+        instanceRoot,
+        ...nodes.flatMap((node) => [
+            node.remotePath,
+            ...(node.tokenDirectory ? [node.tokenDirectory] : [])
+        ]),
+        ...serverConfigs.map((serverConfig) => serverConfig.remotePath)
+    ], execFileImpl);
+    await loadPiAgent(dockerCommand, dockerPrefix, containerName, agent.slug, options.restart === true ? "restart" : "load", execFileImpl);
+    if (!existingAgent) {
+        for (const node of nodes) {
+            const prepare = node.tokenDirectory ? `mkdir -p ${shellQuote(node.tokenDirectory)} && ` : "";
+            const command = `${prepare}/usr/local/bin/moltnet node ${shellQuote(node.remotePath)}`;
+            await runDocker(dockerCommand, [...dockerPrefix, "exec", "-d", "--user", "spawnfile", containerName, "sh", "-lc", command], execFileImpl);
+        }
+    }
+    return {
+        agentId: agent.id,
+        bridgeStarted: !existingAgent && nodes.length > 0,
+        containerName,
+        deploymentName: record.name,
+        existingAgent,
+        outputDirectory
+    };
+};
+export const devRestartProject = async (inputPath, options) => devApplyProject(inputPath, { ...options, restart: true });
+export const devStopProject = async (inputPath, options = {}) => {
+    const outputDirectory = await resolveDevOutputDirectory(inputPath, options.outputDirectory);
+    const record = await selectDeploymentRecord(outputDirectory, options.deploymentName);
+    const containerName = firstContainerName(record);
+    await runDocker(options.dockerCommand ?? "docker", [...dockerArgsForRecord(record), "rm", "-f", containerName], options.execFile ?? defaultExecFile);
+    return { containerName, deploymentName: record.name, outputDirectory };
+};

package/dist/distribution/buildDistributionReport.d.ts

@@ -1,4 +1,4 @@
-import type { DistributionImageLabels, DistributionMoltnetNetwork, DistributionOrganizationSummary, DistributionPersistentMount, DistributionPortMapping, DistributionReport, DistributionRuntimeInstance, DistributionSecretCategory, DistributionWorkspaceResource } from "./types.js";
+import type { DistributionImageLabels, DistributionMoltnetNetwork, DistributionOrganizationSummary, DistributionPersistentMount, DistributionPortMapping, DistributionReport, DistributionRuntimeInstance, DistributionSecretCategory, DistributionWorkspaceResource, DistributionWorldBindingsEvidence } from "./types.js";
 export interface DistributionEnvVariableInput {
     categories: DistributionSecretCategory[];
     generated: boolean;
@@ -17,6 +17,7 @@ export interface BuildDistributionReportInput {
     publishedPorts: number[];
     resources: DistributionWorkspaceResource[];
     runtimeInstances: DistributionRuntimeInstance[];
+    worldBindings?: DistributionWorldBindingsEvidence;
 }
 export declare const buildDistributionReport: (input: BuildDistributionReportInput) => DistributionReport;
 export declare const createDistributionImageLabels: (projectSlug: string, compileFingerprint: string) => DistributionImageLabels;

package/dist/distribution/buildDistributionReport.js

@@ -35,7 +35,8 @@ export const buildDistributionReport = (input) => {
         resources: input.resources,
         runtime_instances: [...input.runtimeInstances].sort((left, right) => left.id.localeCompare(right.id)),
         secrets: createSecretCategoryMap(input.envVariables),
-        version: DISTRIBUTION_REPORT_VERSION
+        version: DISTRIBUTION_REPORT_VERSION,
+        ...(input.worldBindings ? { world_bindings: input.worldBindings } : {})
     };
     return {
         compile_fingerprint: createDistributionFingerprint(body),

package/dist/distribution/distributionReportSchema.d.ts

@@ -80,5 +80,10 @@ export declare const distributionReportSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>;
     version: z.ZodLiteral<"spawnfile.distribution-report.v1">;
+    world_bindings: z.ZodOptional<z.ZodObject<{
+        artifact_path: z.ZodLiteral<"/spawnfile/world-bindings.json">;
+        digest: z.ZodString;
+        schema: z.ZodLiteral<"simfile.world-bindings.v1">;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const parseDistributionReport: (source: unknown, sourceLabel?: string) => DistributionReport;

package/dist/distribution/distributionReportSchema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { SpawnfileError } from "../shared/index.js";
-import { DISTRIBUTION_REPORT_VERSION } from "./types.js";
+import { DISTRIBUTION_REPORT_VERSION, WORLD_BINDINGS_IMAGE_PATH } from "./types.js";
 const secretEntrySchema = z.object({
     generated: z.boolean(),
     name: z.string().min(1),
@@ -96,7 +96,12 @@ export const distributionReportSchema = z.object({
         runtime: z.array(secretEntrySchema),
         surface: z.array(secretEntrySchema)
     }).strict(),
-    version: z.literal(DISTRIBUTION_REPORT_VERSION)
+    version: z.literal(DISTRIBUTION_REPORT_VERSION),
+    world_bindings: z.object({
+        artifact_path: z.literal(WORLD_BINDINGS_IMAGE_PATH),
+        digest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+        schema: z.literal("simfile.world-bindings.v1")
+    }).strict().optional()
 }).strict();
 export const parseDistributionReport = (source, sourceLabel = "distribution report") => {
     const parsed = distributionReportSchema.safeParse(source);

package/dist/distribution/index.d.ts

@@ -20,5 +20,5 @@ export { extractSingleFileFromTar } from "./tarReader.js";
 export { hasRegistryComponent, parseImageReference, parseImplicitImageReference } from "./imageRef.js";
 export type { ParsedImageReference } from "./imageRef.js";
 export { normalizeProjectLabelSlug } from "./projectName.js";
-export { DISTRIBUTION_REPORT_IMAGE_PATH, DISTRIBUTION_REPORT_OUTPUT_FILE, DISTRIBUTION_REPORT_VERSION, IMAGE_CONTRACT_VERSION } from "./types.js";
-export type { DistributionAgentSummary, DistributionImageLabels, DistributionMoltnetNetwork, DistributionOrganizationSummary, DistributionPersistentMount, DistributionPortMapping, DistributionReport, DistributionRuntimeInstance, DistributionSecretCategory, DistributionSecretEntry, DistributionTeamSummary, DistributionWorkspaceResource } from "./types.js";
+export { DISTRIBUTION_REPORT_IMAGE_PATH, DISTRIBUTION_REPORT_OUTPUT_FILE, DISTRIBUTION_REPORT_VERSION, IMAGE_CONTRACT_VERSION, WORLD_BINDINGS_IMAGE_PATH } from "./types.js";
+export type { DistributionAgentSummary, DistributionImageLabels, DistributionMoltnetNetwork, DistributionOrganizationSummary, DistributionPersistentMount, DistributionPortMapping, DistributionReport, DistributionRuntimeInstance, DistributionSecretCategory, DistributionSecretEntry, DistributionTeamSummary, DistributionWorkspaceResource, DistributionWorldBindingsEvidence } from "./types.js";

package/dist/distribution/index.js

@@ -13,4 +13,4 @@ export { buildImageInterfaceSummary, renderImageInterface } from "./renderImageI
 export { extractSingleFileFromTar } from "./tarReader.js";
 export { hasRegistryComponent, parseImageReference, parseImplicitImageReference } from "./imageRef.js";
 export { normalizeProjectLabelSlug } from "./projectName.js";
-export { DISTRIBUTION_REPORT_IMAGE_PATH, DISTRIBUTION_REPORT_OUTPUT_FILE, DISTRIBUTION_REPORT_VERSION, IMAGE_CONTRACT_VERSION } from "./types.js";
+export { DISTRIBUTION_REPORT_IMAGE_PATH, DISTRIBUTION_REPORT_OUTPUT_FILE, DISTRIBUTION_REPORT_VERSION, IMAGE_CONTRACT_VERSION, WORLD_BINDINGS_IMAGE_PATH } from "./types.js";

package/dist/distribution/types.d.ts

@@ -56,6 +56,11 @@ export interface DistributionPortMapping {
     internal_port: number;
     published_port: number;
 }
+export interface DistributionWorldBindingsEvidence {
+    artifact_path: typeof WORLD_BINDINGS_IMAGE_PATH;
+    digest: string;
+    schema: "simfile.world-bindings.v1";
+}
 export interface DistributionReport {
     compile_fingerprint: string;
     generated_at: string;
@@ -72,9 +77,11 @@ export interface DistributionReport {
     runtime_instances: DistributionRuntimeInstance[];
     secrets: Record<DistributionSecretCategory, DistributionSecretEntry[]>;
     version: "spawnfile.distribution-report.v1";
+    world_bindings?: DistributionWorldBindingsEvidence;
 }
 export declare const DISTRIBUTION_REPORT_VERSION = "spawnfile.distribution-report.v1";
 export declare const DISTRIBUTION_REPORT_IMAGE_PATH = "/spawnfile/spawnfile-report.json";
 export declare const DISTRIBUTION_REPORT_OUTPUT_FILE = "distribution-report.json";
 export declare const IMAGE_CONTRACT_VERSION = "spawnfile.image.v1";
+export declare const WORLD_BINDINGS_IMAGE_PATH = "/spawnfile/world-bindings.json";
 export type DistributionImageLabels = Record<"com.spawnfile.compile_fingerprint" | "com.spawnfile.image_contract" | "com.spawnfile.project" | "com.spawnfile.report", string> & Record<string, string>;

package/dist/distribution/types.js

@@ -2,3 +2,4 @@ export const DISTRIBUTION_REPORT_VERSION = "spawnfile.distribution-report.v1";
 export const DISTRIBUTION_REPORT_IMAGE_PATH = "/spawnfile/spawnfile-report.json";
 export const DISTRIBUTION_REPORT_OUTPUT_FILE = "distribution-report.json";
 export const IMAGE_CONTRACT_VERSION = "spawnfile.image.v1";
+export const WORLD_BINDINGS_IMAGE_PATH = "/spawnfile/world-bindings.json";

package/dist/filesystem/paths.js

@@ -1,3 +1,4 @@
+import { statSync } from "node:fs";
 import path from "node:path";
 import { SpawnfileError } from "../shared/index.js";
 export const assertPortableRelativePath = (inputPath) => {
@@ -9,7 +10,15 @@ export const assertPortableRelativePath = (inputPath) => {
     }
 };
 export const getCanonicalManifestPath = (filePath) => path.resolve(filePath);
-export const getManifestPath = (inputPath) => path.basename(inputPath) === "Spawnfile"
+const isExistingFile = (inputPath) => {
+    try {
+        return statSync(inputPath).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+export const getManifestPath = (inputPath) => path.basename(inputPath) === "Spawnfile" || isExistingFile(inputPath)
     ? path.resolve(inputPath)
     : path.resolve(inputPath, "Spawnfile");
 export const getProjectRoot = (manifestPath) => path.dirname(manifestPath);

package/dist/ledger/causalConformanceCli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ledger/causalConformanceCli.js

@@ -0,0 +1,41 @@
+import { runRealConformance } from "./conformance.js";
+/**
+ * `npm run test:causal-conformance` entry point (B92). Runs the four real
+ * sibling causal fixture emitters (simfile, mneme, daimon, moltnet — see
+ * emitters.ts) by path, validates every record against the schema and
+ * payload minimums, stitches them into one interaction chain, and
+ * reconciles it. Prints per-source counts, any issues, and the
+ * reconstructed chain edges; exits 1 when the report is not ok.
+ *
+ * This is a hermetic-suite exception: it spawns real processes (a `go run`
+ * compile, three tsx processes), so it is its own npm script rather than a
+ * vitest test — `npm test` stays fully in-process (see emitters.test.ts and
+ * realConformance.test.ts for the injected-exec unit coverage of this same
+ * logic).
+ */
+const main = async () => {
+    const report = await runRealConformance();
+    console.log(`causal conformance: ${report.ok ? "OK" : "FAILED"} (events=${report.eventCount})`);
+    console.log("per-source counts:");
+    for (const { count, source } of report.sourceCounts) {
+        console.log(`  - ${source}: ${count}`);
+    }
+    if (report.issues.length > 0) {
+        console.log("issues:");
+        for (const issue of report.issues) {
+            const line = issue.line !== undefined ? ` (line ${issue.line})` : "";
+            console.log(`  - [${issue.source}]${line} ${issue.message}`);
+        }
+    }
+    console.log(`chain: ${report.chain.stitchedEventCount} stitched events, ${report.chain.edges.length} backward edges`);
+    for (const edge of report.chain.edges) {
+        console.log(`  - ${edge.from} -> ${edge.to}`);
+    }
+    if (!report.ok) {
+        process.exitCode = 1;
+    }
+};
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/ledger/causeNamespace.d.ts

@@ -0,0 +1,8 @@
+import { type CausalEvent } from "@noopolis/stele";
+import type { ConformanceIssue } from "./conformance.js";
+/**
+ * Reports B169 D4 cause-namespace violations without throwing, filtering, or
+ * mutating events. Real conformance calls this only after chain stitching has
+ * had its chance to repair producer-local bare causes.
+ */
+export declare const checkCauseNamespaces: (events: readonly CausalEvent[], sourceName?: string) => ConformanceIssue[];

package/dist/ledger/causeNamespace.js

@@ -0,0 +1,24 @@
+import { parseCausalCauseId } from "@noopolis/stele";
+/**
+ * Reports B169 D4 cause-namespace violations without throwing, filtering, or
+ * mutating events. Real conformance calls this only after chain stitching has
+ * had its chance to repair producer-local bare causes.
+ */
+export const checkCauseNamespaces = (events, sourceName = "<cause-namespace>") => {
+    const issues = [];
+    for (const event of events) {
+        for (const causeId of event.cause_event_ids) {
+            try {
+                parseCausalCauseId(causeId);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                issues.push({
+                    message: `event ${event.event_id} has nonconforming cause id ${JSON.stringify(causeId)}: ${reason}`,
+                    source: sourceName
+                });
+            }
+        }
+    }
+    return issues;
+};

package/dist/ledger/conformance.d.ts

@@ -0,0 +1,83 @@
+import type { CausalEdge, CausalEvent } from "@noopolis/stele";
+import type { EmitterSpec, Exec } from "./emitters.js";
+export interface ConformanceFixtureSource {
+    /** JSONL text for this source. In synthetic mode this is seeded fixture text, not a live emitter invocation. */
+    jsonl: string;
+    name: string;
+}
+export interface ConformancePayloadMinimum {
+    requiredKeys: string[];
+    type: string;
+}
+export interface ConformanceIssue {
+    line?: number;
+    message: string;
+    source: string;
+}
+export interface ConformanceReport {
+    eventCount: number;
+    issues: ConformanceIssue[];
+    ok: boolean;
+}
+/**
+ * Payload minimums for the event types named in specs/CAUSAL.md and the B57/
+ * B92 family packets. `runSyntheticConformance` validates seeded fixture
+ * text against these; `runRealConformance` (B92) validates the four real
+ * sibling emitters' output against the same minimums.
+ */
+export declare const DEFAULT_PAYLOAD_MINIMUMS: ConformancePayloadMinimum[];
+/**
+ * Validates seeded/synthetic CausalEvent JSONL fixtures against the schema
+ * (via parseCausalJsonl), per-stream seq contiguity, payload minimums, and
+ * (B62) the principal grammar/consistency discipline in
+ * `PRINCIPAL_DISCIPLINE_CHECKS`. An empty source list is always reported as
+ * a failure — this harness never silently skips a missing source, even in
+ * synthetic mode.
+ */
+export declare const runSyntheticConformance: (sources: ConformanceFixtureSource[], payloadMinimums?: ConformancePayloadMinimum[]) => ConformanceReport;
+/**
+ * Stitches the four independent, non-cross-referencing real fixtures into
+ * one interaction chain (B92 §4). Pure: never mutates its input, never does
+ * I/O. Rewrites ONLY linkage fields — R[i].cause_event_ids, T1.cause_event_ids,
+ * T1.payload.input_message_ids, T1.payload.input_content_sha256, and
+ * M2.cause_event_ids — every other field of every event is carried through
+ * byte-identical. T1out.cause_event_ids is asserted to already equal [T1.id]
+ * (daimon stamps that for real) rather than rewritten.
+ *
+ * Missing roles or a violated T1out->T1 assertion are reported as issues and
+ * the input is returned unstitched rather than guessed at.
+ */
+export declare const stitchInteractionChain: (events: CausalEvent[]) => {
+    issues: ConformanceIssue[];
+    stitched: CausalEvent[];
+};
+export interface ConformanceSourceCount {
+    count: number;
+    source: string;
+}
+export interface ChainSummary {
+    edges: CausalEdge[];
+    issues: ConformanceIssue[];
+    stitchedEventCount: number;
+}
+export interface RealConformanceReport extends ConformanceReport {
+    chain: ChainSummary;
+    events: CausalEvent[];
+    sourceCounts: ConformanceSourceCount[];
+}
+export interface RunRealConformanceOptions {
+    exec?: Exec;
+    specs?: EmitterSpec[];
+}
+/**
+ * Collects the four real sibling emitters (emitters.ts), validates them
+ * (schema + payload minimums + combined seq contiguity + (B62) the
+ * principal grammar/consistency discipline in `PRINCIPAL_DISCIPLINE_CHECKS`
+ * — the real path now enforces exactly what `runSyntheticConformance` does,
+ * so a real emitter stamping a non-grammar principal is a reported issue,
+ * not a silent pass), stitches them into one interaction chain, and
+ * reconciles the result. This is B92's real-mode counterpart to
+ * runSyntheticConformance: same validation core, live process spawning
+ * instead of seeded fixture text.
+ */
+export declare const runRealConformance: (options?: RunRealConformanceOptions) => Promise<RealConformanceReport>;