@nikelyh/offscript 0.0.0-stage → 1.1.0

package/dist/packages/browser/session.js

@@ -0,0 +1,209 @@
+import { assertInScope, isAllowedSubresource, isUrlInScope, normalizeTargetUrl } from "./scope-guard.js";
+import { capturePageSnapshot } from "./dom-snapshot.js";
+export class BrowserUserSession {
+    context;
+    page;
+    targetUrl;
+    actionTimeoutMs;
+    navigationTimeoutMs;
+    currentEpoch = 0;
+    closed = false;
+    constructor(context, page, targetUrl, actionTimeoutMs = 5000, navigationTimeoutMs = 10000) {
+        this.context = context;
+        this.page = page;
+        this.targetUrl = targetUrl;
+        this.actionTimeoutMs = actionTimeoutMs;
+        this.navigationTimeoutMs = navigationTimeoutMs;
+    }
+    static async create(context, options) {
+        const targetUrl = normalizeTargetUrl(options.targetUrl);
+        const actionTimeoutMs = options.actionTimeoutMs ?? 5000;
+        const navigationTimeoutMs = options.navigationTimeoutMs ?? 10000;
+        await context.route("**", (route) => {
+            const requestUrl = route.request().url();
+            if (!isAllowedSubresource(requestUrl, targetUrl)) {
+                void route.abort("accessdenied");
+                return;
+            }
+            void route.continue();
+        });
+        const page = await context.newPage();
+        page.setDefaultTimeout(actionTimeoutMs);
+        page.setDefaultNavigationTimeout(navigationTimeoutMs);
+        return new BrowserUserSession(context, page, targetUrl, actionTimeoutMs, navigationTimeoutMs);
+    }
+    isClosed() {
+        return this.closed;
+    }
+    getTargetUrl() {
+        return this.targetUrl;
+    }
+    getCurrentUrl() {
+        return this.page.url();
+    }
+    async navigate(url) {
+        if (this.closed)
+            return { success: false, action: "navigate", url: this.getCurrentUrl(), error: "SESSION_CLOSED" };
+        let resolvedUrl;
+        try {
+            resolvedUrl = assertInScope(url, this.targetUrl);
+        }
+        catch (error) {
+            return {
+                success: false,
+                action: "navigate",
+                url: this.getCurrentUrl(),
+                error: error instanceof Error ? error.message : "TARGET_OUT_OF_SCOPE",
+            };
+        }
+        this.currentEpoch++;
+        try {
+            await this.page.goto(resolvedUrl, {
+                timeout: this.navigationTimeoutMs,
+                waitUntil: "domcontentloaded",
+            });
+            return { success: true, action: "navigate", url: this.page.url() };
+        }
+        catch (cause) {
+            return {
+                success: false,
+                action: "navigate",
+                url: this.page.url(),
+                error: cause instanceof Error ? cause.message : "NAVIGATION_FAILED",
+            };
+        }
+    }
+    async inspect() {
+        if (this.closed)
+            throw new Error("Session is closed.");
+        this.currentEpoch++;
+        return await capturePageSnapshot(this.page, this.currentEpoch);
+    }
+    resolveLocator(ref) {
+        if (!/^elem_\d+$/.test(ref))
+            return null;
+        return this.page.locator(`[data-offscript-ref="${ref}"][data-offscript-epoch="${this.currentEpoch}"]`);
+    }
+    async click(ref) {
+        if (this.closed)
+            return { success: false, action: "click", url: this.getCurrentUrl(), error: "SESSION_CLOSED" };
+        const locator = this.resolveLocator(ref);
+        if (!locator)
+            return { success: false, action: "click", url: this.getCurrentUrl(), error: "INVALID_ELEMENT_REF" };
+        try {
+            if ((await locator.count()) === 0) {
+                return { success: false, action: "click", url: this.page.url(), error: "STALE_OR_MISSING_ELEMENT_REF" };
+            }
+            if (await locator.first().isDisabled().catch(() => false)) {
+                return { success: false, action: "click", url: this.page.url(), error: "ELEMENT_IS_DISABLED" };
+            }
+            await locator.first().click({ timeout: this.actionTimeoutMs });
+            const newUrl = this.page.url();
+            if (!isUrlInScope(newUrl, this.targetUrl)) {
+                return { success: false, action: "click", url: newUrl, error: `Navigation resulted in out-of-scope URL "${newUrl}".` };
+            }
+            return { success: true, action: "click", url: newUrl };
+        }
+        catch (cause) {
+            return { success: false, action: "click", url: this.page.url(), error: cause instanceof Error ? cause.message : "CLICK_FAILED" };
+        }
+    }
+    async type(ref, text) {
+        if (this.closed)
+            return { success: false, action: "type", url: this.getCurrentUrl(), error: "SESSION_CLOSED" };
+        const locator = this.resolveLocator(ref);
+        if (!locator)
+            return { success: false, action: "type", url: this.getCurrentUrl(), error: "INVALID_ELEMENT_REF" };
+        try {
+            if ((await locator.count()) === 0) {
+                return { success: false, action: "type", url: this.page.url(), error: "STALE_OR_MISSING_ELEMENT_REF" };
+            }
+            if (await locator.first().isDisabled().catch(() => false)) {
+                return { success: false, action: "type", url: this.page.url(), error: "ELEMENT_IS_DISABLED" };
+            }
+            await locator.first().fill(text, { timeout: this.actionTimeoutMs });
+            return { success: true, action: "type", url: this.page.url() };
+        }
+        catch (cause) {
+            return { success: false, action: "type", url: this.page.url(), error: cause instanceof Error ? cause.message : "TYPE_FAILED" };
+        }
+    }
+    async scroll(direction = "down", ref) {
+        if (this.closed)
+            return { success: false, action: "scroll", url: this.getCurrentUrl(), error: "SESSION_CLOSED" };
+        try {
+            if (ref) {
+                const locator = this.resolveLocator(ref);
+                if (!locator)
+                    return { success: false, action: "scroll", url: this.getCurrentUrl(), error: "INVALID_ELEMENT_REF" };
+                if ((await locator.count()) === 0) {
+                    return { success: false, action: "scroll", url: this.page.url(), error: "STALE_OR_MISSING_ELEMENT_REF" };
+                }
+                await locator.first().scrollIntoViewIfNeeded({ timeout: this.actionTimeoutMs });
+            }
+            else {
+                const delta = direction === "up" ? -400 : 400;
+                await this.page.evaluate((d) => window.scrollBy(0, d), delta);
+            }
+            return { success: true, action: "scroll", url: this.page.url() };
+        }
+        catch (cause) {
+            return { success: false, action: "scroll", url: this.page.url(), error: cause instanceof Error ? cause.message : "SCROLL_FAILED" };
+        }
+    }
+    async select(ref, value) {
+        if (this.closed)
+            return { success: false, action: "select", url: this.getCurrentUrl(), error: "SESSION_CLOSED" };
+        const locator = this.resolveLocator(ref);
+        if (!locator)
+            return { success: false, action: "select", url: this.getCurrentUrl(), error: "INVALID_ELEMENT_REF" };
+        try {
+            if ((await locator.count()) === 0) {
+                return { success: false, action: "select", url: this.page.url(), error: "STALE_OR_MISSING_ELEMENT_REF" };
+            }
+            if (await locator.first().isDisabled().catch(() => false)) {
+                return { success: false, action: "select", url: this.page.url(), error: "ELEMENT_IS_DISABLED" };
+            }
+            await locator.first().selectOption(value, { timeout: this.actionTimeoutMs });
+            const newUrl = this.page.url();
+            if (!isUrlInScope(newUrl, this.targetUrl)) {
+                return { success: false, action: "select", url: newUrl, error: `Navigation resulted in out-of-scope URL "${newUrl}".` };
+            }
+            return { success: true, action: "select", url: newUrl };
+        }
+        catch (cause) {
+            return { success: false, action: "select", url: this.page.url(), error: cause instanceof Error ? cause.message : "SELECT_FAILED" };
+        }
+    }
+    /**
+     * Captures the rendered viewport of the active in-scope page as a PNG image.
+     * Password fields (<input type="password">) are rendered with native masking.
+     * Universal optical redaction on arbitrary rendered text/canvas is not performed.
+     */
+    async screenshot() {
+        if (this.closed)
+            return { success: false, error: "SESSION_CLOSED" };
+        try {
+            const currentUrl = this.page.url();
+            if (!isUrlInScope(currentUrl, this.targetUrl)) {
+                return { success: false, error: `OUT_OF_SCOPE: Cannot capture screenshot from "${currentUrl}".` };
+            }
+            const data = await this.page.screenshot({ type: "png" });
+            return { success: true, data, mimeType: "image/png" };
+        }
+        catch (cause) {
+            return { success: false, error: cause instanceof Error ? cause.message : "SCREENSHOT_FAILED" };
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            await this.context.close();
+        }
+        catch {
+            // Ignore errors on closing already terminated contexts
+        }
+    }
+}

