opensquid 0.5.441 → 0.5.449

package/dist/codex/import-skill-md.test.js

@@ -1,225 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import { SkillMdImportError, convertSkillMdToCodex, detectVariant, parseSkillMd, slugify, } from "./import-skill-md.js";
-import { isFocusedCodex } from "./types.js";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const FIXTURES = path.resolve(__dirname, "../../test/fixtures/skill-md");
-async function loadFixture(name) {
-    return fs.readFile(path.join(FIXTURES, name), "utf8");
-}
-// ---------------------------------------------------------------------
-// slugify
-// ---------------------------------------------------------------------
-describe("slugify", () => {
-    it("lowercases ASCII", () => {
-        expect(slugify("HelloWorld")).toBe("helloworld");
-    });
-    it("replaces underscores with dashes", () => {
-        expect(slugify("google_meet")).toBe("google-meet");
-    });
-    it("collapses runs of non-alphanumerics", () => {
-        expect(slugify("foo  bar___baz")).toBe("foo-bar-baz");
-    });
-    it("trims leading/trailing dashes", () => {
-        expect(slugify("---foo---")).toBe("foo");
-    });
-    it("caps at 64 chars", () => {
-        const long = "a".repeat(200);
-        expect(slugify(long).length).toBe(64);
-    });
-    it("throws on empty after stripping", () => {
-        expect(() => slugify("!!!")).toThrow(SkillMdImportError);
-    });
-});
-// ---------------------------------------------------------------------
-// parseSkillMd
-// ---------------------------------------------------------------------
-describe("parseSkillMd", () => {
-    it("rejects empty input", () => {
-        expect(() => parseSkillMd("")).toThrow(/empty/);
-    });
-    it("rejects missing frontmatter", () => {
-        expect(() => parseSkillMd("just a body, no fences")).toThrow(/frontmatter/);
-    });
-    it("rejects missing name", () => {
-        expect(() => parseSkillMd("---\ndescription: x\n---\nbody")).toThrow(/name/);
-    });
-    it("rejects missing description", () => {
-        expect(() => parseSkillMd("---\nname: foo\n---\nbody")).toThrow(/description/);
-    });
-    it("parses minimal valid SKILL.md", () => {
-        const { frontmatter, body } = parseSkillMd("---\nname: foo\ndescription: bar\n---\nhello");
-        expect(frontmatter.name).toBe("foo");
-        expect(frontmatter.description).toBe("bar");
-        expect(body).toBe("hello");
-    });
-    it("handles CRLF line endings", () => {
-        const { frontmatter } = parseSkillMd("---\r\nname: foo\r\ndescription: bar\r\n---\r\nbody\r\n");
-        expect(frontmatter.name).toBe("foo");
-    });
-    it("strips UTF-8 BOM at start of file (v0.6d audit L1)", () => {
-        const bom = "";
-        const { frontmatter, body } = parseSkillMd(`${bom}---\nname: bom-test\ndescription: leading BOM\n---\nbody\n`);
-        expect(frontmatter.name).toBe("bom-test");
-        expect(body).toBe("body");
-    });
-});
-// ---------------------------------------------------------------------
-// detectVariant
-// ---------------------------------------------------------------------
-describe("detectVariant", () => {
-    it("detects ECC by origin", () => {
-        expect(detectVariant({ name: "x", description: "y", origin: "ECC" })).toBe("ecc");
-    });
-    it("detects Hermes by platforms array", () => {
-        expect(detectVariant({ name: "x", description: "y", platforms: ["claude-code"] })).toBe("hermes");
-    });
-    it("detects Hermes by metadata.hermes block", () => {
-        expect(detectVariant({ name: "x", description: "y", metadata: { hermes: { tags: [] } } })).toBe("hermes");
-    });
-    it("detects superpowers by path", () => {
-        expect(detectVariant({ name: "x", description: "y" }, "/repo/superpowers/skills/foo/SKILL.md")).toBe("superpowers");
-    });
-    it("does NOT detect superpowers from CSO description alone (Anthropic skills use it too)", () => {
-        expect(detectVariant({ name: "x", description: "Use when writing tests" })).toBe("anthropic");
-    });
-    it("detects pure Anthropic (only known fields)", () => {
-        expect(detectVariant({ name: "x", description: "extracts text", license: "MIT" })).toBe("anthropic");
-    });
-    it("falls back to unknown for unrecognized non-standard fields", () => {
-        expect(detectVariant({ name: "x", description: "extracts text", randomField: 1 })).toBe("unknown");
-    });
-});
-// ---------------------------------------------------------------------
-// convertSkillMdToCodex — fixture round-trip
-// ---------------------------------------------------------------------
-describe("convertSkillMdToCodex — fixtures", () => {
-    it("converts Anthropic skill-creator (minimal)", async () => {
-        const raw = await loadFixture("anthropic-skill-creator.md");
-        const { codex, lessons, variant } = convertSkillMdToCodex(raw, {
-            originalPath: "/fake/skill-creator/SKILL.md",
-            now: "2026-05-16T00:00:00.000Z",
-        });
-        expect(variant).toBe("anthropic");
-        expect(codex.id).toBe("skill-creator");
-        expect(codex.version).toBe("1.0.0");
-        expect(isFocusedCodex(codex)).toBe(true);
-        if (!isFocusedCodex(codex))
-            throw new Error("unreachable");
-        expect(codex.evolves).toBe(true);
-        expect(codex.source?.kind).toBe("skill_md");
-        expect(codex.source?.original_variant).toBe("anthropic");
-        expect(codex.source?.original_name).toBe("skill-creator");
-        expect(codex.source?.imported_at).toBe("2026-05-16T00:00:00.000Z");
-        expect(codex.metadata?.imported_from).toBe("skill_md");
-        expect(codex.metadata?.imported).toEqual({ synthesized_version: true });
-        expect(codex.seed_lessons).toHaveLength(1);
-        expect(codex.seed_lessons?.[0]?.id).toBe("skill-creator");
-        expect(codex.seed_lessons?.[0]?.body_path).toBe("lessons/skill-creator/lesson.md");
-        expect(lessons).toHaveLength(1);
-        expect(lessons[0].body).toContain("# Skill Creator");
-    });
-    it("converts Anthropic pdf — preserves license", async () => {
-        const raw = await loadFixture("anthropic-pdf.md");
-        const { codex } = convertSkillMdToCodex(raw, { originalPath: "/fake/pdf/SKILL.md" });
-        expect(codex.id).toBe("pdf");
-        expect(codex.license).toBe("Apache-2.0");
-    });
-    it("converts superpowers TDD — path-based detection", async () => {
-        const raw = await loadFixture("superpowers-tdd.md");
-        const { codex, variant } = convertSkillMdToCodex(raw, {
-            originalPath: "/home/u/repos/superpowers/skills/test-driven-development/SKILL.md",
-        });
-        expect(variant).toBe("superpowers");
-        expect(codex.id).toBe("test-driven-development");
-    });
-    it("converts ECC tdd-workflow — preserves origin in metadata", async () => {
-        const raw = await loadFixture("ecc-tdd-workflow.md");
-        const { codex, variant } = convertSkillMdToCodex(raw, {
-            originalPath: "/fake/ecc/SKILL.md",
-        });
-        expect(variant).toBe("ecc");
-        expect(codex.metadata?.origin).toBe("ECC");
-    });
-    it("converts Hermes dogfood — preserves version + author + extensions", async () => {
-        const raw = await loadFixture("hermes-dogfood.md");
-        const { codex, variant } = convertSkillMdToCodex(raw, {
-            originalPath: "/fake/hermes/dogfood/SKILL.md",
-        });
-        expect(variant).toBe("hermes");
-        if (!isFocusedCodex(codex))
-            throw new Error("unreachable");
-        expect(codex.version).toBe("0.3.1");
-        expect(codex.author?.name).toBe("Hermes Team");
-        expect(codex.metadata?.platforms).toEqual(["claude-code", "cursor", "hermes"]);
-        const hermesMeta = codex.metadata?.hermes;
-        expect(hermesMeta?.tags).toContain("testing");
-        expect(hermesMeta?.related_skills).toContain("publish-skill");
-        // synthesized_version marker MUST NOT be set when Hermes supplied a version
-        expect(codex.metadata?.imported).toBeUndefined();
-    });
-    it("converts Hermes google_meet — underscore rewrites to hyphen", async () => {
-        const raw = await loadFixture("hermes-google-meet.md");
-        const { codex } = convertSkillMdToCodex(raw, {
-            originalPath: "/fake/hermes/google_meet/SKILL.md",
-        });
-        expect(codex.id).toBe("google-meet");
-        if (!isFocusedCodex(codex))
-            throw new Error("unreachable");
-        expect(codex.source?.original_name).toBe("google_meet");
-        expect(codex.seed_lessons?.[0]?.body_path).toBe("lessons/google-meet/lesson.md");
-    });
-});
-// ---------------------------------------------------------------------
-// allowed-tools mapping (Anthropic experimental field)
-// ---------------------------------------------------------------------
-describe("convertSkillMdToCodex — allowed-tools", () => {
-    it("maps `allowed-tools` array to foundation.tools[]", () => {
-        const src = `---
-name: tooled
-description: uses specific tools
-allowed-tools:
-  - Read
-  - Bash
-  - Edit
----
-
-body`;
-        const { codex } = convertSkillMdToCodex(src);
-        if (!isFocusedCodex(codex))
-            throw new Error("unreachable");
-        expect(codex.foundation?.tools?.map((t) => t.name)).toEqual(["Read", "Bash", "Edit"]);
-    });
-    it("omits foundation when allowed-tools is empty", () => {
-        const src = `---
-name: untooled
-description: no tool restrictions
----
-
-body`;
-        const { codex } = convertSkillMdToCodex(src);
-        if (!isFocusedCodex(codex))
-            throw new Error("unreachable");
-        expect(codex.foundation).toBeUndefined();
-    });
-});
-// ---------------------------------------------------------------------
-// Unknown frontmatter keys → metadata catch-all
-// ---------------------------------------------------------------------
-describe("convertSkillMdToCodex — extensibility bucket", () => {
-    it("preserves unknown top-level keys under metadata", () => {
-        const src = `---
-name: custom
-description: has random fields
-custom_field: hello
-another: 42
----
-
-body`;
-        const { codex } = convertSkillMdToCodex(src);
-        expect(codex.metadata?.custom_field).toBe("hello");
-        expect(codex.metadata?.another).toBe(42);
-    });
-});

