muonroi-cli 1.8.1 → 1.8.3

package/dist/src/agent-harness/__tests__/idle.spec.js

@@ -1,84 +0,0 @@
-import { createHeuristicIdleDetector, createIdleDetector } from "@muonroi/agent-harness-core/idle";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-describe("idle detector", () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    describe("createIdleDetector", () => {
-        it("emits idle after quiescence window", () => {
-            const events = [];
-            const det = createIdleDetector({
-                quiescenceMs: 50,
-                onIdle: () => events.push("idle"),
-            });
-            det.markActivity();
-            vi.advanceTimersByTime(30);
-            expect(events).toEqual([]);
-            vi.advanceTimersByTime(30);
-            expect(events).toEqual(["idle"]);
-            det.dispose();
-        });
-        it("re-arms on subsequent activity", () => {
-            const events = [];
-            const det = createIdleDetector({
-                quiescenceMs: 50,
-                onIdle: () => events.push("idle"),
-            });
-            det.markActivity();
-            vi.advanceTimersByTime(60);
-            det.markActivity();
-            vi.advanceTimersByTime(60);
-            expect(events).toEqual(["idle", "idle"]);
-            det.dispose();
-        });
-    });
-    describe("createHeuristicIdleDetector", () => {
-        it("emits idle when BOTH frame and stream have been silent for their windows", () => {
-            const events = [];
-            const det = createHeuristicIdleDetector({
-                frameQuietMs: 50,
-                streamQuietMs: 50,
-                onIdle: () => events.push("idle"),
-            });
-            det.markFrame();
-            det.markStreamDelta();
-            vi.advanceTimersByTime(60);
-            expect(events).toEqual(["idle"]);
-            det.dispose();
-        });
-        it("does NOT emit idle when only frame is quiet but stream is recent", () => {
-            const events = [];
-            const det = createHeuristicIdleDetector({
-                frameQuietMs: 50,
-                streamQuietMs: 50,
-                onIdle: () => events.push("idle"),
-            });
-            det.markFrame();
-            vi.advanceTimersByTime(30);
-            det.markStreamDelta();
-            vi.advanceTimersByTime(40);
-            // frame has been quiet 70ms, stream only 40ms
-            expect(events).toEqual([]);
-            det.dispose();
-        });
-        it("does NOT emit idle when only stream is quiet but frame is recent", () => {
-            const events = [];
-            const det = createHeuristicIdleDetector({
-                frameQuietMs: 50,
-                streamQuietMs: 50,
-                onIdle: () => events.push("idle"),
-            });
-            det.markStreamDelta();
-            vi.advanceTimersByTime(30);
-            det.markFrame();
-            vi.advanceTimersByTime(40);
-            // stream has been quiet 70ms, frame only 40ms
-            expect(events).toEqual([]);
-            det.dispose();
-        });
-    });
-});
-//# sourceMappingURL=idle.spec.js.map

package/dist/src/agent-harness/__tests__/mock-llm.spec.d.ts

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

package/dist/src/agent-harness/__tests__/mock-llm.spec.js

@@ -1,91 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createMockLlm } from "@muonroi/agent-harness-core/mock-llm";
-import { describe, expect, it } from "vitest";
-describe("mock-llm", () => {
-    it("returns fixture matching prompt", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-"));
-        writeFileSync(join(dir, "fix.json"), JSON.stringify({
-            responses: [{ match: "hello", text: "world" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "hello there" })).toEqual({ text: "world" });
-    });
-    it("falls back to wildcard", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-"));
-        writeFileSync(join(dir, "fix.json"), JSON.stringify({
-            responses: [{ match: "*", text: "default" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "default" });
-    });
-    it("throws on no match without wildcard", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-"));
-        writeFileSync(join(dir, "fix.json"), JSON.stringify({
-            responses: [{ match: "specific", text: "x" }],
-        }));
-        const m = createMockLlm({ dir });
-        await expect(m.complete({ prompt: "other" })).rejects.toThrow(/no fixture/);
-    });
-    // ── Sequence mode tests ────────────────────────────────────────────────────
-    it("sequence: consumes entries in order", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "first" }, { text: "second" }, { text: "third" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "first" });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "second" });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "third" });
-    });
-    it("sequence: exhausted sequence sticks on last entry", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-exhausted-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "a" }, { text: "b" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "a" });
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "b" });
-        // Exhausted — keeps returning last entry
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "b" });
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "b" });
-    });
-    it("sequence: entry with match constraint is skipped when prompt doesn't match", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-match-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "matched", match: "keyword" }, { text: "fallback" }],
-        }));
-        const m = createMockLlm({ dir });
-        // First call: prompt lacks the required term — skips first seq entry, falls through to second
-        expect(await m.complete({ prompt: "unrelated prompt text" })).toEqual({ text: "fallback" });
-    });
-    it("sequence: entry with match constraint is consumed when prompt includes it", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-match2-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "matched", match: "keyword" }, { text: "second" }],
-        }));
-        const m = createMockLlm({ dir });
-        // First call includes keyword — consumes first entry
-        expect(await m.complete({ prompt: "has keyword in it" })).toEqual({ text: "matched" });
-        // Second call — advances to second entry
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "second" });
-    });
-    it("sequence and responses fixtures coexist: sequence tried first", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-mixed-"));
-        // responses fixture
-        writeFileSync(join(dir, "a-responses.json"), JSON.stringify({
-            responses: [{ match: "*", text: "from-responses" }],
-        }));
-        // sequence fixture (alphabetically after, but tried first by design)
-        writeFileSync(join(dir, "b-sequence.json"), JSON.stringify({
-            sequence: [{ text: "from-sequence" }],
-        }));
-        const m = createMockLlm({ dir });
-        // First call: sequence wins
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "from-sequence" });
-        // Second call: sequence exhausted (sticks on last), still "from-sequence"
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "from-sequence" });
-    });
-});
-//# sourceMappingURL=mock-llm.spec.js.map

