@mmnto/totem 1.78.0 → 1.80.0

package/dist/spine/authored-rule.d.ts.map

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

package/dist/spine/authored-rule.js

@@ -0,0 +1,313 @@
+// ─── ADR-112 Gate-1 authored producer: the AuthoredRuleRecord envelope ───────
+//
+// The human-authored counterpart to ADR-111's mined `CandidateRuleRecord`. An
+// authored rule is anchored to a real historical DEFECT (its `provenance` is the
+// AUTHORED variant of the ADR-112 union — train-side preimage fixtures, §3/§4),
+// carries an INDEPENDENTLY-judged structural-eligibility result (NOT author-
+// asserted — §3), an accelerant-lineage marker (§7), and is minted
+// `unverified`/Yellow (ADR-089) with zero enforcement blast radius.
+//
+// SLICE A scope: the schema spine + the deterministic eligibility check + the
+// stable rule-id mint. The `totem rule author` CLI + the `.totem/spine/
+// authored-rules.yaml` reader are slice B; the compile-feed integration into
+// `runCompileStage` is gated on the `compileCandidate` param-widening flagged in
+// the slice-A report (a controller decision). The whitelist REGISTRY of
+// decidable classes lives in the CLI (slice B, mirroring `valueEqualityFieldsFor`);
+// this core check takes it injected (DI), staying network-free + LLM-free.
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { AuthoredFixtureSchema, AuthoredProvenanceRecordSchema, isIso8601CalendarDate, } from '../compiler-schema.js';
+/** The matcher engines an authored rule may declare (mirrors `CompiledRule.engine`). */
+export const DeclaredEngineSchema = z.enum(['regex', 'ast', 'ast-grep']);
+// The §3 eligibility-basis forms: `whitelist:<class>` (the cert-#1 deterministic basis,
+// a non-empty class after the colon), or the deferred `capability-check` /
+// `draft-classifier+stage4`. Pins `basis` to the contract so a free-form/typo'd value
+// can't validate (strategy item 2, #2259).
+const ELIGIBILITY_BASIS_RE = /^(?:whitelist:.+|capability-check|draft-classifier\+stage4)$/;
+/**
+ * ADR-112 §3 — the result of the INDEPENDENT structural-eligibility check.
+ * Produced by `evaluateStructuralEligibility` (NOT by the author): only
+ * `decidable: true` reaches the compiler, mapping to the compiler's
+ * `classifierDisposition: 'structural'`. `judgedBy` records who/what judged it
+ * (ledger-recorded, never the author), so a human cannot smuggle a behavioral
+ * policy past ADR-091's gate by hand-asserting "structural" (FM(d)).
+ */
+export const StructEligResultSchema = z.object({
+    decidable: z.boolean(),
+    /**
+     * `whitelist:<class>` for the cert-#1 static-whitelist basis; the
+     * `capability-check` / `draft-classifier+stage4` bases are contract-legal but
+     * deferred (slice-A uses the deterministic whitelist only). On a `decidable:
+     * false` verdict the basis still names the attempted whitelist class — the
+     * diagnostic is "no/ambiguous whitelist match", carried in `judgedBy`'s log.
+     * Constrained to the §3 forms (strategy item 2, #2259) so a typo'd/free-form
+     * basis can't validate — non-mutating (no `.trim()`), matching the hash-stability
+     * discipline on the other reference fields.
+     */
+    basis: z.string().refine((s) => ELIGIBILITY_BASIS_RE.test(s), {
+        message: 'basis must be a §3 eligibility basis: whitelist:<class> | capability-check | draft-classifier+stage4',
+    }),
+    judgedBy: z.string().refine((s) => s.trim().length > 0, {
+        message: 'judgedBy must name the check/agent that judged eligibility (never the author)',
+    }),
+});
+/** ADR-112 §3/§7 — accelerant-lineage marker. A mined hint that informed a human is recorded, never erased. */
+export const AuthoredOriginSchema = z.union([
+    z.object({ kind: z.literal('from-scratch') }),
+    z.object({
+        kind: z.literal('mined-accelerant'),
+        sourceRunId: z.string().refine((s) => s.trim().length > 0, { message: 'sourceRunId required' }),
+        suggestionHash: z.string().refine((s) => s.trim().length > 0, {
+            message: 'suggestionHash required',
+        }),
+    }),
+]);
+// The persisted minted-rule-id shape (ADR-112 §8): a 16-char lowercase-hex base from
+// `mintAuthoredRuleId`, with an optional collision suffix. The suffix is EXACTLY what the
+// mint emits — `-<n>` for n≥1, never `-0` and never zero-padded — so schema-valid ≡
+// mint-producible (#2259 CR: a looser `-\d+` admitted ids like `…-0`/`…-01` the mint can't
+// make). Pinned as a shared constant binding the SCHEMA boundary to the mint's codomain.
+const AUTHORED_RULE_ID_HEX_LEN = 16;
+const AUTHORED_RULE_ID_RE = new RegExp(`^[0-9a-f]{${AUTHORED_RULE_ID_HEX_LEN}}(?:-[1-9]\\d*)?$`);
+/**
+ * ADR-112 §3 — the authored producer's sole output envelope. Parallel to
+ * ADR-111's `CandidateRuleRecord` but carrying the AUTHORED provenance variant,
+ * the INDEPENDENTLY-judged eligibility result, and the accelerant lineage.
+ * Minted `unverified: true` (ADR-089) — zero enforcement blast radius.
+ */
+export const AuthoredRuleRecordSchema = z.object({
+    /**
+     * ADR-112 §3/§8 — the stable, minted rule identity (`mintAuthoredRuleId`),
+     * assigned ONCE at authoring time and PERSISTED on the record; NEVER re-derived
+     * from content at read time. `firingLabelId` + the §5.3
+     * `controls.positive[].targetRuleId` ground-truth labels embed it, so a
+     * content-re-derived id would orphan them (§8). Slice A reserves the field (this
+     * IS the schema spine); the authoring flow (slice B) mints it, and threading it
+     * into the compiled artifact's identity (`firingLabelId ← ruleId`, replacing the
+     * `dslSource`-derived `lessonHash`) is slice C/D. The RESOLVED id (with any `-N`
+     * collision suffix) is what is stored.
+     */
+    ruleId: z.string().regex(AUTHORED_RULE_ID_RE, {
+        message: 'ruleId must be a minted authored rule id — 16 hex chars + optional -<n> suffix (ADR-112 §3/§8)',
+    }),
+    provenance: AuthoredProvenanceRecordSchema,
+    /** INDEPENDENTLY established (§3) — the author never sets this; the check does. */
+    structuralEligibility: StructEligResultSchema,
+    origin: AuthoredOriginSchema,
+    declaredEngine: DeclaredEngineSchema,
+    /** Reference to the §8 authoring-ledger entry (author/date/engine/splitRef/attestations). */
+    authoringLedgerRef: z.string().refine((s) => s.trim().length > 0, {
+        message: 'authoringLedgerRef must be a non-empty ledger reference',
+    }),
+    /** The human-written matcher (same DSL the compiler accepts from the miner). */
+    dslSource: z.string().refine((s) => s.trim().length > 0, {
+        message: 'dslSource must be non-empty',
+    }),
+    /** Zero-trust mint (ADR-089 / ADR-112 §1) — always literally `true`. */
+    unverified: z.literal(true),
+});
+// ── SLICE B — the authoring INTAKE schema (ADR-112 §3/§8, FM(d)) ──────────────
+//
+// `AuthoredRuleInput` is the STRICT shape a human may supply in
+// `.totem/spine/authored-rules.yaml`. It is DELIBERATELY distinct from
+// `AuthoredRuleRecord`: the author sets ONLY the fields they legitimately own —
+// the matcher, the declared engine + claimed structural class, the defect
+// anchor, the fixtures, the accelerant origin. Every PRODUCER-owned field is
+// REJECTED at parse (`.strict()` ⇒ unknown keys fail), so an author cannot
+// hand-edit the YAML to inject a `structuralEligibility` / `decidable` / `ruleId`
+// / `disposition` / `judgedBy` verdict — those keys are simply not expressible.
+// The reader (slice B, CLI) re-runs `evaluateStructuralEligibility` over the DI
+// whitelist and mints/upserts the id ITSELF; the author's `structuralClass` is a
+// CLAIM that the independent check decides, never a self-certification (FM(d) /
+// the greptile-#3 trust boundary). A file that already looks like an
+// `AuthoredRuleRecord[]` (carrying `structuralEligibility`/`ruleId`/…) therefore
+// fails the read as the WRONG SHAPE — it is never accepted as an "advanced" form.
+//
+// Identity/metadata strings are `.transform(trim)` BEFORE the refine (GCA-high
+// diff-review): a non-mutating `.refine` would let `"alice "` (trailing space)
+// bypass the `judgedBy !== author` independence check and mint a DIFFERENT ruleId
+// for a semantically-identical input. `dslSource` is the one string NOT trimmed —
+// trimming a matcher could change its meaning (leading/trailing pattern chars).
+export const AuthoredRuleInputSchema = z
+    .object({
+    /** Agent-id or operator handle — attributable (mirrors the provenance field). Trimmed. */
+    author: z
+        .string()
+        .transform((s) => s.trim())
+        .refine((s) => s.length > 0, { message: 'author must be a non-empty, attributable handle' }),
+    /**
+     * ISO-8601 authoring date — trimmed + calendar-validated at the INTAKE boundary
+     * (CR diff-review): the same `isIso8601CalendarDate` the record provenance uses,
+     * so a malformed `not-a-date` fails here with a clean `CONFIG_INVALID` instead of
+     * escaping to a raw ZodError at record construction (pass 1).
+     */
+    authoredAt: z
+        .string()
+        .transform((s) => s.trim())
+        .refine(isIso8601CalendarDate, {
+        message: 'authoredAt must be a valid ISO-8601 calendar date (YYYY-MM-DD or a full timestamp)',
+    }),
+    /** The declared DEFECT the rule targets — the pre-image, not its fix (ADR-110 §4 TP-def). Trimmed. */
+    targetDefect: z
+        .string()
+        .transform((s) => s.trim())
+        .refine((s) => s.length > 0, {
+        message: 'targetDefect must be a non-empty defect description',
+    }),
+    /** The matcher engine the author declares; the eligibility check confirms it can represent the class. */
+    declaredEngine: DeclaredEngineSchema,
+    /**
+     * The structural rule-CLASS the author CLAIMS. Fed to the INDEPENDENT
+     * `evaluateStructuralEligibility` against the DI whitelist; it is NOT stored
+     * verbatim on the record — the *verdict* (`structuralEligibility`, basis
+     * `whitelist:<class>`) is. Naming a class is a claim the check adjudicates,
+     * never a self-certification of `decidable`. Trimmed so a stray space can't
+     * cause an exact-match miss against the registry.
+     */
+    structuralClass: z
+        .string()
+        .transform((s) => s.trim())
+        .refine((s) => s.length > 0, {
+        message: 'structuralClass must be a non-empty rule-class for the whitelist to decide',
+    }),
+    /** The human-written matcher (same DSL the compiler accepts from the miner). */
+    dslSource: z.string().refine((s) => s.trim().length > 0, {
+        message: 'dslSource must be non-empty',
+    }),
+    /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+    positiveFixtures: z.array(AuthoredFixtureSchema).min(1, {
+        message: 'an authored rule must declare ≥1 positive fixture (ADR-112 §3)',
+    }),
+    /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+    negativeFixtures: z.array(AuthoredFixtureSchema).optional(),
+    /**
+     * Accelerant lineage (§7). Optional in the YAML; the reader defaults an
+     * absent value to `{ kind: 'from-scratch' }` when constructing the record, so
+     * the persisted `origin` is always explicit (§7 lineage is never erased).
+     */
+    origin: AuthoredOriginSchema.optional(),
+})
+    .strict();
+/**
+ * SLICE B — the on-disk shape of `.totem/spine/authored-rules.yaml`. A file-level
+ * authoring header carries the §5/§8 leakage-guard ATTESTATIONS once for the
+ * session (not per-rule, since all rules in one file are authored under one
+ * frozen split), followed by the rules. Slice B RECORDS these faithfully into the
+ * authoring-ledger (strategy's boundary confirm: B records `splitRef` /
+ * `authoredAfterSplit` / `fixturePrs`); the MECHANICAL verification — the split
+ * was frozen BEFORE authoring (§5.1/FM(g)), fixtures resolve train-side (§5.2),
+ * the harness is sandboxed (§5.4) — is the cert-run harness in SLICE C. The
+ * attestations are `literal(true)`: an author who cannot attest them is not
+ * authoring legitimately, so a `false` fails the read rather than recording a
+ * self-defeating attestation. `.strict()` rejects unknown header keys.
+ */
+export const AuthoredRulesFileSchema = z
+    .object({
+    /** The frozen split (ADR-110 §6) the rules were authored under (recorded; verified in C). Trimmed (GCA) so stray whitespace can't bypass the non-empty check or perturb the revision fingerprint. */
+    splitRef: z
+        .string()
+        .transform((s) => s.trim())
+        .refine((s) => s.length > 0, {
+        message: 'splitRef must name the frozen split the rules were authored under (ADR-112 §5.1)',
+    }),
+    /** §1(g) embargo attestation — authored AFTER the split was frozen. Always `true`; verified in C. */
+    authoredAfterSplit: z.literal(true),
+    /** §5 attestation — the author did not inspect the held-out slice. Always `true`; sandboxed in C. */
+    heldOutNonInspectionAttestation: z.literal(true),
+    /** The authored rules (≥1). */
+    rules: z.array(AuthoredRuleInputSchema).min(1, {
+        message: 'authored-rules.yaml must declare ≥1 rule',
+    }),
+})
+    .strict();
+/**
+ * ADR-112 §3 — the INDEPENDENT structural-eligibility check. A CLOSED registry
+ * predicate, NOT prose: `decidable` is true iff EXACTLY ONE whitelist entry
+ * matches `(declaredEngine, structuralClass)`. Unknown class, unsupported
+ * engine, or multiple matches → `decidable: false` (NO default-to-structural).
+ * The author supplies `declaredEngine` + `structuralClass`; this check OWNS the
+ * verdict — any author-supplied disposition is irrelevant here (FM(d)).
+ * Deterministic + pure (no IO, no LLM) — the same input always yields the same
+ * verdict (Tenet-15).
+ */
+export function evaluateStructuralEligibility(input, whitelist, judgedBy) {
+    const matches = whitelist.filter((e) => e.engine === input.declaredEngine && e.structuralClass === input.structuralClass);
+    return {
+        decidable: matches.length === 1,
+        basis: `whitelist:${input.structuralClass}`,
+        judgedBy,
+    };
+}
+// ── Stable rule-id mint (ADR-112 §8) ──────────────────────────────────────────
+/**
+ * ADR-112 §8 — mint a stable, deterministic authored rule-id. The seed is
+ * `sha256(JSON.stringify([author, targetDefect]))[:16]` (an INJECTIVE encoding —
+ * see the inline note) — `dslSource` is DELIBERATELY EXCLUDED so an author can
+ * tighten/refactor the matcher without orphaning the rule's ledger history. On collision with an already-resolved id (two rules sharing the same
+ * `(author, targetDefect)`), a stable `-N` counter is appended. The RESOLVED id
+ * is what callers persist — never recompute the raw seed at read time, or a
+ * later sibling could shift the suffix (the gemini/agy break). The
+ * `never-remine` marker is keyed to `targetDefect`, handled by the accelerant
+ * miner, not here.
+ */
+export function mintAuthoredRuleId(author, targetDefect, existingIds) {
+    // Unambiguous seed encoding (GCA-high + CR-major, #2259): a bare `author·targetDefect`
+    // ALIASES distinct tuples — ('a·b','c') and ('a','b·c') collapse onto one seed. A JSON
+    // array of the two inputs is injective: distinct (author, targetDefect) pairs can never
+    // serialize to the same string, so a persisted id can't collide by encoding.
+    const seed = createHash('sha256')
+        .update(JSON.stringify([author, targetDefect]))
+        .digest('hex')
+        .slice(0, AUTHORED_RULE_ID_HEX_LEN);
+    if (!existingIds.has(seed))
+        return seed;
+    for (let n = 1;; n += 1) {
+        const candidate = `${seed}-${n}`;
+        if (!existingIds.has(candidate))
+            return candidate;
+    }
+}
+/**
+ * ADR-112 §2/§8 — turn structurally-DECIDABLE authored rules into the input
+ * `runCompileStage` consumes, reusing the ONE G-series compiler (never a second).
+ * The disposition is set HERE to `'structural'` from the INDEPENDENT eligibility
+ * verdict (§3) — the author never sets it. A NON-decidable record is a contract
+ * violation → FAIL LOUD (the FM(d) backstop in code), never a silent skip.
+ * `classifierLedgerRef = authored:<authoringLedgerRef>` is unique per rule (the
+ * authoring ledger is 1:1 with the rule); a duplicate fails loud so the downstream
+ * 1:1 classifier-ledger join can't silently collapse.
+ */
+export function toCompileFeed(records) {
+    const candidates = [];
+    const entries = [];
+    const seen = new Set();
+    for (const record of records) {
+        if (!record.structuralEligibility.decidable) {
+            throw new Error(`[Totem Error] toCompileFeed: authored rule '${record.authoringLedgerRef}' is not structurally decidable — a non-decidable rule must never reach the compiler (ADR-112 §3 / FM(d))`);
+        }
+        const classifierLedgerRef = `authored:${record.authoringLedgerRef}`;
+        if (seen.has(classifierLedgerRef)) {
+            throw new Error(`[Totem Error] toCompileFeed: duplicate authoringLedgerRef '${record.authoringLedgerRef}' — each authored rule needs a unique ledger ref for the 1:1 compile join`);
+        }
+        seen.add(classifierLedgerRef);
+        candidates.push({
+            provenance: record.provenance,
+            classifierDisposition: 'structural',
+            classifierLedgerRef,
+            dslSource: record.dslSource,
+            // §3 (#7): carry the whitelist-judged engine so the compiler can assert it
+            // compiled under THAT engine — a regex-whitelisted rule whose dslSource parses
+            // as ast-grep must fail loud, not silently re-route to a different engine.
+            declaredEngine: record.declaredEngine,
+            unverified: true,
+        });
+        entries.push({
+            candidateRef: classifierLedgerRef,
+            disposition: 'structural',
+            stage4Confirmed: false,
+            dispositionSource: 'authored-whitelist',
+        });
+    }
+    return { candidates, classifierLedger: { entries } };
+}
+//# sourceMappingURL=authored-rule.js.map

