@rotifer/playground 0.25.1 → 0.26.0

package/dist/testsuite/generate.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Seeded input generation, shared by `arena submit` and the §47.5 T1 property
+ * test.
+ *
+ * Moved verbatim out of arena-submit.ts rather than reimplemented: S_r has to
+ * stay reproducible across releases, and a second generator that drifted from
+ * this one would make `rotifer test` and Arena admission disagree about what a
+ * Gene was fed. Same seed, same input, both callers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mulberry32 = mulberry32;
+exports.generateTestInput = generateTestInput;
+function mulberry32(seed) {
+    let s = seed | 0;
+    return () => {
+        s = (s + 0x6d2b79f5) | 0;
+        let t = Math.imul(s ^ (s >>> 15), 1 | s);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function generateTestInput(schema, seed) {
+    if (!schema || !schema.properties)
+        return { data: `test-input-${seed}` };
+    const rng = mulberry32(seed * 2654435761);
+    const input = {};
+    for (const [key, prop] of Object.entries(schema.properties)) {
+        if (prop.default !== undefined) {
+            input[key] = prop.default;
+        }
+        else if (prop.enum && prop.enum.length > 0) {
+            input[key] = prop.enum[seed % prop.enum.length];
+        }
+        else if (prop.type === "array" && prop.items) {
+            const count = 50 + seed * 10;
+            const arr = [];
+            if (prop.items.type === "number") {
+                let price = 100;
+                for (let i = 0; i < count; i++) {
+                    price *= 1 + (rng() - 0.48) * 0.04;
+                    arr.push(Math.round(price * 100) / 100);
+                }
+            }
+            else if (prop.items.type === "string") {
+                for (let i = 0; i < Math.min(count, 5); i++)
+                    arr.push(`item-${i}`);
+            }
+            else if (prop.items.type === "object") {
+                for (let i = 0; i < Math.min(count, 3); i++) {
+                    arr.push(generateTestInput({ properties: prop.items.properties }, seed + i));
+                }
+            }
+            input[key] = arr;
+        }
+        else if (prop.type === "number") {
+            const min = prop.minimum ?? 1;
+            const max = prop.maximum ?? 100;
+            input[key] = Math.min(min + seed, max);
+        }
+        else if (prop.type === "string") {
+            input[key] = `test-${seed}`;
+        }
+        else if (prop.type === "boolean") {
+            input[key] = seed % 2 === 0;
+        }
+    }
+    return input;
+}
+//# sourceMappingURL=generate.js.map

package/dist/testsuite/generate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.js","sourceRoot":"","sources":["../../src/testsuite/generate.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAEH,gCAQC;AAED,8CAsCC;AAhDD,SAAgB,UAAU,CAAC,IAAY;IACrC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;IACjB,OAAO,GAAG,EAAE;QACV,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACzC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/C,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC;IAC/C,CAAC,CAAC;AACJ,CAAC;AAED,SAAgB,iBAAiB,CAAC,MAAW,EAAE,IAAY;IACzD,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,IAAI,EAAE,EAAE,CAAC;IAEzE,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAwB,EAAE,CAAC;IACtC,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAoB,EAAE,CAAC;QAC/E,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC/B,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7C,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClD,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/C,MAAM,KAAK,GAAG,EAAE,GAAG,IAAI,GAAG,EAAE,CAAC;YAC7B,MAAM,GAAG,GAAU,EAAE,CAAC;YACtB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACjC,IAAI,KAAK,GAAG,GAAG,CAAC;gBAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;oBACnC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;gBAC1C,CAAC;YACH,CAAC;iBAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;oBAAE,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACrE,CAAC;iBAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC5C,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC/E,CAAC;YACH,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;QACnB,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAClC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;YAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;YAChC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,EAAE,GAAG,CAAC,CAAC;QACzC,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAClC,KAAK,CAAC,GAAG,CAAC,GAAG,QAAQ,IAAI,EAAE,CAAC;QAC9B,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACnC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/testsuite/load.d.ts

@@ -0,0 +1,23 @@
+import type { TestSuite } from "./types.js";
+export declare const TESTSUITE_FILENAME = "testsuite.json";
+export interface LoadOk {
+    status: "ok";
+    suite: TestSuite;
+    path: string;
+}
+/** The file is absent. Stage 1 sets no gate, so this is not an error — the
+ * caller decides. §47.5's gate (stage 2) is the thing that turns it into one. */
+export interface LoadAbsent {
+    status: "absent";
+    path: string;
+}
+export interface LoadInvalid {
+    status: "invalid";
+    path: string;
+    /** Field-level, e.g. `testCases[2].timeout: expected a number, got string`. */
+    errors: string[];
+}
+export type LoadResult = LoadOk | LoadAbsent | LoadInvalid;
+export declare function parseTestSuite(text: string, path: string): LoadOk | LoadInvalid;
+export declare function loadTestSuite(geneDir: string): LoadResult;
+//# sourceMappingURL=load.d.ts.map

package/dist/testsuite/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/testsuite/load.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAwB,MAAM,YAAY,CAAC;AAElE,eAAO,MAAM,kBAAkB,mBAAmB,CAAC;AAEnD,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;iFACiF;AACjF,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,QAAQ,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,CAAC;AAuE3D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,CA2C/E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAIzD"}

package/dist/testsuite/load.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TESTSUITE_FILENAME = void 0;
+exports.parseTestSuite = parseTestSuite;
+exports.loadTestSuite = loadTestSuite;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.TESTSUITE_FILENAME = "testsuite.json";
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Validation is hand-written rather than delegated to ajv on purpose: the
+ * struct is six fields, and the value of this file is the error message. A
+ * schema validator would answer "does not match schema" where the author
+ * needs "testCases[2].timeout: expected a number, got string".
+ *
+ * Unknown fields are rejected rather than ignored. A typo'd `expectedOutputs`
+ * that is silently dropped means a case that never asserts anything and still
+ * reports as passing — the exact failure mode this whole plan exists to close.
+ */
+const CASE_FIELDS = new Set([
+    "input",
+    "expectedOutput",
+    "expectedSchema",
+    "timeout",
+]);
+const CONFIG_FIELDS = new Set(["fuzzIterations", "seed"]);
+const SUITE_FIELDS = new Set(["testCases", "config"]);
+function validateCase(raw, at, errors) {
+    if (!isPlainObject(raw)) {
+        errors.push(`${at}: expected an object, got ${Array.isArray(raw) ? "array" : typeof raw}`);
+        return;
+    }
+    for (const key of Object.keys(raw)) {
+        if (!CASE_FIELDS.has(key)) {
+            errors.push(`${at}.${key}: unknown field (spec §4.2 TestCase has input, expectedOutput, expectedSchema, timeout)`);
+        }
+    }
+    if (!("input" in raw)) {
+        errors.push(`${at}.input: required (spec §4.2 TestCase)`);
+    }
+    if ("expectedSchema" in raw && !isPlainObject(raw.expectedSchema)) {
+        errors.push(`${at}.expectedSchema: expected a JSON Schema object, got ${typeof raw.expectedSchema}`);
+    }
+    if ("timeout" in raw) {
+        const t = raw.timeout;
+        if (typeof t !== "number" || !Number.isFinite(t) || t <= 0) {
+            errors.push(`${at}.timeout: expected a positive number of milliseconds, got ${JSON.stringify(t)}`);
+        }
+    }
+}
+function validateConfig(raw, errors) {
+    if (!isPlainObject(raw)) {
+        errors.push(`config: expected an object, got ${typeof raw}`);
+        return;
+    }
+    for (const key of Object.keys(raw)) {
+        if (!CONFIG_FIELDS.has(key)) {
+            errors.push(`config.${key}: unknown field (spec §4.2 TestConfig has fuzzIterations, seed)`);
+        }
+    }
+    for (const key of ["fuzzIterations", "seed"]) {
+        if (key in raw) {
+            const v = raw[key];
+            if (typeof v !== "number" || !Number.isInteger(v) || v < 0) {
+                errors.push(`config.${key}: expected a non-negative integer, got ${JSON.stringify(v)}`);
+            }
+        }
+    }
+}
+function parseTestSuite(text, path) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (e) {
+        return { status: "invalid", path, errors: [`not valid JSON — ${e.message}`] };
+    }
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return {
+            status: "invalid",
+            path,
+            errors: [`expected an object at the top level, got ${Array.isArray(raw) ? "array" : typeof raw}`],
+        };
+    }
+    for (const key of Object.keys(raw)) {
+        if (!SUITE_FIELDS.has(key)) {
+            errors.push(`${key}: unknown field (spec §4.2 TestSuite has testCases, config)`);
+        }
+    }
+    if (!Array.isArray(raw.testCases)) {
+        errors.push(`testCases: required, expected an array (spec §4.2 TestSuite)`);
+    }
+    else if (raw.testCases.length === 0) {
+        errors.push(`testCases: must not be empty — a suite with no cases asserts nothing`);
+    }
+    else {
+        raw.testCases.forEach((c, i) => validateCase(c, `testCases[${i}]`, errors));
+    }
+    if ("config" in raw)
+        validateConfig(raw.config, errors);
+    if (errors.length > 0)
+        return { status: "invalid", path, errors };
+    return {
+        status: "ok",
+        path,
+        suite: {
+            testCases: raw.testCases,
+            ...(isPlainObject(raw.config) ? { config: raw.config } : {}),
+        },
+    };
+}
+function loadTestSuite(geneDir) {
+    const path = (0, node_path_1.join)(geneDir, exports.TESTSUITE_FILENAME);
+    if (!(0, node_fs_1.existsSync)(path))
+        return { status: "absent", path };
+    return parseTestSuite((0, node_fs_1.readFileSync)(path, "utf-8"), path);
+}
+//# sourceMappingURL=load.js.map

