@mmnto/totem 1.118.1 → 1.119.0

package/dist/spine/record-lower.js

@@ -0,0 +1,418 @@
+// ─── Prop 310 V1 record grammar — the LOWERING (slice 2 of the V1 build) ──────
+//
+// Slice 1 (`rule-record.ts`) turns record bytes into a validated
+// `ParsedRuleRecord`. This module turns that value into a `CompiledRule`. It is
+// the § Design 1 seam replacement for records: the record path does NOT go
+// through `extractManualPattern` or `CompileInputCandidate.dslSource`, because
+// the record is ALREADY parsed — re-serializing it into lesson markdown just to
+// re-parse it would reintroduce the incumbent grammar this proposal supersedes.
+// What is reused is the VALIDATORS (`validateRegex`, `validateAstGrepPattern`)
+// and the field builder (`engineFields`), never the parser and never the frozen
+// `LessonInput` actuator.
+//
+// § Design 12 (R2) is this slice's charter: **every construct the parser admits
+// either lands on the compiled record or fails compile LOUD.** No construct is
+// accepted at parse and dropped at compile. That obligation is enforced
+// mechanically here, not by inspection — see § "Total lowering, mechanically".
+//
+// ── OPERATOR RULING 2026-08-21 (tree-form) ───────────────────────────────────
+//
+// `target.rule` is the ast-grep RULE TREE, not a whole NapiConfig — the
+// exemplar-faithful reading of § Design 4's "NapiConfig subset" (its exemplar
+// shows `rule: {kind: catch_clause, not: {...}}`, a rule tree, with `language`
+// living one level up at `target.language`).
+//
+//   - LOWERING DERIVES the NapiConfig wrapper: `{rule: <tree>, language: <napi
+//     language derived from the resolved `target.language`>}`. The record
+//     therefore never carries a duplicate language home (§ Design 3's no-mirror
+//     discipline; Tenet 20) and no language COLLISION between the payload
+//     interior and `target.language` is representable.
+//   - `constraints` / `utils` are INEXPRESSIBLE at V1 (censused: zero of the 19
+//     compound corpus rules use them). Demand becomes a typed `construct-gap` at
+//     the R14 trial plus a grammar version bump giving each its own SIBLING home
+//     under `target:` — never a silent smuggle inside the rule tree, which is
+//     why the tree gate below names them explicitly instead of leaving them to
+//     napi's generic unknown-field error.
+//
+// Grounds of record: the spec-normative exemplar (§ Design 14's normativity
+// flip), language-collision avoidance, and zero corpus cost.
+//
+// ── Identity ─────────────────────────────────────────────────────────────────
+//
+// Identity is an INPUT, never minted here (§ Design 3 / R17): the ADR-112 §8
+// producer mints `ruleId` at the intake seam and slice 3 threads it in. This
+// function asserts it is well-formed and makes it the compiled identity
+// (`lessonHash ← ruleId`, the §8/§9 `firingLabelId ← ruleId` unification), and
+// NEVER hashes `dslSource` — there is no `dslSource` on this path, and a
+// content-derived id would orphan the rule's ground-truth labels on every
+// matcher edit.
+//
+// ── Freeze boundary ──────────────────────────────────────────────────────────
+//
+// `sanitizeFileGlobs` is NEVER called here. The record's globs were validated at
+// parse against § Design 7's strict dialect and are carried BYTE-VERBATIM:
+// brace expansion and shallow-glob promotion are exactly the silent transforms
+// the grammar kills (§ Design 7's conformance-scope paragraph), while the
+// sanitizer's tolerant behaviour for the FROZEN legacy lesson corpus is
+// untouched — the freeze covers that path and nothing regenerates it.
+import { extensionToLanguage, registeredExtensions } from '../ast-classifier.js';
+import { extensionToLang, TRAILING_EXT_RE } from '../ast-grep-query.js';
+import { validateAstGrepPattern } from '../compile-lesson.js';
+import { engineFields, validateRegex } from '../compiler.js';
+import { CompiledRuleSchema } from '../compiler-schema.js';
+import { AUTHORED_RULE_ID_RE } from './authored-rule.js';
+/**
+ * Resolve `target.language` against the registry, using `extensionToLanguage` as
+ * the authority verbatim (§ Design 6). Deterministic: `registeredExtensions()`
+ * returns a sorted snapshot, so the representative extension for a language with
+ * several (`.ts`/`.mts`/`.cts` → `typescript`) is always the same one — and every
+ * extension of one language maps to the same napi grammar anyway, so the pick
+ * cannot change the validation verdict, only the diagnostic.
+ *
+ * An unresolvable language FAILS LOUD (§ Design 6 / § Failure modes: "Unresolvable
+ * `language:` at compile — hard error"). It is surfaced as a `rejected` outcome
+ * rather than a throw, matching the incumbent's treatment of every other
+ * authored-content validation failure: `rejected` is a counted, reported,
+ * NON-silent state, while throws are reserved for producer-contract violations
+ * (a malformed id, a payload/type divergence) — see `compileRuleRecord`.
+ */
+export function resolveRecordLanguage(language) {
+    const extensions = registeredExtensions();
+    const extension = extensions.find((ext) => extensionToLanguage(ext) === language);
+    if (extension === undefined) {
+        const known = [...new Set(extensions.map((ext) => extensionToLanguage(ext)))]
+            .filter((lang) => lang !== undefined)
+            .sort();
+        return {
+            resolved: false,
+            reason: `Prop 310 § Design 6: target.language '${language}' is not registered — the resolution authority is the Map-backed extensionToLanguage registry (built-ins + pack contributions), never a spec-frozen enum. Registered languages: ${known.join(', ') || '(none)'}. Install the pack that provides this language, or correct the record.`,
+        };
+    }
+    return { resolved: true, language, extension };
+}
+/**
+ * The glob list handed to `validateAstGrepPattern` so it resolves to EXACTLY the
+ * declared language.
+ *
+ * The shipped validator's language input is a glob list (`resolveAstGrepLangs`
+ * derives Langs from trailing extensions), so pinning it to one grammar means
+ * handing it one glob carrying one registered extension. These globs are a
+ * VALIDATOR PROBE and nothing else — they are never the record's globs, never
+ * reach the compiled rule, and never touch `sanitizeFileGlobs`.
+ *
+ * The coupling to `resolveAstGrepLangs`' derivation is pinned by a conformance
+ * test (`record-lower.test.ts`: the probe resolves to exactly one Lang, and that
+ * Lang equals `extensionToLang(extension)`), so a change to the shipped
+ * derivation fails loud here instead of silently un-pinning the record path.
+ */
+export function languageProbeGlobs(extension) {
+    return [`**/*${extension}`];
+}
+// ── The language⇄glob consistency floor ──────────────────────────────────────
+//
+// OPERATOR-CONSISTENT RULING (falsification round, 2026-08-21): for a
+// `type: ast-grep` record, EVERY `target.scope.fileGlobs` entry must end in a
+// registered extension that resolves — via `extensionToLanguage`, the same
+// § Design 6 authority — to the DECLARED `target.language`. Otherwise the record
+// is rejected.
+//
+// Grounds. § Design 6 fixes ONE declared language per record and the options
+// table spells out the consequence: "a multi-language ast-grep rule is N
+// records". Without this floor a record could declare `language: typescript`
+// and scope itself to `**\/*.js`, and the runtime — which dispatches ast-grep by
+// FILE EXTENSION, not by the rule's compiled `language` — would then evaluate it
+// under a grammar it was never validated against. The review demonstrated both
+// halves of that gap: a compound payload fails inertly per file (a silent
+// non-firing rule), and a flat pattern FIRES under the wrong grammar. Neither is
+// visible to the author. With the floor, validated-as-declared and
+// evaluated-by-extension agree BY CONSTRUCTION, so the runtime needs no
+// language gate of its own.
+//
+// Scope of the floor, precisely:
+//   - `fileGlobs` only. `excludeGlobs` entries are EXEMPT: they only ever narrow
+//     an already-consistent positive scope, so an exclusion written against a
+//     different extension can widen nothing.
+//   - `type: regex` records are UNCHECKED — a regex payload has no grammar
+//     binding at all (`target.language` is forbidden there, § Design 4), and the
+//     match is textual, so the same globs are legitimate.
+//   - An EXTENSION-LESS glob (`packages/**`) rejects under the same rule: a
+//     scope that cannot be pinned to a language cannot be validated as it will
+//     be evaluated, and silently admitting it would reopen the gap for every
+//     file the directory happens to contain.
+/**
+ * Check the § Design 6 one-declared-language rule against a record's positive
+ * globs. Returns `null` when the scope is consistent, or the rejection reason.
+ * ast-grep targets only — the caller does not invoke it for regex.
+ */
+export function checkLanguageGlobConsistency(language, fileGlobs) {
+    const advice = `§ Design 6 fixes ONE declared language per record — "a multi-language ast-grep rule is N records". Split the rule per language, or correct the glob. (The runtime dispatches ast-grep by FILE EXTENSION, so a scope the declared language does not cover would be evaluated under a grammar the payload was never validated against.)`;
+    for (const glob of fileGlobs) {
+        const match = TRAILING_EXT_RE.exec(glob);
+        if (match === null) {
+            return `Prop 310 § Design 6: target.scope.fileGlobs entry '${glob}' carries no file extension, so its scope cannot be pinned to the declared language '${language}'. ${advice}`;
+        }
+        const extension = `.${match[1].toLowerCase()}`;
+        const globLanguage = extensionToLanguage(extension);
+        if (globLanguage === undefined) {
+            return `Prop 310 § Design 6: target.scope.fileGlobs entry '${glob}' targets extension '${extension}', which is not registered, so it cannot be confirmed to match the declared language '${language}'. ${advice}`;
+        }
+        if (globLanguage !== language) {
+            return `Prop 310 § Design 6: target.scope.fileGlobs entry '${glob}' targets language '${globLanguage}' but the record declares '${language}'. ${advice}`;
+        }
+    }
+    return null;
+}
+// ── The tree-form gate (operator ruling 2026-08-21) ──────────────────────────
+/**
+ * NapiConfig siblings of `rule` that V1 cannot express. Named explicitly so the
+ * author is told the truth — a typed construct-gap awaiting a version bump with
+ * its own sibling home under `target:` — instead of napi's generic
+ * "unknown field" error, which would read as a typo in the rule tree.
+ */
+export const V1_INEXPRESSIBLE_NAPI_KEYS = ['constraints', 'utils'];
+const RECORD_KEY_LOWERING = {
+    schemaVersion: 'consumed-at-parse',
+    severity: 'compiled',
+    message: 'compiled',
+    recoveryHint: 'compiled',
+    target: 'compiled',
+    examples: 'compiled',
+    requires: 'compiled',
+    curation: 'compiled',
+    verification_shadow: 'compiled',
+};
+const TARGET_KEY_LOWERING = {
+    // `type` lowers to `engine` — and is re-derived INDEPENDENTLY from the payload's
+    // compilation path for the § Design 3 engine-binding assert.
+    type: 'compiled',
+    language: 'compiled',
+    pattern: 'compiled',
+    rule: 'compiled',
+    scope: 'compiled',
+};
+const SCOPE_KEY_LOWERING = {
+    fileGlobs: 'compiled',
+    excludeGlobs: 'compiled',
+};
+function assertKeysDispositioned(value, table, at) {
+    for (const key of Object.keys(value)) {
+        // `Object.hasOwn`, not `table[key] === undefined`: a key named `constructor`
+        // or `toString` would otherwise resolve up the prototype chain and read as
+        // "dispositioned". Slice 1's prototype floor already rejects those at parse,
+        // so nothing reaching here through `parseRuleRecord` can carry one — this is
+        // defence in depth for a hand-constructed `ParsedRuleRecord`, which is
+        // exactly the caller class this whole assertion exists for.
+        if (!Object.hasOwn(table, key)) {
+            throw new Error(`[Totem Error] compileRuleRecord: record key '${at}${key}' has no defined lowering — Prop 310 § Design 12 forbids accepting a construct at parse and dropping it at compile. Give it a compiled home (and a disposition in record-lower.ts) or reject it at parse.`);
+        }
+    }
+}
+/** § Design 12 — the runtime half of the total-lowering proof (see above). */
+function assertTotalLowering(record) {
+    assertKeysDispositioned(record, RECORD_KEY_LOWERING, '');
+    assertKeysDispositioned(record.target, TARGET_KEY_LOWERING, 'target.');
+    assertKeysDispositioned(record.target.scope, SCOPE_KEY_LOWERING, 'target.scope.');
+}
+// ── The compiled engine, re-derived from the payload ─────────────────────────
+/**
+ * Derive the engine from the fields `engineFields` actually produced. This is
+ * the INDEPENDENT second side of the § Design 3 engine-binding assert: one side
+ * is the record's `target.type` (via `derivedEngine`), the other is the payload's
+ * actual compilation path. § Design 3 is explicit that the derivation must not
+ * make the shipped assert tautological, and it does not — a payload routed
+ * through the wrong `engineFields` branch diverges here and fails loud.
+ */
+function engineFromCompiledFields(fields) {
+    const hasAstGrep = (typeof fields.astGrepPattern === 'string' && fields.astGrepPattern.length > 0) ||
+        fields.astGrepYamlRule !== undefined;
+    if (hasAstGrep)
+        return 'ast-grep';
+    if (fields.pattern.length > 0)
+        return 'regex';
+    return 'unknown';
+}
+/**
+ * A stable, deterministic diagnostic label for a record-compiled rule.
+ *
+ * `CompiledRule.lessonHeading` is a required diagnostic field on a schema built
+ * for lesson-compiled rules; the record grammar has no heading construct and
+ * § Design 4's key space is closed against inventing one. Deriving the label
+ * from the identity mirrors the shipped authored-path idiom
+ * (`compile.ts: candidateHeading`) and deliberately does NOT copy `message` —
+ * two homes for the author's one sentence is Tenet 20's prohibited mirror, and
+ * a heading that drifts from the message would be worse than a generic one.
+ */
+function recordHeading(ruleId) {
+    return `Prop 310 rule record (${ruleId})`;
+}
+/**
+ * Lower a parsed Prop 310 record into a `CompiledRule`.
+ *
+ * PURE (no IO). Returns a `CompileOutcome`:
+ *   - `{kind: 'compiled'}` — the record lowered totally.
+ *   - `{kind: 'rejected', reason}` — an authored-content gate failed (bad regex
+ *     in the target or in `requires`, an unresolvable `language`, a malformed
+ *     ast-grep tree, a V1-inexpressible NapiConfig key). Loud and counted, never
+ *     silent; the reason names the governing § so the author is sent to the spec.
+ *
+ * THROWS on a producer-contract violation — a missing/malformed `ruleId`, a key
+ * with no defined lowering, or an engine-binding divergence. These are bugs in
+ * the code that CALLED this function, not defects in the author's record, and
+ * they carry the incumbent's fail-loud idiom (`compile.ts: compileCandidate`)
+ * verbatim: assert up front, before any validation work, so a violation can
+ * never be masked by a coincidental `rejected` outcome.
+ */
+export function compileRuleRecord(parsed, opts) {
+    // ── Identity precondition, asserted UP FRONT (ADR-112 §8/§9) ──
+    if (!AUTHORED_RULE_ID_RE.test(opts.ruleId)) {
+        throw new Error(`[Totem Error] compileRuleRecord: malformed ruleId '${opts.ruleId}' — identity is minted by the ADR-112 §8 producer at the intake seam and threaded in (16 hex + optional -<n> suffix, ADR-112 §3/§8). The record grammar makes 'ruleId' INEXPRESSIBLE in-record (Prop 310 § Design 3/R17), so a malformed value here is a producer/threading bug; enthroning it would orphan the rule's controls.positive[].targetRuleId.`);
+    }
+    const record = parsed.record;
+    // ── § Design 12 — no construct is accepted at parse and dropped at compile ──
+    assertTotalLowering(record);
+    const target = record.target;
+    // ── Engine gates (§ Design 12: fail loud, never accept-then-drop) ──
+    //
+    // `requires.pattern` is gated on EVERY engine, not just regex: § Design 8 makes
+    // it "a safe-regex2-gated regex evaluated textually … independent of
+    // `target.type`", so an ast-grep rule's requirement is subject to the same
+    // ReDoS gate as a regex rule's target. Gated BEFORE the target payload so the
+    // author gets the first defect in a fixed, deterministic order.
+    if (record.requires !== undefined) {
+        const v = validateRegex(record.requires.pattern);
+        if (!v.valid) {
+            return {
+                kind: 'rejected',
+                reason: `Prop 310 § Design 8: requires.pattern is not a usable regex (${v.reason ?? 'invalid regex pattern'}) — the requirement is a safe-regex2-gated regex evaluated textually at the declared scope, independent of target.type.`,
+            };
+        }
+        // RULING (falsification round, 2026-08-21): `requires.scope: line` is
+        // REJECTED on an ast-grep target. An ast-grep match is a SPAN, not a line,
+        // so "the line containing L" has no engine-defined answer: the runtime reads
+        // the span's START line, which makes the verdict depend on how the author
+        // wrapped their source — the review measured a rule firing once when its
+        // subject was split across lines and not at all when it was written on one.
+        // A formatting-dependent verdict is not a semantic. § Design 8 already
+        // reserves `block` — the span's natural unit — as unimplemented pending a
+        // language adapter's boundary definition, so the honest V1 answer is to
+        // reject the combination rather than ship a line reading that only
+        // coincidentally agrees with the author's intent. `file` scope stays valid
+        // on ast-grep (whole-file text is unambiguous), and `line` stays valid on
+        // regex targets (a regex match IS line-local by construction).
+        if (record.target.type === 'ast-grep' && record.requires.scope === 'line') {
+            return {
+                kind: 'rejected',
+                reason: "Prop 310 § Design 8: `requires.scope: line` is not available on an `ast-grep` target — an ast-grep match is a SPAN, and reading it as its start line makes the verdict depend on source formatting rather than on the rule. Use `scope: file` (unambiguous on any engine), move the requirement into the payload's own `not:`/`has:` combinators (§ Design 8: node-scoped absence stays payload-owned), or wait for the reserved `block` unit, which is the span's natural scope and is unimplemented at V1.",
+            };
+        }
+    }
+    let payloadFields;
+    let resolvedLanguage;
+    if (target.type === 'regex') {
+        // The record grammar guarantees `pattern` present and `rule`/`language` absent
+        // for `type: regex`; the non-null assertion is the schema's contract, not an
+        // assumption (`RuleTargetSchema.superRefine`).
+        const pattern = target.pattern;
+        const v = validateRegex(pattern);
+        if (!v.valid) {
+            return {
+                kind: 'rejected',
+                reason: `Prop 310 § Design 6: target.pattern is not a usable regex (${v.reason ?? 'invalid regex pattern'}).`,
+            };
+        }
+        payloadFields = engineFields('regex', pattern);
+    }
+    else {
+        // ── ast-grep: resolve the language FIRST, then validate under exactly it ──
+        const resolution = resolveRecordLanguage(target.language);
+        if (!resolution.resolved)
+            return { kind: 'rejected', reason: resolution.reason };
+        resolvedLanguage = resolution.language;
+        // The language⇄glob consistency floor, BEFORE the payload gate: a scope that
+        // will be evaluated under a different grammar than the payload is validated
+        // under is a defect in the record, and the author should be told that rather
+        // than being handed a payload error for a payload that is fine.
+        const inconsistent = checkLanguageGlobConsistency(resolution.language, target.scope.fileGlobs);
+        if (inconsistent !== null)
+            return { kind: 'rejected', reason: inconsistent };
+        const probeGlobs = languageProbeGlobs(resolution.extension);
+        if (target.rule !== undefined) {
+            const inexpressible = V1_INEXPRESSIBLE_NAPI_KEYS.find((key) => key in target.rule);
+            if (inexpressible !== undefined) {
+                return {
+                    kind: 'rejected',
+                    reason: `Prop 310 § Design 4 (operator ruling 2026-08-21, tree-form): 'target.rule' is the ast-grep RULE TREE, and '${inexpressible}' is a NapiConfig SIBLING of the rule — inexpressible at V1 (zero of the 19 compound corpus rules use it). Demand is typed as a construct-gap at the § Design 15 trial and lands by grammar version bump with its own home under 'target:', never smuggled inside the tree.`,
+                };
+            }
+            // The tree-form ruling's derivation: the record carries the TREE, the
+            // lowering builds the wrapper. `language` is derived from the resolved
+            // `target.language`, so the record never carries a duplicate language home.
+            const napiConfig = {
+                rule: target.rule,
+                language: extensionToLang(resolution.extension),
+            };
+            const v = validateAstGrepPattern(napiConfig, probeGlobs);
+            if (!v.valid) {
+                return {
+                    kind: 'rejected',
+                    reason: `Prop 310 § Design 6: target.rule failed ast-grep validation under the declared language '${resolvedLanguage}' (${v.reason ?? 'invalid ast-grep rule'}). V1 validates under exactly the declared grammar — the shipped try-each-glob-derived-Lang cross-grammar acceptance does not apply on the record path.`,
+                };
+            }
+            payloadFields = engineFields('ast-grep', napiConfig);
+        }
+        else {
+            const pattern = target.pattern;
+            const v = validateAstGrepPattern(pattern, probeGlobs);
+            if (!v.valid) {
+                return {
+                    kind: 'rejected',
+                    reason: `Prop 310 § Design 6: target.pattern failed ast-grep validation under the declared language '${resolvedLanguage}' (${v.reason ?? 'invalid ast-grep pattern'}). V1 validates under exactly the declared grammar — the shipped try-each-glob-derived-Lang cross-grammar acceptance does not apply on the record path.`,
+                };
+            }
+            payloadFields = engineFields('ast-grep', pattern);
+        }
+    }
+    // ── § Design 3 engine binding, asserted on two INDEPENDENTLY-derived sides ──
+    const payloadEngine = engineFromCompiledFields(payloadFields);
+    if (payloadEngine !== parsed.derivedEngine) {
+        throw new Error(`[Totem Error] compileRuleRecord: record declared target.type '${parsed.derivedEngine}' but its payload compiled as '${payloadEngine}' — the two sides originate differently (the record's target.type vs the payload's actual compilation path), so this divergence is a lowering bug, not an authoring one (Prop 310 § Design 3, ADR-112 §3).`);
+    }
+    const heading = recordHeading(opts.ruleId);
+    const rule = CompiledRuleSchema.parse({
+        // ADR-112 §8/§9 id-unification: the compiled identity IS the minted ruleId.
+        lessonHash: opts.ruleId,
+        lessonHeading: heading,
+        message: record.message,
+        engine: parsed.derivedEngine,
+        ...payloadFields,
+        // § Design 7 — VERBATIM. `sanitizeFileGlobs` never runs on this path: the
+        // strict dialect already validated these at parse, and expansion/promotion
+        // are the silent transforms the grammar exists to kill.
+        fileGlobs: [...record.target.scope.fileGlobs],
+        ...(record.target.scope.excludeGlobs !== undefined
+            ? { excludeGlobs: [...record.target.scope.excludeGlobs] }
+            : {}),
+        severity: record.severity,
+        ...(record.recoveryHint !== undefined ? { recoveryHint: record.recoveryHint } : {}),
+        examples: record.examples.map((example) => ({ bad: example.bad, good: example.good })),
+        ...(record.requires !== undefined
+            ? { requires: { pattern: record.requires.pattern, scope: record.requires.scope } }
+            : {}),
+        ...(record.curation !== undefined ? { curation: { ...record.curation } } : {}),
+        // § Design 9 / Amendment R4 — carried VERBATIM, never evaluated at V1. The
+        // record key's named snake_case exception is renamed exactly here, once.
+        ...(record.verification_shadow !== undefined
+            ? { verificationShadow: { ...record.verification_shadow } }
+            : {}),
+        ...(resolvedLanguage !== undefined ? { language: resolvedLanguage } : {}),
+        compiledAt: opts.now,
+        createdAt: opts.now,
+        // Yellow / sensor-only, exactly as the authored path (§ Design "State-surface
+        // backing": every rule minted from this grammar enters unverified, ADR-112
+        // §1). `legitimacy`/`ruleClass` stay ABSENT — the sense→enforce crossing is
+        // priced by the Amendment's proof-required ruling, never by this lowering.
+        unverified: true,
+    });
+    return { kind: 'compiled', rule };
+}
+//# sourceMappingURL=record-lower.js.map

package/dist/spine/record-lower.js.map

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

package/dist/spine/record-lower.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=record-lower.test.d.ts.map

package/dist/spine/record-lower.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-lower.test.d.ts","sourceRoot":"","sources":["../../src/spine/record-lower.test.ts"],"names":[],"mappings":""}