agentfootprint 9.76.1 → 9.78.0

package/dist/types/integrity/column-types/types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The COLUMN-TYPE CONTRACT's vocabulary — what a tool may say about the
+ * columns of the rowset it returns, and the one rule that judges the saying.
+ *
+ * Pattern: closed vocabulary + definition-time assert (the `resultCeiling` /
+ *          `resultClass` law: a declaration this library cannot honour fails
+ *          at `defineTool`, never at the first row of the first run).
+ * Role:    leaf. `src/integrity/` imports nothing outside itself, so the
+ *          vocabulary lives HERE and `core/tools.ts` reaches in for it —
+ *          never the other way round.
+ *
+ * ── Why the words are these words ───────────────────────────────────────
+ * They are NOT invented. `number | string | boolean | date` is the vocabulary
+ * this ecosystem's rowset consumers already speak — a column-type union with
+ * exactly these members is what the visualization layer sniffs its way to
+ * today. Declaring in the consumer's own words is the `resultKind` law
+ * (9.70.0) restated one level down: the tool's result in the CONSUMER's
+ * vocabulary, not the framework's.
+ *
+ * The one member deliberately NOT carried over is `unknown`. A sniffer needs
+ * that word — it is what "I looked at the values and could not tell" sounds
+ * like. A DECLARATION has no use for it: an author who does not know what a
+ * column holds should not name the column, and `columns: { x: 'unknown' }`
+ * would be a promise about nothing that the checker would then have to
+ * pretend to verify.
+ *
+ * ── Two spellings, one meaning ──────────────────────────────────────────
+ * A column maps to a bare type (`lun: 'number'`) or to an object form
+ * (`note: { type: 'string', nullable: true }`). That is this library's house
+ * pattern for exactly this shape — `CostBudget` takes a bare number or
+ * `{ usd, onExceed }`, `artifacts` takes a bare store or `{ store, placement }`
+ * — and it is normalized ONCE, here, so every reader downstream sees one
+ * shape and no downstream file learns that there were two.
+ */
+/**
+ * What a declared column holds.
+ *
+ * | word | what a value must be |
+ * | --- | --- |
+ * | `number` | a JavaScript number that is FINITE — `NaN` and the infinities are a number that means "no number", and a chart handed one draws nothing |
+ * | `string` | a JavaScript string, including the empty one (emptiness is meaning, and meaning is above this check's ceiling) |
+ * | `boolean` | `true` or `false` — never `'true'`, never `0`, never `1` |
+ * | `date` | a valid `Date` instance, or a string `Date.parse` accepts (an epoch NUMBER is a `number`; say so and the axis picker stops guessing) |
+ */
+export type ColumnType = 'number' | 'string' | 'boolean' | 'date';
+/** The closed set, in one place, for the assert and for its own error message. */
+export declare const COLUMN_TYPES: readonly ColumnType[];
+/** The object spelling of one column's declaration. */
+export interface ColumnDeclaration {
+    /** What the column holds. */
+    readonly type: ColumnType;
+    /**
+     * `true` — a row of this column may legitimately carry NO VALUE (`null`,
+     * `undefined`, or the key simply not set on that row), and such a row is
+     * never a type violation.
+     *
+     * Default `false`, and the default is the strict one ON PURPOSE. The field
+     * failure this check is built from was a value that went missing and left
+     * an empty string behind; had the same code left a `null` behind, the
+     * defect would have been identical and a lenient default would have waved
+     * it through. One word turns it off, and every finding names that word — so
+     * a legitimate null column costs a one-word edit, while a silent default
+     * would cost the bug.
+     *
+     * `nullable` is a promise about VALUES. It is NOT a promise about the
+     * column's existence: a declared column that appears in no row at all is a
+     * `missing-column` finding whether or not it is nullable, because the
+     * declaration named a column and the result has no such column. The valve
+     * for "this column may or may not be there" is to not declare it —
+     * unlisted columns are allowed and unjudged.
+     */
+    readonly nullable?: boolean;
+}
+/**
+ * What a tool declares about the columns of its rowset — column name to type.
+ *
+ * OPEN, NEVER CLOSED. A declaration is a promise about what it NAMES, not a
+ * schema of everything the result may contain: a column nobody listed is
+ * allowed and is never judged. Two reasons, and both are the same reason.
+ *
+ *   • A closed schema punishes the wrong party. The day the backend adds a
+ *     column, every one of these tools starts filing findings about a change
+ *     that broke nothing — and a check that cries about correct behaviour is
+ *     a check people switch off, which is how the failure it exists to catch
+ *     gets back in.
+ *   • It is the rule the neighbouring boundary already keeps.
+ *     `toolArgsValidation` is permissive on keywords it does not know and
+ *     enforces `additionalProperties: false` only when an author explicitly
+ *     asks for it. Two validators at one seam disagreeing about whether
+ *     silence means "allowed" would be a worse defect than either could
+ *     catch.
+ */
+export type ToolResultColumns = Readonly<Record<string, ColumnType | ColumnDeclaration>>;
+/** One column's declaration after normalization — the ONLY shape any reader
+ *  downstream of `normalizeColumns` ever sees. */
+export interface NormalizedColumn {
+    readonly name: string;
+    readonly type: ColumnType;
+    readonly nullable: boolean;
+}
+/**
+ * Both spellings into one list, in declaration order.
+ *
+ * Order is kept because it is the author's order, and a finding that names
+ * columns in the order the author wrote them is a finding they can scan
+ * against their own source.
+ */
+export declare function normalizeColumns(columns: ToolResultColumns): readonly NormalizedColumn[];
+/**
+ * Refuse a `resultColumns` this library cannot honour, at definition time —
+ * naming the tool, the column and the fix.
+ *
+ * Exported beside {@link ColumnType} and called from `defineTool`, so a
+ * misspelled type fails on the line that wrote it rather than at the first
+ * rowset of the first armed run. Also called by the MCP ingest
+ * (`readToolExtras`) on a bag from a server this process does not control —
+ * which is why every read below goes through a fallback: a `null`, a number
+ * or an array must reach the teaching refusal, never blow up on the way to
+ * it.
+ */
+export declare function assertResultColumns(toolName: string, columns: unknown): void;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/integrity/column-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrity/column-types/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;AAElE,kFAAkF;AAClF,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAA4C,CAAC;AAE3F,uDAAuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,iBAAiB,CAAC,CAAC,CAAC;AAEzF;kDACkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,gBAAgB,EAAE,CAUxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAgD5E"}