package/dist/testsuite/load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.js","sourceRoot":"","sources":["../../src/testsuite/load.ts"],"names":[],"mappings":"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"}

package/dist/testsuite/run.d.ts

@@ -0,0 +1,109 @@
+import Ajv from "ajv";
+import type { ValidateFunction } from "ajv";
+import type { ClassifiedCase, TestCase, TestResult, TestSuite } from "./types.js";
+/** §47.5 fixes the publishing gate's property test at 10 random inputs. */
+export declare const DEFAULT_FUZZ_ITERATIONS = 10;
+/**
+ * What running one input against the Gene produced. The runner is injected
+ * rather than imported so this module stays free of the native binding: the
+ * caller already owns a compiled Gene and a fuel policy, and the T1 rules are
+ * about interpreting outcomes, not about producing them.
+ */
+export interface RunOutcome {
+    /** The Gene ran to completion and returned an output. */
+    success: boolean;
+    output?: unknown;
+    /** Present when success is false. A *controlled* rejection also lands here. */
+    errorMessage?: string;
+    /** True when the Gene did not reject but died — trap, fuel exhaustion,
+     * timeout. §47.5's negative case is about handling illegal input
+     * "correctly", and dying is not handling it. */
+    crashed?: boolean;
+    durationMs?: number;
+}
+export type GeneRunner = (input: unknown, timeoutMs?: number) => RunOutcome;
+/**
+ * Classify a case as positive or negative from the input alone.
+ *
+ * spec §4.2's TestCase has no field saying which it is, and §47.5 words the
+ * negative case as "gene can correctly handle illegal input" — legality being
+ * decided by the Gene's own inputSchema. So the classification is derived:
+ * an input the schema accepts is a positive case, one it rejects is negative.
+ *
+ * The consequence worth stating: a positive case whose input is accidentally
+ * malformed silently becomes a negative case. That is why the reason string
+ * carries the validator's complaint — an author who meant it to be positive
+ * sees exactly which field disqualified it.
+ */
+export declare function classify(testCases: TestCase[], inputValidator: ValidateFunction | null): ClassifiedCase[];
+/**
+ * A positive case passes when the Gene runs and its output satisfies whatever
+ * the case asserts: `expectedOutput` exactly, `expectedSchema` structurally,
+ * or — when the case asserts neither — the Gene's declared outputSchema.
+ *
+ * The fallback matters. Without it a case carrying only an input would pass on
+ * any output at all, including one that violates the Gene's own contract, and
+ * the suite would look populated while asserting nothing.
+ */
+export declare function runPositive(c: ClassifiedCase, run: GeneRunner, outputValidator: ValidateFunction | null, ajv: Ajv): TestResult;
+/**
+ * A negative case: the Gene is fed input its own inputSchema forbids.
+ *
+ * §47.5 asks that the Gene "correctly handle illegal input" without saying
+ * what handling looks like, and measuring four real Genes shows why it cannot
+ * be decided from the outcome alone:
+ *
+ *   grammar-checker   throws     — `not a function`, a TypeError from inside
+ *   source-linker     returns    — echoes the illegal value straight back
+ *   url-extractor     returns    — an empty result
+ *   json-validator    returns    — `{ valid: false }`, which IS correct handling
+ *
+ * "Returned output" therefore cannot mean acceptance: for json-validator it is
+ * the right answer, and for source-linker it is the bug. The difference is not
+ * in the outcome, it is in what the author intended — so the author has to say,
+ * using the fields spec §4.2 already provides.
+ *
+ * The rules, in order:
+ *
+ *   1. Crashed — fail. Dying is not handling, whatever was intended.
+ *   2. Errored without crashing — pass. The Gene refused, deliberately.
+ *   3. Returned, and the case declares expectedOutput/expectedSchema that
+ *      matches — pass. This is the author saying "rejection looks like this".
+ *   4. Returned, and the declaration does not match — fail.
+ *   5. Returned, and the case declares nothing — fail, and say why. Silent
+ *      acceptance and correct handling are indistinguishable here; refusing to
+ *      guess is the whole point, since guessing "pass" is what lets a
+ *      source-linker through.
+ */
+export declare function runNegative(c: ClassifiedCase, run: GeneRunner, ajv: Ajv): TestResult;
+/**
+ * §47.4 Schema Legality, run as §47.5's third T1 requirement: generated inputs
+ * must always produce output conforming to outputSchema.
+ *
+ * The seed is what makes a failure actionable — the same seed replays the same
+ * inputs, so a property failure can be reproduced rather than merely observed.
+ * When the suite gives no seed one is derived from nothing but a constant, so
+ * two runs of an unseeded suite still agree; randomness across runs would make
+ * the gate flaky and the flake would be blamed on the Gene.
+ */
+export declare function runProperty(suite: TestSuite, inputSchema: Record<string, unknown> | null, run: GeneRunner, outputValidator: ValidateFunction | null): TestResult;
+export interface T1Report {
+    results: TestResult[];
+    classified: ClassifiedCase[];
+    /** The three §47.5 T1 requirements, each satisfied or not. */
+    requirements: {
+        positive: boolean;
+        negative: boolean;
+        property: boolean;
+    };
+    /** True only when all three hold. This is what stage 2's publish gate reads. */
+    gatePassed: boolean;
+}
+export declare function runT1(suite: TestSuite, opts: {
+    inputSchema: Record<string, unknown> | null;
+    outputSchema: Record<string, unknown> | null;
+    run: GeneRunner;
+}): T1Report;
+/** Stable id for a report, for callers that persist results. */
+export declare function newTestRunId(): string;
+//# sourceMappingURL=run.d.ts.map