package/dist/src/agent-harness/__tests__/mock-model.spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for the mock-model helper. Verifies the recording surface and
- * sequential stream semantics that downstream cost-leak specs depend on.
- */
-export {};

package/dist/src/agent-harness/__tests__/mock-model.spec.js

@@ -1,270 +0,0 @@
-/**
- * Unit tests for the mock-model helper. Verifies the recording surface and
- * sequential stream semantics that downstream cost-leak specs depend on.
- */
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { APICallError } from "@ai-sdk/provider";
-import { generateObject, stepCountIs, streamText, tool } from "ai";
-import { afterAll, describe, expect, it } from "vitest";
-import { z } from "zod";
-import { humanizeApiError } from "../../orchestrator/error-utils.js";
-import { createMockModel, loadMockModelFromDir, textOnlyStream, toolCallStream } from "../mock-model.js";
-// biome-ignore lint/suspicious/noExplicitAny: streamText result generic is provider-specific
-async function drainStream(result) {
-    for await (const _ of result.fullStream) {
-        // discard — we only care about the model's recorded calls
-    }
-}
-describe("createMockModel", () => {
-    it("records every doStream call with full options", async () => {
-        const handle = createMockModel({ stream: textOnlyStream("hello") });
-        const result = streamText({
-            model: handle.model,
-            prompt: "say hi",
-            maxOutputTokens: 50,
-            temperature: 0.7,
-        });
-        await drainStream(result);
-        expect(handle.calls.length).toBe(1);
-        expect(handle.calls[0]?.maxOutputTokens).toBe(50);
-        expect(handle.calls[0]?.temperature).toBe(0.7);
-    });
-    it("preserves providerOptions in recorded calls", async () => {
-        const handle = createMockModel({ stream: textOnlyStream("hello") });
-        const result = streamText({
-            model: handle.model,
-            prompt: "say hi",
-            providerOptions: { openai: { promptCacheKey: "abc123" } },
-        });
-        await drainStream(result);
-        expect(handle.calls[0]?.providerOptions).toEqual({
-            openai: { promptCacheKey: "abc123" },
-        });
-    });
-    it("advances the stream sequence across multiple rounds", async () => {
-        const handle = createMockModel({
-            stream: [toolCallStream({ toolCallId: "1", toolName: "echo", input: { msg: "hi" } }), textOnlyStream("done")],
-        });
-        const echoTool = tool({
-            description: "echo",
-            inputSchema: z.object({ msg: z.string() }),
-            execute: async ({ msg }) => `echoed: ${msg}`,
-        });
-        const result = streamText({
-            model: handle.model,
-            prompt: "use echo",
-            tools: { echo: echoTool },
-            stopWhen: stepCountIs(3),
-        });
-        await drainStream(result);
-        expect(handle.calls.length).toBe(2);
-        // Round 1 sees only the user message; round 2 sees the tool result too.
-        expect(handle.calls[1]?.prompt.length).toBeGreaterThan(handle.calls[0]?.prompt.length ?? 0);
-    });
-    it("repeats the last stream entry when sequence is exhausted", async () => {
-        const handle = createMockModel({ stream: [textOnlyStream("once")] });
-        // Drive two calls — second should silently reuse the last entry.
-        for (let i = 0; i < 2; i++) {
-            const r = streamText({ model: handle.model, prompt: `q${i}` });
-            await drainStream(r);
-        }
-        expect(handle.calls.length).toBe(2);
-    });
-    it("reset() clears doStreamCalls and rewinds the sequence index", async () => {
-        const handle = createMockModel({
-            stream: [textOnlyStream("first"), textOnlyStream("second")],
-        });
-        const r1 = streamText({ model: handle.model, prompt: "q1" });
-        await drainStream(r1);
-        expect(handle.calls.length).toBe(1);
-        handle.reset();
-        expect(handle.calls.length).toBe(0);
-        // After reset, the sequence index is back at 0 → next call gets "first" again.
-        const r2 = streamText({ model: handle.model, prompt: "q2" });
-        await drainStream(r2);
-        expect(handle.calls.length).toBe(1);
-    });
-    it("doGenerate backs generateObject with the configured JSON (council debate-planner path)", async () => {
-        const handle = createMockModel({
-            stream: textOnlyStream("unused"),
-            generate: JSON.stringify({ name: "counter", count: 3 }),
-        });
-        const { object } = await generateObject({
-            model: handle.model,
-            schema: z.object({ name: z.string(), count: z.number() }),
-            prompt: "plan the build",
-        });
-        expect(object).toEqual({ name: "counter", count: 3 });
-    });
-    it("doGenerate sequences across calls and repeats the last entry when exhausted", async () => {
-        const handle = createMockModel({
-            stream: textOnlyStream("unused"),
-            generate: [JSON.stringify({ n: 1 }), JSON.stringify({ n: 2 })],
-        });
-        const schema = z.object({ n: z.number() });
-        const a = await generateObject({ model: handle.model, schema, prompt: "1" });
-        const b = await generateObject({ model: handle.model, schema, prompt: "2" });
-        const c = await generateObject({ model: handle.model, schema, prompt: "3" });
-        expect(a.object.n).toBe(1);
-        expect(b.object.n).toBe(2);
-        expect(c.object.n).toBe(2); // exhausted → last entry repeats
-    });
-    it("doGenerate defaults to {} when no generate fixture is supplied (caller retry/fallback runs)", async () => {
-        const handle = createMockModel({ stream: textOnlyStream("unused") });
-        // An empty object fails a required-field schema → generateObject rejects,
-        // which is exactly what lets debate-planner fall through to its retry path.
-        await expect(generateObject({ model: handle.model, schema: z.object({ required: z.string() }), prompt: "x" })).rejects.toBeTruthy();
-    });
-    it("textOnlyStream emits a well-formed finish chunk", () => {
-        const chunks = textOnlyStream("hi");
-        const finish = chunks.find((c) => c.type === "finish");
-        expect(finish?.finishReason.unified).toBe("stop");
-        expect(finish?.usage.outputTokens.total).toBeGreaterThan(0);
-    });
-    it("toolCallStream emits a tool-calls finish reason", () => {
-        const chunks = toolCallStream({ toolCallId: "x", toolName: "t", input: {} });
-        const finish = chunks.find((c) => c.type === "finish");
-        expect(finish?.finishReason.unified).toBe("tool-calls");
-    });
-});
-describe("loadMockModelFromDir", () => {
-    // Hermetic temp dirs so tests don't depend on tests/harness/fixtures layout.
-    const tmpDirs = [];
-    function mkFixtureDir(model) {
-        const dir = mkdtempSync(join(tmpdir(), "mock-model-fx-"));
-        writeFileSync(join(dir, "fixture.json"), JSON.stringify({ model }), "utf8");
-        tmpDirs.push(dir);
-        return dir;
-    }
-    afterAll(() => {
-        for (const d of tmpDirs) {
-            try {
-                rmSync(d, { recursive: true, force: true });
-            }
-            catch {
-                // ignore — best-effort cleanup
-            }
-        }
-    });
-    it("propagates unsupportedParams from the fixture file", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: textOnlyStream("hello"),
-            unsupportedParams: ["maxOutputTokens"],
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        expect(handle?.unsupportedParams).toEqual(["maxOutputTokens"]);
-        // Sanity: the model itself is usable downstream.
-        const r = streamText({ model: handle.model, prompt: "hi" });
-        await drainStream(r);
-        expect(handle?.calls.length).toBe(1);
-    });
-    it("propagates defaultProviderOptions from the fixture file", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: textOnlyStream("hello"),
-            defaultProviderOptions: { openai: { store: false } },
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        expect(handle?.defaultProviderOptions).toEqual({ openai: { store: false } });
-    });
-    it("propagates generate (doGenerate JSON) from the fixture file for generateObject", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: textOnlyStream("unused"),
-            generate: JSON.stringify({ ok: true, label: "built" }),
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        const { object } = await generateObject({
-            model: handle.model,
-            schema: z.object({ ok: z.boolean(), label: z.string() }),
-            prompt: "go",
-        });
-        expect(object).toEqual({ ok: true, label: "built" });
-    });
-    it("constructs an APICallError from a structured error fixture (drives the humanizeApiError 5xx branch)", async () => {
-        // A pure-JSON fixture cannot otherwise build an APICallError (it arrives as
-        // a plain string). buildFixtureError() in mock-model.ts upgrades a structured
-        // `error` object carrying a statusCode into a real APICallError so harness/
-        // unit specs can exercise the orchestrator's status-aware 5xx path.
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: [
-                [
-                    { type: "stream-start", warnings: [] },
-                    {
-                        type: "error",
-                        error: {
-                            apiCallError: true,
-                            statusCode: 500,
-                            message: "AI_APICallError: Request failed",
-                            responseBody: JSON.stringify({ code: 60000, message: "Request failed: Unknown error." }),
-                            url: "https://api.siliconflow.cn/v1/chat/completions",
-                            isRetryable: true,
-                        },
-                    },
-                    {
-                        type: "finish",
-                        finishReason: { unified: "error", raw: null },
-                        usage: {
-                            inputTokens: { total: 0, noCache: 0, cacheRead: null, cacheWrite: null },
-                            outputTokens: { total: 0, text: 0, reasoning: null },
-                        },
-                    },
-                ],
-            ],
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        const r = streamText({ model: handle.model, prompt: "hi" });
-        let errPart = null;
-        for await (const part of r.fullStream) {
-            if (part.type === "error")
-                errPart = part;
-        }
-        expect(errPart).not.toBeNull();
-        expect(APICallError.isInstance(errPart?.error)).toBe(true);
-        expect((errPart?.error).statusCode).toBe(500);
-        // The 5xx branch must surface the canned actionable text + (HTTP 500) and
-        // SUPPRESS the opaque provider body (the SiliconFlow "Unknown error" mask).
-        const msg = humanizeApiError(errPart?.error);
-        expect(msg).toContain("HTTP 500");
-        expect(msg.toLowerCase()).toContain("try again later");
-        expect(msg).not.toContain("Unknown error");
-        expect(msg).not.toContain("Request failed");
-    });
-    it("supports multi-round stream arrays from the fixture file", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            // Nested array → one entry consumed per doStream call.
-            stream: [toolCallStream({ toolCallId: "1", toolName: "echo", input: { msg: "hi" } }), textOnlyStream("done")],
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        const echoTool = tool({
-            description: "echo",
-            inputSchema: z.object({ msg: z.string() }),
-            execute: async ({ msg }) => `echoed: ${msg}`,
-        });
-        const r = streamText({
-            model: handle.model,
-            prompt: "use echo",
-            tools: { echo: echoTool },
-            stopWhen: stepCountIs(3),
-        });
-        await drainStream(r);
-        expect(handle?.calls.length).toBe(2);
-        expect(handle?.calls[1]?.prompt.length).toBeGreaterThan(handle?.calls[0]?.prompt.length ?? 0);
-    });
-});
-//# sourceMappingURL=mock-model.spec.js.map