package/dist/codex/loader.d.ts

@@ -1,27 +0,0 @@
-/**
- * Bundled-default codex loader (drift-as-codex chunk 2).
- *
- * Reads `bundled-default/codex.yaml` once per process and returns the
- * parsed FocusedCodex. Downstream hooks (workflow-gate, honesty-ledger,
- * versioning-gate — see chunks 3a/3b) call this to source their rules
- * from the codex instead of having them hard-coded in TypeScript.
- *
- * Singleton cache: the YAML is small and unchanging across a process
- * lifetime; computing the path + parsing once is cheap and avoids
- * surprising the test suite with stale state.
- */
-import { FocusedCodex } from "./types.js";
-/**
- * Load the bundled-default codex once per process and return it.
- *
- * Throws if the file is missing, malformed, or parses to a
- * CompositeCodex (the bundled-default is always focused — composite
- * codexes are a separate consumer pattern).
- */
-export declare function loadBundledDefaultCodex(): FocusedCodex;
-/**
- * Clear the loader cache. Test-only — production code should never
- * need to invalidate the bundled-default codex within a process.
- */
-export declare function __resetCachedCodexForTesting(): void;
-//# sourceMappingURL=loader.d.ts.map

package/dist/codex/loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src.legacy/codex/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,EAAE,YAAY,EAAkB,MAAM,YAAY,CAAC;AAgD1D;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,YAAY,CAqBtD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD"}