package/dist/testsuite/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/testsuite/run.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAC;AAE5C,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,UAAU,EACV,SAAS,EACV,MAAM,YAAY,CAAC;AAGpB,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,yDAAyD;IACzD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;oDAEgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,QAAQ,EAAE,EACrB,cAAc,EAAE,gBAAgB,GAAG,IAAI,GACtC,cAAc,EAAE,CA2BlB;AA4CD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE,UAAU,EACf,eAAe,EAAE,gBAAgB,GAAG,IAAI,EACxC,GAAG,EAAE,GAAG,GACP,UAAU,CA2CZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE,UAAU,EACf,GAAG,EAAE,GAAG,GACP,UAAU,CAmDZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EAC3C,GAAG,EAAE,UAAU,EACf,eAAe,EAAE,gBAAgB,GAAG,IAAI,GACvC,UAAU,CAkCZ;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,8DAA8D;IAC9D,YAAY,EAAE;QACZ,QAAQ,EAAE,OAAO,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,gFAAgF;IAChF,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,wBAAgB,KAAK,CACnB,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE;IACJ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC7C,GAAG,EAAE,UAAU,CAAC;CACjB,GACA,QAAQ,CA2DV;AAED,gEAAgE;AAChE,wBAAgB,YAAY,IAAI,MAAM,CAErC"}