package/dist/types/integrity/disposition/lifecycle.d.ts

@@ -10,7 +10,14 @@
  *          compose-invariant: a mount kernel is configured; dangling: at
  *          least one tool declared `argumentsFrom`, which arms BOTH the
  *          compose-seam dangling-reference check and the choice-seam
- *          unsupported-argument check off the same declaration).
+ *          unsupported-argument check off the same declaration;
+ *          empty-lookup: that same declaration AND the operator's
+ *          `noticeEmptyLookups` dial — two halves, because an advisory that
+ *          armed itself off a declaration made for something else would not
+ *          be opt-in at all; column-types: `Tool.resultColumns` AND the
+ *          operator's `checkColumnTypes` dial off `'off'` — the same two
+ *          halves, arming BOTH `column-type-mismatch` and `missing-column`
+ *          off the one declaration).
  *          Registration is what makes silence auditable — an unregistered
  *          check is honest
  *          absence, a registered one that never notes is the wiring rot
@@ -45,6 +52,29 @@ export interface IntegrityChecksPresent {
     readonly dangling: boolean;
     /** A `.claims()` contract is declared (9.61.0). */
     readonly claim?: boolean;
+    /**
+     * The write seam's `empty-lookup` notice (9.77.0) — armed only when BOTH
+     * halves are true: the operator turned `noticeEmptyLookups` on AND at least
+     * one tool declared `argumentsFrom`. Deliberately NOT armed by the
+     * declaration alone, unlike its two siblings: this check would otherwise
+     * start filing advisories in every app that already declares
+     * `argumentsFrom` for the other two, and an absent dial must leave a run
+     * byte-identical. Absent → a registered `not-applicable` ROW, never
+     * silence.
+     */
+    readonly emptyLookup?: boolean;
+    /**
+     * The write seam's COLUMN-TYPE CONTRACT (9.78.0) — armed only when BOTH
+     * halves are true: the operator set `checkColumnTypes` to something other
+     * than `'off'` AND at least one tool declared `resultColumns`. The same
+     * two-halves law as `empty-lookup`, for the same reason: a declaration is
+     * a promise a consumer may already be reading for its own purposes, and
+     * arming a boundary check off it alone would make an absent dial change a
+     * run's bytes. ONE FLAG, TWO CHECKS — `column-type-mismatch` and
+     * `missing-column` are the same declaration read two ways, and nothing can
+     * arm one without arming the other.
+     */
+    readonly columnTypes?: boolean;
 }
 /**
  * Start one run's ledger: register the present checks and, in dev posture,

package/dist/types/integrity/disposition/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/integrity/disposition/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AASxE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,KAAK,CAAC;AAEjD,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,gBAAgB,GACxB,iBAAiB,CA8HnB"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/integrity/disposition/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAWxE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,KAAK,CAAC;AAEjD,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,gBAAgB,GACxB,iBAAiB,CAgLnB"}

package/dist/types/integrity/empty-lookup/check.d.ts

@@ -0,0 +1,141 @@
+/**
+ * empty-lookup — the run itself produced this identifier, and the lookup for
+ * it found nothing. Filed at the WRITE seam, as an advisory, never an
+ * accusation.
+ *
+ * Pattern: pure function over (one finished call, the results its declared
+ *          producers served); the domain check, one seam later than
+ *          `unsupported-argument`.
+ * Role:    the decidable fragment of "did this tool answer, or did it only
+ *          appear to answer?".
+ *
+ * THE MEASURED FAILURE. A triage agent's reverse-lookup tool filtered a
+ * column before a pivot, so the column did not exist yet and EVERY reverse
+ * lookup returned an empty result — for every identifier, always. The tool
+ * then answered SUCCESSFULLY with an empty list, and the agent reported in a
+ * table, with confidence, that the device was "not currently logged in to any
+ * port on the collected switches" and advised checking physical cabling. It
+ * was logged in the whole time. Nothing in the framework noticed, because an
+ * empty result from a broken filter is byte-identical to an empty result from
+ * a genuine absence.
+ *
+ * WHAT THE LIBRARY ALREADY KNOWS, and this check is nothing more than the
+ * join of the two:
+ *   (a) the identifier was GROUNDED — it came out of an earlier tool result
+ *       in THIS run, from a tool the consumer's author named in
+ *       `Tool.argumentsFrom`;
+ *   (b) the lookup keyed on it came back EMPTY.
+ * When the run produced the identifier and the lookup for it finds nothing,
+ * that is worth filing. It is not worth accusing anyone of.
+ *
+ * THE CEILING, and it is the whole reason this is an advisory: an empty
+ * answer can be perfectly true. The device may exist and simply have no
+ * logins right now. NOTHING IN THIS FILE CAN TELL THOSE APART, and nothing in
+ * this file pretends to — the finding says "here is a pair worth a look", the
+ * record carries the ceiling sentence verbatim, and the same finding is filed
+ * for the true absence and the broken filter alike. A check that guessed
+ * which one it was looking at would be inventing the certainty the field
+ * failure was made of.
+ *
+ * DECLARED, NEVER INFERRED — the `argumentsFrom` precedent, THIRD use. A tool
+ * is this check's subject only because its author said its arguments come
+ * from another tool's results. One declaration now arms three seams:
+ * `dangling-reference` asks whether the ground is still in reach when the
+ * tool is OFFERED, `unsupported-argument` whether the value the model chose
+ * came from that ground when the tool was CALLED, and this whether the ground
+ * the run really did serve then found anything when the tool ANSWERED.
+ *
+ * WHAT COUNTS AS EMPTY — and what this refuses to judge. See
+ * {@link readLookupResult}. A rowset is counted, never interpreted; an
+ * absence is read from the marker its own helper mints. Every other shape a
+ * tool has ever returned — a sentence, an object, a `null`, a claim ticket —
+ * is BESPOKE: the library cannot see whether it holds rows, so the encounter
+ * is `not-applicable` and says so in the ledger. That row is the point. A
+ * check that silently skipped what it could not read would be the decoration
+ * the disposition family exists to make impossible.
+ *
+ * Detection only. Nothing here blocks, retries, rewrites or delays anything;
+ * the result the model reads is the result the tool returned.
+ */
+import type { Disposition } from '../disposition/types.js';
+import type { ContextError } from '../finding/types.js';
+/**
+ * THE CEILING, as one string with one owner.
+ *
+ * Quoted verbatim into every finding's message, into the check's README and
+ * into its docs page, so the bound cannot drift out of one of them and leave
+ * a reader thinking the library knows more than it does.
+ */
+export declare const EMPTY_LOOKUP_CEILING: string;
+/** What the library could read about a finished lookup's result. */
+export interface LookupResultReading {
+    /** `'rowset'` — an array, counted. `'absence'` — the `absent()` envelope. */
+    readonly shape: 'rowset' | 'absence';
+    readonly empty: boolean;
+    /** Rows counted, for a rowset. Absent for an absence, which declares itself. */
+    readonly rows?: number;
+}
+/**
+ * READ a finished result's shape, or decline to.
+ *
+ * The two readable shapes, and why only these two:
+ *
+ *   • a **rowset** — an array. Its length is COUNTED, not interpreted: zero
+ *     rows is zero rows, and no judgement about what the tool meant is
+ *     involved. This is the shape the recorded failure actually returned.
+ *   • an **absence** — the `absent()` envelope, whose author said in so many
+ *     words "the search ran and matched nothing".
+ *
+ * Everything else returns `undefined`, which the caller files as
+ * `not-applicable`. A prose sentence, a bespoke `{ rows: [...] }` wrapper, a
+ * `null`, a placement claim ticket — the library cannot see rows in any of
+ * them, and guessing is how a checker starts lying.
+ *
+ * @param value the tool's own answer, as it returned it.
+ * @param declaredAbsence whether `readAbsence` recognized the value. PASSED
+ *   IN rather than re-derived here on purpose: the `af_absent` marker has
+ *   exactly one owner (`core/agent/coverage/absent.ts`), a second spelling of
+ *   a reserved word would eventually disagree with the first, and
+ *   `src/integrity/` stays a leaf that imports no agent code.
+ */
+export declare function readLookupResult(value: unknown, declaredAbsence: boolean): LookupResultReading | undefined;
+/** One finished call to a tool whose author declared where its arguments come from. */
+export interface EmptyLookupCall {
+    /** The CONSUMER — the tool that was called and answered. */
+    readonly toolName: string;
+    /** The provider's id for this call — what the witness points a reader at. */
+    readonly toolCallId: string;
+    readonly args: Readonly<Record<string, unknown>>;
+    /** `Tool.argumentsFrom` — the tools whose results were meant to ground these arguments. */
+    readonly argumentsFrom: readonly string[];
+    /** What the library could read about the result — `undefined` = bespoke shape. */
+    readonly reading: LookupResultReading | undefined;
+}
+/** One earlier tool result this run served, with the tool that produced it. */
+export interface ProducedResult {
+    readonly toolName: string;
+    /** The result exactly as the run served it into the conversation. */
+    readonly text: string;
+}
+/** One encounter's outcome: the findings, and the disposition it earns. */
+export interface EmptyLookupEncounter {
+    readonly findings: readonly ContextError[];
+    /**
+     * The ledger row this encounter files — computed HERE, beside the rules
+     * that decide it, so "the library refused to judge this shape" is provable
+     * without a live agent.
+     */
+    readonly disposition: Disposition;
+}
+/**
+ * Judge one finished call to an armed tool.
+ *
+ * @param call the call and what the library could read of its result. The
+ *   caller has already established the tool declared `argumentsFrom`;
+ *   nothing here re-decides who is a subject.
+ * @param produced every tool result this run served BEFORE this call, with
+ *   the tool that produced each. Filtered to the declared producers here.
+ * @param epoch the run iteration, stamped on every witness.
+ */
+export declare function emptyLookupOf(call: EmptyLookupCall, produced: readonly ProducedResult[], epoch: number): EmptyLookupEncounter;
+//# sourceMappingURL=check.d.ts.map

