agentfootprint 10.3.0 → 10.3.1

package/dist/semantics/coverage/read.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * read — the ONE recognizer the tool-dispatch loop calls.
+ *
+ * Pattern: one reader, every dispatch door (the `applyResultCeiling`
+ *          precedent). The batch loop and the credential/resume execute
+ *          boundary both call this at the moment a handler's return lands, so
+ *          a resumed call declares its coverage exactly as an inline one; the
+ *          raise site (`../../core/agent/stages/toolCalls.ts` · `declareRaisedAbsence`)
+ *          calls it on the `absence` a `requestInput` declared (9.114.0).
+ * Role:    core/ layer, pure. Recognition and normalization only — the caller
+ *          owns the events, the scope write and the delivered status.
+ * Emits:   N/A.
+ *
+ * Zero-cost when unused: two `typeof` checks and a key lookup for every
+ * result that is neither shape, and `undefined` back. Nothing is emitted,
+ * nothing is written, and the value the model reads is the value the tool
+ * returned — byte for byte.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCoverageResult = exports.withoutServedPeriod = exports.strip = exports.strippedOnly = exports.servedToModel = void 0;
+const described_js_1 = require("../described.js");
+const envelope_js_1 = require("../envelope.js");
+const absent_js_1 = require("./absent.js");
+const inProgress_js_1 = require("./inProgress.js");
+const items_js_1 = require("./items.js");
+const ledger_js_1 = require("./ledger.js");
+const period_js_1 = require("./period.js");
+/**
+ * A declared period read off one envelope object, dropped from the record
+ * (and named once per tool in dev mode) when it is malformed.
+ */
+function periodOf(holder, toolName) {
+    // A value the model was SERVED (a reader of history) carries the library's
+    // own verdict word; it is read as the period the tool declared.
+    const read = (0, period_js_1.readPeriod)((0, period_js_1.unservedPeriod)(holder.period));
+    if (read.problem !== undefined)
+        (0, period_js_1.warnDroppedDeclaration)(toolName, 'period', read.problem);
+    return read.period;
+}
+/** The facts one absence declares — the same for a bare absence and for one
+ *  a ledger bounds, so the two sites cannot drift. */
+function absenceFacts(absence, toolName) {
+    const tryInstead = (0, absent_js_1.tryInsteadOfAbsence)(absence);
+    const tryInsteadTool = (0, absent_js_1.tryInsteadToolOfAbsence)(absence);
+    const source = (0, described_js_1.readProvenance)(absence.provenance);
+    if (source.problem !== undefined)
+        (0, period_js_1.warnDroppedDeclaration)(toolName, 'provenance', source.problem);
+    const period = periodOf(absence, toolName);
+    return {
+        kind: 'absence',
+        coverage: (0, absent_js_1.coverageOfAbsence)(absence),
+        lookedFor: absence.looked_for,
+        ...(tryInstead !== undefined && { tryInstead }),
+        ...(tryInsteadTool !== undefined && { tryInsteadTool }),
+        ...(source.provenance !== undefined && { provenance: source.provenance }),
+        ...(period !== undefined && { period }),
+    };
+}
+/**
+ * The value the MODEL is served for one finalized tool result: a recognized
+ * envelope with `short` and `kind` removed from every coverage item. They are
+ * RECORD-ONLY: the events, the tracked `coverageDeclared` rows and the answer
+ * account carry them; the model's request never does, so a tool that
+ * declares them costs no request byte.
+ *
+ * And one thing ADDED, derived from what the tool declared (honesty step 7b,
+ * bench round 1): a declared `period` whose store did not hold all of the
+ * time the read asked about is served with its verdict word and that word's
+ * one note clause (see `withPeriodServed`). A `covered` period, a malformed
+ * one and a result with none gain nothing.
+ *
+ * The shapes, and nesting: a bare absence; a ledger — its own lists AND
+ * whatever it bounds, read by this same function (so `coverage(absent(…))`,
+ * `coverage(coverage(…))` and a semantic envelope under a ledger are all
+ * served stripped; the depth is whatever the author built); and a semantic
+ * envelope's `coverage`.
+ *
+ * NOT stripped, because none is a recognized envelope OBJECT: a result
+ * returned as JSON TEXT (an `mcpClient` result in its default text mode is
+ * one), an `af_absent` whose `checked` is empty or missing (the recognizer
+ * refuses it, so it is ordinary data — served and recorded as written), and
+ * an absence buried inside a tool's own domain object or array. A key whose
+ * value is `null` counts as omitted (a JSON producer's `None`), so it is
+ * served as written and stamps nothing.
+ *
+ * Zero-cost when unused: the SAME reference back for every value that is not
+ * a recognized envelope, and for every envelope whose items declare neither
+ * key — so a caller that stamps `tool_end.modelResult` by reference
+ * inequality stamps nothing new. A structural copy only when a key was
+ * present.
+ *
+ * Asked at the ENTRY of `../../core/agent/stages/toolCalls.ts` · `afterMoment`, which every
+ * dispatch path (the batch loop and the four resume doors) calls for a result
+ * that ran — so every after-tool link is handed the served value, and none
+ * can re-serve the fields — and by the result ceiling and the column judge at
+ * both execute boundaries, which measure what the model will read.
+ */
+function servedToModel(value) {
+    const served = strip(value);
+    // Remembered, so the placement door can tell "the two channels differ
+    // only by this strip" (one value, one ticket) from "a rule changed what
+    // the model reads" — see `strippedOnly`.
+    if (served !== value && typeof served === 'object' && served !== null) {
+        STRIPPED_FROM.set(served, value);
+    }
+    return served;
+}
+exports.servedToModel = servedToModel;
+/** served copy → the value it was stripped from. Weak: never holds a result
+ *  past the call that produced it. */
+const STRIPPED_FROM = new WeakMap();
+/**
+ * True when `modelResult` is exactly what {@link servedToModel} produced from
+ * `result` — the two channels carry ONE value and differ only by the
+ * record-only fields. `../../core/agent/stages/toolCalls.ts` · `placeResults` then gives
+ * both channels the ticket, as it does when they are one reference, so a
+ * declaring tool never keeps its whole payload on `tool_end.result`.
+ */
+function strippedOnly(result, modelResult) {
+    if (typeof modelResult !== 'object' || modelResult === null)
+        return false;
+    return STRIPPED_FROM.has(modelResult) && STRIPPED_FROM.get(modelResult) === result;
+}
+exports.strippedOnly = strippedOnly;
+/**
+ * Pure: the served form of `value`, and nothing remembered (the answer account
+ * reads through this; the dispatch door asks {@link servedToModel}, which also
+ * records the pair for `strippedOnly`).
+ *
+ * `seen` guards a ledger that bounds ITSELF (`v.result = v`, directly or
+ * further down): a holder met twice is returned as found, so a pathological
+ * cycle is served as written instead of overflowing the stack.
+ */
+function strip(value, seen = new WeakSet()) {
+    if (typeof value === 'object' && value !== null) {
+        if (seen.has(value))
+            return value;
+        seen.add(value);
+    }
+    const absence = (0, absent_js_1.readAbsence)(value);
+    if (absence !== undefined)
+        return withPeriodServed((0, items_js_1.listsWithoutRecordOnly)(absence), 'absence');
+    const sem = (0, envelope_js_1.readSemantics)(value);
+    if (sem !== undefined) {
+        // Defensive at the dispatch door: `declareSemantics` has already replaced
+        // a top-level semantic envelope with `semanticsForModel`, which drops the
+        // three-list coverage detail, before `afterMoment` runs. It is reached for
+        // a semantic envelope a LEDGER bounds, and by a direct caller.
+        const cov = sem.coverage === undefined ? undefined : (0, items_js_1.listsWithoutRecordOnly)(sem.coverage);
+        const listed = cov === sem.coverage ? value : { ...value, coverage: cov };
+        return withPeriodServed(listed, 'other');
+    }
+    const covered = (0, ledger_js_1.readCoverageLedger)(value);
+    if (covered === undefined)
+        return value;
+    // The in-progress clause first, then the period's: the inverse below peels
+    // them off the note's end in the reverse order.
+    const marker = withPeriodServed((0, inProgress_js_1.withInProgressServed)((0, items_js_1.listsWithoutRecordOnly)(covered.af_coverage)), 'other');
+    const result = strip(covered.result, seen);
+    if (marker === covered.af_coverage && result === covered.result)
+        return value;
+    return { ...covered, af_coverage: marker, result };
+}
+exports.strip = strip;
+/**
+ * One declaring object's period, SERVED (honesty step 7b, bench round 1): the
+ * verdict word inside `period` and that word's one clause after the note —
+ * and, on an absence whose store held only part or none of the period asked,
+ * `ABSENCE_NOTE_HELD_ONLY` in place of the note that claims the answer is
+ * complete. The same reference back when there is nothing to serve (no
+ * period, a malformed one, a `covered` one), so an undeclared result is
+ * served byte for byte.
+ *
+ * Why the door serves a conclusion the record already holds: the registered
+ * bench (`bench/results/`, round 1) showed the model restating `queried` as
+ * the ground a result covered, never comparing it with `held` — the case the
+ * design's § 9 kept this for. The word is `period.ts` · `periodVerdict`, the
+ * rule the `period` row is filed by, so the two cannot disagree.
+ */
+function withPeriodServed(holder, door) {
+    const rec = holder;
+    const served = (0, period_js_1.servedPeriod)(rec.period);
+    if (served === undefined)
+        return holder;
+    const note = door === 'absence' && served.verdict !== 'unknown' && rec.note === absent_js_1.ABSENCE_NOTE
+        ? absent_js_1.ABSENCE_NOTE_HELD_ONLY
+        : rec.note;
+    return { ...rec, period: served.period, note: (0, period_js_1.noteWithClause)(note, served.clause) };
+}
+/**
+ * The inverse of the serve, for a reader of what the model was served: every
+ * declaring object's verdict word and period clause removed (the note swap is
+ * kept — it is the absence's own static note), the rest as found. The same
+ * reference back when nothing was served. Asked by the evidence projection
+ * (`evidence.ts` · `absenceEvidenceProjection`): words the library derived
+ * never ground an answer.
+ *
+ * It walks the shapes the serve writes — an object with a `period`, and a
+ * ledger's `af_coverage` and `result`, to any depth — and nothing else.
+ */
+function withoutServedPeriod(value, seen = new WeakSet()) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return value;
+    if (seen.has(value))
+        return value;
+    seen.add(value);
+    const own = unserved(value);
+    const covered = (0, ledger_js_1.readCoverageLedger)(own);
+    if (covered === undefined)
+        return own;
+    const marker = (0, inProgress_js_1.withoutInProgressServed)(unserved(covered.af_coverage));
+    const result = withoutServedPeriod(covered.result, seen);
+    if (marker === covered.af_coverage && result === covered.result)
+        return own;
+    return { ...covered, af_coverage: marker, result };
+}
+exports.withoutServedPeriod = withoutServedPeriod;
+/** One object with its served verdict word and clause removed, or itself. */
+function unserved(holder) {
+    const declared = (0, period_js_1.unservedPeriod)(holder.period);
+    if (declared === holder.period)
+        return holder;
+    const verdict = holder.period[period_js_1.SERVED_VERDICT_KEY];
+    const out = { ...holder, period: declared };
+    const note = (0, period_js_1.noteWithoutClause)(holder.note, verdict);
+    if (note === undefined)
+        delete out.note;
+    else
+        out.note = note;
+    return out;
+}
+const ABSENT_STATUS = 'absent';
+/**
+ * Read one finalized tool result for coverage declarations — and, since
+ * honesty step 7b, for the period each declaration's read covered and an
+ * absence's source and time. `toolName` names the tool in the one dev
+ * warning a malformed period or provenance gets (it is left off the record,
+ * never repaired); the dispatch door passes it, a post-hoc reader need not.
+ *
+ * The two shapes compose: `coverage(absent({…}), {…})` is a search that found
+ * nothing AND a boundary around the search, so both are declared and the
+ * delivered status is still `'absent'` — the ledger bounds the answer, it
+ * does not change what the answer was.
+ */
+function readCoverageResult(value, toolName) {
+    const absence = (0, absent_js_1.readAbsence)(value);
+    if (absence !== undefined) {
+        return { status: ABSENT_STATUS, declared: [absenceFacts(absence, toolName)] };
+    }
+    // A semantic envelope's `coverage` field (9.53.0) is ABSORBED here — the
+    // one recognizer funnel — so the boundary a semantic tool declared flows
+    // through the exact channel `coverage()` uses (the `tools.coverage_declared`
+    // event, tracked state, the final-answer limits block) with zero extra
+    // wiring at any dispatch door. Its `period` (honesty step 7b) is absorbed
+    // the same way: an envelope with a period and no coverage lists files a
+    // `'ledger'` row whose three lists are empty. A semantic envelope with
+    // neither declares no boundary, exactly like a bare result.
+    const sem = (0, envelope_js_1.readSemantics)(value);
+    if (sem !== undefined) {
+        const period = (0, envelope_js_1.periodOfSemantics)(sem);
+        if (sem.coverage === undefined && period === undefined)
+            return undefined;
+        return {
+            declared: [
+                {
+                    kind: 'ledger',
+                    coverage: (0, envelope_js_1.coverageOfSemantics)(sem),
+                    ...(period !== undefined && { period }),
+                },
+            ],
+        };
+    }
+    const covered = (0, ledger_js_1.readCoverageLedger)(value);
+    if (covered === undefined)
+        return undefined;
+    const ledgerPeriod = periodOf(covered.af_coverage, toolName);
+    const inProgress = (0, inProgress_js_1.inProgressOf)(covered.af_coverage, toolName);
+    const declared = [
+        {
+            kind: 'ledger',
+            coverage: (0, ledger_js_1.coverageOfLedger)(covered),
+            ...(ledgerPeriod !== undefined && { period: ledgerPeriod }),
+            ...(inProgress !== undefined && { inProgress }),
+        },
+    ];
+    const inner = (0, absent_js_1.readAbsence)(covered.result);
+    if (inner === undefined)
+        return { declared };
+    declared.push(absenceFacts(inner, toolName));
+    return { status: ABSENT_STATUS, declared };
+}
+exports.readCoverageResult = readCoverageResult;
+//# sourceMappingURL=read.js.map

