@mmnto/totem 2.14.0 → 2.16.0

package/dist/rule-tier.test.d.ts.map

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

package/dist/rule-tier.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import * as coreIndex from './index.js';
+import { effectiveSeverity, isBlockingRule, ruleTier } from './rule-tier.js';
+const ENGINES = ['ast', 'ast-grep', 'regex', undefined];
+const RULE_CLASSES = ['hard', 'advisory', undefined];
+const SEVERITIES = ['error', 'warning', undefined];
+/**
+ * Build an input with ABSENT keys left off entirely (not set to undefined), the
+ * shape a legacy row parsed from compiled-rules.json actually has. `engine` is
+ * required by the schema, so an absent engine is a legacy-row cast.
+ */
+function makeInput(engine, ruleClass, severity) {
+    const input = {};
+    if (engine !== undefined)
+        input['engine'] = engine;
+    if (ruleClass !== undefined)
+        input['ruleClass'] = ruleClass;
+    if (severity !== undefined)
+        input['severity'] = severity;
+    return input;
+}
+/** Expected tier, written out per case rather than re-deriving the formula. */
+function expectedTier(engine, ruleClass) {
+    if (ruleClass === 'hard')
+        return 'hard';
+    if (ruleClass === 'advisory')
+        return 'advisory';
+    switch (engine) {
+        case 'ast':
+            return 'hard';
+        case 'ast-grep':
+            return 'hard';
+        case 'regex':
+            return 'advisory';
+        default:
+            return 'advisory';
+    }
+}
+const TABLE = ENGINES.flatMap((engine) => RULE_CLASSES.flatMap((ruleClass) => SEVERITIES.map((severity) => {
+    const tier = expectedTier(engine, ruleClass);
+    const blocking = tier === 'hard' && severity !== 'warning';
+    return {
+        engine: engine ?? '(absent)',
+        ruleClass: ruleClass ?? '(absent)',
+        severity: severity ?? '(absent)',
+        input: makeInput(engine, ruleClass, severity),
+        tier,
+        blocking,
+    };
+})));
+describe('rule-tier truth table (mmnto-ai/totem#3035)', () => {
+    it('covers all 36 combinations', () => {
+        expect(TABLE).toHaveLength(36);
+    });
+    it.each(TABLE)('engine=$engine ruleClass=$ruleClass severity=$severity -> tier=$tier blocking=$blocking', ({ input, tier, blocking }) => {
+        expect(ruleTier(input)).toBe(tier);
+        expect(isBlockingRule(input)).toBe(blocking);
+    });
+});
+describe('rule-tier invariants (mmnto-ai/totem#3035)', () => {
+    it('ruleClass wins over the engine upward: a regex row stamped hard is hard and blocks', () => {
+        const rule = makeInput('regex', 'hard', 'error');
+        expect(ruleTier(rule)).toBe('hard');
+        expect(isBlockingRule(rule)).toBe(true);
+    });
+    it('ruleClass wins over the engine downward: an ast / ast-grep row stamped advisory never blocks', () => {
+        for (const engine of ['ast', 'ast-grep']) {
+            for (const severity of SEVERITIES) {
+                const rule = makeInput(engine, 'advisory', severity);
+                expect(ruleTier(rule)).toBe('advisory');
+                expect(isBlockingRule(rule)).toBe(false);
+            }
+        }
+    });
+    it('an absent severity blocks on a hard tier', () => {
+        expect(isBlockingRule(makeInput('ast', undefined, undefined))).toBe(true);
+        expect(isBlockingRule(makeInput('ast-grep', undefined, undefined))).toBe(true);
+        expect(isBlockingRule(makeInput('regex', 'hard', undefined))).toBe(true);
+    });
+    it('a warning never blocks, whatever the tier', () => {
+        for (const engine of ENGINES) {
+            for (const ruleClass of RULE_CLASSES) {
+                expect(isBlockingRule(makeInput(engine, ruleClass, 'warning'))).toBe(false);
+            }
+        }
+    });
+    it('a regex row (or a legacy row with no engine) never blocks unless stamped hard', () => {
+        for (const engine of ['regex', undefined]) {
+            for (const ruleClass of ['advisory', undefined]) {
+                for (const severity of SEVERITIES) {
+                    expect(isBlockingRule(makeInput(engine, ruleClass, severity))).toBe(false);
+                }
+            }
+        }
+    });
+    it('effectiveSeverity is the stored value, or error when absent', () => {
+        expect(effectiveSeverity(makeInput('regex', undefined, 'warning'))).toBe('warning');
+        expect(effectiveSeverity(makeInput('regex', undefined, 'error'))).toBe('error');
+        expect(effectiveSeverity(makeInput('regex', undefined, undefined))).toBe('error');
+    });
+    it('is exported from the core index', () => {
+        expect(coreIndex.ruleTier).toBe(ruleTier);
+        expect(coreIndex.isBlockingRule).toBe(isBlockingRule);
+        expect(coreIndex.effectiveSeverity).toBe(effectiveSeverity);
+    });
+});
+//# sourceMappingURL=rule-tier.test.js.map