package/dist/types/integrity/empty-lookup/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/integrity/empty-lookup/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,QAEkD,CAAC;AAEpF,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,eAAe,EAAE,OAAO,GACvB,mBAAmB,GAAG,SAAS,CAKjC;AAED,uFAAuF;AACvF,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,2FAA2F;IAC3F,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,kFAAkF;IAClF,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACnD;AAED,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,KAAK,EAAE,MAAM,GACZ,oBAAoB,CAyGtB"}

package/dist/types/integrity/finding/types.d.ts

@@ -20,7 +20,7 @@
 import type { Assertion, SubjectRef } from '../assertion/types.js';
 import type { IntegritySeam } from '../disposition/types.js';
 /**
- * The five defect classes, by their plain names:
+ * The eight defect classes, by their plain names:
  *
  * | kind | means | mechanism |
  * |---|---|---|
@@ -29,8 +29,29 @@ import type { IntegritySeam } from '../disposition/types.js';
  * | `dangling-reference`   | offered an action whose inputs are no longer available | closure   |
  * | `duplicate-execution`  | did settled work again                                 | once      |
  * | `unsupported-claim`    | stated something the record does not support           | grounding |
+ * | `empty-lookup`         | the run produced this value, and the lookup for it found nothing | join |
+ * | `column-type-mismatch` | a column holds something other than the type its tool declared | type |
+ * | `missing-column`       | a column the tool declared is in none of its rows      | presence  |
+ *
+ * `empty-lookup` is the one class that is ADVISORY BY CONSTRUCTION (9.77.0) —
+ * every finding it files carries `advisory: true`, because an empty result
+ * can be perfectly true and nothing in the library can tell a true absence
+ * from a lookup that could never have matched. It is a place to look, not a
+ * defect that was proven. It is deliberately NOT `dangling-reference`, whose
+ * meaning is the opposite: there the ground has left reach, here the ground
+ * is in reach and the lookup came back with nothing.
+ *
+ * `column-type-mismatch` and `missing-column` (9.78.0) are two classes rather
+ * than one ON PURPOSE, and the field failure they come from is the argument:
+ * a LUN of 0 stored as `''` and a LUN column that was never delivered send a
+ * person to two different files, and a checker that said only "something is
+ * off with logical_unit_number" would have helped with neither. Unlike
+ * `empty-lookup`, neither is advisory: a column declared `number` that holds
+ * a string is not a place to look, it is a broken promise — though what the
+ * check can see about it is bounded, and the bound ships as
+ * `COLUMN_TYPE_CEILING` in every message.
  */