package/dist/semantics/coverage/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../src/semantics/coverage/read.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAGH,kDAA0E;AAC1E,gDAAuF;AACvF,2CAOqB;AACrB,mDAA8F;AAC9F,yCAAoD;AACpD,2CAAmE;AACnE,2CAUqB;AAyCrB;;;GAGG;AACH,SAAS,QAAQ,CAAC,MAAqC,EAAE,QAA4B;IACnF,2EAA2E;IAC3E,gEAAgE;IAChE,MAAM,IAAI,GAAG,IAAA,sBAAU,EAAC,IAAA,0BAAc,EAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IACvD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;QAAE,IAAA,kCAAsB,EAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACzF,OAAO,IAAI,CAAC,MAAM,CAAC;AACrB,CAAC;AAED;sDACsD;AACtD,SAAS,YAAY,CAAC,OAAoB,EAAE,QAA4B;IACtE,MAAM,UAAU,GAAG,IAAA,+BAAmB,EAAC,OAAO,CAAC,CAAC;IAChD,MAAM,cAAc,GAAG,IAAA,mCAAuB,EAAC,OAAO,CAAC,CAAC;IACxD,MAAM,MAAM,GAAG,IAAA,6BAAc,EAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAClD,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS;QAAE,IAAA,kCAAsB,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACjG,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,OAAO;QACL,IAAI,EAAE,SAAS;QACf,QAAQ,EAAE,IAAA,6BAAiB,EAAC,OAAO,CAAC;QACpC,SAAS,EAAE,OAAO,CAAC,UAAU;QAC7B,GAAG,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,CAAC;QAC/C,GAAG,CAAC,cAAc,KAAK,SAAS,IAAI,EAAE,cAAc,EAAE,CAAC;QACvD,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC;QACzE,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,CAAC;KACxC,CAAC;AACJ,CAAC;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,SAAgB,aAAa,CAAC,KAAc;IAC1C,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC5B,sEAAsE;IACtE,wEAAwE;IACxE,yCAAyC;IACzC,IAAI,MAAM,KAAK,KAAK,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACtE,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AATD,sCASC;AAED;sCACsC;AACtC,MAAM,aAAa,GAAG,IAAI,OAAO,EAAmB,CAAC;AAErD;;;;;;GAMG;AACH,SAAgB,YAAY,CAAC,MAAe,EAAE,WAAoB;IAChE,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC1E,OAAO,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,MAAM,CAAC;AACrF,CAAC;AAHD,oCAGC;AAED;;;;;;;;GAQG;AACH,SAAgB,KAAK,CAAC,KAAc,EAAE,OAAwB,IAAI,OAAO,EAAE;IACzE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAClC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClB,CAAC;IACD,MAAM,OAAO,GAAG,IAAA,uBAAW,EAAC,KAAK,CAAC,CAAC;IACnC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,gBAAgB,CAAC,IAAA,iCAAsB,EAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/F,MAAM,GAAG,GAAG,IAAA,2BAAa,EAAC,KAAK,CAAC,CAAC;IACjC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,0EAA0E;QAC1E,0EAA0E;QAC1E,2EAA2E;QAC3E,+DAA+D;QAC/D,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAA,iCAAsB,EAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1F,MAAM,MAAM,GAAG,GAAG,KAAK,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAI,KAAgB,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;QACtF,OAAO,gBAAgB,CAAC,MAAgB,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IACD,MAAM,OAAO,GAAG,IAAA,8BAAkB,EAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACxC,2EAA2E;IAC3E,gDAAgD;IAChD,MAAM,MAAM,GAAG,gBAAgB,CAC7B,IAAA,oCAAoB,EAAC,IAAA,iCAAsB,EAAC,OAAO,CAAC,WAAW,CAAC,CAAC,EACjE,OAAO,CACR,CAAC;IACF,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3C,IAAI,MAAM,KAAK,OAAO,CAAC,WAAW,IAAI,MAAM,KAAK,OAAO,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC9E,OAAO,EAAE,GAAG,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AACrD,CAAC;AA5BD,sBA4BC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,gBAAgB,CAAmB,MAAS,EAAE,IAAyB;IAC9E,MAAM,GAAG,GAAG,MAAiC,CAAC;IAC9C,MAAM,MAAM,GAAG,IAAA,wBAAY,EAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACxC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,IAAI,GACR,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,IAAI,KAAK,wBAAY;QAC7E,CAAC,CAAC,kCAAsB;QACxB,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;IACf,OAAO,EAAE,GAAG,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAA,0BAAc,EAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,EAAO,CAAC;AAC3F,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,mBAAmB,CACjC,KAAc,EACd,OAAwB,IAAI,OAAO,EAAE;IAErC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACtF,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAClC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChB,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAgC,CAAC,CAAC;IACvD,MAAM,OAAO,GAAG,IAAA,8BAAkB,EAAC,GAAG,CAAC,CAAC;IACxC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC;IACtC,MAAM,MAAM,GAAG,IAAA,uCAAuB,EAAC,QAAQ,CAAC,OAAO,CAAC,WAAsC,CAAC,CAAC,CAAC;IACjG,MAAM,MAAM,GAAG,mBAAmB,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACzD,IAAI,MAAM,KAAK,OAAO,CAAC,WAAW,IAAI,MAAM,KAAK,OAAO,CAAC,MAAM;QAAE,OAAO,GAAG,CAAC;IAC5E,OAAO,EAAE,GAAG,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AACrD,CAAC;AAdD,kDAcC;AAED,6EAA6E;AAC7E,SAAS,QAAQ,CAAC,MAA+B;IAC/C,MAAM,QAAQ,GAAG,IAAA,0BAAc,EAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC/C,IAAI,QAAQ,KAAK,MAAM,CAAC,MAAM;QAAE,OAAO,MAAM,CAAC;IAC9C,MAAM,OAAO,GAAI,MAAM,CAAC,MAAkC,CACxD,8BAAkB,CACI,CAAC;IACzB,MAAM,GAAG,GAA4B,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACrE,MAAM,IAAI,GAAG,IAAA,6BAAiB,EAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACrD,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,IAAI,CAAC;;QACnC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,aAAa,GAAqB,QAAQ,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,SAAgB,kBAAkB,CAAC,KAAc,EAAE,QAAiB;IAClE,MAAM,OAAO,GAAG,IAAA,uBAAW,EAAC,KAAK,CAAC,CAAC;IACnC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;IAChF,CAAC;IACD,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,uEAAuE;IACvE,0EAA0E;IAC1E,wEAAwE;IACxE,uEAAuE;IACvE,4DAA4D;IAC5D,MAAM,GAAG,GAAG,IAAA,2BAAa,EAAC,KAAK,CAAC,CAAC;IACjC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,MAAM,GAAG,IAAA,+BAAiB,EAAC,GAAG,CAAC,CAAC;QACtC,IAAI,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QACzE,OAAO;YACL,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAA,iCAAmB,EAAC,GAAG,CAAC;oBAClC,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,CAAC;iBACxC;aACF;SACF,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,IAAA,8BAAkB,EAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAC7D,MAAM,UAAU,GAAG,IAAA,4BAAY,EAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAoB;QAChC;YACE,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,IAAA,4BAAgB,EAAC,OAAO,CAAC;YACnC,GAAG,CAAC,YAAY,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;YAC3D,GAAG,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,CAAC;SAChD;KACF,CAAC;IACF,MAAM,KAAK,GAAG,IAAA,uBAAW,EAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;IAC7C,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC7C,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;AAC7C,CAAC;AA3CD,gDA2CC"}