package/dist/src/agent-harness/__tests__/predicate.spec.d.ts

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

package/dist/src/agent-harness/__tests__/predicate.spec.js

@@ -1,27 +0,0 @@
-import { evaluatePredicate, predicateSchema } from "@muonroi/agent-harness-core/predicate";
-import { describe, expect, it } from "vitest";
-const node = { id: "x", role: "button", name: "Send", focus: true };
-describe("predicate", () => {
-    it("parses a field-op predicate", () => {
-        const p = predicateSchema.parse({ field: "name", op: "eq", rhs: "Send" });
-        expect(evaluatePredicate(p, node)).toBe(true);
-    });
-    it("parses a flag predicate", () => {
-        const p = predicateSchema.parse({ flag: "focus", value: true });
-        expect(evaluatePredicate(p, node)).toBe(true);
-    });
-    it("supports all/any/not", () => {
-        const p = predicateSchema.parse({
-            all: [{ field: "name", op: "contains", rhs: "Sen" }, { not: { flag: "disabled", value: true } }],
-        });
-        expect(evaluatePredicate(p, node)).toBe(true);
-    });
-    it("rejects unknown shapes", () => {
-        expect(() => predicateSchema.parse({ field: "x", op: "weird", rhs: "y" })).toThrow();
-    });
-    it("rejects rhs longer than 200 chars (ReDoS guard)", () => {
-        const huge = "a".repeat(201);
-        expect(() => predicateSchema.parse({ field: "name", op: "regex", rhs: huge })).toThrow();
-    });
-});
-//# sourceMappingURL=predicate.spec.js.map