package/dist/spine/authored-rule.js.map

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

package/dist/spine/authored-rule.test.d.ts

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

package/dist/spine/authored-rule.test.d.ts.map

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

package/dist/spine/authored-rule.test.js

@@ -0,0 +1,226 @@
+import { describe, expect, it } from 'vitest';
+import { AuthoredRuleRecordSchema, evaluateStructuralEligibility, mintAuthoredRuleId, toCompileFeed, } from './authored-rule.js';
+const WHITELIST = [
+    { engine: 'regex', structuralClass: 'float-finite-assert' },
+    { engine: 'ast-grep', structuralClass: 'divisor-le-zero' },
+];
+describe('evaluateStructuralEligibility (ADR-112 §3 — closed predicate)', () => {
+    it('decidable:true on EXACTLY ONE (engine,class) match', () => {
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'float-finite-assert' }, WHITELIST, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(true);
+        expect(r.basis).toBe('whitelist:float-finite-assert');
+        expect(r.judgedBy).toBe('static-whitelist@cert-1');
+    });
+    it('decidable:false on an UNKNOWN class (no default-to-structural)', () => {
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'unbounded-recursion-behavioral' }, WHITELIST, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(false);
+    });
+    it('decidable:false when the engine cannot represent the class (no matching pair)', () => {
+        // class is whitelisted for ast-grep, not regex → no (regex, divisor-le-zero) entry.
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'divisor-le-zero' }, WHITELIST, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(false);
+    });
+    it('decidable:false on MULTIPLE matches (ambiguous)', () => {
+        const dupes = [
+            { engine: 'regex', structuralClass: 'float-finite-assert' },
+            { engine: 'regex', structuralClass: 'float-finite-assert' },
+        ];
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'float-finite-assert' }, dupes, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(false);
+    });
+    it('is deterministic — 100 sequential iterations yield an identical verdict (LLM-free)', () => {
+        const first = JSON.stringify(evaluateStructuralEligibility({ declaredEngine: 'ast-grep', structuralClass: 'divisor-le-zero' }, WHITELIST, 'static-whitelist@cert-1'));
+        for (let i = 0; i < 100; i += 1) {
+            const again = JSON.stringify(evaluateStructuralEligibility({ declaredEngine: 'ast-grep', structuralClass: 'divisor-le-zero' }, WHITELIST, 'static-whitelist@cert-1'));
+            expect(again).toBe(first);
+        }
+    });
+});
+describe('AuthoredRuleRecord schema (ADR-112 §3)', () => {
+    const base = {
+        ruleId: '0f1e2d3c4b5a6978',
+        provenance: {
+            kind: 'authored',
+            author: 'totem-claude',
+            authoredAt: '2026-06-27',
+            targetDefect: 'float equality compared with == instead of a finite-tolerance check',
+            positiveFixtures: [
+                {
+                    pr: 100,
+                    preimageSource: {
+                        kind: 'commit',
+                        preimageCommitSha: 'c'.repeat(40),
+                        mergeCommitSha: 'b'.repeat(40),
+                    },
+                    filePath: 'src/physics/step.ts',
+                    matchedSpan: 'L10-L12',
+                    contentHash: 'deadbeefcafe',
+                },
+            ],
+        },
+        structuralEligibility: {
+            decidable: true,
+            basis: 'whitelist:float-finite-assert',
+            judgedBy: 's',
+        },
+        origin: { kind: 'from-scratch' },
+        declaredEngine: 'regex',
+        authoringLedgerRef: 'alr-0001',
+        dslSource: '**Pattern:** `== *\\d+\\.\\d+f?`',
+        unverified: true,
+    };
+    it('accepts a complete authored record', () => {
+        expect(() => AuthoredRuleRecordSchema.parse(base)).not.toThrow();
+    });
+    it('has NO author-settable disposition/routing field (the check owns eligibility — FM(d))', () => {
+        const parsed = AuthoredRuleRecordSchema.parse(base);
+        expect('classifierDisposition' in parsed).toBe(false);
+        expect('routing' in parsed).toBe(false);
+    });
+    it('requires the independent structuralEligibility result', () => {
+        const { structuralEligibility: _omit, ...without } = base;
+        expect(() => AuthoredRuleRecordSchema.parse(without)).toThrow();
+    });
+    it('reserves the minted ruleId on the record (ADR-112 §3/§8 — persisted, never re-derived)', () => {
+        const { ruleId: _omit, ...without } = base;
+        expect(() => AuthoredRuleRecordSchema.parse(without)).toThrow();
+        expect(() => AuthoredRuleRecordSchema.parse({ ...base, ruleId: '  ' })).toThrow();
+        expect(AuthoredRuleRecordSchema.parse(base).ruleId).toBe('0f1e2d3c4b5a6978');
+    });
+    it('enforces the minted ruleId SHAPE at the boundary — 16 hex + optional -<n> (#2259 CR-major)', () => {
+        for (const bad of [
+            'NOTHEXNOTHEXNOTH',
+            '0f1e2d3c',
+            '0f1e2d3c4b5a6978abcd',
+            '0F1E2D3C4B5A6978',
+            'rid-alr-1',
+            // non-canonical suffixes the mint never emits (n≥1, no zero-pad) — #2259 CR
+            '0f1e2d3c4b5a6978-0',
+            '0f1e2d3c4b5a6978-01',
+        ]) {
+            expect(() => AuthoredRuleRecordSchema.parse({ ...base, ruleId: bad })).toThrow();
+        }
+        for (const ok of ['0f1e2d3c4b5a6978', '0f1e2d3c4b5a6978-1', 'abcdef0123456789-42']) {
+            expect(() => AuthoredRuleRecordSchema.parse({ ...base, ruleId: ok })).not.toThrow();
+        }
+        // the mint always produces a schema-valid id (the shared shape constant binds both).
+        expect(() => AuthoredRuleRecordSchema.parse({
+            ...base,
+            ruleId: mintAuthoredRuleId('totem-claude', 'float-finite-assert', new Set()),
+        })).not.toThrow();
+    });
+    it('forces unverified:true (zero blast radius — ADR-089/§1)', () => {
+        expect(() => AuthoredRuleRecordSchema.parse({ ...base, unverified: false })).toThrow();
+    });
+    it('constrains structuralEligibility.basis to the §3 forms — not free-form (strategy item 2, #2259)', () => {
+        const withBasis = (basis) => ({
+            ...base,
+            structuralEligibility: { ...base.structuralEligibility, basis },
+        });
+        for (const bad of [
+            '',
+            'freeform',
+            'whitelist:',
+            'whitelisted',
+            'stage4',
+            ' capability-check',
+        ]) {
+            expect(() => AuthoredRuleRecordSchema.parse(withBasis(bad))).toThrow();
+        }
+        for (const ok of [
+            'whitelist:float-finite-assert',
+            'capability-check',
+            'draft-classifier+stage4',
+        ]) {
+            expect(() => AuthoredRuleRecordSchema.parse(withBasis(ok))).not.toThrow();
+        }
+    });
+});
+describe('mintAuthoredRuleId (ADR-112 §8)', () => {
+    it('is deterministic for the same (author,targetDefect) and excludes dslSource', () => {
+        const a = mintAuthoredRuleId('totem-claude', 'float-finite-assert', new Set());
+        const b = mintAuthoredRuleId('totem-claude', 'float-finite-assert', new Set());
+        expect(a).toBe(b);
+        expect(a).toMatch(/^[0-9a-f]{16}$/);
+    });
+    it('encodes (author,targetDefect) injectively — delimiter-aliased tuples do NOT collide (#2259)', () => {
+        // A bare `author·targetDefect` seed would alias these two distinct tuples onto one id.
+        const a = mintAuthoredRuleId('a·b', 'c', new Set());
+        const b = mintAuthoredRuleId('a', 'b·c', new Set());
+        expect(a).not.toBe(b);
+    });
+    it('appends a stable counter on collision and yields distinct persisted ids', () => {
+        const first = mintAuthoredRuleId('totem-claude', 'divisor-le-zero', new Set());
+        const second = mintAuthoredRuleId('totem-claude', 'divisor-le-zero', new Set([first]));
+        const third = mintAuthoredRuleId('totem-claude', 'divisor-le-zero', new Set([first, second]));
+        expect(second).toBe(`${first}-1`);
+        expect(third).toBe(`${first}-2`);
+        expect(new Set([first, second, third]).size).toBe(3);
+    });
+    it('is stable across re-runs given the already-resolved id set', () => {
+        const resolved = mintAuthoredRuleId('a', 'd', new Set());
+        expect(mintAuthoredRuleId('a', 'd', new Set([resolved]))).toBe(`${resolved}-1`);
+        expect(mintAuthoredRuleId('a', 'd', new Set([resolved]))).toBe(`${resolved}-1`);
+    });
+});
+describe('toCompileFeed (ADR-112 §2/§8 — authored → compile-stage input)', () => {
+    const decidable = (ref) => ({
+        ruleId: mintAuthoredRuleId('totem-claude', ref, new Set()),
+        provenance: {
+            kind: 'authored',
+            author: 'totem-claude',
+            authoredAt: '2026-06-27',
+            targetDefect: 'float equality compared with == instead of a finite check',
+            positiveFixtures: [
+                {
+                    pr: 1,
+                    preimageSource: {
+                        kind: 'commit',
+                        preimageCommitSha: 'b'.repeat(40),
+                        mergeCommitSha: 'a'.repeat(40),
+                    },
+                    filePath: 'src/a.ts',
+                    matchedSpan: 'L1',
+                    contentHash: 'h1',
+                },
+            ],
+        },
+        structuralEligibility: {
+            decidable: true,
+            basis: 'whitelist:float-finite-assert',
+            judgedBy: 's',
+        },
+        origin: { kind: 'from-scratch' },
+        declaredEngine: 'regex',
+        authoringLedgerRef: ref,
+        dslSource: '**Pattern:** `== *\\d`',
+        unverified: true,
+    });
+    it('emits one structural candidate + a 1:1 authored-whitelist ledger entry per decidable rule', () => {
+        const feed = toCompileFeed([decidable('alr-1'), decidable('alr-2')]);
+        expect(feed.candidates).toHaveLength(2);
+        // the adapter — not the author — sets the disposition to structural.
+        expect(feed.candidates.every((c) => c.classifierDisposition === 'structural')).toBe(true);
+        // authored provenance is carried through, not flattened to a mined shape.
+        expect(feed.candidates[0].provenance.kind).toBe('authored');
+        expect(feed.candidates.map((c) => c.classifierLedgerRef)).toEqual([
+            'authored:alr-1',
+            'authored:alr-2',
+        ]);
+        // the classifier ledger NEVER claims an LLM judged a human rule (Tenet-20).
+        expect(feed.classifierLedger.entries.every((e) => e.dispositionSource === 'authored-whitelist')).toBe(true);
+        // the join key is 1:1 between candidate and ledger entry (runCompileStage requires it).
+        expect(feed.classifierLedger.entries.map((e) => e.candidateRef)).toEqual(feed.candidates.map((c) => c.classifierLedgerRef));
+    });
+    it('FAILS LOUD on a non-decidable record (FM(d) — never reaches the compiler)', () => {
+        const nd = {
+            ...decidable('alr-x'),
+            structuralEligibility: { decidable: false, basis: 'whitelist:foo', judgedBy: 's' },
+        };
+        expect(() => toCompileFeed([nd])).toThrow(/not structurally decidable/);
+    });
+    it('FAILS LOUD on a duplicate authoringLedgerRef (protects the 1:1 compile join)', () => {
+        expect(() => toCompileFeed([decidable('dup'), decidable('dup')])).toThrow(/duplicate authoringLedgerRef/);
+    });
+});
+//# sourceMappingURL=authored-rule.test.js.map

