opensquid 0.5.395

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

@@ -0,0 +1,225 @@
+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

@@ -0,0 +1,27 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,86 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,28 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}