package/dist/src/agent-harness/__tests__/protocol.spec.d.ts

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

package/dist/src/agent-harness/__tests__/protocol.spec.js

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-describe("protocol types", () => {
-    it("compiles a minimal LiveFrame", () => {
-        const frame = {
-            mode: "live",
-            version: "0.4.0",
-            seq: 0,
-            ts: 0,
-            nodes: [],
-        };
-        expect(frame.mode).toBe("live");
-    });
-    it("compiles a UINode with all flags", () => {
-        const node = {
-            id: "a",
-            role: "button",
-            name: "OK",
-            focus: true,
-            selected: true,
-            disabled: true,
-            hidden: true,
-            state: "loading",
-            props: { pct: 50 },
-            children: [],
-        };
-        expect(node.id).toBe("a");
-    });
-    it("compiles a DesignSpec with state patches", () => {
-        const spec = {
-            mode: "design",
-            version: "0.4.0",
-            scenes: [
-                {
-                    id: "s1",
-                    name: "Composer",
-                    layout: { id: "root", role: "dialog" },
-                    states: [{ name: "loading", patches: [{ id: "root", state: "loading" }] }],
-                },
-            ],
-        };
-        expect(spec.scenes.length).toBe(1);
-    });
-    it("compiles a stream.delta LiveEvent", () => {
-        const e = { t: "event", kind: "stream.delta", target: "x", text: "y" };
-        expect(e.kind).toBe("stream.delta");
-    });
-    it("compiles a toast LiveEvent", () => {
-        const e = { t: "event", kind: "toast", level: "error", text: "boom" };
-        expect(e.level).toBe("error");
-    });
-    it("compiles an idle LiveEvent", () => {
-        const e = { t: "idle" };
-        expect(e.t).toBe("idle");
-    });
-});
-//# sourceMappingURL=protocol.spec.js.map