package/dist/spine/authored-rule.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-rule.test.js","sourceRoot":"","sources":["../../src/spine/authored-rule.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAEL,wBAAwB,EACxB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,GAEd,MAAM,oBAAoB,CAAC;AAE5B,MAAM,SAAS,GAA8B;IAC3C,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE;IAC3D,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE;CAC3D,CAAC;AAEF,QAAQ,CAAC,+DAA+D,EAAE,GAAG,EAAE;IAC7E,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,MAAM,CAAC,GAAG,6BAA6B,CACrC,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,EACnE,SAAS,EACT,yBAAyB,CAC1B,CAAC;QACF,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;QACtD,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gEAAgE,EAAE,GAAG,EAAE;QACxE,MAAM,CAAC,GAAG,6BAA6B,CACrC,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,EAAE,gCAAgC,EAAE,EAC9E,SAAS,EACT,yBAAyB,CAC1B,CAAC;QACF,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+EAA+E,EAAE,GAAG,EAAE;QACvF,oFAAoF;QACpF,MAAM,CAAC,GAAG,6BAA6B,CACrC,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,EAC/D,SAAS,EACT,yBAAyB,CAC1B,CAAC;QACF,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QACzD,MAAM,KAAK,GAAqB;YAC9B,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE;YAC3D,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE;SAC5D,CAAC;QACF,MAAM,CAAC,GAAG,6BAA6B,CACrC,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,EACnE,KAAK,EACL,yBAAyB,CAC1B,CAAC;QACF,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oFAAoF,EAAE,GAAG,EAAE;QAC5F,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAC1B,6BAA6B,CAC3B,EAAE,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,EAClE,SAAS,EACT,yBAAyB,CAC1B,CACF,CAAC;QACF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAC1B,6BAA6B,CAC3B,EAAE,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,EAClE,SAAS,EACT,yBAAyB,CAC1B,CACF,CAAC;YACF,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,wCAAwC,EAAE,GAAG,EAAE;IACtD,MAAM,IAAI,GAAG;QACX,MAAM,EAAE,kBAAkB;QAC1B,UAAU,EAAE;YACV,IAAI,EAAE,UAAmB;YACzB,MAAM,EAAE,cAAc;YACtB,UAAU,EAAE,YAAY;YACxB,YAAY,EAAE,qEAAqE;YACnF,gBAAgB,EAAE;gBAChB;oBACE,EAAE,EAAE,GAAG;oBACP,cAAc,EAAE;wBACd,IAAI,EAAE,QAAiB;wBACvB,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;wBACjC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;qBAC/B;oBACD,QAAQ,EAAE,qBAAqB;oBAC/B,WAAW,EAAE,SAAS;oBACtB,WAAW,EAAE,cAAc;iBAC5B;aACF;SACF;QACD,qBAAqB,EAAE;YACrB,SAAS,EAAE,IAAI;YACf,KAAK,EAAE,+BAA+B;YACtC,QAAQ,EAAE,GAAG;SACd;QACD,MAAM,EAAE,EAAE,IAAI,EAAE,cAAuB,EAAE;QACzC,cAAc,EAAE,OAAgB;QAChC,kBAAkB,EAAE,UAAU;QAC9B,SAAS,EAAE,kCAAkC;QAC7C,UAAU,EAAE,IAAa;KAC1B,CAAC;IAEF,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAC5C,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IACnE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uFAAuF,EAAE,GAAG,EAAE;QAC/F,MAAM,MAAM,GAAG,wBAAwB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,CAAC,uBAAuB,IAAI,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtD,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,MAAM,EAAE,qBAAqB,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC;QAC1D,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wFAAwF,EAAE,GAAG,EAAE;QAChG,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC;QAC3C,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QAChE,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QAClF,MAAM,CAAC,wBAAwB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAC/E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4FAA4F,EAAE,GAAG,EAAE;QACpG,KAAK,MAAM,GAAG,IAAI;YAChB,kBAAkB;YAClB,UAAU;YACV,sBAAsB;YACtB,kBAAkB;YAClB,WAAW;YACX,4EAA4E;YAC5E,oBAAoB;YACpB,qBAAqB;SACtB,EAAE,CAAC;YACF,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QACnF,CAAC;QACD,KAAK,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,oBAAoB,EAAE,qBAAqB,CAAC,EAAE,CAAC;YACnF,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACtF,CAAC;QACD,qFAAqF;QACrF,MAAM,CAAC,GAAG,EAAE,CACV,wBAAwB,CAAC,KAAK,CAAC;YAC7B,GAAG,IAAI;YACP,MAAM,EAAE,kBAAkB,CAAC,cAAc,EAAE,qBAAqB,EAAE,IAAI,GAAG,EAAE,CAAC;SAC7E,CAAC,CACH,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACzF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iGAAiG,EAAE,GAAG,EAAE;QACzG,MAAM,SAAS,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC;YACpC,GAAG,IAAI;YACP,qBAAqB,EAAE,EAAE,GAAG,IAAI,CAAC,qBAAqB,EAAE,KAAK,EAAE;SAChE,CAAC,CAAC;QACH,KAAK,MAAM,GAAG,IAAI;YAChB,EAAE;YACF,UAAU;YACV,YAAY;YACZ,aAAa;YACb,QAAQ;YACR,mBAAmB;SACpB,EAAE,CAAC;YACF,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QACzE,CAAC;QACD,KAAK,MAAM,EAAE,IAAI;YACf,+BAA+B;YAC/B,kBAAkB;YAClB,yBAAyB;SAC1B,EAAE,CAAC;YACF,MAAM,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QAC5E,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,iCAAiC,EAAE,GAAG,EAAE;IAC/C,EAAE,CAAC,4EAA4E,EAAE,GAAG,EAAE;QACpF,MAAM,CAAC,GAAG,kBAAkB,CAAC,cAAc,EAAE,qBAAqB,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAC/E,MAAM,CAAC,GAAG,kBAAkB,CAAC,cAAc,EAAE,qBAAqB,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAC/E,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6FAA6F,EAAE,GAAG,EAAE;QACrG,uFAAuF;QACvF,MAAM,CAAC,GAAG,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QACpD,MAAM,CAAC,GAAG,kBAAkB,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QACpD,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yEAAyE,EAAE,GAAG,EAAE;QACjF,MAAM,KAAK,GAAG,kBAAkB,CAAC,cAAc,EAAE,iBAAiB,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAC/E,MAAM,MAAM,GAAG,kBAAkB,CAAC,cAAc,EAAE,iBAAiB,EAAE,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACvF,MAAM,KAAK,GAAG,kBAAkB,CAAC,cAAc,EAAE,iBAAiB,EAAE,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9F,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;QAClC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;QACjC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;QACpE,MAAM,QAAQ,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QACzD,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,QAAQ,IAAI,CAAC,CAAC;QAChF,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,QAAQ,IAAI,CAAC,CAAC;IAClF,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gEAAgE,EAAE,GAAG,EAAE;IAC9E,MAAM,SAAS,GAAG,CAAC,GAAW,EAAsB,EAAE,CAAC,CAAC;QACtD,MAAM,EAAE,kBAAkB,CAAC,cAAc,EAAE,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC;QAC1D,UAAU,EAAE;YACV,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,cAAc;YACtB,UAAU,EAAE,YAAY;YACxB,YAAY,EAAE,2DAA2D;YACzE,gBAAgB,EAAE;gBAChB;oBACE,EAAE,EAAE,CAAC;oBACL,cAAc,EAAE;wBACd,IAAI,EAAE,QAAiB;wBACvB,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;wBACjC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;qBAC/B;oBACD,QAAQ,EAAE,UAAU;oBACpB,WAAW,EAAE,IAAI;oBACjB,WAAW,EAAE,IAAI;iBAClB;aACF;SACF;QACD,qBAAqB,EAAE;YACrB,SAAS,EAAE,IAAI;YACf,KAAK,EAAE,+BAA+B;YACtC,QAAQ,EAAE,GAAG;SACd;QACD,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;QAChC,cAAc,EAAE,OAAO;QACvB,kBAAkB,EAAE,GAAG;QACvB,SAAS,EAAE,wBAAwB;QACnC,UAAU,EAAE,IAAI;KACjB,CAAC,CAAC;IAEH,EAAE,CAAC,2FAA2F,EAAE,GAAG,EAAE;QACnG,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACrE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACxC,qEAAqE;QACrE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,qBAAqB,KAAK,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1F,0EAA0E;QAC1E,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7D,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,OAAO,CAAC;YAChE,gBAAgB;YAChB,gBAAgB;SACjB,CAAC,CAAC;QACH,4EAA4E;QAC5E,MAAM,CACJ,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,iBAAiB,KAAK,oBAAoB,CAAC,CACzF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,wFAAwF;QACxF,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,CACtE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAClD,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2EAA2E,EAAE,GAAG,EAAE;QACnF,MAAM,EAAE,GAAuB;YAC7B,GAAG,SAAS,CAAC,OAAO,CAAC;YACrB,qBAAqB,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,GAAG,EAAE;SACnF,CAAC;QACF,MAAM,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8EAA8E,EAAE,GAAG,EAAE;QACtF,MAAM,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CACvE,8BAA8B,CAC/B,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}