simfile 0.0.1

package/dist/ledger/stable.js

@@ -0,0 +1,78 @@
+import { createHash } from "node:crypto";
+/**
+ * Causal envelope constants shared with `specs/causal-event.v1.schema.json`
+ * (root, canonical) and `specs/CAUSAL.md`. Simfile does not import that
+ * schema file directly — this is simfile's own native TS copy of the wire
+ * contract, per the "type sharing" rule: siblings do not vendor the schema,
+ * they each hand-write a native type and stay conformant with the wire JSON.
+ */
+export const CAUSAL_ENVELOPE_VERSION = "noopolis.causal-event.v1";
+export const SIMFILE_EMITTER_SYSTEM = "simfile";
+export const DEFAULT_EMITTER_STREAM_ID = "world";
+export const DEFAULT_PRINCIPAL_ID = "system:simfile.world";
+const asJsonCompatible = (value) => {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(asJsonCompatible);
+    }
+    if (typeof value === "object") {
+        const ordered = Object.keys(value)
+            .sort()
+            .reduce((acc, key) => {
+            const nested = value[key];
+            if (nested !== undefined) {
+                acc[key] = asJsonCompatible(nested);
+            }
+            return acc;
+        }, {});
+        return ordered;
+    }
+    return String(value);
+};
+export const stableStringify = (value) => {
+    return JSON.stringify(asJsonCompatible(value));
+};
+/** simfile's event_id convention: `simfile:<runId>:<seq>` (system:local, per the shared schema). */
+export const createEventId = (runId, seq) => `${SIMFILE_EMITTER_SYSTEM}:${runId}:${seq}`;
+const defaultRecordedAt = (simTime) => new Date(Math.max(0, Number.isFinite(simTime) ? simTime : 0) * 1000).toISOString();
+export const createCanonicalEventEnvelope = (input) => {
+    if (!Number.isInteger(input.seq) || input.seq < 1) {
+        throw new Error(`seq must be a positive integer: ${input.seq}`);
+    }
+    if (!Number.isFinite(input.simTime)) {
+        throw new Error(`simTime must be finite: ${input.simTime}`);
+    }
+    if (input.runId.length === 0) {
+        throw new Error("runId must not be empty");
+    }
+    const streamId = input.streamId ?? DEFAULT_EMITTER_STREAM_ID;
+    const principalId = input.principalId ?? DEFAULT_PRINCIPAL_ID;
+    const causeEventIds = input.causeEventIds ? [...input.causeEventIds] : [];
+    return {
+        version: CAUSAL_ENVELOPE_VERSION,
+        run_id: input.runId,
+        event_id: createEventId(input.runId, input.seq),
+        emitter: {
+            system: SIMFILE_EMITTER_SYSTEM,
+            stream_id: streamId,
+            seq: input.seq
+        },
+        kind: input.kind,
+        principal_id: principalId,
+        recorded_at: input.observedAt ?? defaultRecordedAt(input.simTime),
+        cause_event_ids: causeEventIds,
+        sim_time: input.simTime,
+        provenance: input.provenance,
+        actor: input.actor,
+        target: input.target,
+        scope: input.scope,
+        payload: input.payload
+    };
+};
+export const stableEventLine = (input) => stableStringify(createCanonicalEventEnvelope(input));
+export const createEventDigest = (input) => createHash("sha256").update(stableEventLine(input)).digest("hex");

package/dist/ledger/validation.d.ts