package/dist/packages/browser/tools/browser-tools.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+import { createObservation, observationId } from "../../domain/index.js";
+function asObject(val, expectedKeys) {
+    if (!val || typeof val !== "object" || Array.isArray(val)) {
+        throw new Error("Tool arguments must be an object.");
+    }
+    const obj = val;
+    for (const k of Object.keys(obj)) {
+        if (!expectedKeys.includes(k))
+            throw new Error(`Unexpected argument: ${k}`);
+    }
+    return obj;
+}
+function asText(val, field) {
+    if (typeof val !== "string" || val.trim().length === 0) {
+        throw new Error(`Argument "${field}" must be non-empty text.`);
+    }
+    return val.trim();
+}
+export function createBrowserTools(session, agentId, simulationId, onObservation) {
+    return [
+        {
+            name: "browser_navigate",
+            description: "Navigate to an authorized URL within the target application scope.",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: { type: "string", description: "Relative path or full URL within authorized target scope" },
+                },
+                required: ["url"],
+                additionalProperties: false,
+            },
+            async invoke(rawArgs) {
+                const args = asObject(rawArgs, ["url"]);
+                const url = asText(args.url, "url");
+                const result = await session.navigate(url);
+                if (!result.success) {
+                    return { error: result.error || "Navigation failed" };
+                }
+                return { currentUrl: result.url };
+            },
+        },
+        {
+            name: "browser_inspect",
+            description: "Inspect the current page state, returning accessible ARIA structure and interactive element references.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+                additionalProperties: false,
+            },
+            async invoke() {
+                const snapshot = await session.inspect();
+                return {
+                    url: snapshot.url,
+                    title: snapshot.title,
+                    textSummary: snapshot.textSummary,
+                    ariaSnapshot: snapshot.ariaSnapshot,
+                    elements: snapshot.elements.map((el) => ({
+                        ref: el.ref,
+                        role: el.role,
+                        name: el.name,
+                        text: el.text,
+                        disabled: el.disabled,
+                        ...(el.type ? { type: el.type } : {}),
+                        ...(el.placeholder ? { placeholder: el.placeholder } : {}),
+                        ...(el.checked !== undefined ? { checked: el.checked } : {}),
+                        ...(el.expanded !== undefined ? { expanded: el.expanded } : {}),
+                    })),
+                };
+            },
+        },
+        {
+            name: "browser_click",
+            description: "Click an interactive element identified by its opaque reference (e.g. 'elem_1') from the latest inspection.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ref: { type: "string", description: "Opaque element reference identifier (e.g. 'elem_1')" },
+                },
+                required: ["ref"],
+                additionalProperties: false,
+            },
+            async invoke(rawArgs) {
+                const args = asObject(rawArgs, ["ref"]);
+                const ref = asText(args.ref, "ref");
+                const result = await session.click(ref);
+                if (!result.success) {
+                    return { error: result.error || "Click failed" };
+                }
+                return { success: true, currentUrl: result.url };
+            },
+        },
+        {
+            name: "browser_type",
+            description: "Type text into an interactive input element identified by its opaque reference.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ref: { type: "string", description: "Opaque element reference identifier (e.g. 'elem_1')" },
+                    text: { type: "string", description: "Text to type into the input element" },
+                },
+                required: ["ref", "text"],
+                additionalProperties: false,
+            },
+            async invoke(rawArgs) {
+                const args = asObject(rawArgs, ["ref", "text"]);
+                const ref = asText(args.ref, "ref");
+                const text = typeof args.text === "string" ? args.text : "";
+                const result = await session.type(ref, text);
+                if (!result.success) {
+                    return { error: result.error || "Type failed" };
+                }
+                return { success: true, currentUrl: result.url };
+            },
+        },
+        {
+            name: "browser_scroll",
+            description: "Scroll the page up or down to reveal hidden content or elements.",
+            parameters: {
+                type: "object",
+                properties: {
+                    direction: { type: "string", enum: ["up", "down"], description: "Scroll direction: up or down" },
+                },
+                required: ["direction"],
+                additionalProperties: false,
+            },
+            async invoke(rawArgs) {
+                const args = asObject(rawArgs, ["direction"]);
+                const direction = args.direction === "up" ? "up" : "down";
+                const result = await session.scroll(direction);
+                if (!result.success) {
+                    return { error: result.error || "Scroll failed" };
+                }
+                return { success: true, currentUrl: result.url };
+            },
+        },
+        {
+            name: "browser_select",
+            description: "Select an option in a dropdown or select element by its opaque reference and option value.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ref: { type: "string", description: "Opaque element reference identifier (e.g. 'elem_1')" },
+                    value: { type: "string", description: "Option value to select" },
+                },
+                required: ["ref", "value"],
+                additionalProperties: false,
+            },
+            async invoke(rawArgs) {
+                const args = asObject(rawArgs, ["ref", "value"]);
+                const ref = asText(args.ref, "ref");
+                const value = asText(args.value, "value");
+                const result = await session.select(ref, value);
+                if (!result.success) {
+                    return { error: result.error || "Select failed" };
+                }
+                return { success: true, currentUrl: result.url };
+            },
+        },
+        {
+            name: "browser_record_observation",
+            description: "Record an observed behavior on the current page as untrusted observation data attributed to this user.",
+            parameters: {
+                type: "object",
+                properties: {
+                    description: { type: "string", description: "Description of the observed behavior or anomaly" },
+                },
+                required: ["description"],
+                additionalProperties: false,
+            },
+            async invoke(rawArgs) {
+                const args = asObject(rawArgs, ["description"]);
+                const description = asText(args.description, "description");
+                const location = session.getCurrentUrl() || session.getTargetUrl();
+                const observation = createObservation({
+                    id: observationId(randomUUID()),
+                    simulationId,
+                    agentId,
+                    observedAt: new Date().toISOString(),
+                    description,
+                    context: { location },
+                    evidenceIds: [],
+                });
+                if (onObservation) {
+                    await onObservation(observation);
+                }
+                return { observationId: observation.id, location: observation.context.location };
+            },
+        },
+    ];
+}