package/dist/codex/loader.js

@@ -1,86 +0,0 @@
-/**
- * Bundled-default codex loader (drift-as-codex chunk 2).
- *
- * Reads `bundled-default/codex.yaml` once per process and returns the
- * parsed FocusedCodex. Downstream hooks (workflow-gate, honesty-ledger,
- * versioning-gate — see chunks 3a/3b) call this to source their rules
- * from the codex instead of having them hard-coded in TypeScript.
- *
- * Singleton cache: the YAML is small and unchanging across a process
- * lifetime; computing the path + parsing once is cheap and avoids
- * surprising the test suite with stale state.
- */
-import { readFileSync } from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseCodexYaml } from "./parse.js";
-import { isFocusedCodex } from "./types.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Path to the bundled-default codex YAML. Resolved relative to this
- * file's location, so it works in both `src/` (vitest direct execution)
- * and `dist/` (built + published npm package, since
- * `src/codex/bundled-default/codex.yaml` is listed in `package.json`
- * `files[]`).
- *
- * The relative layout is identical in both worlds:
- *   src/codex/loader.ts + src/codex/bundled-default/codex.yaml
- *   dist/codex/loader.js + src/codex/bundled-default/codex.yaml
- *
- * Wait — the `dist/` build only includes the loader.js. The YAML
- * stays at its `src/codex/bundled-default/codex.yaml` location because
- * that's what package.json `files[]` ships. We resolve from
- * `loader.{ts,js}` up to the package root then back down to the YAML.
- */
-function resolveBundledCodexPath() {
-    // From `dist/codex/loader.js` or `src/codex/loader.ts`, the YAML is
-    // at `../../src/codex/bundled-default/codex.yaml` relative to the
-    // dist build, or `./bundled-default/codex.yaml` in the src tree.
-    // Try the src-tree path first (works in test runs); fall back to
-    // the dist-relative path (works in published npm package).
-    const srcRelative = path.resolve(__dirname, "bundled-default", "codex.yaml");
-    // Distinguish dist vs src by checking whether __dirname ends with
-    // .../dist/codex. In `dist/`, the bundled YAML is one level higher.
-    const distRelative = path.resolve(__dirname, "..", "..", "src", "codex", "bundled-default", "codex.yaml");
-    // When running from src/, srcRelative resolves correctly; when
-    // running from dist/, only distRelative does (the YAML stays in
-    // src/codex/bundled-default/ per package.json files[]). Branch on
-    // whether __dirname is inside /dist/.
-    return srcRelative.includes(`${path.sep}dist${path.sep}`) ? distRelative : srcRelative;
-}
-let cachedCodex = null;
-/**
- * Load the bundled-default codex once per process and return it.
- *
- * Throws if the file is missing, malformed, or parses to a
- * CompositeCodex (the bundled-default is always focused — composite
- * codexes are a separate consumer pattern).
- */
-export function loadBundledDefaultCodex() {
-    if (cachedCodex !== null) {
-        return cachedCodex;
-    }
-    const yamlPath = resolveBundledCodexPath();
-    let yaml;
-    try {
-        yaml = readFileSync(yamlPath, "utf-8");
-    }
-    catch (err) {
-        throw new Error(`[opensquid loader] bundled-default codex not found at ${yamlPath}: ${err instanceof Error ? err.message : err}`);
-    }
-    const parsed = parseCodexYaml(yaml);
-    if (!isFocusedCodex(parsed)) {
-        throw new Error(`[opensquid loader] bundled-default codex must be focused, got composite (id=${parsed.id})`);
-    }
-    cachedCodex = parsed;
-    return cachedCodex;
-}
-/**
- * Clear the loader cache. Test-only — production code should never
- * need to invalidate the bundled-default codex within a process.
- */
-export function __resetCachedCodexForTesting() {
-    cachedCodex = null;
-}
-//# sourceMappingURL=loader.js.map