@@ -0,0 +1,16 @@
+import { type LedgerEventEnvelope } from "./stable.js";
+export interface CanonicalLedgerValidationOptions {
+    runId?: string;
+    /** Restrict validation to a single emitter stream (defaults to accepting any). */
+    streamId?: string;
+}
+/**
+ * Validates and normalizes a stream of simfile causal ledger envelopes.
+ *
+ * Contiguity is generalized to (run_id, stream_id): every emitter.seq must be
+ * 1-based and contiguous within its own (run_id, stream_id) group, even if
+ * multiple streams are interleaved across the input array.
+ */
+export declare const validateCanonicalLedgerEvents: (events: readonly unknown[], options?: CanonicalLedgerValidationOptions) => LedgerEventEnvelope[];
+export declare const parseCanonicalLedgerJsonl: (source: string, options?: CanonicalLedgerValidationOptions) => LedgerEventEnvelope[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/ledger/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/ledger/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,mBAAmB,EAEzB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,gCAAgC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAiDD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,SAAS,OAAO,EAAE,EAC1B,UAAS,gCAAqC,KAC7C,mBAAmB,EAuErB,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,QAAQ,MAAM,EACd,UAAS,gCAAqC,KAC7C,mBAAmB,EAerB,CAAC"}

package/dist/ledger/validation.js

@@ -0,0 +1,127 @@
+import { createEventId, stableStringify, CAUSAL_ENVELOPE_VERSION, SIMFILE_EMITTER_SYSTEM } from "./stable.js";
+const provenanceValues = new Set(["mechanical", "agentic", "external"]);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const requireString = (event, key, index) => {
+    const value = event[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`ledger event ${index} has invalid ${key}`);
+    }
+    return value;
+};
+const requireStringArray = (event, key, index) => {
+    const value = event[key];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+        throw new Error(`ledger event ${index} has invalid ${key}`);
+    }
+    return value;
+};
+const requirePayload = (event, index) => {
+    if (!Object.hasOwn(event, "payload") || event.payload === undefined) {
+        throw new Error(`ledger event ${index} is missing payload`);
+    }
+    return event.payload;
+};
+const requireEmitter = (event, index) => {
+    const emitter = event.emitter;
+    if (!isRecord(emitter)) {
+        throw new Error(`ledger event ${index} has invalid emitter`);
+    }
+    if (emitter.system !== SIMFILE_EMITTER_SYSTEM) {
+        throw new Error(`ledger event ${index} has invalid emitter.system`);
+    }
+    const streamId = emitter.stream_id;
+    if (typeof streamId !== "string" || streamId.length === 0) {
+        throw new Error(`ledger event ${index} has invalid emitter.stream_id`);
+    }
+    const seq = emitter.seq;
+    if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 1) {
+        throw new Error(`ledger event ${index} has invalid emitter.seq`);
+    }
+    return { system: SIMFILE_EMITTER_SYSTEM, stream_id: streamId, seq };
+};
+/**
+ * Validates and normalizes a stream of simfile causal ledger envelopes.
+ *
+ * Contiguity is generalized to (run_id, stream_id): every emitter.seq must be
+ * 1-based and contiguous within its own (run_id, stream_id) group, even if
+ * multiple streams are interleaved across the input array.
+ */
+export const validateCanonicalLedgerEvents = (events, options = {}) => {
+    let runId = options.runId;
+    const nextSeqByStream = new Map();
+    return events.map((event, index) => {
+        if (!isRecord(event)) {
+            throw new Error(`ledger event ${index} is not an object`);
+        }
+        const version = event.version;
+        if (version !== CAUSAL_ENVELOPE_VERSION) {
+            throw new Error(`ledger event ${index} has invalid version`);
+        }
+        const eventRunId = requireString(event, "run_id", index);
+        runId ??= eventRunId;
+        if (eventRunId !== runId) {
+            throw new Error(`ledger event ${index} has mismatched run_id`);
+        }
+        const emitter = requireEmitter(event, index);
+        if (options.streamId !== undefined && emitter.stream_id !== options.streamId) {
+            throw new Error(`ledger event ${index} has unexpected emitter.stream_id`);
+        }
+        const streamKey = `${runId} ${emitter.stream_id}`;
+        const expectedSeq = (nextSeqByStream.get(streamKey) ?? 0) + 1;
+        if (emitter.seq !== expectedSeq) {
+            throw new Error(`ledger event ${index} has non-contiguous seq for (run_id, stream_id)`);
+        }
+        nextSeqByStream.set(streamKey, emitter.seq);
+        const eventId = requireString(event, "event_id", index);
+        if (eventId !== createEventId(runId, emitter.seq)) {
+            throw new Error(`ledger event ${index} has invalid event_id`);
+        }
+        const principalId = requireString(event, "principal_id", index);
+        const recordedAt = requireString(event, "recorded_at", index);
+        if (Number.isNaN(Date.parse(recordedAt))) {
+            throw new Error(`ledger event ${index} has invalid recorded_at`);
+        }
+        const causeEventIds = requireStringArray(event, "cause_event_ids", index);
+        const simTime = event.sim_time;
+        if (typeof simTime !== "number" || !Number.isFinite(simTime)) {
+            throw new Error(`ledger event ${index} has invalid sim_time`);
+        }
+        const provenance = requireString(event, "provenance", index);
+        if (!provenanceValues.has(provenance)) {
+            throw new Error(`ledger event ${index} has invalid provenance`);
+        }
+        return {
+            version: CAUSAL_ENVELOPE_VERSION,
+            run_id: runId,
+            event_id: eventId,
+            emitter,
+            kind: requireString(event, "kind", index),
+            principal_id: principalId,
+            recorded_at: recordedAt,
+            cause_event_ids: causeEventIds,
+            sim_time: simTime,
+            provenance: provenance,
+            actor: requireString(event, "actor", index),
+            target: requireString(event, "target", index),
+            scope: requireString(event, "scope", index),
+            payload: requirePayload(event, index)
+        };
+    });
+};
+export const parseCanonicalLedgerJsonl = (source, options = {}) => {
+    const lines = source.split(/\r?\n/u).filter((line) => line.length > 0);
+    const parsed = lines.map((line, index) => {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`ledger line ${index} is not valid JSON: ${error.message}`);
+        }
+        if (stableStringify(value) !== line) {
+            throw new Error(`ledger line ${index} is not canonical JSON`);
+        }
+        return value;
+    });
+    return validateCanonicalLedgerEvents(parsed, options);
+};