package/dist/rule-tier.test.js.map

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

package/dist/spine/serving-plan.d.ts

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { type CompiledRule } from '../compiler-schema.js';
+import { type AuthoringLedgerEntry } from './authoring-ledger.js';
+import type { ParsedRuleRecord } from './rule-record.js';
+/** The one instant form the writer accepts, as a refusal message names it. */
+export declare const STRICT_INSTANT_FORM = "YYYY-MM-DDTHH:MM:SS(.fraction)?(Z|+HH:MM|-HH:MM)";
+/**
+ * Epoch milliseconds of a STRICT instant (`STRICT_INSTANT_FORM`: a date-time
+ * with seconds and an explicit zone, every component a real calendar value), or
+ * `undefined` for anything else.
+ */
+export declare function parseStrictInstant(s: string): number | undefined;
+/**
+ * The serving writer's input: one file, so one sha256 names a run. Strict at
+ * every level: an unknown key anywhere is refused. Both dispositions are
+ * required, with no default.
+ */
+export declare const ServingInputSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"serving-input/1">;
+    /**
+     * The `now` for every lowered row and for the manifest, so a re-run is
+     * byte-identical. A STRICT instant: a zone-less date-time would read as the
+     * machine's local time and make the stale-floor verdict machine-dependent.
+     */
+    asOf: z.ZodEffects<z.ZodString, string, string>;
+    /** Free text naming the runs of record and the ruling; not machine-read. */
+    source: z.ZodString;
+    dispositions: z.ZodObject<{
+        legacyRow: z.ZodEnum<["archive", "remove"]>;
+        stamp: z.ZodEnum<["none", "advisory"]>;
+    }, "strict", z.ZodTypeAny, {
+        legacyRow: "archive" | "remove";
+        stamp: "advisory" | "none";
+    }, {
+        legacyRow: "archive" | "remove";
+        stamp: "advisory" | "none";
+    }>;
+    floor: z.ZodArray<z.ZodObject<{
+        legacyHash: z.ZodOptional<z.ZodString>;
+        records: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            ruleId: z.ZodString;
+            /**
+             * REQUIRED binding by content: the record's sha256 (64 hex) the
+             * floor was scored against, which must equal the effective
+             * ledger row's `record.contentHash` (mmnto-ai/totem#3045).
+             */
+            contentHash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            ruleId: string;
+            contentHash: string;
+        }, {
+            path: string;
+            ruleId: string;
+            contentHash: string;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        records: {
+            path: string;
+            ruleId: string;
+            contentHash: string;
+        }[];
+        legacyHash?: string | undefined;
+    }, {
+        records: {
+            path: string;
+            ruleId: string;
+            contentHash: string;
+        }[];
+        legacyHash?: string | undefined;
+    }>, "many">;
+    archive: z.ZodArray<z.ZodObject<{
+        lessonHash: z.ZodString;
+        reason: z.ZodString;
+        ref: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        lessonHash: string;
+        reason: string;
+        ref: string;
+    }, {
+        lessonHash: string;
+        reason: string;
+        ref: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    source: string;
+    floor: {
+        records: {
+            path: string;
+            ruleId: string;
+            contentHash: string;
+        }[];
+        legacyHash?: string | undefined;
+    }[];
+    schema: "serving-input/1";
+    archive: {
+        lessonHash: string;
+        reason: string;
+        ref: string;
+    }[];
+    asOf: string;
+    dispositions: {
+        legacyRow: "archive" | "remove";
+        stamp: "advisory" | "none";
+    };
+}, {
+    source: string;
+    floor: {
+        records: {
+            path: string;
+            ruleId: string;
+            contentHash: string;
+        }[];
+        legacyHash?: string | undefined;
+    }[];
+    schema: "serving-input/1";
+    archive: {
+        lessonHash: string;
+        reason: string;
+        ref: string;
+    }[];
+    asOf: string;
+    dispositions: {
+        legacyRow: "archive" | "remove";
+        stamp: "advisory" | "none";
+    };
+}>;
+export type ServingInput = z.infer<typeof ServingInputSchema>;
+/**
+ * Refuse an input whose mode is not built. `stamp: 'advisory'` waits on the
+ * ADR-110 reading; only `none` (unstamped) is implemented. Called by the writer
+ * right after the schema check and again by the planner, so neither path can
+ * reach a write with it.
+ */
+export declare function assertServingInputSupported(input: ServingInput): void;
+/** One floor record, ingested by the caller (`ingestRecord`): its content hash and parsed value. */
+export interface ServingRecord {
+    path: string;
+    ruleId: string;
+    /** sha256 (64 hex) of the record file's LF image, as the intake computes it. */
+    contentHash: string;
+    parsed: ParsedRuleRecord;
+}
+export interface PlanServingWriteArgs {
+    /** The serving file's rows, as plain parsed JSON. Never mutated. */
+    rows: readonly CompiledRule[];
+    /** The authoring ledger as read (all revisions); folded here to the effective row per ruleId. */
+    ledger: readonly AuthoringLedgerEntry[];
+    /** Every record the floor names, ingested. */
+    records: readonly ServingRecord[];
+    input: ServingInput;
+    /** sha256 of the input file's text after CRLF to LF, carried into the report. */
+    inputSha256: string;
+}
+export type ServingRowClass = 'floor-legacy' | 'lowered' | 'archive' | 'already-archived';
+/**
+ * `replace` is a lowered row already in the file at that ruleId whose lowering
+ * now differs (a new asOf, say; `changedFields` names the fields);
+ * `already-archived` is a floor legacy row a human archived before this run,
+ * left byte-untouched under `archive`; `none` is a touched row whose bytes stay.
+ */
+export type ServingRowAction = 'archive' | 'remove' | 'insert' | 'replace' | 'already-archived' | 'none';
+export interface ServingReportRow {
+    class: ServingRowClass;
+    action: ServingRowAction;
+    lessonHash: string;
+    /** For a lowered row and a floor legacy row: the floor entry's legacy hash, when it has one. */
+    legacyHash?: string;
+    /** For a lowered row: its rule id. For a floor legacy row: the record ids that serve it, joined by ', '. */
+    ruleId?: string;
+    /** For a lowered row: its record path. */
+    recordPath?: string;
+    /** For a `replace`: the top-level fields whose values differ from the row in the file. */
+    changedFields?: string[];
+}
+export interface ServingReport {
+    inputSha256: string;
+    asOf: string;
+    legacyRow: ServingInput['dispositions']['legacyRow'];
+    /** True when the planned rows serialize differently from the input rows; false means nothing to write. */
+    changed: boolean;
+    rows: ServingReportRow[];
+    /** Report rows per class, plus every other row of the input file counted as `carried`. */
+    totals: Record<ServingRowClass | 'carried', number>;
+    rowsBefore: number;
+    rowsAfter: number;
+    /** Floor legacy rows removed under `remove` (counted in `rowsBefore`, absent from `rowsAfter`). */
+    removed: number;
+    /** Lowered rows already present in the input file (counted in `rowsBefore`). */
+    loweredExisting: number;
+    /** Rows `isActiveCompiledRule` counts. */
+    active: {
+        before: number;
+        after: number;
+    };
+    /** Rows with `status: 'archived'`. */
+    archived: {
+        before: number;
+        after: number;
+    };
+    /** Sorted lesson hashes of the ACTIVE rows `isBlockingRule` marks (lint loads active rows only). */
+    blocking: {
+        before: string[];
+        after: string[];
+    };
+}
+export interface ServingPlan {
+    rows: CompiledRule[];
+    changed: boolean;
+    report: ServingReport;
+}
+/**
+ * Plan one serving write. PURE: no IO, no clock (`input.asOf` is the `now`).
+ *
+ * Placement. Under `archive` a floor entry's legacy row stays at its index,
+ * archived with a reason naming its record ids (or byte-untouched when it was
+ * already archived), and the lowered rows follow it in the entry's record order;
+ * under `remove` the lowered rows replace it at its index. An entry with no
+ * `legacyHash` appends its lowered rows at the end, in floor order. An entry
+ * whose lowered rows are already in the file (a re-run) keeps them where they
+ * are, so a second run with the same input is a fixpoint that changes nothing.
+ *
+ * Untouched rows are the same object references in the output.
+ */
+export declare function planServingWrite(args: PlanServingWriteArgs): ServingPlan;
+//# sourceMappingURL=serving-plan.d.ts.map

package/dist/spine/serving-plan.d.ts.map

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