package/dist/packages/browser/types.js

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

package/dist/packages/contracts/errors.js

@@ -0,0 +1,8 @@
+export class ContractValidationError extends Error {
+    path;
+    constructor(path, detail) {
+        super(`${path}: ${detail}`);
+        this.name = "ContractValidationError";
+        this.path = path;
+    }
+}

package/dist/packages/contracts/event-envelope.js

@@ -0,0 +1,28 @@
+import { ContractValidationError } from "./errors.js";
+import { readAgentId, readSimulationId, record, text, timestamp } from "./validation.js";
+function origin(value) {
+    const input = record(value, "event.origin", ["kind", "agentId"]);
+    if (input.kind === "agent") {
+        return Object.freeze({ kind: "agent", agentId: readAgentId(input.agentId, "event.origin.agentId") });
+    }
+    if (input.kind !== "system" || Object.hasOwn(input, "agentId")) {
+        throw new ContractValidationError("event.origin", "Expected a system origin or an agent origin with an ID.");
+    }
+    return Object.freeze({ kind: "system" });
+}
+export function parseEventEnvelope(value) {
+    const input = record(value, "event", [
+        "eventId", "type", "schemaVersion", "occurredAt", "simulationId", "origin", "correlationId", "payload",
+    ]);
+    if (input.schemaVersion !== 1) {
+        throw new ContractValidationError("event.schemaVersion", "Only schema version 1 is supported.");
+    }
+    const metadata = {
+        eventId: text(input.eventId, "event.eventId"),
+        occurredAt: timestamp(input.occurredAt, "event.occurredAt"),
+        simulationId: readSimulationId(input.simulationId, "event.simulationId"),
+        origin: origin(input.origin),
+        correlationId: text(input.correlationId, "event.correlationId"),
+    };
+    return { input, base: { ...metadata, schemaVersion: 1 } };
+}