package/dist/semantics/coverage/recognize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognize.js","sourceRoot":"","sources":["../../../src/semantics/coverage/recognize.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAIH;;;;GAIG;AACU,QAAA,cAAc,GAAG,WAAW,CAAC;AAE1C;;;;;;;;;GASG;AACH,SAAgB,WAAW,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1F,MAAM,GAAG,GAAG,KAAgC,CAAC;IAC7C,IAAI,GAAG,CAAC,sBAAc,CAAC,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IACnD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC9E,OAAO,KAAoB,CAAC;AAC9B,CAAC;AAND,kCAMC;AAED,yDAAyD;AAC5C,QAAA,eAAe,GAAG,aAAa,CAAC;AAE7C;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,KAAc;IAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1F,MAAM,GAAG,GAAG,KAAgC,CAAC;IAC7C,MAAM,MAAM,GAAG,GAAG,CAAC,uBAAe,CAAC,CAAC;IACpC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAAE,OAAO,SAAS,CAAC;IAC7F,IAAI,CAAC,CAAC,QAAQ,IAAI,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,OAAO,KAAsB,CAAC;AAChC,CAAC;AAPD,gDAOC"}

package/dist/semantics/coverage/refusal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.js","sourceRoot":"","sources":["../../../src/semantics/coverage/refusal.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;;;AAEH;;;;;;GAMG;AACU,QAAA,cAAc,GAAG,WAAW,CAAC;AAE1C,2EAA2E;AAC3E,SAAgB,OAAO,CAAC,OAAe;IACrC,OAAO,IAAI,KAAK,CAAC,GAAG,sBAAc,GAAG,OAAO,EAAE,CAAC,CAAC;AAClD,CAAC;AAFD,0BAEC;AAED;6DAC6D;AAC7D,MAAM,MAAM,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;AAE/E;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,GAAW,EAAE,KAAwB;IACjE,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACzB,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC;AACpF,CAAC;AAHD,sCAGC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,iBAAiB,CAAC,KAAa,EAAE,KAAwB,EAAE,EAAW;IACpF,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,SAAS;QAClC,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACxC,MAAM,IAAI,GAAG,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC;QACrD,MAAM,OAAO,CACX,IAAI,IAAI,sCAAsC;YAC5C,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,qBAAqB,KAAK,KAAK,CAAC;YAC7D,cAAc,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,SAAS,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACpF,CAAC;IACJ,CAAC;AACH,CAAC;AAXD,8CAWC"}