package/dist/moltnet/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./world-participant.js";
+export * from "./transcript-export.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/moltnet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/moltnet/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/dist/moltnet/index.js

@@ -0,0 +1,2 @@
+export * from "./world-participant.js";
+export * from "./transcript-export.js";

package/dist/moltnet/transcript-export.d.ts

@@ -0,0 +1,34 @@
+import type { MoltnetMessageActor, MoltnetMessagePart, MoltnetMessageTarget, MoltnetWorldDeliveryOptions } from "./world-participant.js";
+export type TranscriptSource = "harness-derived" | "moltnet-exported";
+export interface MoltnetTranscriptTarget {
+    kind: "dm" | "room";
+    id: string;
+    scope?: string;
+}
+export interface MoltnetExportedTranscriptMessage {
+    from?: MoltnetMessageActor;
+    id: string;
+    parts?: MoltnetMessagePart[];
+    target?: MoltnetMessageTarget;
+}
+export interface MoltnetConversationTranscript {
+    messages: MoltnetExportedTranscriptMessage[];
+    target: MoltnetTranscriptTarget;
+}
+export interface MoltnetExportedTranscript {
+    conversations: MoltnetConversationTranscript[];
+    source: "moltnet-exported";
+    version: "simfile.moltnet.transcript.v1";
+}
+export interface TranscriptSourceArtifact {
+    source?: TranscriptSource;
+}
+export interface ExportMoltnetTranscriptOptions extends MoltnetWorldDeliveryOptions {
+    limit?: number;
+    targets: readonly MoltnetTranscriptTarget[];
+}
+export declare const roomTranscriptTargetFromScope: (scope: string) => MoltnetTranscriptTarget;
+export declare const extractSimfileEventIds: (transcript: MoltnetExportedTranscript) => string[];
+export declare const requireMoltnetExportedTranscript: (artifact: TranscriptSourceArtifact) => void;
+export declare const exportMoltnetTranscript: (options: ExportMoltnetTranscriptOptions) => Promise<MoltnetExportedTranscript>;
+//# sourceMappingURL=transcript-export.d.ts.map

package/dist/moltnet/transcript-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript-export.d.ts","sourceRoot":"","sources":["../../src/moltnet/transcript-export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAC5B,MAAM,wBAAwB,CAAC;AAKhC,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAEtE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gCAAgC;IAC/C,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,gCAAgC,EAAE,CAAC;IAC7C,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,6BAA6B,EAAE,CAAC;IAC/C,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,+BAA+B,CAAC;CAC1C;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,MAAM,WAAW,8BAA+B,SAAQ,2BAA2B;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC7C;AAED,eAAO,MAAM,6BAA6B,GAAI,OAAO,MAAM,KAAG,uBAM7D,CAAC;AA4BF,eAAO,MAAM,sBAAsB,GACjC,YAAY,yBAAyB,KACpC,MAAM,EAYR,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAC3C,UAAU,wBAAwB,KACjC,IAIF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,SAAS,8BAA8B,KACtC,OAAO,CAAC,yBAAyB,CAmBnC,CAAC"}