-export type ContextErrorKind = 'invariant-violation' | 'unsupported-argument' | 'dangling-reference' | 'duplicate-execution' | 'unsupported-claim';
+export type ContextErrorKind = 'invariant-violation' | 'unsupported-argument' | 'dangling-reference' | 'duplicate-execution' | 'unsupported-claim' | 'empty-lookup' | 'column-type-mismatch' | 'missing-column';
 /** One detected context error — a labelled instance, automatically. */
 export interface ContextError {
     readonly kind: ContextErrorKind;

package/dist/types/integrity/finding/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrity/finding/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GACxB,qBAAqB,GACrB,sBAAsB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,mBAAmB,CAAC;AAExB,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,SAAS,EAAE,CAAC;IACzC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IACzB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAW5D;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,YAAY,EAAE,CAU5F"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrity/finding/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,gBAAgB,GACxB,qBAAqB,GACrB,sBAAsB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,mBAAmB,GACnB,cAAc,GACd,sBAAsB,GACtB,gBAAgB,CAAC;AAErB,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,SAAS,EAAE,CAAC;IACzC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IACzB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAW5D;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,YAAY,EAAE,CAU5F"}

package/dist/types/integrity/unsupported-argument/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/integrity/unsupported-argument/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,2FAA2F;IAC3F,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,uFAAuF;IACvF,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CAC/C;AAED,wEAAwE;AACxE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,0EAA0E;IAC1E,QAAQ,CAAC,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC3D;AAkCD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAgBzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,GACZ,oBAAoB,CAwGtB"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/integrity/unsupported-argument/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,2FAA2F;IAC3F,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,uFAAuF;IACvF,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CAC/C;AAED,wEAAwE;AACxE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,0EAA0E;IAC1E,QAAQ,CAAC,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC3D;AAcD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAgBzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,GACZ,oBAAoB,CA4GtB"}

