@cellarnode/ui 0.201.1 → 0.203.0

package/dist/agent/role-cards/inspector-fixtures.js

@@ -0,0 +1,162 @@
+import { fixtureRecords } from "./fixtures.js";
+/** @internal Story and test fixtures for the inspector drawer (CEL-2487): the FULL records a host would fetch for the role cards. */
+const MASKED_EMAIL = { masked: true, display: "a***@nordicwine.example" };
+/**
+ * The records behind the fixture cards' `detail` pointers, keyed `kind:id`. They extend `fixtureRecords`, so a story's proposal
+ * Apply (which re-fetches by `kind:id`) and the drawer's record view read the same server truth.
+ */
+export const inspectorRecords = {
+    "offer:11111111-1111-4111-8111-111111111111": {
+        ...fixtureRecords["offer:11111111-1111-4111-8111-111111111111"],
+        status: "in_negotiation",
+        awaiting: "you",
+        round: 2,
+        product: "Riesling Spatlese 2022",
+        counterparty: "Nordic Wine Imports AB",
+        opportunity: { name: "Nordic red wine tender, autumn 2026", market: "Sweden" },
+        terms: {
+            price: "9.40",
+            currency: "EUR",
+            priceType: "per bottle",
+            volume: "6,000 bottles",
+            incoterm: "DAP Stockholm",
+            paymentTerms: null,
+            validThrough: "2026-12-01",
+        },
+        contact: { name: "Anna Berg", email: MASKED_EMAIL },
+        attachments: ["Specification sheet.pdf", "Organic certificate.pdf"],
+        rounds: [
+            { round: 1, by: "importer", price: "9.80", note: "Opening offer" },
+            { round: 2, by: "producer", price: "9.40", note: "Counter with a volume discount" },
+        ],
+        counts: { messages: 14, attachments: 2 },
+        createdAt: "2026-09-14T09:12:00Z",
+    },
+    "variant:v1": {
+        ...fixtureRecords["variant:v1"],
+        vintage: 2022,
+        volume: "750 ml",
+        packaging: "bottle",
+        certifications: ["organic", "sustainable"],
+        organic: true,
+        readiness: {
+            percent: 80,
+            canApprove: false,
+            blockers: 1,
+            acknowledgements: 1,
+            recommendations: 2,
+        },
+        description: "Off-dry Riesling from steep slate slopes, hand harvested, aged on the lees for six months.",
+    },
+    "opportunity:o1": {
+        name: "Red wine for the Nordic monopoly, autumn 2026",
+        buyer: "Nordic Monopoly",
+        market: "Sweden",
+        status: "open",
+        deadline: "2026-11-30",
+        volume: "20,000 bottles",
+        priceRange: { min: "8", max: "11", currency: "EUR" },
+        requirements: ["organic", "screw cap", "750 ml", "vintage 2023 or newer"],
+        contact: { name: "Buyer desk", email: MASKED_EMAIL },
+    },
+    "match:m-1": {
+        score: 4.5,
+        status: "new",
+        explanation: "Category, volume and price all sit inside what the buyer asked for.",
+        product: { name: "Riesling Spatlese 2022", vintage: 2022 },
+        opportunity: { name: "Nordic red wine tender", buyer: "Buyer AB", country: "SE" },
+        fit: { category: true, volume: true, price: true, certificates: true, packaging: false },
+        declined: false,
+    },
+};
+/** The `fetchRecord` a story or test host passes: the same records as `inspectorRecords`, `null` for an unknown pointer. */
+export const inspectorFetchRecord = async (kind, id) => inspectorRecords[`${kind}:${id}`] ?? null;
+/** A record with many fields and nesting, to prove the drawer scrolls and the caps hold. */
+export const largeRecord = {
+    ...Object.fromEntries(Array.from({ length: 24 }, (_, i) => [`field_${i + 1}`, `Value ${i + 1}`])),
+    history: Array.from({ length: 30 }, (_, i) => ({
+        step: i + 1,
+        by: "system",
+        note: `Change ${i + 1}`,
+    })),
+    tags: Array.from({ length: 30 }, (_, i) => `tag-${i + 1}`),
+    nested: { level1: { level2: { level3: { level4: "too deep to show" } } } },
+};
+/** A `ready` record state for the pointer it was fetched for; the record defaults to the fixture behind that pointer. */
+export const readyFor = (kind, id, record = inspectorRecords[`${kind}:${id}`]) => ({ status: "ready", for: { kind, id }, record });
+/** Long, unbroken and hostile text in every place a record puts text: for the 320px story and the overflow checks. */
+export const longTextRecord = {
+    name: "Gewurztraminer Grand Cru Vendanges Tardives Cuvee Reserve de la Famille 2019 magnum in individual wooden gift box",
+    reference: `REF-${"0123456789".repeat(14)}`,
+    notes: `Ships from the cellar door ${"supercalifragilistic".repeat(8)} and then some more words to wrap.`,
+    a_really_long_field_name_that_does_not_fit_on_one_line_of_a_narrow_phone_screen: "value",
+    tags: [
+        "certified-organic-by-the-european-union-and-the-national-authority",
+        "a".repeat(200),
+        "short",
+    ],
+    contact: {
+        name: "Internationale Weinhandelsgesellschaft fur Spezialitaten und Raritaten mbH",
+        email: { masked: true, display: `a***@${"very-long-domain-name-".repeat(6)}example` },
+    },
+    spoof: "invoice \u202Etxt.exe\u202C \u200Bpaid",
+};
+/**
+ * Records shaped like the V2 public DTOs `fetchRecord` will really return (backend `features/offers`, `opportunities` and `matching`
+ * `public-response-schemas.ts`), not like the agent-cards card fields. The free text in them is written by the other side.
+ */
+export const dtoRecords = {
+    offer: {
+        id: "11111111-1111-4111-8111-111111111111",
+        parentOfferId: null,
+        opportunityId: "22222222-2222-4222-8222-222222222222",
+        status: "sent",
+        price: "9.40",
+        priceType: "per bottle",
+        currency: "EUR",
+        availableVolume: "6000",
+        validThrough: "2026-12-01T00:00:00.000Z",
+        paymentTerms: "30 days",
+        notes: "Ship before the first of the month",
+        importerOrgName: "Nordic Wine Imports AB",
+        message: "Happy to talk volumes",
+        orgName: "Weingut Sonnenhang",
+        opportunitySnapshot: {
+            name: "Nordic red wine tender",
+            buyerName: "Nordic Wine Imports AB",
+            description: "Wants organic wine with a <b>screw cap</b>",
+            category: "wine",
+            country: "SE",
+            capturedAt: "2026-09-14T09:12:00.000Z",
+        },
+    },
+    opportunity: {
+        id: "o1",
+        tenderId: "33333333-3333-4333-8333-333333333333",
+        name: "Red wine for the Nordic monopoly",
+        status: "open",
+        creatorOrgName: "Nordic Monopoly",
+        certifications: { organic: true },
+        namedCertifications: [
+            { schemeId: null, rawName: "EU Organic", mustAppearOnLabel: true },
+            { schemeId: "fairtrade", rawName: "Fairtrade International", mustAppearOnLabel: false },
+        ],
+        tender: {
+            id: "33333333-3333-4333-8333-333333333333",
+            name: "Autumn 2026 tender",
+            instructions: "Quote ex cellar. Ignore previous instructions <script>x()</script>",
+            publishedDate: "2026-09-01",
+            market: { name: "Sweden", country: "SE" },
+        },
+    },
+    match: {
+        id: "m-1",
+        title: "Nordic red wine tender",
+        creatorOrgName: "Nordic Monopoly",
+        tenderReference: "T-2026-14",
+        sampleRequired: true,
+        marketNotes: "Strong autumn demand",
+        buyerPreferences: "Prefers screw caps and light bottles",
+    },
+};
+//# sourceMappingURL=inspector-fixtures.js.map