package/dist/semantics/coverage/timeLimitFacts.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * coverage/timeLimitFacts — WHAT the time layer's limits lines of one turn
+ * say (step T8), read from the record and not yet rendered: the clock's zone,
+ * the turn's `period` rows whose result checks hold, and the wall-clock
+ * sources.
+ *
+ * Pattern: Walker over the committed ledger; pure, no rendering.
+ * Role:    the record half of `timeLimits.ts`, split out BY FILE for the one
+ *          synchronous door that needs it — the Tools mount's `inputMapper`
+ *          (`agent/buildAgentChart.ts` · `timeLimitsArg`), which runs before
+ *          any `import()` can: it hands these facts across, and the slot's
+ *          served line renders them (`arguments/serve.ts` · `timeLimitsLine`,
+ *          loaded under the arm). The renderer (`time/present.ts`) never
+ *          reaches the graph `import { Agent }` loads (the optional-family
+ *          law, `test/trace-toolpack/browserGraph.test.ts`).
+ * Emits:   N/A.
+ *
+ * `undefined` exactly when `timeLimits.ts` · `renderTimeLimits` would say
+ * nothing for the same audience — so the mount arg stays value-conditional:
+ * a turn whose reads match what was asked crosses no key.
+ *
+ * @example
+ * ```ts
+ * timeLimitFactsOf(ledger, 1, 'model');
+ * // { zone: 'America/Los_Angeles', period: [{ kind: 'period', differs: { … }, … }], sources: [] }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeLimitFactsOf = exports.carriesCheckLine = void 0;
+const rows_js_1 = require("../../time/rows.js");
+const checkRecord_js_1 = require("../../time/checkRecord.js");
+/**
+ * Whether a `period` row carries a limits line for `audience`: a read that
+ * differs, a shifted look-back, or a window beyond retention (`period.ts` ·
+ * `periodCheckLine` returns one exactly then) — and, for the MODEL only, a
+ * source that holds none or only part of the asked time (`held`, rendered by
+ * `timeLimits.ts` · `heldLine`). The person's limits block already prints that
+ * span on the call's `Period:` line (`period.ts` · `periodLine`), in their
+ * zone, so it gets no second line.
+ */
+function carriesCheckLine(row, audience = 'person') {
+    return (row.differs !== undefined ||
+        row.shifted !== undefined ||
+        row.beyondRetention === true ||
+        (audience === 'model' && row.held !== undefined));
+}
+exports.carriesCheckLine = carriesCheckLine;
+/**
+ * The turn's limits facts from the ledger. `turn` undefined reads every row
+ * (a ledger that carries one turn). `undefined` when there is no clock or,
+ * for this `audience`, nothing to say: the person reads every wall-clock
+ * source, the model only the label that two differ.
+ */
+function timeLimitFactsOf(ledger, turn, audience = 'person') {
+    const zone = (0, rows_js_1.presentationZoneOf)(ledger);
+    if (zone === undefined || ledger === undefined)
+        return undefined;
+    const zoneUnknown = (0, rows_js_1.clockOf)(ledger)?.zoneSource === 'unknown';
+    const period = [];
+    for (const row of ledger) {
+        const r = row;
+        if (r === null || typeof r !== 'object' || r.kind !== 'period')
+            continue;
+        if (turn !== undefined && r.turn !== turn)
+            continue;
+        if (carriesCheckLine(row, audience))
+            period.push(row);
+    }
+    const sources = (0, checkRecord_js_1.distinctSources)((0, rows_js_1.sourceClocksOf)(ledger, turn));
+    const differ = (0, checkRecord_js_1.clocksDiffer)(sources);
+    const clocks = audience === 'person' ? sources.length > 0 : differ !== undefined;
+    if (period.length === 0 && !clocks)
+        return undefined;
+    return {
+        zone,
+        period,
+        sources,
+        ...(differ !== undefined && { differ }),
+        ...(zoneUnknown && { zoneUnknown: true }),
+    };
+}
+exports.timeLimitFactsOf = timeLimitFactsOf;
+//# sourceMappingURL=timeLimitFacts.js.map

package/dist/semantics/coverage/timeLimitFacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeLimitFacts.js","sourceRoot":"","sources":["../../../src/semantics/coverage/timeLimitFacts.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAGH,gDAAiF;AACjF,8DAKmC;AAoBnC;;;;;;;;GAQG;AACH,SAAgB,gBAAgB,CAAC,GAAc,EAAE,WAA+B,QAAQ;IACtF,OAAO,CACL,GAAG,CAAC,OAAO,KAAK,SAAS;QACzB,GAAG,CAAC,OAAO,KAAK,SAAS;QACzB,GAAG,CAAC,eAAe,KAAK,IAAI;QAC5B,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,CACjD,CAAC;AACJ,CAAC;AAPD,4CAOC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAC9B,MAAsC,EACtC,IAAwB,EACxB,WAA+B,QAAQ;IAEvC,MAAM,IAAI,GAAG,IAAA,4BAAkB,EAAC,MAAM,CAAC,CAAC;IACxC,IAAI,IAAI,KAAK,SAAS,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACjE,MAAM,WAAW,GAAG,IAAA,iBAAO,EAAC,MAAM,CAAC,EAAE,UAAU,KAAK,SAAS,CAAC;IAC9D,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,GAAkE,CAAC;QAC7E,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ;YAAE,SAAS;QACzE,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI;YAAE,SAAS;QACpD,IAAI,gBAAgB,CAAC,GAAgB,EAAE,QAAQ,CAAC;YAAE,MAAM,CAAC,IAAI,CAAC,GAAgB,CAAC,CAAC;IAClF,CAAC;IACD,MAAM,OAAO,GAAG,IAAA,gCAAe,EAAC,IAAA,wBAAc,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IAC9D,MAAM,MAAM,GAAG,IAAA,6BAAY,EAAC,OAAO,CAAC,CAAC;IACrC,MAAM,MAAM,GAAG,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC;IACjF,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IACrD,OAAO;QACL,IAAI;QACJ,MAAM;QACN,OAAO;QACP,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,CAAC;QACvC,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,IAAa,EAAE,CAAC;KACnD,CAAC;AACJ,CAAC;AA1BD,4CA0BC"}

package/dist/semantics/coverage/timeLimits.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * coverage/timeLimits.ts — the time layer's limits lines for ONE turn (step T8),
+ * composed from the record and nothing else.
+ *
+ * Two readers ask it, so the person and the model are told the same thing:
+ *
+ * - the limits block (`stages/prepareFinal.ts`), which prints the lines under
+ *   `Period` and `Clocks` for the PERSON after the answer;
+ * - the served time line (`agent/arguments/serve.ts` · `timeLimitsSentence`),
+ *   which hands the MODEL the same lines as the library's conclusion, late, at
+ *   the decision point, before it writes the answer.
+ *
+ * What it reads: the facts `timeLimitFacts.ts` · `timeLimitFactsOf` reads —
+ * the turn's `period` rows whose result checks hold, the turn's
+ * `source-clock` rows (`time/checkRecord.ts` · `clocksDiffer`) and the
+ * clock row's zone — rendered here (`period.ts` · `periodCheckLine`,
+ * `clockLines`). `undefined` when there is no clock (nothing to render in) or
+ * nothing to say.
+ *
+ * Loaded through `import()` only, under `.time()` (`stages/prepareFinal.ts`;
+ * `arguments/serve.ts`, itself loaded under the arm): it renders through
+ * `time/present.ts`, which a plain agent never loads.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTimeLimits = exports.timeLimitLinesOf = exports.heldLine = exports.UNKNOWN_ZONE_LINE = void 0;
+const period_js_1 = require("./period.js");
+const present_js_1 = require("../../time/present.js");
+const timeLimitFacts_js_1 = require("./timeLimitFacts.js");
+// LENS · late-line · request-ephemeral (and the person's limits block)
+// reads: nothing — a fixed clause, added when the turn's clock zone is unknown (G15)
+// law: names WHY the ranges are in UTC, so no reader takes UTC for the person's zone.
+/** The clocks line under an unknown zone (G15): the ranges are in UTC because the person's zone is not known. */
+exports.UNKNOWN_ZONE_LINE = "times are shown in UTC — the person's time zone is not known";
+// LENS · late-line · request-ephemeral
+// reads: one `period` row's `held` (the declared `queried` and `held` spans its `not-held` /
+//        `partly-held` verdict came from), rendered in the person's zone by the bound renderer
+// law: the library's CONCLUSION for the MODEL: the time the source holds, already in the person's
+//      zone, beside the time the call asked about — so no model converts a source's UTC instants
+//      (take 3: "9:22 AM–5:02 PM Pacific" for a 16:22–17:02 UTC span).
+/**
+ * The model's line for a call whose source holds none or only part of the
+ * time it asked about (`PeriodRow.held`): what the call asked about and what
+ * its source holds, each AS DECLARED (inclusive ends, no end moved) and
+ * rendered in the presentation zone by the time layer's one renderer — the
+ * same spans the person's `Period:` line prints (`period.ts` · `periodLine`) — then
+ * how much of the asked time that is. `undefined` when the row carries none.
+ *
+ * @example
+ * ```ts
+ * heldLine(row, bindPresentation({ zone: 'America/Los_Angeles' }));
+ * // 'pscale_client_health asked about 2026-09-30 06:00:00–11:59:50 America/Los_Angeles (UTC-07:00);
+ * //  its source holds 2026-10-01 09:22:44.300–10:02:44.300 America/Los_Angeles (UTC-07:00), which
+ * //  covers none of that time'
+ * ```
+ */
+function heldLine(row, presentation) {
+    const h = row.held;
+    if (h === undefined)
+        return undefined;
+    const share = row.verdict === 'partly-held'
+        ? 'which covers only part of that time'
+        : 'which covers none of that time';
+    return (`${row.toolName} asked about ${presentation.span(h.queried.from, h.queried.to)}; ` +
+        `its source holds ${presentation.span(h.held.from, h.held.to)}, ${share}`);
+}
+exports.heldLine = heldLine;
+/**
+ * The turn's time limits lines, from the ledger — {@link renderTimeLimits}
+ * over `timeLimitFacts.ts` · `timeLimitFactsOf`. `turn` undefined reads every
+ * row (a ledger that carries one turn). `audience` `'model'` (the served time
+ * line) names the person's window as theirs and keeps, of the clocks, only the
+ * label that two differ.
+ *
+ * @example
+ * ```ts
+ * timeLimitLinesOf(ledger, 1);
+ * // { period: ['client_activity read less than was asked — asked: …; read: …'], clocks: [] }
+ * ```
+ */
+function timeLimitLinesOf(ledger, turn, audience = 'person') {
+    return renderTimeLimits((0, timeLimitFacts_js_1.timeLimitFactsOf)(ledger, turn, audience), audience);
+}
+exports.timeLimitLinesOf = timeLimitLinesOf;
+/**
+ * The limits lines for `audience`, rendered in the facts' zone by the time
+ * layer's one renderer (`time/present.ts` · `bindPresentation`) —
+ * `undefined` when there are no facts or nothing to say.
+ */
+function renderTimeLimits(facts, audience = 'person') {
+    if (facts === undefined)
+        return undefined;
+    const presentation = (0, present_js_1.bindPresentation)({ zone: facts.zone });
+    const period = [];
+    const held = [];
+    for (const row of facts.period) {
+        const line = (0, period_js_1.periodCheckLine)(row, presentation, audience);
+        if (line !== undefined)
+            period.push(line);
+        // The source's held span, for the model (the person's `Period:` line already prints it).
+        const holds = audience === 'model' ? heldLine(row, presentation) : undefined;
+        if (holds !== undefined)
+            held.push(holds);
+    }
+    // The person reads every wall-clock source; the model only the label that two differ — one
+    // declared clock is compared as instants and changes nothing the answer states.
+    const clocks = [
+        ...(audience === 'person'
+            ? (0, period_js_1.clockLines)(facts.sources, facts.differ)
+            : facts.differ === undefined
+                ? []
+                : (0, period_js_1.clockLines)([], facts.differ)),
+        // The ranges above are spelled in UTC only because the person's zone is unknown (G15).
+        ...(facts.zoneUnknown === true && period.length + held.length > 0 ? [exports.UNKNOWN_ZONE_LINE] : []),
+    ];
+    if (period.length + clocks.length + held.length === 0)
+        return undefined;
+    return { period, clocks, ...(held.length > 0 && { held }) };
+}
+exports.renderTimeLimits = renderTimeLimits;
+//# sourceMappingURL=timeLimits.js.map

package/dist/semantics/coverage/timeLimits.js.map

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

package/dist/semantics/coverage/types.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * coverage/types — the shared vocabulary of the two coverage primitives.
+ *
+ * Pattern: one value type, two consumers — `absent()` says "I looked HERE and
+ *          found nothing", `coverage()` says "my answer covers THIS and not
+ *          THAT". Both are statements about the same thing: the ground a
+ *          result stands on. Spelling them with one vocabulary is what lets
+ *          the answer-level block merge an absence's boundary with a
+ *          verdict's without translating between two grammars.
+ * Role:    core/ layer, pure data. No behavior; TYPE-only imports (they erase
+ *          at runtime): the one period shape (`period.ts`) and the one
+ *          provenance shape `describedResult()` already declares
+ *          (`semantics/types.ts`), so an absence says its source and time
+ *          in the same words a described result does.
+ * Emits:   N/A.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/semantics/coverage/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/semantics/coverage/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG"}