package/dist/types/lib/mcp/toolExtras.d.ts

@@ -28,7 +28,7 @@
  *
  * ── What may travel, and the bar ────────────────────────────────────────
  * **A declaration a consumer-side check or rail reads; nothing that governs
- * execution.** The five fields below pass it. `needs` (credentials), `checkIn`
+ * execution.** Every field below passes it. `needs` (credentials), `checkIn`
  * (human consent) and the session hooks do NOT and never will: they govern how
  * a tool RUNS, and the tool runs on the server. Sending them would tell a
  * client to hold a gate that the only executor of the tool has already held,
@@ -49,7 +49,7 @@
  * That is the honest outcome: the rail it would have armed stays unarmed, and
  * the developer is told which rail and why.
  */
-import { type Tool, type ToolOwner, type ToolResultCeiling } from '../../core/tools.js';
+import { type Tool, type ToolOwner, type ToolResultCeiling, type ToolResultColumns } from '../../core/tools.js';
 import type { ToolResultClass } from '../semantics/types.js';
 /**
  * The single `_meta` key every agentfootprint declaration travels under.
@@ -79,6 +79,21 @@ export interface McpToolExtras {
     /** The artifact kind a PLACED result is minted under — see
      *  {@link Tool.resultKind}. What makes a placed result spendable by `wants`. */
     readonly resultKind?: string;