package/dist/packages/contracts/event-validation.js

@@ -0,0 +1,44 @@
+import { ContractValidationError } from "./errors.js";
+import { parseAgentSummary, parseSimulationSummary } from "./summaries.js";
+import { record } from "./validation.js";
+import { parseEventEnvelope } from "./event-envelope.js";
+function simulationPayload(value, status, simulationId) {
+    const input = record(value, "event.payload", ["simulation"]);
+    const simulation = parseSimulationSummary(input.simulation);
+    if (simulation.lifecycle.status !== status || simulation.id !== simulationId) {
+        throw new ContractValidationError("event.payload.simulation", "Lifecycle or simulation ID does not match the envelope.");
+    }
+    // The equality checks above narrow both the subject and its event-specific status.
+    return Object.freeze({ simulation });
+}
+function agentPayload(value, status, simulationId) {
+    const input = record(value, "event.payload", ["agent"]);
+    const agent = parseAgentSummary(input.agent);
+    if (agent.lifecycle.status !== status || agent.simulationId !== simulationId) {
+        throw new ContractValidationError("event.payload.agent", "Lifecycle or simulation ID does not match the envelope.");
+    }
+    return Object.freeze({ agent });
+}
+export function parseLifecycleEvent(value) {
+    const { input, base } = parseEventEnvelope(value);
+    switch (input.type) {
+        case "simulation.started":
+            return Object.freeze({ ...base, type: input.type, payload: simulationPayload(input.payload, "running", base.simulationId) });
+        case "simulation.completed":
+            return Object.freeze({ ...base, type: input.type, payload: simulationPayload(input.payload, "completed", base.simulationId) });
+        case "simulation.failed":
+            return Object.freeze({ ...base, type: input.type, payload: simulationPayload(input.payload, "failed", base.simulationId) });
+        case "simulation.cancelled":
+            return Object.freeze({ ...base, type: input.type, payload: simulationPayload(input.payload, "cancelled", base.simulationId) });
+        case "agent.started":
+            return Object.freeze({ ...base, type: input.type, payload: agentPayload(input.payload, "running", base.simulationId) });
+        case "agent.completed":
+            return Object.freeze({ ...base, type: input.type, payload: agentPayload(input.payload, "completed", base.simulationId) });
+        case "agent.failed":
+            return Object.freeze({ ...base, type: input.type, payload: agentPayload(input.payload, "failed", base.simulationId) });
+        case "agent.cancelled":
+            return Object.freeze({ ...base, type: input.type, payload: agentPayload(input.payload, "cancelled", base.simulationId) });
+        default:
+            throw new ContractValidationError("event.type", "Unknown lifecycle event type.");
+    }
+}