package/dist/codex/loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../src.legacy/codex/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAgB,cAAc,EAAE,MAAM,YAAY,CAAC;AAE1D,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,SAAS,uBAAuB;IAC9B,oEAAoE;IACpE,kEAAkE;IAClE,iEAAiE;IACjE,iEAAiE;IACjE,2DAA2D;IAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAC;IAC7E,kEAAkE;IAClE,oEAAoE;IACpE,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAC/B,SAAS,EACT,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,OAAO,EACP,iBAAiB,EACjB,YAAY,CACb,CAAC;IACF,+DAA+D;IAC/D,gEAAgE;IAChE,kEAAkE;IAClE,sCAAsC;IACtC,OAAO,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC;AACzF,CAAC;AAED,IAAI,WAAW,GAAwB,IAAI,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB;IACrC,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;QACzB,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAC;IAC3C,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,yDAAyD,QAAQ,KAAK,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CACjH,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CACb,+EAA+E,MAAM,CAAC,EAAE,GAAG,CAC5F,CAAC;IACJ,CAAC;IACD,WAAW,GAAG,MAAM,CAAC;IACrB,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,4BAA4B;IAC1C,WAAW,GAAG,IAAI,CAAC;AACrB,CAAC"}

package/dist/codex/loader.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, it, beforeEach } from "vitest";
-import { __resetCachedCodexForTesting, loadBundledDefaultCodex } from "./loader.js";
-import { isFocusedCodex } from "./types.js";
-describe("loadBundledDefaultCodex", () => {
-    beforeEach(() => {
-        __resetCachedCodexForTesting();
-    });
-    it("loads the bundled-default codex and returns a focused codex", () => {
-        const codex = loadBundledDefaultCodex();
-        expect(codex.id).toBe("opensquid-default");
-        expect(isFocusedCodex(codex)).toBe(true);
-    });
-    it("exposes the drift, workflow, claim, and policy sections (chunk 1 content)", () => {
-        const codex = loadBundledDefaultCodex();
-        expect(codex.drifts).toBeDefined();
-        expect((codex.drifts ?? []).length).toBeGreaterThanOrEqual(4);
-        expect(codex.workflows).toBeDefined();
-        expect((codex.workflows ?? []).length).toBeGreaterThanOrEqual(1);
-        expect(codex.default_workflow_id).toBe("standard-7-phase");
-        expect(codex.claims).toBeDefined();
-        expect((codex.claims ?? []).length).toBeGreaterThanOrEqual(5);
-        expect(codex.policies).toBeDefined();
-        expect((codex.policies ?? []).length).toBeGreaterThanOrEqual(2);
-    });
-    it("caches across calls (returns the same object instance on repeated calls)", () => {
-        const first = loadBundledDefaultCodex();
-        const second = loadBundledDefaultCodex();
-        expect(first).toBe(second);
-    });
-    it("re-parses after __resetCachedCodexForTesting (fresh object instance)", () => {
-        const first = loadBundledDefaultCodex();
-        __resetCachedCodexForTesting();
-        const second = loadBundledDefaultCodex();
-        // Same content, different reference because cache was cleared.
-        expect(first).not.toBe(second);
-        expect(first.id).toBe(second.id);
-    });
-    it("exposes the standard-7-phase workflow with all 7 phases", () => {
-        const codex = loadBundledDefaultCodex();
-        const workflow = (codex.workflows ?? []).find((w) => w.id === "standard-7-phase");
-        expect(workflow).toBeDefined();
-        const phaseNames = (workflow?.phases ?? []).map((p) => p.name);
-        expect(phaseNames).toEqual([
-            "pre_research",
-            "learn",
-            "code",
-            "test",
-            "audit",
-            "post_research",
-            "fix",
-        ]);
-        // `fix` is the only soft phase (required: false). The other 6 are required.
-        const requiredPhases = (workflow?.phases ?? []).filter((p) => p.required).map((p) => p.name);
-        expect(requiredPhases).toEqual([
-            "pre_research",
-            "learn",
-            "code",
-            "test",
-            "audit",
-            "post_research",
-        ]);
-    });
-    it("exposes versioning-pre1-patch-only policy with allowed_slots = [patch]", () => {
-        const codex = loadBundledDefaultCodex();
-        const policy = (codex.policies ?? []).find((p) => p.id === "versioning-pre1-patch-only");
-        expect(policy).toBeDefined();
-        if (policy?.kind === "versioning") {
-            expect(policy.params.per_commit_required).toBe(true);
-            expect(policy.params.allowed_slots).toEqual(["patch"]);
-        }
-        else {
-            throw new Error("versioning-pre1-patch-only policy is not of kind=versioning");
-        }
-    });
-});