+    /**
+     * What this tool's ROWS contain (9.78.0) — see {@link Tool.resultColumns}.
+     * Arms the write seam's `column-type-mismatch` and `missing-column` checks.
+     *
+     * It clears the bar this file states, and by the widest margin of the eight.
+     * It is a flat, inert fact about the RESULT that a consumer-side check
+     * reads; it governs nothing about how the tool runs, and the tool runs on
+     * the server. It is also the field case for carrying declarations at all: a
+     * remote catalogue of rowset tools is exactly where a numeric column
+     * arriving as text goes unnoticed, because the consumer holding the chart
+     * has no way to know what the producer meant. Leaving it behind would arm
+     * the check for local tools and leave every MCP tool a second-class citizen
+     * of it — the whole defect `toolExtras` was built to end.
+     */
+    readonly resultColumns?: ToolResultColumns;
     /** The identity edge integrity checks join on — see {@link Tool.owner}. */
     readonly owner?: ToolOwner;
     /** The declared class of this tool's results — see {@link Tool.resultClass}. */

package/dist/types/lib/mcp/toolExtras.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolExtras.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/toolExtras.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAQL,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;uEACmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;oFACgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC;sCACkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;gBAEY;IACZ,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;+CAE2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,SAAS,CAWlE;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAuCxF;AA+ED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}
+{"version":3,"file":"toolExtras.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/toolExtras.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EASL,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;uEACmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;oFACgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC;sCACkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;gBAEY;IACZ,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;+CAE2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,SAAS,CAYlE;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CA2CxF;AA+ED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}

package/dist/types/lib/trace-toolpack/traceToolpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traceToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AASH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,qBAAqB,CAAC;AAcvF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAuQpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,sBAAsB,EACjC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CA0BR;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,kMAYnB,CAAC;AAopEX;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,MAAM,CAAC,CASjB"}
+{"version":3,"file":"traceToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AASH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,qBAAqB,CAAC;AAcvF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAuQpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,sBAAsB,EACjC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CA0BR;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,kMAYnB,CAAC;AAwpEX;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "9.76.1",
+  "version": "9.78.0",
   "description": "The explainable agent framework — backtrack a wrong answer to the exact context that caused it (evidence, not guesses). Built on footprintjs.",
   "license": "MIT",
   "type": "commonjs",