package/dist/packages/contracts/events.js

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

package/dist/packages/contracts/finding-assessment.js

@@ -0,0 +1,128 @@
+export function evaluateFindingAssessment(investigation, observations = []) {
+    const lifecycle = investigation.lifecycle;
+    const outcome = lifecycle.result.outcome;
+    const explanation = lifecycle.result.explanation;
+    const evidenceIds = lifecycle.result.evidenceIds;
+    const participants = Array.from(new Set([investigation.requestedBy, ...lifecycle.agentIds, lifecycle.completedBy]));
+    if (outcome === "inconclusive") {
+        return Object.freeze({
+            investigationId: investigation.id,
+            hypothesis: investigation.hypothesis,
+            outcome,
+            confidence: "inconclusive",
+            explanation,
+            isConfirmedFinding: false,
+            participatingAgents: Object.freeze(participants),
+            evidenceIds: Object.freeze([...evidenceIds]),
+            uncertaintyReason: "Investigation did not establish either a supporting or contradictory conclusion.",
+        });
+    }
+    if (outcome === "contradicted") {
+        return Object.freeze({
+            investigationId: investigation.id,
+            hypothesis: investigation.hypothesis,
+            outcome,
+            confidence: "refuted",
+            explanation,
+            isConfirmedFinding: false,
+            participatingAgents: Object.freeze(participants),
+            evidenceIds: Object.freeze([...evidenceIds]),
+            uncertaintyReason: "The hypothesis was contradicted by investigative assessment.",
+        });
+    }
+    // Outcome is "supported": apply strict verification and independent corroboration criteria.
+    // 1. Evidence presence: conclusion must cite positive supporting evidence.
+    if (evidenceIds.length === 0) {
+        return Object.freeze({
+            investigationId: investigation.id,
+            hypothesis: investigation.hypothesis,
+            outcome,
+            confidence: "provisional",
+            explanation,
+            isConfirmedFinding: false,
+            participatingAgents: Object.freeze(participants),
+            evidenceIds: Object.freeze([]),
+            uncertaintyReason: "Provisional assessment: supported conclusion does not reference any supporting evidence.",
+        });
+    }
+    // 2. Observations presence: simulation observations must be available.
+    const simulationObservations = observations.filter((obs) => obs.simulationId === investigation.simulationId);
+    if (simulationObservations.length === 0) {
+        return Object.freeze({
+            investigationId: investigation.id,
+            hypothesis: investigation.hypothesis,
+            outcome,
+            confidence: "provisional",
+            explanation,
+            isConfirmedFinding: false,
+            participatingAgents: Object.freeze(participants),
+            evidenceIds: Object.freeze([...evidenceIds]),
+            uncertaintyReason: "Provisional assessment: no simulation observations are available to verify evidence or corroborate findings.",
+        });
+    }
+    // 3. Evidence verification: all cited evidenceIds must exist in observed simulation data.
+    const observedEvidenceMap = new Map(); // evidenceId -> agentId
+    for (const obs of simulationObservations) {
+        for (const eid of obs.evidenceIds) {
+            observedEvidenceMap.set(eid, obs.agentId);
+        }
+    }
+    const hasUnverifiedEvidence = evidenceIds.some((eid) => !observedEvidenceMap.has(eid));
+    if (hasUnverifiedEvidence) {
+        return Object.freeze({
+            investigationId: investigation.id,
+            hypothesis: investigation.hypothesis,
+            outcome,
+            confidence: "provisional",
+            explanation,
+            isConfirmedFinding: false,
+            participatingAgents: Object.freeze(participants),
+            evidenceIds: Object.freeze([...evidenceIds]),
+            uncertaintyReason: "Provisional assessment: one or more referenced evidence identifiers are unverified in observed simulation data.",
+        });
+    }
+    // 4. Independent corroboration:
+    // Requester/assignee counts, roster membership, or completion authorship alone do NOT constitute corroboration.
+    // Independent corroboration requires observations contributed by at least two distinct artificial users.
+    const observationMap = new Map();
+    for (const obs of simulationObservations) {
+        observationMap.set(obs.id, obs);
+    }
+    const observingAgents = new Set();
+    for (const obsId of investigation.observationIds) {
+        const obs = observationMap.get(obsId);
+        if (obs) {
+            observingAgents.add(obs.agentId);
+        }
+    }
+    for (const eid of evidenceIds) {
+        const agentId = observedEvidenceMap.get(eid);
+        if (agentId) {
+            observingAgents.add(agentId);
+        }
+    }
+    const isCorroboratedByDistinctObservers = observingAgents.size >= 2;
+    if (!isCorroboratedByDistinctObservers) {
+        return Object.freeze({
+            investigationId: investigation.id,
+            hypothesis: investigation.hypothesis,
+            outcome,
+            confidence: "provisional",
+            explanation,
+            isConfirmedFinding: false,
+            participatingAgents: Object.freeze(participants),
+            evidenceIds: Object.freeze([...evidenceIds]),
+            uncertaintyReason: "Provisional assessment: conclusion was reached without independent collaborator corroboration across distinct observing agents.",
+        });
+    }
+    return Object.freeze({
+        investigationId: investigation.id,
+        hypothesis: investigation.hypothesis,
+        outcome,
+        confidence: "corroborated",
+        explanation,
+        isConfirmedFinding: true,
+        participatingAgents: Object.freeze(participants),
+        evidenceIds: Object.freeze([...evidenceIds]),
+    });
+}