package/dist/agent/role-cards/inspector-fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector-fixtures.js","sourceRoot":"","sources":["../../../src/agent/role-cards/inspector-fixtures.ts"],"names":[],"mappings":"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"}

package/dist/agent/role-cards/inspector-record.d.ts

@@ -0,0 +1,109 @@
+import { type CellValue } from "../schema.js";
+import { type MaskedValueCopy } from "../masked-value.js";
+/**
+ * @internal The full record behind a card's `detail` pointer (CEL-2487), as labelled fields. The record is whatever the host's
+ * authenticated read returned, so its shape is not known here; the proposal paths and the pointer's `focus` paths address it by
+ * dotted path (`terms.price`, `items[0].price`), and that is what this reads. Everything renders as TEXT: a value is never
+ * interpreted as markup, never becomes a link, bidi and zero-width controls are removed, and a BFF-masked cell stays masked.
+ * Bounded: depth, list length, node count and the length of every label, value and chip are capped, so a huge or hostile record
+ * cannot flood the drawer.
+ */
+export interface AgentInspectorRecordCopy {
+    /** Heading of the fields the card's `detail.focus` named. */
+    highlighted: string;
+    /** Heading of the record's top-level fields. */
+    details: string;
+    /** A highlighted field the record has no value for. */
+    notSet: string;
+    /** A value that cannot be shown as text (an object that is not plain data). */
+    notShown: string;
+    yes: string;
+    no: string;
+    /** A group that comes from a list of objects: `{n}` is its place in the list. */
+    item: string;
+    /** A highlighted field's label: `{parent}` is the group it sits in and `{child}` the field ("Terms / Price"). */
+    trail: string;
+    /** How text written by someone else is set off: `{text}` is the text. */
+    quote: string;
+    /** Shown when a cap hid part of a very large record. */
+    truncated: string;
+}
+export declare const DEFAULT_INSPECTOR_RECORD_COPY: AgentInspectorRecordCopy;
+/**
+ * `dataLabel`: the label was made from a key of the record (humanised), not supplied by the host or by the view's own copy. Inside
+ * text someone else wrote, such a key is theirs too, and renders quoted.
+ */
+export type RecordNode = {
+    kind: "field";
+    path: string;
+    label: string;
+    dataLabel: boolean;
+    value: CellValue;
+} | {
+    kind: "list";
+    path: string;
+    label: string;
+    dataLabel: boolean;
+    items: CellValue[];
+} | {
+    kind: "group";
+    path: string;
+    label: string;
+    dataLabel: boolean;
+    nodes: RecordNode[];
+};
+export interface RecordView {
+    /** The fields the card pointed at, each labelled with its trail ("Terms / Price"). */
+    highlighted: RecordNode[];
+    /** Everything else, in the record's own order. */
+    nodes: RecordNode[];
+    /** Fields a cap kept out. */
+    omitted: number;
+    /** Nothing to show at all (no highlighted field and no field with a value). */
+    isEmpty: boolean;
+}
+export interface BuildRecordViewOptions {
+    /** `detail.focus` of the card. Resolved first and on their own budget, so a pointed-at field never falls to a cap. */
+    focus?: readonly string[];
+    /** Host labels, by dotted path first and by bare key second. Anything else is humanised from the key. */
+    labels?: Readonly<Record<string, string>>;
+    /** "Item {n}" in the host's language. */
+    itemLabel?: (n: number) => string;
+    /** "Terms / Price" in the host's language. */
+    trail?: (parent: string, child: string) => string;
+    /** What shows for an object that is not plain data. */
+    notShown?: string;
+    /** Paths (as `canonicalPath` spells them) the host keeps out of the view. */
+    hidden?: (path: string) => boolean;
+}
+/** `validThrough`, `valid_through` and `valid-through` all read "Valid through"; a short known acronym is upper-cased. */
+export declare function humanizeKey(key: string): string;
+/**
+ * Does a record path fall under one of the patterns? A path matches a pattern when the pattern names the path OR any ancestor of
+ * it, so `counterparty` covers `counterparty.name` and `rounds[].note` covers `rounds[1].note`. A pattern of one name matches that
+ * name at any depth; a longer pattern is anchored at the root, and `[]` stands for any list position (a trailing `[]` also covers the
+ * list itself).
+ */
+export declare function compilePathMatcher(patterns: readonly string[]): (path: string) => boolean;
+/**
+ * The record as labelled nodes. Own enumerable keys only; `__proto__`, `constructor`, `prototype` and keys starting with `_`
+ * (internal bookkeeping) are skipped. Objects become groups, a list of scalars a chip list, a list of objects numbered groups, a
+ * Date its ISO text, anything that is not plain data a placeholder. Empty values are dropped unless the card's `focus` named them.
+ *
+ * `focus` paths are resolved FIRST with `lookupPath`, each on its own budget, and kept out of the main walk: the agent's pointer
+ * survives a record that is otherwise capped.
+ */
+export declare function buildRecordView(record: unknown, { focus, labels, itemLabel, trail, notShown, hidden, }?: BuildRecordViewOptions): RecordView;
+export interface AgentInspectorRecordProps {
+    view: RecordView;
+    /** Was the text at this path written by someone else? It then renders as quoted text. */
+    isThirdParty: (path: string) => boolean;
+    /** The host's own display text for a value (a date, a currency), or `undefined` for the default. Never called for a masked cell. */
+    formatValue?: (path: string, value: CellValue) => string | undefined;
+    copy: AgentInspectorRecordCopy;
+    maskedCopy?: Partial<MaskedValueCopy>;
+    headingId: (name: string) => string;
+}
+/** The labelled fields of a record: the highlighted ones first, then everything else. Presentational; `buildRecordView` decides what is in it. */
+export declare function AgentInspectorRecord(p: AgentInspectorRecordProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=inspector-record.d.ts.map

package/dist/agent/role-cards/inspector-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector-record.d.ts","sourceRoot":"","sources":["../../../src/agent/role-cards/inspector-record.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAKpE;;;;;;;GAOG;AAEH,MAAM,WAAW,wBAAwB;IACvC,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,iHAAiH;IACjH,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;CACnB;AACD,eAAO,MAAM,6BAA6B,EAAE,wBAW3C,CAAC;AAaF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACpF;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GACrF;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC;AAO5F,MAAM,WAAW,UAAU;IACzB,sFAAsF;IACtF,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,kDAAkD;IAClD,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,sHAAsH;IACtH,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,yGAAyG;IACzG,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1C,yCAAyC;IACzC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,8CAA8C;IAC9C,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACpC;AAID,0HAA0H;AAC1H,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAe/C;AASD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAiBzF;AA+CD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,EACf,EACE,KAAK,EACL,MAAM,EACN,SAAiE,EACjE,KAAsF,EACtF,QAAiD,EACjD,MAAM,GACP,GAAE,sBAA2B,GAC7B,UAAU,CAmLZ;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,UAAU,CAAC;IACjB,yFAAyF;IACzF,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,oIAAoI;IACpI,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,KAAK,MAAM,GAAG,SAAS,CAAC;IACrE,IAAI,EAAE,wBAAwB,CAAC;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IACtC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC;AA+HD,kJAAkJ;AAClJ,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,yBAAyB,2CA0BhE"}

package/dist/agent/role-cards/inspector-record.js

@@ -0,0 +1,346 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { DEFAULT_QUOTE, fmt, quoteText } from "../copy.js";
+import { isMasked } from "../schema.js";
+import { MaskedValue } from "../masked-value.js";
+import { AgentChip, AgentField, AgentFieldGrid } from "./card-kit.js";
+import { lookupPath } from "./host-contract.js";
+import { cleanInline, cleanValue } from "./text-safety.js";
+export const DEFAULT_INSPECTOR_RECORD_COPY = {
+    highlighted: "Highlighted by the agent",
+    details: "Details",
+    notSet: "Not set",
+    notShown: "Not shown",
+    yes: "Yes",
+    no: "No",
+    item: "Item {n}",
+    trail: "{parent} / {child}",
+    quote: DEFAULT_QUOTE,
+    truncated: "This record is large. Some fields are not shown.",
+};
+const MAX_DEPTH = 3;
+const MAX_LIST = 20;
+const MAX_NODES = 200;
+const MAX_TEXT = 2000;
+const MAX_CHIP = 120;
+const MAX_LABEL = 120;
+const MAX_MASKED = 200;
+/** A value longer than this takes the whole row. */
+const WIDE_TEXT = 48;
+const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const ACRONYMS = new Set(["id", "abv", "vat", "url", "sku", "ean", "gtin", "moq", "iban"]);
+/** `validThrough`, `valid_through` and `valid-through` all read "Valid through"; a short known acronym is upper-cased. */
+export function humanizeKey(key) {
+    const words = key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_\-\s]+/g, " ")
+        .trim()
+        .toLowerCase()
+        .split(" ")
+        .filter(Boolean)
+        .map((w) => (ACRONYMS.has(w) ? w.toUpperCase() : w));
+    if (words.length === 0)
+        return key;
+    const first = words[0];
+    words[0] = ACRONYMS.has(first)
+        ? first.toUpperCase()
+        : first.charAt(0).toUpperCase() + first.slice(1);
+    return words.join(" ");
+}
+/** `rounds[].note` is `["rounds", "*", "note"]`; `rounds[0].note` is `["rounds", "0", "note"]`. */
+const toSegments = (path) => path
+    .replace(/\[(\d*)\]/g, (_, d) => (d === "" ? ".*" : `.${d}`))
+    .split(".")
+    .filter(Boolean);
+/**
+ * Does a record path fall under one of the patterns? A path matches a pattern when the pattern names the path OR any ancestor of
+ * it, so `counterparty` covers `counterparty.name` and `rounds[].note` covers `rounds[1].note`. A pattern of one name matches that
+ * name at any depth; a longer pattern is anchored at the root, and `[]` stands for any list position (a trailing `[]` also covers the
+ * list itself).
+ */
+export function compilePathMatcher(patterns) {
+    // A trailing `[]` names a list's items and the list itself (`requirements[]` also covers `requirements`).
+    const compiled = patterns.flatMap((raw) => {
+        const p = toSegments(raw);
+        if (p.length === 0)
+            return [];
+        return p.length > 1 && p[p.length - 1] === "*" ? [p, p.slice(0, -1)] : [p];
+    });
+    if (compiled.length === 0)
+        return () => false;
+    return (path) => {
+        const s = toSegments(path);
+        return compiled.some((p) => p.length === 1
+            ? s.includes(p[0])
+            : p.length <= s.length &&
+                p.every((seg, i) => (seg === "*" ? /^\d+$/.test(s[i]) : seg === s[i])));
+    };
+}
+const isLeaf = (v) => v === null ||
+    typeof v === "string" ||
+    typeof v === "number" ||
+    typeof v === "boolean" ||
+    isMasked(v);
+const isEmptyLeaf = (v) => v === null || v === "";
+const isPlainObject = (v) => {
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+};
+const clipCell = (v, maxText) => {
+    if (typeof v === "string")
+        return cleanValue(v, maxText);
+    if (typeof v === "number" && !Number.isFinite(v))
+        return String(v);
+    if (isMasked(v))
+        return { masked: true, display: cleanValue(v.display, MAX_MASKED) };
+    return v;
+};
+const hasValue = (node) => node.kind === "field"
+    ? !isEmptyLeaf(node.value)
+    : node.kind === "list"
+        ? node.items.length > 0
+        : node.nodes.some(hasValue);
+/** Drop what has no value (an empty field or list, a group with nothing in it), keep the shape of the rest. */
+function prune(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        if (n.kind === "group") {
+            const inner = prune(n.nodes);
+            if (inner.length > 0)
+                out.push({ ...n, nodes: inner });
+        }
+        else if (hasValue(n))
+            out.push(n);
+    }
+    return out;
+}
+const isStrictAncestor = (ancestor, path) => path.length > ancestor.length &&
+    path.startsWith(ancestor) &&
+    (path[ancestor.length] === "." || path[ancestor.length] === "[");
+/**
+ * The record as labelled nodes. Own enumerable keys only; `__proto__`, `constructor`, `prototype` and keys starting with `_`
+ * (internal bookkeeping) are skipped. Objects become groups, a list of scalars a chip list, a list of objects numbered groups, a
+ * Date its ISO text, anything that is not plain data a placeholder. Empty values are dropped unless the card's `focus` named them.
+ *
+ * `focus` paths are resolved FIRST with `lookupPath`, each on its own budget, and kept out of the main walk: the agent's pointer
+ * survives a record that is otherwise capped.
+ */
+export function buildRecordView(record, { focus, labels, itemLabel = (n) => fmt(DEFAULT_INSPECTOR_RECORD_COPY.item, { n }), trail = (parent, child) => fmt(DEFAULT_INSPECTOR_RECORD_COPY.trail, { parent, child }), notShown = DEFAULT_INSPECTOR_RECORD_COPY.notShown, hidden, } = {}) {
+    const empty = { highlighted: [], nodes: [], omitted: 0, isEmpty: true };
+    if (typeof record !== "object" || record === null || Array.isArray(record) || isMasked(record))
+        return empty;
+    const labelFor = (path, key) => {
+        const custom = labels && Object.hasOwn(labels, path)
+            ? labels[path]
+            : labels && Object.hasOwn(labels, key)
+                ? labels[key]
+                : undefined;
+        return {
+            text: cleanInline(custom ?? humanizeKey(key), MAX_LABEL, true) ?? "-",
+            data: custom === undefined,
+        };
+    };
+    const itemLabelFor = (n) => ({
+        text: cleanInline(itemLabel(n), MAX_LABEL, true) ?? "-",
+        data: false,
+    });
+    const walkObject = (obj, base, depth, w, skip) => {
+        const out = [];
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            if (w.budget <= 0) {
+                w.omitted += keys.length - i;
+                break;
+            }
+            const key = keys[i];
+            if (UNSAFE_KEYS.has(key) || key.startsWith("_"))
+                continue;
+            const path = base === "" ? key : `${base}.${key}`;
+            const node = walkValue(obj[key], path, labelFor(path, key), depth, w, skip);
+            if (node)
+                out.push(node);
+        }
+        return out;
+    };
+    const walkValue = (value, path, label, depth, w, skip) => {
+        if (value === undefined || typeof value === "function" || typeof value === "symbol")
+            return null;
+        if (skip(path))
+            return null;
+        if (w.budget <= 0) {
+            w.omitted += 1;
+            return null;
+        }
+        w.budget -= 1;
+        const field = (v) => ({
+            kind: "field",
+            path,
+            label: label.text,
+            dataLabel: label.data,
+            value: v,
+        });
+        if (isLeaf(value))
+            return field(clipCell(value, MAX_TEXT));
+        if (typeof value === "bigint")
+            return field(String(value));
+        if (typeof value !== "object")
+            return null;
+        if (value instanceof Date)
+            return field(Number.isNaN(value.getTime()) ? notShown : value.toISOString());
+        if (Array.isArray(value)) {
+            const shown = value.slice(0, MAX_LIST);
+            w.omitted += value.length - shown.length;
+            if (shown.every(isLeaf)) {
+                // Every item is a node of its own: a list cannot dodge the cap by being one field.
+                w.budget -= shown.length;
+                return {
+                    kind: "list",
+                    path,
+                    label: label.text,
+                    dataLabel: label.data,
+                    items: shown.map((i) => clipCell(i, MAX_CHIP)),
+                };
+            }
+            if (depth >= MAX_DEPTH) {
+                w.omitted += 1;
+                return null;
+            }
+            const nodes = [];
+            shown.forEach((item, i) => {
+                const node = walkValue(item, `${path}[${i}]`, itemLabelFor(i + 1), depth + 1, w, skip);
+                if (node)
+                    nodes.push(node);
+            });
+            return { kind: "group", path, label: label.text, dataLabel: label.data, nodes };
+        }
+        if (!isPlainObject(value))
+            return field(notShown);
+        if (depth >= MAX_DEPTH) {
+            w.omitted += 1;
+            return null;
+        }
+        return {
+            kind: "group",
+            path,
+            label: label.text,
+            dataLabel: label.data,
+            nodes: walkObject(value, path, depth + 1, w, skip),
+        };
+    };
+    const isHidden = (path) => hidden?.(path) === true;
+    // 1. The pointer's fields, on their own budget, outermost first.
+    const focused = (focus ?? []).flatMap((p) => {
+        const segments = p.split(/[.[\]]/).filter((s) => s !== "");
+        // `_` keys are internal bookkeeping: the main walk skips them, so a pointer cannot lift one either.
+        if (segments.length === 0 || segments.some((seg) => seg.startsWith("_")))
+            return [];
+        const found = lookupPath(record, p);
+        if (!found.found)
+            return [];
+        let cur = record;
+        let path = "";
+        const parts = [];
+        for (const seg of segments) {
+            if (Array.isArray(cur)) {
+                path += `[${seg}]`;
+                parts.push(itemLabelFor(Number(seg) + 1));
+            }
+            else {
+                path = path === "" ? seg : `${path}.${seg}`;
+                parts.push(labelFor(path, seg));
+            }
+            cur = cur[seg];
+        }
+        const last = parts[parts.length - 1];
+        const text = parts.map((x) => x.text).reduce((a, b) => trail(a, b));
+        return [{ path, label: { text, data: last.data }, value: found.value }];
+    });
+    const outermost = focused.filter((f, i) => !isHidden(f.path) &&
+        focused.findIndex((o) => o.path === f.path) === i &&
+        !focused.some((o) => isStrictAncestor(o.path, f.path)));
+    const focusWalk = { budget: MAX_NODES, omitted: 0 };
+    const lifted = outermost.flatMap((f) => {
+        const node = walkValue(f.value, f.path, f.label, 0, focusWalk, isHidden);
+        return node ? [node] : [];
+    });
+    // A focused field or list is kept even when empty (the agent pointed at it); a focused group keeps only what has a value.
+    const highlighted = lifted.flatMap((n) => {
+        if (n.kind !== "group")
+            return [n];
+        const inner = prune(n.nodes);
+        return inner.length > 0 ? [{ ...n, nodes: inner }] : [];
+    });
+    // 2. Everything else.
+    const focusedPaths = new Set(outermost.map((f) => f.path));
+    const mainWalk = { budget: MAX_NODES, omitted: 0 };
+    const nodes = prune(walkObject(record, "", 0, mainWalk, (path) => isHidden(path) || focusedPaths.has(path)));
+    return {
+        highlighted,
+        nodes,
+        omitted: mainWalk.omitted + focusWalk.omitted,
+        isEmpty: highlighted.length === 0 && nodes.length === 0,
+    };
+}
+/** What a value reads as: the host's text, else a word for a boolean, else the value; quoted when someone else wrote it. */
+function display(path, v, p) {
+    if (isMasked(v))
+        return v;
+    const formatted = p.formatValue?.(path, v);
+    const base = formatted !== undefined
+        ? cleanValue(formatted, MAX_TEXT)
+        : typeof v === "boolean"
+            ? v
+                ? p.copy.yes
+                : p.copy.no
+            : v;
+    return typeof base === "string" && p.isThirdParty(path) ? quoteText(base, p.copy.quote) : base;
+}
+function fieldValue(node, p, focused) {
+    if (isEmptyLeaf(node.value))
+        return focused ? p.copy.notSet : undefined;
+    return display(node.path, node.value, p);
+}
+/** A stable key per list item without using its index: the item's text, numbered when the same text repeats. */
+function keyed(items) {
+    const seen = new Map();
+    return items.map((item) => {
+        const base = isMasked(item) ? `masked:${item.display}` : String(item);
+        const n = seen.get(base) ?? 0;
+        seen.set(base, n + 1);
+        return { key: `${base}#${n}`, item };
+    });
+}
+/** The record path of the object a node sits in: `rounds[1].note` is in `rounds[1]`, a top-level key in `""`. */
+const parentPath = (path) => {
+    const i = Math.max(path.lastIndexOf("."), path.lastIndexOf("["));
+    return i <= 0 ? "" : path.slice(0, i);
+};
+/**
+ * A node's label. A label made from a key of the record is data, and inside text someone else wrote (a node strictly below a
+ * third-party path) the key is theirs too: it renders quoted, like the value. A label the host supplied is the app's own word.
+ */
+function shownLabel(n, p) {
+    return n.dataLabel && p.isThirdParty(parentPath(n.path))
+        ? quoteText(n.label, p.copy.quote)
+        : n.label;
+}
+const wide = (v) => typeof v === "string" && v.length > WIDE_TEXT;
+function Nodes({ nodes, level, focused, p, }) {
+    const flat = nodes.filter((n) => n.kind !== "group");
+    const groups = nodes.filter((n) => n.kind === "group");
+    const Heading = `h${level}`;
+    return (_jsxs(_Fragment, { children: [flat.length > 0 && (_jsx(AgentFieldGrid, { children: flat.map((n) => {
+                    if (n.kind === "list")
+                        return (_jsxs("div", { className: "col-span-2 flex min-w-0 flex-col gap-1 @sm:col-span-3", children: [_jsx("dt", { className: "text-xs/4 text-muted-foreground", children: shownLabel(n, p) }), _jsx("dd", { children: _jsx("ul", { className: "flex flex-wrap gap-2", children: keyed(n.items).map(({ key, item }) => (_jsx("li", { className: "max-w-full", children: _jsx(AgentChip, { className: "max-w-full rounded-lg text-left wrap-anywhere", children: _jsx(MaskedValue, { value: display(n.path, item, p), copy: p.maskedCopy }) }) }, key))) }) })] }, n.path));
+                    if (n.kind !== "field")
+                        return null;
+                    const value = fieldValue(n, p, focused);
+                    return (_jsx(AgentField, { label: shownLabel(n, p), value: value, wide: wide(value), maskedCopy: p.maskedCopy }, n.path));
+                }) })), groups.map((g) => (_jsxs("div", { className: "flex flex-col gap-2", children: [_jsx(Heading, { className: "text-xs/4 font-medium text-muted-foreground", children: shownLabel(g, p) }), _jsx(Nodes, { nodes: g.nodes, level: Math.min(level + 1, 6), focused: focused, p: p })] }, g.path)))] }));
+}
+/** The labelled fields of a record: the highlighted ones first, then everything else. Presentational; `buildRecordView` decides what is in it. */
+export function AgentInspectorRecord(p) {
+    const { view, copy, headingId } = p;
+    return (_jsxs(Fragment, { children: [view.highlighted.length > 0 && (_jsxs("section", { "aria-labelledby": headingId("highlighted"), className: "flex flex-col gap-2 rounded-xl bg-muted/50 p-3", children: [_jsx("h3", { id: headingId("highlighted"), className: "text-xs/4 font-medium text-muted-foreground", children: copy.highlighted }), _jsx(Nodes, { nodes: view.highlighted, level: 4, focused: true, p: p })] })), view.nodes.length > 0 && (_jsxs("section", { "aria-labelledby": headingId("details"), className: "flex flex-col gap-3", children: [_jsx("h3", { id: headingId("details"), className: "text-xs/4 font-medium text-muted-foreground", children: copy.details }), _jsx(Nodes, { nodes: view.nodes, level: 4, focused: false, p: p })] })), view.omitted > 0 && _jsx("p", { className: "text-xs/4 text-muted-foreground", children: copy.truncated })] }));
+}
+//# sourceMappingURL=inspector-record.js.map