package/dist/moltnet/transcript-export.js

@@ -0,0 +1,68 @@
+const DEFAULT_LIMIT = 200;
+const DEFAULT_TIMEOUT_MS = 10_000;
+export const roomTranscriptTargetFromScope = (scope) => {
+    const [kind, network, room] = scope.split(":");
+    if (kind !== "room" || !network || !room) {
+        throw new Error(`invalid room scope ${scope}`);
+    }
+    return { kind: "room", id: room, scope };
+};
+const requestHeaders = (options) => ({
+    ...(options.authToken?.trim() ? { Authorization: `Bearer ${options.authToken.trim()}` } : {})
+});
+const readJSON = async (url, options) => {
+    const timeout = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const signal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
+    const response = await (options.fetchFn ?? fetch)(url.href, {
+        method: "GET",
+        headers: requestHeaders(options),
+        ...(signal ? { signal } : {})
+    });
+    if (!response.ok) {
+        throw new Error(`moltnet endpoint ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+};
+const transcriptPath = (target, limit) => {
+    const encodedId = encodeURIComponent(target.id);
+    const encodedLimit = encodeURIComponent(String(limit));
+    return target.kind === "room"
+        ? `/v1/rooms/${encodedId}/messages?limit=${encodedLimit}`
+        : `/v1/dms/${encodedId}/messages?limit=${encodedLimit}`;
+};
+export const extractSimfileEventIds = (transcript) => {
+    const ids = new Set();
+    for (const conversation of transcript.conversations) {
+        for (const message of conversation.messages) {
+            const data = message.parts?.[0]?.data;
+            const eventId = data && typeof data === "object"
+                ? data.simfile_event_id
+                : undefined;
+            if (typeof eventId === "string")
+                ids.add(eventId);
+        }
+    }
+    return [...ids].sort();
+};
+export const requireMoltnetExportedTranscript = (artifact) => {
+    if (artifact.source !== "moltnet-exported") {
+        throw new Error("live simulation acceptance requires a moltnet-exported transcript");
+    }
+};
+export const exportMoltnetTranscript = async (options) => {
+    const base = options.baseUrl.replace(/\/+$/u, "");
+    const limit = Math.max(1, Math.floor(options.limit ?? DEFAULT_LIMIT));
+    const conversations = [];
+    for (const target of options.targets) {
+        const page = await readJSON(new URL(`${base}${transcriptPath(target, limit)}`), options);
+        conversations.push({
+            messages: page.messages ?? [],
+            target
+        });
+    }
+    return {
+        conversations,
+        source: "moltnet-exported",
+        version: "simfile.moltnet.transcript.v1"
+    };
+};

package/dist/moltnet/world-participant.d.ts

@@ -0,0 +1,77 @@
+import type { RuntimeTraceEvent } from "../runtime/types.js";
+export declare const WORLD_MESSAGE_EVENT_KINDS: readonly ["world.message", "world.dm", "wake.recommended"];
+type WorldMessageEventKind = (typeof WORLD_MESSAGE_EVENT_KINDS)[number];
+export interface MoltnetMessageActor {
+    type: "agent";
+    id: string;
+    name?: string;
+    network_id?: string;
+}
+export interface MoltnetMessageTarget {
+    kind: "room" | "dm";
+    room_id?: string;
+    dm_id?: string;
+    participant_ids?: string[];
+}
+export interface MoltnetMessagePart {
+    kind: "text";
+    text: string;
+    data?: Record<string, unknown>;
+}
+interface MoltnetMessageOrigin {
+    network_id: string;
+    message_id: string;
+}
+export interface MoltnetSendMessageRequest {
+    id?: string;
+    origin?: MoltnetMessageOrigin;
+    target: MoltnetMessageTarget;
+    from: MoltnetMessageActor;
+    parts: MoltnetMessagePart[];
+}
+export interface MoltnetMessageAccepted {
+    message_id: string;
+    event_id: string;
+    accepted: boolean;
+    thread_created: boolean;
+    dm_created: boolean;
+}
+export interface MoltnetWorldDeliveryOptions {
+    actorId?: string;
+    actorName?: string;
+    authToken?: string;
+    baseUrl: string;
+    networkId?: string;
+    buildDmId?: (network: string, agentId: string, event: RuntimeTraceEvent) => string;
+    fetchFn?: typeof fetch;
+    requestTimeoutMs?: number;
+}
+export interface MoltnetWorldDeliveryResult {
+    eventId: string;
+    request: MoltnetSendMessageRequest;
+    response: MoltnetMessageAccepted;
+}
+export interface MoltnetTranscriptMessage {
+    from?: MoltnetMessageActor;
+    id: string;
+    parts?: MoltnetMessagePart[];
+    target?: MoltnetMessageTarget;
+}
+export interface MoltnetWorldTranscriptEntry {
+    eventId?: string;
+    kind?: string;
+    message: MoltnetTranscriptMessage;
+    target: MoltnetMessageTarget;
+}
+export interface MoltnetWorldTranscriptOptions extends MoltnetWorldDeliveryOptions {
+    events: readonly RuntimeTraceEvent[];
+}
+export declare const isWorldMessageEvent: (event: RuntimeTraceEvent) => event is RuntimeTraceEvent & {
+    kind: WorldMessageEventKind;
+};
+export declare const buildMoltnetMessageRequest: (event: RuntimeTraceEvent, options: MoltnetWorldDeliveryOptions) => MoltnetSendMessageRequest;
+export declare const sendWorldEventToMoltnet: (event: RuntimeTraceEvent, options: MoltnetWorldDeliveryOptions) => Promise<MoltnetWorldDeliveryResult>;
+export declare const sendWorldEventsToMoltnet: (events: readonly RuntimeTraceEvent[], options: MoltnetWorldDeliveryOptions) => Promise<MoltnetWorldDeliveryResult[]>;
+export declare const readWorldTranscriptFromMoltnet: (options: MoltnetWorldTranscriptOptions) => Promise<MoltnetWorldTranscriptEntry[]>;
+export {};
+//# sourceMappingURL=world-participant.d.ts.map

package/dist/moltnet/world-participant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-participant.d.ts","sourceRoot":"","sources":["../../src/moltnet/world-participant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,eAAO,MAAM,yBAAyB,4DAA6D,CAAC;AACpG,KAAK,qBAAqB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAYxE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,UAAU,oBAAoB;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,EAAE,kBAAkB,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,KAAK,MAAM,CAAC;IACnF,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,yBAAyB,CAAC;IACnC,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,wBAAwB,CAAC;IAClC,MAAM,EAAE,oBAAoB,CAAC;CAC9B;AAED,MAAM,WAAW,6BAA8B,SAAQ,2BAA2B;IAChF,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACtC;AAED,eAAO,MAAM,mBAAmB,GAAI,OAAO,iBAAiB,KAAG,KAAK,IAAI,iBAAiB,GAAG;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAChD,CAAC;AAgJ1E,eAAO,MAAM,0BAA0B,GACrC,OAAO,iBAAiB,EACxB,SAAS,2BAA2B,KACnC,yBAKF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,OAAO,iBAAiB,EACxB,SAAS,2BAA2B,KACnC,OAAO,CAAC,0BAA0B,CAmBpC,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,SAAS,iBAAiB,EAAE,EACpC,SAAS,2BAA2B,KACnC,OAAO,CAAC,0BAA0B,EAAE,CAOtC,CAAC;AAwCF,eAAO,MAAM,8BAA8B,GACzC,SAAS,6BAA6B,KACrC,OAAO,CAAC,2BAA2B,EAAE,CAuBvC,CAAC"}

package/dist/moltnet/world-participant.js

@@ -0,0 +1,221 @@
+export const WORLD_MESSAGE_EVENT_KINDS = ["world.message", "world.dm", "wake.recommended"];
+const WORLD_ACTOR_ID = "world";
+const WORLD_ACTOR_NAME = "@world";
+const WORLD_HTTP_TIMEOUT_MS = 10_000;
+const WORLD_EVENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+export const isWorldMessageEvent = (event) => WORLD_MESSAGE_EVENT_KINDS.includes(event.kind);
+const asRoomScope = (scope) => {
+    const [kind, network, room] = scope.split(":");
+    if (kind !== "room" || !network || !room) {
+        throw new Error(`invalid room target scope ${scope}`);
+    }
+    return { network, room };
+};
+const asAgentScope = (scope) => {
+    const [kind, agent] = scope.split(":");
+    if (kind !== "agent" || !agent) {
+        throw new Error(`invalid agent target scope ${scope}`);
+    }
+    return agent;
+};
+const defaultActor = (networkId) => ({
+    type: "agent",
+    id: WORLD_ACTOR_ID,
+    name: WORLD_ACTOR_NAME,
+    ...(networkId ? { network_id: networkId } : {})
+});
+const defaultDmId = (network, agentId, event) => `world-${network}-${agentId}`;
+const deriveActorNetworkId = (event, options) => {
+    if (options.networkId)
+        return options.networkId;
+    if (event.kind === "world.message" || event.kind === "wake.recommended") {
+        return asRoomScope(event.target).network;
+    }
+    return undefined;
+};
+const requestTextFromEvent = (event) => {
+    const payload = typeof event.payload === "object" && event.payload !== null && !Array.isArray(event.payload)
+        ? event.payload
+        : {};
+    if (typeof payload.content === "string" && payload.content.length > 0) {
+        return payload.content;
+    }
+    if (typeof payload.reason === "string" && payload.reason.length > 0) {
+        return `${event.kind}: ${payload.reason}`;
+    }
+    return `${event.kind}: ${event.target}`;
+};
+const metadataFromEvent = (event) => ({
+    simfile_event_id: event.event_id,
+    simfile_event_kind: event.kind,
+    simfile_rule_id: event.actor
+});
+const requestHeaders = (options) => ({
+    "Content-Type": "application/json",
+    ...(options.authToken?.trim() ? { Authorization: `Bearer ${options.authToken.trim()}` } : {})
+});
+const requestFromWorldEvent = (event, options) => {
+    const actorNetwork = deriveActorNetworkId(event, options);
+    const metadata = metadataFromEvent(event);
+    const messageText = requestTextFromEvent(event);
+    if (event.kind === "world.dm") {
+        const actorId = options.actorId?.trim() || WORLD_ACTOR_ID;
+        const network = options.networkId ?? actorNetwork;
+        if (!network) {
+            throw new Error("networkId is required for world.dm delivery");
+        }
+        const toAgent = asAgentScope(event.target);
+        const dmIdFactory = options.buildDmId ?? defaultDmId;
+        const dmId = dmIdFactory(network, toAgent, event);
+        return {
+            id: WORLD_EVENT_ID_PATTERN.test(event.event_id) ? event.event_id : undefined,
+            origin: { network_id: network, message_id: event.event_id },
+            from: {
+                ...defaultActor(network),
+                id: actorId
+            },
+            target: {
+                kind: "dm",
+                dm_id: dmId,
+                participant_ids: [actorId, toAgent]
+            },
+            parts: [{
+                    kind: "text",
+                    text: messageText,
+                    data: metadata
+                }]
+        };
+    }
+    const roomScope = asRoomScope(event.target);
+    const actorId = options.actorId?.trim() || WORLD_ACTOR_ID;
+    return {
+        id: WORLD_EVENT_ID_PATTERN.test(event.event_id) ? event.event_id : undefined,
+        origin: { network_id: roomScope.network, message_id: event.event_id },
+        from: {
+            ...defaultActor(roomScope.network),
+            id: actorId
+        },
+        target: {
+            kind: "room",
+            room_id: roomScope.room
+        },
+        parts: [{
+                kind: "text",
+                text: messageText,
+                data: metadata
+            }]
+    };
+};
+const parseMoltnetAccepted = async (response) => {
+    const body = await response.text();
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch (error) {
+        throw new Error(`moltnet response decode failed: ${error.message}`);
+    }
+    const message = payload;
+    if (typeof message !== "object" ||
+        message === null ||
+        typeof message.message_id !== "string" ||
+        typeof message.event_id !== "string" ||
+        typeof message.accepted !== "boolean" ||
+        typeof message.thread_created !== "boolean" ||
+        typeof message.dm_created !== "boolean") {
+        throw new Error("moltnet response missing expected fields");
+    }
+    return message;
+};
+export const buildMoltnetMessageRequest = (event, options) => {
+    if (!isWorldMessageEvent(event)) {
+        throw new Error(`unsupported event kind ${event.kind}`);
+    }
+    return requestFromWorldEvent(event, options);
+};
+export const sendWorldEventToMoltnet = async (event, options) => {
+    const request = buildMoltnetMessageRequest(event, options);
+    const requestTarget = new URL(`${options.baseUrl.replace(/\/+$/u, "")}/v1/messages`);
+    const timeout = options.requestTimeoutMs ?? WORLD_HTTP_TIMEOUT_MS;
+    const signal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
+    const fetcher = options.fetchFn ?? fetch;
+    const response = await fetcher(requestTarget.href, {
+        method: "POST",
+        headers: requestHeaders(options),
+        body: JSON.stringify(request),
+        ...(signal ? { signal } : {})
+    });
+    if (!response.ok) {
+        throw new Error(`moltnet endpoint ${response.status} ${response.statusText}`);
+    }
+    const accepted = await parseMoltnetAccepted(response);
+    return { eventId: event.event_id, request, response: accepted };
+};
+export const sendWorldEventsToMoltnet = async (events, options) => {
+    const results = [];
+    for (const event of events) {
+        if (!isWorldMessageEvent(event))
+            continue;
+        results.push(await sendWorldEventToMoltnet(event, options));
+    }
+    return results;
+};
+const readJSON = async (url, options) => {
+    const timeout = options.requestTimeoutMs ?? WORLD_HTTP_TIMEOUT_MS;
+    const signal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
+    const response = await (options.fetchFn ?? fetch)(url.href, {
+        method: "GET",
+        headers: requestHeaders(options),
+        ...(signal ? { signal } : {})
+    });
+    if (!response.ok) {
+        throw new Error(`moltnet endpoint ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+};
+const transcriptTargets = (events, options) => {
+    const targets = new Map();
+    for (const event of events) {
+        if (!isWorldMessageEvent(event))
+            continue;
+        const request = buildMoltnetMessageRequest(event, options);
+        const target = request.target;
+        if (target.kind === "room" && target.room_id) {
+            targets.set(`room:${target.room_id}`, target);
+        }
+        if (target.kind === "dm" && target.dm_id) {
+            targets.set(`dm:${target.dm_id}`, target);
+        }
+    }
+    return [...targets.values()];
+};
+const firstPartMetadata = (message) => {
+    const data = message.parts?.[0]?.data;
+    return data && typeof data === "object" ? data : undefined;
+};
+export const readWorldTranscriptFromMoltnet = async (options) => {
+    const base = options.baseUrl.replace(/\/+$/u, "");
+    const entries = [];
+    for (const target of transcriptTargets(options.events, options)) {
+        const path = target.kind === "room" && target.room_id
+            ? `/v1/rooms/${encodeURIComponent(target.room_id)}/messages?limit=200`
+            : target.kind === "dm" && target.dm_id
+                ? `/v1/dms/${encodeURIComponent(target.dm_id)}/messages?limit=200`
+                : undefined;
+        if (!path)
+            continue;
+        const page = await readJSON(new URL(`${base}${path}`), options);
+        for (const message of page.messages ?? []) {
+            const data = firstPartMetadata(message);
+            if (typeof data?.simfile_event_id !== "string")
+                continue;
+            entries.push({
+                eventId: data.simfile_event_id,
+                kind: typeof data.simfile_event_kind === "string" ? data.simfile_event_kind : undefined,
+                message,
+                target
+            });
+        }
+    }
+    return entries;
+};

package/dist/observe/artifacts.d.ts

@@ -0,0 +1,16 @@
+import type { RunManifestArtifactEntry } from "./manifest.js";
+export interface ArtifactIntegrityCheck {
+    path: string;
+    expectedSha256: string;
+    actualSha256: string | null;
+    ok: boolean;
+}
+/**
+ * Verifies every manifest-declared artifact's sha256 against the file on
+ * disk. A mismatch (or a missing file) is reported as a failed check, never
+ * silently repaired or stitched over — the caller decides what to do with a
+ * failed integrity check (contracts.md: "missing links are reported, not
+ * synthesized" applies just as much to artifact bytes as to causal edges).
+ */
+export declare const verifyManifestArtifacts: (runDir: string, artifacts: readonly RunManifestArtifactEntry[]) => Promise<ArtifactIntegrityCheck[]>;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/observe/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/observe/artifacts.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAE9D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,EAAE,EAAE,OAAO,CAAC;CACb;AAID;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,QAAQ,MAAM,EACd,WAAW,SAAS,wBAAwB,EAAE,KAC7C,OAAO,CAAC,sBAAsB,EAAE,CAkBlC,CAAC"}