package/dist/packages/contracts/index.js

@@ -0,0 +1,15 @@
+export { ContractValidationError } from "./errors.js";
+export { parseAgentSummary, parseSimulationSummary } from "./summaries.js";
+export { toAgentSummary, toSimulationSummary } from "./mappers.js";
+export { parseLifecycleEvent } from "./event-validation.js";
+export { createLifecycleEvent, serializeLifecycleEvent, deserializeLifecycleEvent } from "./serialization.js";
+export { parseObservationSummary } from "./observation-summary.js";
+export { parseSemanticEvent, createSemanticEvent, serializeSemanticEvent, deserializeSemanticEvent } from "./semantic-events.js";
+export { parseInvestigationSummary, parseInvestigationResult } from "./investigation-summary.js";
+export { parseInvestigationEvent } from "./investigation-events.js";
+export { evaluateFindingAssessment } from "./finding-assessment.js";
+export { parseSimulationSetup, parseExecutionLimits, defaultExecutionLimits, userProfileIds } from "./simulation-setup.js";
+export { parseSimulationConfiguration, parseProjectDescriptor } from "./simulation-configuration.js";
+export { parseLocalTargetUrl, parseTargetConnection, parseTargetSuggestion } from "./target-connection.js";
+export { simulationExecutionModes, simulationExecutionPhases, parseStartSimulationRequest, parseSimulationExecutionStatus, } from "./simulation-execution.js";
+export { parseSimulationResults } from "./simulation-results.js";