package/dist/codex/parse.d.ts

@@ -1,28 +0,0 @@
-/**
- * Codex YAML parsing + runtime validation.
- *
- * Authoritative parse for codex.yaml files. Used by `opensquid codex
- * install <path>` to validate before storing locally. Foreign-format
- * imports (superpowers SKILL.md, ECC, etc.) come pre-converted to
- * native codex YAML via LLM at install time — this parser sees the
- * native shape only.
- */
-import { z } from "zod";
-import type { Codex } from "./types.js";
-export declare class CodexParseError extends Error {
-    readonly issues?: z.ZodIssue[] | undefined;
-    constructor(message: string, issues?: z.ZodIssue[] | undefined);
-}
-/**
- * Parse + validate a codex from a raw object (already-parsed YAML/JSON).
- *
- * Throws `CodexParseError` on schema violations with detailed issues.
- */
-export declare function parseCodex(raw: unknown): Codex;
-/**
- * Parse a codex from a YAML string.
- *
- * Throws `CodexParseError` on YAML syntax error or schema violation.
- */
-export declare function parseCodexYaml(source: string): Codex;
-//# sourceMappingURL=parse.d.ts.map

package/dist/codex/parse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src.legacy/codex/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EACV,KAAK,EAeN,MAAM,YAAY,CAAC;AAiSpB,qBAAa,eAAgB,SAAQ,KAAK;aAGtB,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;gBADrC,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,YAAA;CAKxC;AAMD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,CAgB9C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAepD"}