@openprose/reactor-cradle 0.1.0-rc.1

package/dist/scenario/parser.d.ts

@@ -0,0 +1,11 @@
+import { type ReactorScenarioV0 } from "./types";
+export interface ParseScenarioOptionsV0 {
+    readonly sourceName?: string;
+}
+export declare class ScenarioParseError extends Error {
+    readonly sourceName: string;
+    readonly line: number;
+    constructor(sourceName: string, line: number, message: string);
+}
+export declare function parseScenarioV0(text: string, options?: ParseScenarioOptionsV0): ReactorScenarioV0;
+//# sourceMappingURL=parser.d.ts.map

package/dist/scenario/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/scenario/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EASvB,MAAM,SAAS,CAAC;AAMjB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAuBD,qBAAa,kBAAmB,SAAQ,KAAK;IAEzC,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM;gBADZ,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM;CAKlB;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,iBAAiB,CAmDnB"}

package/dist/scenario/parser.js

@@ -0,0 +1,490 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioParseError = void 0;
+exports.parseScenarioV0 = parseScenarioV0;
+const types_1 = require("./types");
+const time_1 = require("./time");
+const TOP_LEVEL_KEYS = new Set(["scenario", "world", "initial", "initial_instant", "cassette"]);
+const BLOCK_KEYS = new Set(["sources", "script", "expect"]);
+const WORLD_PROFILES = new Set([
+    "static",
+    "periodic-surprise",
+    "adversarial-silent",
+]);
+const MODEL_REQUEST_KINDS = new Set(["judge", "policy-compile", "spike"]);
+class ScenarioParseError extends Error {
+    sourceName;
+    line;
+    constructor(sourceName, line, message) {
+        super(`${sourceName}:${line}: ${message}`);
+        this.sourceName = sourceName;
+        this.line = line;
+        this.name = "ScenarioParseError";
+    }
+}
+exports.ScenarioParseError = ScenarioParseError;
+function parseScenarioV0(text, options = {}) {
+    const sourceName = options.sourceName ?? "<scenario>";
+    const draft = {
+        sources: [],
+        script: [],
+        relationships: [],
+    };
+    let currentBlock;
+    for (const [zeroIndex, rawLine] of text.split(/\r?\n/).entries()) {
+        const lineNumber = zeroIndex + 1;
+        const line = stripComment(rawLine).trim();
+        if (line.length === 0) {
+            continue;
+        }
+        if (line.startsWith("-")) {
+            if (currentBlock === undefined) {
+                throw parseError(sourceName, lineNumber, "list item is not inside a block");
+            }
+            parseListItem(draft, currentBlock, line.slice(1).trim(), sourceName, lineNumber);
+            continue;
+        }
+        const topLevel = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+        if (topLevel === null) {
+            throw parseError(sourceName, lineNumber, "expected a top-level key or list item");
+        }
+        const key = topLevel[1];
+        const value = topLevel[2];
+        if (key === undefined || value === undefined) {
+            throw parseError(sourceName, lineNumber, "malformed top-level key");
+        }
+        if (BLOCK_KEYS.has(key) && value.length === 0) {
+            currentBlock = key;
+            continue;
+        }
+        currentBlock = undefined;
+        if (!TOP_LEVEL_KEYS.has(key)) {
+            throw parseError(sourceName, lineNumber, `unexpected top-level key ${key}`);
+        }
+        if (value.length === 0) {
+            throw parseError(sourceName, lineNumber, `${key} must have a value`);
+        }
+        setTopLevel(draft, key, parseInlineScalar(value), sourceName, lineNumber);
+    }
+    return finalizeScenario(draft, sourceName);
+}
+function parseListItem(draft, block, text, sourceName, lineNumber) {
+    if (text.length === 0) {
+        throw parseError(sourceName, lineNumber, "list item must not be empty");
+    }
+    const fields = parseFields(text, sourceName, lineNumber);
+    switch (block) {
+        case "sources":
+            draft.sources.push(parseSource(fields, sourceName, lineNumber));
+            return;
+        case "script":
+            draft.script.push(parseScriptStep(fields, sourceName, lineNumber));
+            return;
+        case "expect":
+            draft.relationships.push(parseRelationship(fields, sourceName, lineNumber));
+            return;
+    }
+}
+function setTopLevel(draft, key, value, sourceName, lineNumber) {
+    switch (key) {
+        case "scenario":
+            draft.id = requireIdentifier(value, "scenario", sourceName, lineNumber);
+            return;
+        case "world":
+            draft.world = parseWorldConfig(value, sourceName, lineNumber);
+            return;
+        case "initial":
+        case "initial_instant":
+            draft.initialInstant = (0, time_1.canonicalScenarioInstant)(value, key);
+            return;
+        case "cassette":
+            draft.cassette = requireNonEmpty(value, "cassette", sourceName, lineNumber);
+            return;
+        default:
+            throw parseError(sourceName, lineNumber, `unexpected top-level key ${key}`);
+    }
+}
+function parseSource(fields, sourceName, lineNumber) {
+    const idValue = readStringField(fields, "id") ?? readStringField(fields, "source");
+    const id = requireIdentifier(idValue, "source id", sourceName, lineNumber);
+    const kind = readStringField(fields, "kind");
+    const fixtureRef = readStringField(fields, "fixture");
+    const extra = omitFields(fields, ["id", "source", "kind", "fixture"]);
+    return {
+        id,
+        ...(kind === undefined ? {} : { kind }),
+        ...(fixtureRef === undefined ? {} : { fixture_ref: fixtureRef }),
+        fields: freezeFields(extra),
+    };
+}
+function parseScriptStep(fields, sourceName, lineNumber) {
+    const time = parseStepTime(fields, sourceName, lineNumber);
+    const label = readStringField(fields, "label");
+    if (fields.has("ingest")) {
+        const event = stringFieldValue(fields.get("ingest"), "ingest", sourceName, lineNumber);
+        const sourceId = readStringField(fields, "source");
+        const extra = omitFields(fields, ["at", "after", "label", "ingest", "source"]);
+        return {
+            kind: "ingest",
+            time,
+            event,
+            ...(label === undefined ? {} : { label }),
+            ...(sourceId === undefined ? {} : { source_id: sourceId }),
+            fields: freezeFields(extra),
+        };
+    }
+    if (fields.has("tick")) {
+        const tickValue = fields.get("tick");
+        const recheckKind = readTickRecheckKind(tickValue, sourceName, lineNumber);
+        const extra = omitFields(fields, ["at", "after", "label", "tick"]);
+        return {
+            kind: "tick",
+            time,
+            ...(label === undefined ? {} : { label }),
+            ...(recheckKind === undefined ? {} : { recheck_kind: recheckKind }),
+            fields: freezeFields(extra),
+        };
+    }
+    if (fields.has("read")) {
+        const sourceId = stringFieldValue(fields.get("read"), "read", sourceName, lineNumber);
+        const extra = omitFields(fields, ["at", "after", "label", "read"]);
+        return {
+            kind: "read",
+            time,
+            source_id: sourceId,
+            ...(label === undefined ? {} : { label }),
+            fields: freezeFields(extra),
+        };
+    }
+    if (fields.has("model")) {
+        const requestKind = stringFieldValue(fields.get("model"), "model", sourceName, lineNumber);
+        if (!MODEL_REQUEST_KINDS.has(requestKind)) {
+            throw parseError(sourceName, lineNumber, "model must be judge, policy-compile, or spike");
+        }
+        const prompt = readStringField(fields, "prompt");
+        if (prompt === undefined) {
+            throw parseError(sourceName, lineNumber, "model step requires prompt");
+        }
+        const extra = omitFields(fields, ["at", "after", "label", "model", "prompt"]);
+        return {
+            kind: "model",
+            time,
+            request_kind: requestKind,
+            prompt,
+            ...(label === undefined ? {} : { label }),
+            fields: freezeFields(extra),
+        };
+    }
+    throw parseError(sourceName, lineNumber, "script item must declare ingest, tick, read, or model");
+}
+function parseStepTime(fields, sourceName, lineNumber) {
+    const at = readStringField(fields, "at");
+    const after = readStringField(fields, "after");
+    if (at !== undefined && after !== undefined) {
+        throw parseError(sourceName, lineNumber, "script item cannot use both at and after");
+    }
+    if (at === undefined && after === undefined) {
+        throw parseError(sourceName, lineNumber, "script item requires at or after");
+    }
+    if (at !== undefined) {
+        (0, time_1.parseScenarioDurationMs)(at, "at");
+        return { at };
+    }
+    if (after === undefined) {
+        throw parseError(sourceName, lineNumber, "script item requires after");
+    }
+    (0, time_1.parseScenarioDurationMs)(after, "after");
+    return { after };
+}
+function readTickRecheckKind(value, sourceName, lineNumber) {
+    if (value === undefined || value === true || value === "forecast") {
+        return undefined;
+    }
+    if (value === "evidence-age" || value === "plan-age") {
+        return value;
+    }
+    if (typeof value === "string") {
+        throw parseError(sourceName, lineNumber, "tick must be forecast, evidence-age, or plan-age when it carries a value");
+    }
+    throw parseError(sourceName, lineNumber, "tick value must be a string");
+}
+function parseRelationship(fields, sourceName, lineNumber) {
+    const relationship = readStringField(fields, "relationship") ??
+        readStringField(fields, "assertion") ??
+        readBareRelationship(fields);
+    if (relationship === undefined) {
+        throw parseError(sourceName, lineNumber, "expect item requires relationship");
+    }
+    return {
+        relationship: requireIdentifier(relationship, "relationship", sourceName, lineNumber),
+        fields: freezeFields(omitFields(fields, ["relationship", "assertion", relationship])),
+    };
+}
+function readBareRelationship(fields) {
+    if (fields.size !== 1) {
+        return undefined;
+    }
+    const first = fields.entries().next().value;
+    if (first === undefined) {
+        return undefined;
+    }
+    const [key, value] = first;
+    return value === true ? key : undefined;
+}
+function finalizeScenario(draft, sourceName) {
+    const missing = [];
+    if (draft.id === undefined) {
+        missing.push("scenario");
+    }
+    if (draft.world === undefined) {
+        missing.push("world");
+    }
+    if (draft.initialInstant === undefined) {
+        missing.push("initial");
+    }
+    if (draft.cassette === undefined) {
+        missing.push("cassette");
+    }
+    if (draft.sources.length === 0) {
+        missing.push("sources");
+    }
+    if (draft.script.length === 0) {
+        missing.push("script");
+    }
+    if (missing.length > 0) {
+        throw new ScenarioParseError(sourceName, 0, `scenario is missing required field(s): ${missing.join(", ")}`);
+    }
+    return {
+        schema: types_1.REACTOR_SCENARIO_SCHEMA_V0,
+        v: types_1.REACTOR_SCENARIO_VERSION_V0,
+        id: draft.id,
+        world: draft.world,
+        initial_instant: draft.initialInstant,
+        cassette: { path: draft.cassette },
+        sources: Object.freeze([...draft.sources]),
+        script: Object.freeze([...draft.script]),
+        expect: {
+            relationships: Object.freeze([...draft.relationships]),
+        },
+    };
+}
+function parseWorldConfig(value, sourceName, lineNumber) {
+    const tokens = tokenize(value, sourceName, lineNumber);
+    const profileToken = tokens[0];
+    if (profileToken === undefined) {
+        throw parseError(sourceName, lineNumber, "world must have a profile");
+    }
+    if (profileToken.includes("=") || profileToken.includes(":")) {
+        throw parseError(sourceName, lineNumber, "world profile must be the first bare value");
+    }
+    if (!WORLD_PROFILES.has(profileToken)) {
+        throw parseError(sourceName, lineNumber, "world must be one of static, periodic-surprise, adversarial-silent");
+    }
+    const fields = parseFields(tokens.slice(1).join(" "), sourceName, lineNumber);
+    const everyEvents = fields.get("every_events");
+    if (everyEvents !== undefined) {
+        if (typeof everyEvents !== "number" ||
+            !Number.isSafeInteger(everyEvents) ||
+            everyEvents <= 0) {
+            throw parseError(sourceName, lineNumber, "world every_events must be a positive safe integer");
+        }
+        if (profileToken !== "periodic-surprise") {
+            throw parseError(sourceName, lineNumber, "world every_events only applies to periodic-surprise");
+        }
+    }
+    if (fields.size > (everyEvents === undefined ? 0 : 1)) {
+        throw parseError(sourceName, lineNumber, "world has unsupported field(s)");
+    }
+    return everyEvents === undefined
+        ? { profile: profileToken }
+        : {
+            profile: profileToken,
+            every_events: everyEvents,
+        };
+}
+function parseFields(text, sourceName, lineNumber) {
+    const fields = new Map();
+    const tokens = tokenize(text, sourceName, lineNumber);
+    let index = 0;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token === undefined) {
+            break;
+        }
+        const inline = splitInlineKeyValue(token);
+        if (inline !== undefined) {
+            setField(fields, inline.key, parseFieldValue(inline.value), sourceName, lineNumber);
+            index += 1;
+            continue;
+        }
+        if (token.endsWith(":") && token.length > 1) {
+            const key = token.slice(0, -1);
+            const next = tokens[index + 1];
+            if (next === undefined || isKeyToken(next)) {
+                setField(fields, key, true, sourceName, lineNumber);
+                index += 1;
+                continue;
+            }
+            setField(fields, key, parseFieldValue(next), sourceName, lineNumber);
+            index += 2;
+            continue;
+        }
+        setField(fields, token, true, sourceName, lineNumber);
+        index += 1;
+    }
+    return fields;
+}
+function splitInlineKeyValue(token) {
+    const equalsIndex = token.indexOf("=");
+    if (equalsIndex > 0) {
+        return {
+            key: token.slice(0, equalsIndex),
+            value: token.slice(equalsIndex + 1),
+        };
+    }
+    const colonIndex = token.indexOf(":");
+    if (colonIndex > 0 && colonIndex < token.length - 1) {
+        return {
+            key: token.slice(0, colonIndex),
+            value: token.slice(colonIndex + 1),
+        };
+    }
+    return undefined;
+}
+function tokenize(text, sourceName, lineNumber) {
+    const tokens = [];
+    let current = "";
+    let quote;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (char === undefined) {
+            continue;
+        }
+        if (quote !== undefined) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (quote !== undefined) {
+        throw parseError(sourceName, lineNumber, "unterminated quoted value");
+    }
+    if (current.length > 0) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function stripComment(line) {
+    let quote;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (char === undefined) {
+            continue;
+        }
+        if (quote !== undefined) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            quote = char;
+            continue;
+        }
+        if (char === "#") {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+function isKeyToken(token) {
+    return token.endsWith(":") || /^[A-Za-z_][A-Za-z0-9_-]*(?:=|:).+$/.test(token);
+}
+function parseFieldValue(value) {
+    const scalar = parseInlineScalar(value);
+    if (scalar === "true") {
+        return true;
+    }
+    if (scalar === "false") {
+        return false;
+    }
+    if (/^-?\d+$/.test(scalar)) {
+        const parsed = Number(scalar);
+        if (Number.isSafeInteger(parsed)) {
+            return parsed;
+        }
+    }
+    return scalar;
+}
+function parseInlineScalar(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function setField(fields, key, value, sourceName, lineNumber) {
+    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(key)) {
+        throw parseError(sourceName, lineNumber, `invalid field key ${key}`);
+    }
+    if (fields.has(key)) {
+        throw parseError(sourceName, lineNumber, `duplicate field key ${key}`);
+    }
+    fields.set(key, value);
+}
+function readStringField(fields, key) {
+    const value = fields.get(key);
+    return typeof value === "string" ? value : undefined;
+}
+function stringFieldValue(value, key, sourceName, lineNumber) {
+    if (typeof value !== "string") {
+        throw parseError(sourceName, lineNumber, `${key} must be a string value`);
+    }
+    return requireNonEmpty(value, key, sourceName, lineNumber);
+}
+function omitFields(fields, omitted) {
+    const omittedKeys = new Set(omitted);
+    const result = {};
+    for (const [key, value] of fields.entries()) {
+        if (!omittedKeys.has(key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function freezeFields(fields) {
+    return Object.freeze({ ...fields });
+}
+function requireIdentifier(value, label, sourceName, lineNumber) {
+    const id = requireNonEmpty(value, label, sourceName, lineNumber);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(id)) {
+        throw parseError(sourceName, lineNumber, `${label} must use letters, numbers, dots, underscores, colons, or dashes`);
+    }
+    return id;
+}
+function requireNonEmpty(value, label, sourceName, lineNumber) {
+    if (value === undefined || value.length === 0) {
+        throw parseError(sourceName, lineNumber, `${label} must be non-empty`);
+    }
+    return value;
+}
+function parseError(sourceName, lineNumber, message) {
+    return new ScenarioParseError(sourceName, lineNumber, message);
+}

package/dist/scenario/runner.d.ts

@@ -0,0 +1,12 @@
+import type { ReactorModelGatewayAdapterV0 } from "@openprose/reactor/sdk";
+import { type ReactorScenarioV0, type ScenarioClockAdapterV0, type ScenarioRunReceiptV0, type ScenarioRunnerReactorV0, type ScenarioRunnerStorageV0, type ScenarioWorldAdapterV0 } from "./types";
+export interface RunScenarioInputV0 {
+    readonly scenario: ReactorScenarioV0;
+    readonly clock: ScenarioClockAdapterV0;
+    readonly world: ScenarioWorldAdapterV0;
+    readonly modelGateway: ReactorModelGatewayAdapterV0;
+    readonly storage?: ScenarioRunnerStorageV0;
+    readonly reactor?: ScenarioRunnerReactorV0;
+}
+export declare function runScenarioV0(input: RunScenarioInputV0): ScenarioRunReceiptV0;
+//# sourceMappingURL=runner.d.ts.map

package/dist/scenario/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/scenario/runner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,4BAA4B,EAE7B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAG3B,KAAK,oBAAoB,EAEzB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAG5B,KAAK,sBAAsB,EAG5B,MAAM,SAAS,CAAC;AAOjB,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,4BAA4B,CAAC;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAC;CAC5C;AAkBD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,kBAAkB,GACxB,oBAAoB,CAqCtB"}