package/dist/src/agent-harness/__tests__/schema.spec.d.ts

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

package/dist/src/agent-harness/__tests__/schema.spec.js

@@ -1,76 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import Ajv from "ajv/dist/2020.js";
-import { describe, expect, it } from "vitest";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const schema = JSON.parse(readFileSync(new URL("../../../docs/agent-harness/schema.json", import.meta.url), "utf8"));
-const ajv = new Ajv({ strict: false });
-ajv.addSchema(schema);
-describe("schema fixtures", () => {
-    const examplesDir = join(__dirname, "../../../docs/agent-harness/examples");
-    const files = readdirSync(examplesDir).filter((f) => f.endsWith(".json"));
-    for (const f of files) {
-        it(`${f} matches schema`, () => {
-            const data = JSON.parse(readFileSync(join(examplesDir, f), "utf8"));
-            const def = data.mode === "live" ? "LiveFrame" : "DesignSpec";
-            const validate = ajv.compile({
-                $ref: `${schema.$id}#/definitions/${def}`,
-            });
-            const ok = validate(data);
-            if (!ok)
-                console.error(validate.errors);
-            expect(ok).toBe(true);
-        });
-    }
-});
-describe("schema rejects invalid data", () => {
-    it("rejects a LiveFrame missing mode", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/LiveFrame`,
-        });
-        const badData = {
-            version: "0.3.0",
-            seq: 0,
-            ts: 0,
-            nodes: [],
-        };
-        expect(validate(badData)).toBe(false);
-    });
-    it("rejects a LiveFrame with extra unknown field", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/LiveFrame`,
-        });
-        const badData = {
-            mode: "live",
-            version: "0.3.0",
-            seq: 0,
-            ts: 0,
-            nodes: [],
-            extra: "x",
-        };
-        expect(validate(badData)).toBe(false);
-    });
-    it("rejects a DesignSpec where a StatePatch includes children", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/StatePatch`,
-        });
-        const badData = {
-            id: "root",
-            children: [],
-        };
-        expect(validate(badData)).toBe(false);
-    });
-    it("rejects a UINode with invalid role value", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/UINode`,
-        });
-        const badData = {
-            id: "test",
-            role: "notarole",
-        };
-        expect(validate(badData)).toBe(false);
-    });
-});
-//# sourceMappingURL=schema.spec.js.map

package/dist/src/agent-harness/__tests__/selector.spec.d.ts

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