package/dist/testsuite/run.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FUZZ_ITERATIONS = void 0;
+exports.classify = classify;
+exports.runPositive = runPositive;
+exports.runNegative = runNegative;
+exports.runProperty = runProperty;
+exports.runT1 = runT1;
+exports.newTestRunId = newTestRunId;
+const ajv_1 = __importDefault(require("ajv"));
+const node_crypto_1 = require("node:crypto");
+const generate_js_1 = require("./generate.js");
+/** §47.5 fixes the publishing gate's property test at 10 random inputs. */
+exports.DEFAULT_FUZZ_ITERATIONS = 10;
+/**
+ * Classify a case as positive or negative from the input alone.
+ *
+ * spec §4.2's TestCase has no field saying which it is, and §47.5 words the
+ * negative case as "gene can correctly handle illegal input" — legality being
+ * decided by the Gene's own inputSchema. So the classification is derived:
+ * an input the schema accepts is a positive case, one it rejects is negative.
+ *
+ * The consequence worth stating: a positive case whose input is accidentally
+ * malformed silently becomes a negative case. That is why the reason string
+ * carries the validator's complaint — an author who meant it to be positive
+ * sees exactly which field disqualified it.
+ */
+function classify(testCases, inputValidator) {
+    return testCases.map((testCase, index) => {
+        if (!inputValidator) {
+            // No inputSchema to judge against. Everything is a positive case, and
+            // the §47.5 gate will report the missing negative rather than inventing
+            // one — see requirementsMet().
+            return {
+                index,
+                kind: "positive",
+                testCase,
+                reason: "gene declares no inputSchema, so no input can be illegal",
+            };
+        }
+        const isLegalInput = inputValidator(testCase.input);
+        if (isLegalInput) {
+            return { index, kind: "positive", testCase, reason: "input conforms to inputSchema" };
+        }
+        const complaint = (inputValidator.errors ?? [])
+            .map((e) => `${e.instancePath || "(root)"} ${e.message}`)
+            .join("; ");
+        return {
+            index,
+            kind: "negative",
+            testCase,
+            reason: `input violates inputSchema — ${complaint || "no detail"}`,
+        };
+    });
+}
+/**
+ * Serialize for comparison with object keys in a stable order.
+ *
+ * `expectedOutput` was compared with plain JSON.stringify, which is key-order
+ * sensitive: a case declaring `{formatted, changed, language}` failed against a
+ * Gene returning `{changed, formatted, language}` — same object by every
+ * meaning JavaScript gives the word, unequal as text. That is a property of the
+ * serializer, not of the Gene, and every author writing an expectedOutput by
+ * hand would hit it. Found by hitting it.
+ *
+ * Array order is preserved: in an array it carries meaning.
+ */
+function canonical(value) {
+    const walk = (v) => {
+        if (Array.isArray(v))
+            return v.map(walk);
+        if (v && typeof v === "object") {
+            const out = {};
+            for (const k of Object.keys(v).sort()) {
+                out[k] = walk(v[k]);
+            }
+            return out;
+        }
+        return v;
+    };
+    return JSON.stringify(walk(value));
+}
+function fail(testId, started, reason, details) {
+    return {
+        testId,
+        level: "T1",
+        passed: false,
+        duration: Date.now() - started,
+        failureReason: reason,
+        ...(details ? { details } : {}),
+    };
+}
+function pass(testId, started, details) {
+    return { testId, level: "T1", passed: true, duration: Date.now() - started, details };
+}
+/**
+ * A positive case passes when the Gene runs and its output satisfies whatever
+ * the case asserts: `expectedOutput` exactly, `expectedSchema` structurally,
+ * or — when the case asserts neither — the Gene's declared outputSchema.
+ *
+ * The fallback matters. Without it a case carrying only an input would pass on
+ * any output at all, including one that violates the Gene's own contract, and
+ * the suite would look populated while asserting nothing.
+ */
+function runPositive(c, run, outputValidator, ajv) {
+    const started = Date.now();
+    const id = `t1-positive-${c.index}`;
+    const outcome = run(c.testCase.input, c.testCase.timeout);
+    if (!outcome.success) {
+        return fail(id, started, `Gene rejected a legal input: ${outcome.errorMessage ?? "no message"}`, c.reason);
+    }
+    if ("expectedOutput" in c.testCase) {
+        const got = canonical(outcome.output);
+        const want = canonical(c.testCase.expectedOutput);
+        if (got !== want) {
+            return fail(id, started, "output does not equal expectedOutput", `expected ${want}, got ${got}`);
+        }
+        return pass(id, started, "output matches expectedOutput exactly");
+    }
+    if (c.testCase.expectedSchema) {
+        let validate;
+        try {
+            validate = ajv.compile(c.testCase.expectedSchema);
+        }
+        catch (e) {
+            return fail(id, started, `expectedSchema is not a valid JSON Schema: ${e.message}`);
+        }
+        if (!validate(outcome.output)) {
+            return fail(id, started, "output does not conform to expectedSchema", JSON.stringify(validate.errors));
+        }
+        return pass(id, started, "output conforms to expectedSchema");
+    }
+    if (outputValidator) {
+        if (!outputValidator(outcome.output)) {
+            return fail(id, started, "output does not conform to the Gene's outputSchema", JSON.stringify(outputValidator.errors));
+        }
+        return pass(id, started, "output conforms to the Gene's outputSchema");
+    }
+    return fail(id, started, "case asserts nothing: no expectedOutput, no expectedSchema, and the Gene declares no outputSchema");
+}
+/**
+ * A negative case: the Gene is fed input its own inputSchema forbids.
+ *
+ * §47.5 asks that the Gene "correctly handle illegal input" without saying
+ * what handling looks like, and measuring four real Genes shows why it cannot
+ * be decided from the outcome alone:
+ *
+ *   grammar-checker   throws     — `not a function`, a TypeError from inside
+ *   source-linker     returns    — echoes the illegal value straight back
+ *   url-extractor     returns    — an empty result
+ *   json-validator    returns    — `{ valid: false }`, which IS correct handling
+ *
+ * "Returned output" therefore cannot mean acceptance: for json-validator it is
+ * the right answer, and for source-linker it is the bug. The difference is not
+ * in the outcome, it is in what the author intended — so the author has to say,
+ * using the fields spec §4.2 already provides.
+ *
+ * The rules, in order:
+ *
+ *   1. Crashed — fail. Dying is not handling, whatever was intended.
+ *   2. Errored without crashing — pass. The Gene refused, deliberately.
+ *   3. Returned, and the case declares expectedOutput/expectedSchema that
+ *      matches — pass. This is the author saying "rejection looks like this".
+ *   4. Returned, and the declaration does not match — fail.
+ *   5. Returned, and the case declares nothing — fail, and say why. Silent
+ *      acceptance and correct handling are indistinguishable here; refusing to
+ *      guess is the whole point, since guessing "pass" is what lets a
+ *      source-linker through.
+ */
+function runNegative(c, run, ajv) {
+    const started = Date.now();
+    const id = `t1-negative-${c.index}`;
+    const outcome = run(c.testCase.input, c.testCase.timeout);
+    if (outcome.crashed) {
+        // ADR-333: a crash fails not because it is necessarily a bug, but because
+        // it is necessarily unusable. A trap reaching the caller carries no
+        // information — the caller cannot tell deliberate refusal from defect, so
+        // nothing downstream can act on it correctly. §47.5 asks for "correctly
+        // handle", and a signal the caller cannot handle is not handling completed.
+        return fail(id, started, `Gene crashed on illegal input instead of handling it: ${outcome.errorMessage ?? "no message"}`, c.reason);
+    }
+    if (!outcome.success) {
+        return pass(id, started, `Gene refused illegal input: ${outcome.errorMessage ?? "no message"}`);
+    }
+    if ("expectedOutput" in c.testCase) {
+        const got = canonical(outcome.output);
+        const want = canonical(c.testCase.expectedOutput);
+        return got === want
+            ? pass(id, started, "Gene handled illegal input exactly as the case declares")
+            : fail(id, started, "output does not equal the declared expectedOutput", `expected ${want}, got ${got}`);
+    }
+    if (c.testCase.expectedSchema) {
+        let validate;
+        try {
+            validate = ajv.compile(c.testCase.expectedSchema);
+        }
+        catch (e) {
+            return fail(id, started, `expectedSchema is not a valid JSON Schema: ${e.message}`);
+        }
+        return validate(outcome.output)
+            ? pass(id, started, "Gene handled illegal input in the declared shape")
+            : fail(id, started, "output does not conform to the declared expectedSchema", JSON.stringify(validate.errors));
+    }
+    return fail(id, started, "Gene returned output for illegal input and the case declares no expected shape", `${c.reason}; output was ${JSON.stringify(outcome.output).slice(0, 200)}. ` +
+        `If returning this is correct handling, declare it with expectedOutput or expectedSchema; ` +
+        `otherwise the Gene is silently accepting input its own schema forbids.`);
+}
+/**
+ * §47.4 Schema Legality, run as §47.5's third T1 requirement: generated inputs
+ * must always produce output conforming to outputSchema.
+ *
+ * The seed is what makes a failure actionable — the same seed replays the same
+ * inputs, so a property failure can be reproduced rather than merely observed.
+ * When the suite gives no seed one is derived from nothing but a constant, so
+ * two runs of an unseeded suite still agree; randomness across runs would make
+ * the gate flaky and the flake would be blamed on the Gene.
+ */
+function runProperty(suite, inputSchema, run, outputValidator) {
+    const started = Date.now();
+    const id = "t1-property-schema-legality";
+    const iterations = suite.config?.fuzzIterations ?? exports.DEFAULT_FUZZ_ITERATIONS;
+    const seed = suite.config?.seed ?? 1;
+    if (iterations === 0) {
+        return fail(id, started, "config.fuzzIterations is 0 — the property test asserts nothing");
+    }
+    if (!outputValidator) {
+        return fail(id, started, "Gene declares no outputSchema, so schema legality cannot be asserted");
+    }
+    for (let i = 0; i < iterations; i++) {
+        const input = (0, generate_js_1.generateTestInput)(inputSchema, seed + i);
+        const outcome = run(input);
+        if (!outcome.success) {
+            return fail(id, started, `iteration ${i + 1}/${iterations} did not produce output: ${outcome.errorMessage ?? "no message"}`, `reproduce with seed ${seed}, input ${JSON.stringify(input).slice(0, 200)}`);
+        }
+        if (!outputValidator(outcome.output)) {
+            return fail(id, started, `iteration ${i + 1}/${iterations} produced output violating outputSchema`, `reproduce with seed ${seed}, input ${JSON.stringify(input).slice(0, 200)}`);
+        }
+    }
+    return pass(id, started, `${iterations} generated inputs all produced schema-legal output (seed ${seed})`);
+}
+function runT1(suite, opts) {
+    const ajv = new ajv_1.default({ allErrors: true, strict: false });
+    let inputValidator = null;
+    let outputValidator = null;
+    try {
+        if (opts.inputSchema)
+            inputValidator = ajv.compile(opts.inputSchema);
+    }
+    catch {
+        inputValidator = null;
+    }
+    try {
+        if (opts.outputSchema)
+            outputValidator = ajv.compile(opts.outputSchema);
+    }
+    catch {
+        outputValidator = null;
+    }
+    const classified = classify(suite.testCases, inputValidator);
+    const results = [];
+    for (const c of classified) {
+        results.push(c.kind === "positive"
+            ? runPositive(c, opts.run, outputValidator, ajv)
+            : runNegative(c, opts.run, ajv));
+    }
+    const property = runProperty(suite, opts.inputSchema, opts.run, outputValidator);
+    results.push(property);
+    const hasPassingPositive = classified.some((c, i) => c.kind === "positive" && results[i].passed);
+    const hasPassingNegative = classified.some((c, i) => c.kind === "negative" && results[i].passed);
+    const requirements = {
+        positive: hasPassingPositive,
+        negative: hasPassingNegative,
+        property: property.passed,
+    };
+    // §47.5 sets a floor on coverage — "at least 1 positive", "at least 1
+    // negative" — not permission to ship failing assertions. A suite with three
+    // negatives where two fail still satisfies the letter of the requirement, and
+    // that is how a case an author wrote, and a Gene does not honour, could reach
+    // the registry. Every declared case has to pass as well.
+    const hasFailingCase = results.some((r) => !r.passed);
+    return {
+        results,
+        classified,
+        requirements,
+        gatePassed: requirements.positive &&
+            requirements.negative &&
+            requirements.property &&
+            !hasFailingCase,
+    };
+}
+/** Stable id for a report, for callers that persist results. */
+function newTestRunId() {
+    return (0, node_crypto_1.randomUUID)();
+}
+//# sourceMappingURL=run.js.map