@iota-uz/sdk 0.4.44 → 0.5.1

package/dist/lens/panels/WaterfallPlot.d.ts

@@ -0,0 +1,51 @@
+import { type ReactNode } from 'react';
+import type { WaterfallItem, WaterfallModel } from './CascadePanel';
+/** Chrome a host wraps around a single column, today: activation for a drill. */
+export type WaterfallInteraction = (item: WaterfallItem, index: number) => Record<string, unknown> | undefined;
+/**
+ * When the split band names itself. The band's own colour already says a part of
+ * the movement differs in kind; its chip answers a follow-up question — how much,
+ * and called what — and standing permanently beside the bar it spends the plot's
+ * scarcest space (the gutter the neighbouring columns print their totals in) on
+ * an answer nobody asked for yet. `hover` floats it over the column as a
+ * tooltip, the way every other panel on the board answers a pointer. A sheet of
+ * paper has no pointer, so the printed report keeps the chip standing in-plot.
+ */
+export type WaterfallSplitCallout = 'hover' | 'always';
+export interface WaterfallPlotProps {
+    model: WaterfallModel;
+    label: string;
+    interaction?: WaterfallInteraction;
+    /** A grouping role when the columns are activatable; an image otherwise. */
+    role?: 'group' | 'img';
+    /** Defaults to `hover`; a static rendering must pass `always`. */
+    splitCallout?: WaterfallSplitCallout;
+    /** The unit the ticks no longer repeat, stated once at the head of the axis. */
+    axisUnit?: string;
+    /** What activating a column does, printed at the foot of its tooltip. */
+    actionHint?: string;
+    children?: ReactNode;
+}
+export interface WaterfallTipPosition {
+    left: number;
+    top: number;
+    /** Which side of the band the tip took, so the tail can point back. */
+    side: 'above' | 'below';
+}
+/**
+ * Centres the tip over the band it explains and keeps it on screen. It prefers
+ * to sit above: the band is at the top of its bar, and below it would cover the
+ * rest of the movement it is a part of.
+ */
+export declare function positionWaterfallTip(anchor: Pick<DOMRect, 'left' | 'width' | 'top' | 'bottom'>, tip: Pick<DOMRect, 'width' | 'height'>, viewport: {
+    width: number;
+    height: number;
+}): WaterfallTipPosition;
+/**
+ * The waterfall's markup, shared by the interactive panel and the printed
+ * report. Everything positional lives in the model, so the same DOM serves a
+ * clickable dashboard column and an inert printed one — the printed report gets
+ * the real bridge instead of a table of the same numbers.
+ */
+export declare function WaterfallPlot({ model, label, interaction, role, splitCallout, axisUnit, actionHint, children, }: WaterfallPlotProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WaterfallPlot.d.ts.map

package/dist/lens/panels/WaterfallPlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterfallPlot.d.ts","sourceRoot":"","sources":["../../src/panels/WaterfallPlot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,SAAS,EAEf,MAAM,OAAO,CAAA;AAKd,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEnE,iFAAiF;AACjF,MAAM,MAAM,oBAAoB,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;AAE9G;;;;;;;;GAQG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEtD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,cAAc,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,oBAAoB,CAAA;IAClC,4EAA4E;IAC5E,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;IACtB,kEAAkE;IAClE,YAAY,CAAC,EAAE,qBAAqB,CAAA;IACpC,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB;AAKD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,uEAAuE;IACvE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;CACxB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC,EAC1D,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,EACtC,QAAQ,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1C,oBAAoB,CAUtB;AAkPD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,KAAK,EACL,WAAW,EACX,IAAY,EACZ,YAAsB,EACtB,QAAQ,EACR,UAAU,EACV,QAAQ,GACT,EAAE,kBAAkB,2CAwDpB"}

package/dist/lens/panels/actions.d.ts

@@ -0,0 +1,75 @@
+import { type FocusEventHandler, type MouseEventHandler, type PointerEventHandler } from 'react';
+import type { Action, Frame, Panel } from '../contract';
+export interface PrefetchHandlers {
+    onPointerEnter: PointerEventHandler;
+    onPointerLeave: PointerEventHandler;
+    onFocus: FocusEventHandler;
+    onBlur: FocusEventHandler;
+}
+/**
+ * Bounded idle plus hover/focus prefetch for a stat drawer target. The idle
+ * registration supplies the automatic first-level warm-up; concrete intent
+ * promotes the same target after a short cancellable dwell.
+ */
+export declare function usePrefetch(url: string | undefined, action: Action | undefined, prefetchIdle?: (urls: ReadonlyArray<string>) => () => void): PrefetchHandlers | undefined;
+/**
+ * Panel-level navigation.
+ *
+ * A panel-level navigate action makes a whole stat / segment-bar card a link
+ * and makes chart data points navigate. The wire keeps that action in
+ * `panel.actions` as kind `navigate`.
+ */
+export declare function panelNavigateAction(panel: Panel): Action | undefined;
+/**
+ * True when the action's URL depends on the row it is resolved against — the
+ * rule used to decide between one card-wide link and one link per segment.
+ */
+export declare function isRowScoped(action: Action): boolean;
+export interface PanelNavigation {
+    action?: Action;
+    rowScoped: boolean;
+    /** URL for one row of the panel's frame, or undefined when it cannot resolve. */
+    urlForRow: (frame: Frame | undefined, row: Array<unknown> | undefined) => string | undefined;
+    /** URL for the panel as a whole: the first row's, when the action is not row-scoped. */
+    cardURL: (frame: Frame | undefined) => string | undefined;
+    onClick: (url: string | undefined) => MouseEventHandler<HTMLAnchorElement> | undefined;
+    activate: (url: string | undefined, opener?: HTMLElement, options?: {
+        newTab?: boolean;
+    }) => void;
+    /** Promote a concrete drawer target on pointer/focus intent. */
+    prefetch: (url: string | undefined) => () => void;
+    /** Register low-cardinality targets in the runtime's one-slot idle queue. */
+    prefetchIdle: (urls: ReadonlyArray<string>) => () => void;
+}
+/**
+ * An element-level action resolved to an interactive descriptor.
+ *
+ * Unlike {@link usePanelNavigation}, which owns the single panel-wide navigate
+ * action, metric panels attach an action to each stage / row / end. The resolver
+ * is a stable function (one drawer subscription) so it can be applied across a
+ * list of elements without a hook per element.
+ */
+export interface ElementActionTarget {
+    href: string;
+    onClick?: MouseEventHandler<HTMLAnchorElement>;
+    opensDrawer: boolean;
+}
+/**
+ * Returns a resolver that turns an element's `Action` into an anchor descriptor,
+ * or `undefined` when the action carries no navigable URL (e.g. an emit-only
+ * action) or a drawer action is unavailable at the current depth. Element
+ * actions resolve literal/variable params only in v1; `fields` is accepted for
+ * forward compatibility with per-element field resolution.
+ */
+export declare function useElementActionResolver(): (action: Action | undefined, fields?: Readonly<Record<string, unknown>>) => ElementActionTarget | undefined;
+export declare function useActionActivation(action: Action | undefined): {
+    activate: (url: string | undefined, opener?: HTMLElement, options?: {
+        newTab?: boolean;
+    }) => void;
+    available: boolean;
+    onClick: (url: string | undefined) => MouseEventHandler<HTMLAnchorElement> | undefined;
+    prefetch: (url: string | undefined) => () => void;
+    prefetchIdle: (urls: ReadonlyArray<string>) => () => void;
+};
+export declare function usePanelNavigation(panel: Panel): PanelNavigation;
+//# sourceMappingURL=actions.d.ts.map

package/dist/lens/panels/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/panels/actions.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,KAAK,mBAAmB,EAAE,MAAM,OAAO,CAAA;AACzI,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AASvD,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,mBAAmB,CAAA;IACnC,cAAc,EAAE,mBAAmB,CAAA;IACnC,OAAO,EAAE,iBAAiB,CAAA;IAC1B,MAAM,EAAE,iBAAiB,CAAA;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,IAAI,GACzD,gBAAgB,GAAG,SAAS,CA0B9B;AAED;;;;;;GAMG;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAOpE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAInD;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;IAClB,iFAAiF;IACjF,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,CAAA;IAC5F,wFAAwF;IACxF,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,CAAA;IACzD,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,KAAK,iBAAiB,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAA;IACtF,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACjG,gEAAgE;IAChE,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,IAAI,CAAA;IACjD,6EAA6E;IAC7E,YAAY,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,IAAI,CAAA;CAC1D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;IAC9C,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,mBAAmB,GAAG,SAAS,CAuBtJ;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;oBAiCzB,MAAM,GAAG,SAAS,WAAW,WAAW,YAAY;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE;;mBAUzE,MAAM,GAAG,SAAS,KAAG,iBAAiB,CAAC,iBAAiB,CAAC,GAAG,SAAS;oBA5BpE,MAAM,GAAG,SAAS;yBAUb,aAAa,CAAC,MAAM,CAAC;EA4B9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAqChE"}

package/dist/lens/panels/context.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+import type { NodeKey } from '../contract';
+import type { ChartAnchor } from '../charts/adapter';
+/**
+ * Chrome a host (today: the explore panel) injects into the panel header, so
+ * a drill trail and an explore affordance live in the card's own header
+ * instead of adding rows around the card.
+ */
+export interface PanelChrome {
+    trail?: ReactNode;
+    explore?: ReactNode;
+    /**
+     * The panel's name is already on screen, so its own header must not repeat
+     * it. Set by a tab group whose active tab label names the single panel
+     * inside it: two borders, two radii, two header bars and «ЕЖЕДНЕВНЫЙ ДОХОД»
+     * over «ДОХОД» forty pixels apart, all saying one thing. The card keeps its
+     * header — export, expand and the ⓘ live there — and loses the duplicate
+     * line; the accessible name comes from the section's own aria-label.
+     */
+    titleIsRedundant?: boolean;
+}
+export declare const PanelChromeContext: import("react").Context<PanelChrome | undefined>;
+export declare function usePanelChrome(): PanelChrome | undefined;
+/**
+ * When a host handles mark activation itself, a chart reports the mark and
+ * where it was clicked instead of drilling. Without a host the chart keeps
+ * its direct drill behavior.
+ */
+export type MarkSelectionHandler = (key: NodeKey, anchor?: ChartAnchor) => void;
+export declare const MarkSelectionContext: import("react").Context<MarkSelectionHandler | undefined>;
+export declare function useMarkSelection(): MarkSelectionHandler | undefined;
+//# sourceMappingURL=context.d.ts.map

package/dist/lens/panels/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/panels/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED,eAAO,MAAM,kBAAkB,kDAAoD,CAAA;AAEnF,wBAAgB,cAAc,IAAI,WAAW,GAAG,SAAS,CAExD;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,IAAI,CAAA;AAE/E,eAAO,MAAM,oBAAoB,2DAA6D,CAAA;AAE9F,wBAAgB,gBAAgB,IAAI,oBAAoB,GAAG,SAAS,CAEnE"}

package/dist/lens/panels/data.d.ts

@@ -0,0 +1,95 @@
+import type { Availability, Confidence, Encoding, Frame, Panel, Theme } from '../contract';
+/**
+ * Resolves a datum's color the way the chart adapter does, so a React-rendered
+ * legend cannot disagree with the plot: the panel's own `panelId:index` series
+ * entry first, then a series entry keyed by label, then the palette order, then
+ * the panel accent.
+ *
+ * `positional: false` drops the `panelId:index` entry. That entry pins a color
+ * to the n-th row of the panel's *own* frame, so once the panel is showing a
+ * drill level it describes rows that are no longer on screen — the legend was
+ * printing the root's second color next to the level's second slice, which the
+ * plot (which only ever resolves by label) had drawn in a different color.
+ */
+export declare function seriesColorResolver(theme: Theme, panel: Panel, { positional, labels }?: {
+    positional?: boolean;
+    labels?: readonly string[];
+}): (label: string, index: number) => string | undefined;
+/**
+ * Resolves the colour of one frame *row*: the served frame's own positional
+ * palette first, then a series entry keyed by the row's id, then everything
+ * `seriesColorResolver` knows.
+ *
+ * A drill level ships its palette on the frame rather than on the panel — the
+ * aggregation that just ran is the only thing that knows which of its rows is
+ * the collapsed remainder and owes the neutral. The plot read that palette and
+ * the legend did not, so a level drew an arc in one colour and printed another
+ * in the swatch beside it. Both sides come through here now, each handed the
+ * frame it is actually drawing: the plot the visible rows, the legend all of
+ * them, so a hidden entry cannot slide the palette off its rows either.
+ */
+export declare function rowColorResolver(theme: Theme, panel: Panel, { colors, positional, labels }?: {
+    colors?: readonly string[];
+    positional?: boolean;
+    labels?: readonly string[];
+}): (label: string, index: number, nodeKey?: string) => string | undefined;
+/**
+ * The labels this panel will colour, in the frame's own order.
+ *
+ * The palette de-collides across this list, so it has to be the *whole* frame
+ * rather than the visible part: built from the visible rows, hiding one entry
+ * would free its slot and recolour a neighbour, and the plot and the legend —
+ * which are handed different row sets on purpose — would disagree.
+ */
+export declare function colorLabels(frame: Frame | undefined, panel: Panel): string[];
+export declare function columnIndex(frame: Frame | undefined, field: string | undefined): number;
+export declare function cell(frame: Frame | undefined, field: string | undefined, row?: number): unknown;
+export declare function displayText(value: unknown, fallback: string): string;
+export declare const encodingRoles: ReadonlyArray<keyof Encoding>;
+export declare function panelField(panel: Panel, role: keyof Encoding): string | undefined;
+/** A single element's resolved numeric value, or an explicit unavailable slot. */
+export type ResolvedNumber = {
+    kind: 'value';
+    value: number;
+} | {
+    kind: 'unavailable';
+};
+/** Everything the frame contributes for one structural element. */
+export interface ResolvedElement {
+    value: ResolvedNumber;
+    /** Optional producer-supplied share, already a display magnitude. */
+    share?: number;
+    /** Frame override of the element's structural confidence. */
+    confidence?: Confidence;
+    /** Frame override of the element's structural availability. */
+    availability?: Availability;
+}
+/**
+ * The frame either yields a deterministic resolver keyed by element key, or the
+ * panel is mis-contracted (a configured column is absent, or a key is
+ * duplicated) and must be surfaced as a panel-level error — never as a
+ * per-element unavailable, which would hide a wiring mistake behind a plausible
+ * business state.
+ */
+export type KeyedJoin = {
+    kind: 'ok';
+    resolve: (key: string) => ResolvedElement;
+} | {
+    kind: 'contract-error';
+    message: string;
+};
+export interface KeyedJoinMessages {
+    /** A configured column is not present in the frame. */
+    missingColumn: (column: string) => string;
+    /** Two frame rows resolve to the same key. */
+    duplicateKey: (key: string) => string;
+}
+/**
+ * Builds the keyed join for a metric panel.
+ *
+ * An empty frame (no rows) is not a contract error: the declared structure
+ * renders with every element `unavailable`, which the panels present as their
+ * "empty structure" state — deliberately distinct from the loading skeleton.
+ */
+export declare function buildKeyedJoin(panel: Panel, frame: Frame, messages: KeyedJoinMessages): KeyedJoin;
+//# sourceMappingURL=data.d.ts.map

package/dist/lens/panels/data.d.ts.map

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

package/dist/lens/panels/kinds.d.ts

@@ -0,0 +1,4 @@
+import { type Panel, type PanelKind } from '../contract';
+/** Re-project a panel into another renderer kind without leaking old props. */
+export declare function retargetPanel(panel: Panel, kind: PanelKind): Panel;
+//# sourceMappingURL=kinds.d.ts.map

package/dist/lens/panels/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../src/panels/kinds.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAA;AAIlF,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,KAAK,CAOlE"}

package/dist/lens/panels/metricViews.d.ts

@@ -0,0 +1,79 @@
+import type { Availability, Confidence, MetricFlowStage, MetricFlowStageRole, MetricHierarchyRow, MetricRelationshipConfig, MetricRelationshipEnd, Panel } from '../contract';
+import type { KeyedJoin, ResolvedElement } from './data';
+/** A stage's signed contribution to the reconciliation sum (grammar, not display). */
+export declare function contribution(role: MetricFlowStageRole, value: number): number;
+export interface ElementQuality {
+    confidence?: Confidence;
+    availability?: Availability;
+    /** The value slot shows an em dash rather than a number. */
+    showDash: boolean;
+}
+/**
+ * Quality of one resolved element, with the locked precedence: the frame
+ * overrides the structural declaration, and a value that cannot exist is at
+ * least "unavailable" — a more specific producer status survives.
+ */
+export declare function elementQuality(element: ResolvedElement, structural: {
+    confidence?: Confidence;
+    availability?: Availability;
+}, panel: Panel): ElementQuality;
+export interface FlowStageView extends ElementQuality {
+    stage: MetricFlowStage;
+    role: MetricFlowStageRole;
+    /** Rendered operator glyph, or '' for an input stage. */
+    operator: string;
+    /** Formatted magnitude: unsigned under an operator, signed otherwise. */
+    text: string;
+}
+/**
+ * The formula, stage by stage. An absent amount must not rewrite the declared
+ * grammar: an `add` stage keeps its `+` and a `subtract` stage its `−`, because
+ * sign normalization only applies to a value that is actually shown.
+ */
+export declare function flowStageViews(panel: Panel, join: KeyedJoin, formatValue: (value: number) => string): Array<FlowStageView>;
+/**
+ * How far the declared result stands from the sum of its operands, or nothing
+ * when the flow declares no reconciliation, balances inside its tolerance, or
+ * carries an unresolved operand — an incomplete sum would report a discrepancy
+ * that does not exist.
+ */
+export declare function flowReconcileDelta(panel: Panel, join: KeyedJoin): number | undefined;
+export interface HierarchyRowView extends ElementQuality {
+    row: MetricHierarchyRow;
+    depth: number;
+    isParent: boolean;
+    valueText: string;
+    shareText?: string;
+    /** Whole-to-parts check for a parent row: balanced, or off by this much. */
+    reconcile?: {
+        balanced: boolean;
+        delta: number;
+    };
+}
+/**
+ * The hierarchy, row by row. `parent` is authoritative for depth; the wire may
+ * carry a derived `depth`, and a detached parent reference must not send the
+ * walk running.
+ */
+export declare function hierarchyRowViews(panel: Panel, join: KeyedJoin, formatValue: (value: number) => string, formatShare: (value: number) => string): Array<HierarchyRowView>;
+export interface RelationshipEndView extends ElementQuality {
+    end: MetricRelationshipEnd;
+    valueText: string;
+}
+export declare function relationshipEndView(panel: Panel, join: KeyedJoin | undefined, end: MetricRelationshipEnd | undefined, formatValue: (value: number) => string): RelationshipEndView | undefined;
+export declare const relationshipTypeFallback: Record<MetricRelationshipConfig['type'], string>;
+export interface RelationshipGlyphs {
+    horizontal: string;
+    vertical: string;
+}
+/**
+ * Association and reconciliation are symmetric by nature — a neutral
+ * double-headed connector that never implies containment or derivation.
+ */
+export declare function connectorGlyphs(config: MetricRelationshipConfig): RelationshipGlyphs;
+/** The two ends in the order the relationship's own sentence names them. */
+export declare function relationshipOperands(config: MetricRelationshipConfig | undefined, source: string, target: string): {
+    source: string;
+    target: string;
+};
+//# sourceMappingURL=metricViews.d.ts.map

package/dist/lens/panels/metricViews.d.ts.map

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

package/dist/lens/panels/registry.d.ts

@@ -0,0 +1,45 @@
+import { type ComponentType } from 'react';
+import type { Panel, PanelKind } from '../contract';
+import type { CascadePanelProps } from './CascadePanel';
+import type { CoveragePanelProps } from './CoveragePanel';
+import type { GaugePanelProps } from './GaugePanel';
+import type { ChartPanelProps } from './ChartPanel';
+import type { MetricFlowPanelProps } from './MetricFlowPanel';
+import type { MetricHierarchyPanelProps } from './MetricHierarchyPanel';
+import type { MetricRelationshipPanelProps } from './MetricRelationshipPanel';
+import type { MapPanelProps } from './MapPanel';
+import { StatPanel, type StatPanelProps } from './StatPanel';
+import type { TablePanelProps } from './TablePanel';
+export type PanelComponent = ComponentType<StatPanelProps | ChartPanelProps | CascadePanelProps | TablePanelProps | CoveragePanelProps | GaugePanelProps | MetricFlowPanelProps | MetricHierarchyPanelProps | MetricRelationshipPanelProps | MapPanelProps>;
+export type PanelRegistry = Partial<Record<PanelKind, PanelComponent>>;
+export declare const SUPPORTED: {
+    stat: typeof StatPanel;
+    pie: import("react").FunctionComponent<ChartPanelProps>;
+    donut: import("react").FunctionComponent<ChartPanelProps>;
+    radial: import("react").FunctionComponent<ChartPanelProps>;
+    bar: import("react").FunctionComponent<ChartPanelProps>;
+    hbar: import("react").FunctionComponent<ChartPanelProps>;
+    line: import("react").FunctionComponent<ChartPanelProps>;
+    area: import("react").FunctionComponent<ChartPanelProps>;
+    cascade: import("react").FunctionComponent<CascadePanelProps>;
+    table: import("react").FunctionComponent<TablePanelProps>;
+    coverage: import("react").FunctionComponent<CoveragePanelProps>;
+    gauge: import("react").FunctionComponent<GaugePanelProps>;
+    histogram: import("react").FunctionComponent<ChartPanelProps>;
+    boxplot: import("react").FunctionComponent<ChartPanelProps>;
+    heatmap: import("react").FunctionComponent<ChartPanelProps>;
+    map: import("react").FunctionComponent<MapPanelProps>;
+    metric_flow: import("react").FunctionComponent<MetricFlowPanelProps>;
+    metric_hierarchy: import("react").FunctionComponent<MetricHierarchyPanelProps>;
+    metric_relationship: import("react").FunctionComponent<MetricRelationshipPanelProps>;
+};
+export declare const panelRegistry: PanelRegistry;
+export interface RegisteredPanelProps {
+    panel: Panel;
+    registry?: PanelRegistry;
+}
+export declare function UnsupportedPanel({ panel }: {
+    panel: Panel;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function RegisteredPanel({ panel, registry }: RegisteredPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lens/panels/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/panels/registry.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,aAAa,EAAkC,MAAM,OAAO,CAAA;AACrG,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAA;AACvE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAcnD,MAAM,MAAM,cAAc,GAAG,aAAa,CACtC,cAAc,GACd,eAAe,GACf,iBAAiB,GACjB,eAAe,GACf,kBAAkB,GAClB,eAAe,GACf,oBAAoB,GACpB,yBAAyB,GACzB,4BAA4B,GAC5B,aAAa,CAChB,CAAA;AACD,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAA;AAEtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;CAoBuB,CAAA;AAE7C,eAAO,MAAM,aAAa,EAAE,aAAyB,CAAA;AAErD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,KAAK,CAAA;IACZ,QAAQ,CAAC,EAAE,aAAa,CAAA;CACzB;AAED,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,2CAU3D;AAED,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,QAAwB,EAAE,EAAE,oBAAoB,2CAcxF"}

package/dist/lens/panels/useIsClamped.d.ts

@@ -0,0 +1,16 @@
+import { type RefObject } from 'react';
+/**
+ * Whether an element's own box is hiding some of its text.
+ *
+ * Two callers, one question, and it is a question about the rendered box rather
+ * than about the string — a name that fits at 1400px is cut at 900px, and the
+ * clamp that cuts it is a CSS rule nothing in the tree can read.
+ *
+ * The note behind a metric strip's ⓘ exists to carry what the reader cannot
+ * otherwise read, so a caption printed in full two lines below joins it only
+ * when the two-line slot actually cut it. A waterfall's column name asks the
+ * same thing of its native tooltip: the tooltip is the full name behind a clamp,
+ * so where there is no clamp there is nothing for it to say.
+ */
+export declare function useIsClamped(target: RefObject<HTMLElement | null>): boolean;
+//# sourceMappingURL=useIsClamped.d.ts.map

package/dist/lens/panels/useIsClamped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsClamped.d.ts","sourceRoot":"","sources":["../../src/panels/useIsClamped.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAE3D;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,OAAO,CAa3E"}

package/dist/lens/panels/useMenuButton.d.ts

@@ -0,0 +1,68 @@
+import { type CSSProperties, type KeyboardEvent as ReactKeyboardEvent } from 'react';
+export interface MenuPlacement {
+    /** Which side of the trigger the menu opens on. */
+    side: 'up' | 'down';
+    /** Which of the menu's edges is flush with the trigger's. */
+    align: 'start' | 'end';
+}
+/**
+ * Where a menu of this size fits, given its trigger.
+ *
+ * A menu is bound to its trigger and to the viewport, and the two can disagree:
+ * a panel menu opened low on the page ran «Vector (SVG)» below the fold, and a
+ * page-level menu wider than its trigger read as detached because neither edge
+ * lined up with anything. The preferred alignment is the trigger's leading
+ * edge, which is where the eye already is; it flips only when the menu would
+ * leave the viewport, and the menu drops upward only when it does not fit
+ * below and does fit above.
+ */
+export declare function menuPlacement(trigger: Pick<DOMRect, 'left' | 'right' | 'top' | 'bottom'>, menu: Pick<DOMRect, 'width' | 'height'>, viewport: {
+    width: number;
+    height: number;
+}, preferred: MenuPlacement['align']): MenuPlacement;
+/**
+ * How far the aligned menu has to slide to stay on screen.
+ *
+ * Alignment alone cannot always answer the question: a menu wider than the
+ * distance from its trigger to either edge fits neither way, and the flush edge
+ * then hangs off the viewport — a 551px filter menu whose trigger's right edge
+ * sits at 500px opened at x = −51. The shift is the last step of the same rule,
+ * so a menu is bound to its trigger *and* to the viewport instead of one or the
+ * other.
+ */
+export declare function menuShift(trigger: Pick<DOMRect, 'left' | 'right'>, menu: Pick<DOMRect, 'width'>, viewport: {
+    width: number;
+}, align: MenuPlacement['align']): number;
+/** Where the menu is drawn, in viewport coordinates. */
+export interface MenuOffset {
+    left: number;
+    top: number;
+}
+/**
+ * Where the placed menu's own box starts.
+ *
+ * The menu is drawn in a body portal, so the answer has to be absolute rather
+ * than «flush with whichever edge of my offset parent». It is the same rule the
+ * flow-anchored version expressed in CSS — flush with the aligned edge, nudged
+ * by the viewport shift, gapped from the trigger — just resolved to numbers.
+ */
+export declare function menuOffset(trigger: Pick<DOMRect, 'left' | 'right' | 'top' | 'bottom'>, menu: Pick<DOMRect, 'width' | 'height'>, placement: MenuPlacement, shift: number): MenuOffset;
+/** Shared focus, dismissal, placement, and arrow navigation for Lens menu buttons. */
+export declare function useMenuButton(preferredAlign?: MenuPlacement['align']): {
+    close: () => void;
+    closeAndFocusTrigger: () => void;
+    container: import("react").RefObject<HTMLDivElement>;
+    itemRef: (key: string) => (element: HTMLButtonElement | null) => void;
+    menu: import("react").RefObject<HTMLDivElement>;
+    menuPlacementProps: {
+        'data-align': "start" | "end";
+        'data-side': "up" | "down";
+        style: CSSProperties;
+    };
+    onMenuKeyDown: (event: ReactKeyboardEvent) => void;
+    open: boolean;
+    overlay: HTMLElement | undefined;
+    setOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    trigger: import("react").RefObject<HTMLButtonElement>;
+};
+//# sourceMappingURL=useMenuButton.d.ts.map

package/dist/lens/panels/useMenuButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMenuButton.d.ts","sourceRoot":"","sources":["../../src/panels/useMenuButton.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAAE,KAAK,aAAa,IAAI,kBAAkB,EAC7D,MAAM,OAAO,CAAA;AAGd,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,IAAI,EAAE,IAAI,GAAG,MAAM,CAAA;IACnB,6DAA6D;IAC7D,KAAK,EAAE,OAAO,GAAG,KAAK,CAAA;CACvB;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC,EAC3D,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,EACvC,QAAQ,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC3C,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,GAChC,aAAa,CASf;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,EACxC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAC5B,QAAQ,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAC3B,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAC5B,MAAM,CAMR;AAED,wDAAwD;AACxD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC,EAC3D,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,EACvC,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,MAAM,GACZ,UAAU,CAMZ;AAED,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,cAAc,GAAE,aAAa,CAAC,OAAO,CAAS;;;;mBA4FxC,MAAM,eAAe,iBAAiB,GAAG,IAAI;;;;;eAsCtE,aAAa;;2BAlCoB,kBAAkB;;;;;EA0C7D"}

package/dist/lens/prefetch-Dov5CBoH.js

@@ -0,0 +1,74 @@
+var n = Object.defineProperty;
+var o = (h, e, t) => e in h ? n(h, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[e] = t;
+var c = (h, e, t) => o(h, typeof e != "symbol" ? e + "" : e, t);
+import { i as f } from "./index-C45DAO6w.js";
+class g {
+  constructor(e = {}) {
+    c(this, "capacity");
+    // Insertion order is age order, so the first key is always the oldest.
+    c(this, "entries", /* @__PURE__ */ new Map());
+    c(this, "inflight", /* @__PURE__ */ new Map());
+    c(this, "fetcher");
+    c(this, "csrf");
+    this.capacity = Math.max(1, Math.floor(e.capacity ?? 8)), this.fetcher = e.fetcher, this.csrf = e.csrf;
+  }
+  /** Update the credentials used by later prefetches without dropping entries. */
+  configure(e) {
+    this.fetcher = e.fetcher, this.csrf = e.csrf;
+  }
+  /** The cached document for a URL, or undefined on a miss. */
+  get(e) {
+    return this.entries.get(e);
+  }
+  /**
+   * Load a document through the shared cache/singleflight path.
+   *
+   * Unlike prefetch(), failures stay visible to the interactive caller. If a
+   * speculative request is already running, opening the drawer promotes the
+   * same server calculation through a separate activation request.
+   */
+  load(e) {
+    const t = this.entries.get(e);
+    if (t) return Promise.resolve(t);
+    const s = this.inflight.get(e);
+    if (s && !s.speculative) return s.promise;
+    const i = f(e, { fetcher: this.fetcher, csrf: this.csrf }).then((r) => (this.store(e, r), r)).finally(() => {
+      var r;
+      ((r = this.inflight.get(e)) == null ? void 0 : r.promise) === i && this.inflight.delete(e);
+    });
+    return this.inflight.set(e, { promise: i, speculative: !1 }), i;
+  }
+  /**
+   * Warm a URL. Resolves once the fetch settles; a failure resolves (never
+   * rejects) so a prefetch can never surface an error to the caller. A URL that
+   * is already cached or already in flight is not fetched again.
+   */
+  prefetch(e, t) {
+    if (this.entries.has(e) || this.inflight.has(e)) return Promise.resolve();
+    const s = f(e, { fetcher: this.fetcher, csrf: this.csrf, prefetch: !0, signal: t }).then(async (i) => {
+      if (!i.endpoints.panel || t != null && t.aborted) return i;
+      const { prefetchDocumentFirstRow: r } = await import("./prefetchPanels-B7bIY0bM.js");
+      return r(i, {
+        csrf: this.csrf,
+        fetcher: this.fetcher,
+        signal: t
+      });
+    }).then((i) => (this.store(e, i), i)).finally(() => {
+      var i;
+      ((i = this.inflight.get(e)) == null ? void 0 : i.promise) === s && this.inflight.delete(e);
+    });
+    return this.inflight.set(e, { promise: s, speculative: !0 }), s.then(() => {
+    }, () => {
+    });
+  }
+  store(e, t) {
+    for (this.entries.delete(e), this.entries.set(e, t); this.entries.size > this.capacity; ) {
+      const s = this.entries.keys().next().value;
+      if (s === void 0) break;
+      this.entries.delete(s);
+    }
+  }
+}
+export {
+  g as DocumentCache
+};

package/dist/lens/prefetchPanels-B7bIY0bM.js

@@ -0,0 +1,31 @@
+import { am as w } from "./index-C45DAO6w.js";
+async function m(e, n) {
+  var d;
+  const l = e.endpoints.panel, o = e.layout.rows.find(({ panels: a }) => a.length > 0);
+  if (!l || !o || (d = n.signal) != null && d.aborted) return e;
+  const h = new Set(o.panels.map(({ panelId: a }) => a)), f = e.panels.filter(({ id: a, deferred: t }) => t === !0 && h.has(a));
+  if (f.length === 0) return e;
+  const c = new w(l, { csrf: n.csrf, fetcher: n.fetcher, prefetch: !0 });
+  try {
+    const a = await c.loadBatch(f.map(({ id: s }) => ({
+      snapshotId: e.snapshotId,
+      panelId: s
+    })), { signal: n.signal }), t = { ...e.frames }, i = /* @__PURE__ */ new Set();
+    for (const s of f) {
+      const r = a[s.id];
+      if (!(r != null && r.frames) || r.error) continue;
+      const p = r.frames[s.frame] ?? Object.values(r.frames)[0];
+      p && (t[s.frame] = p, i.add(s.id));
+    }
+    return i.size === 0 ? e : {
+      ...e,
+      frames: t,
+      panels: e.panels.map((s) => i.has(s.id) ? { ...s, deferred: !1 } : s)
+    };
+  } finally {
+    c.dispose();
+  }
+}
+export {
+  m as prefetchDocumentFirstRow
+};

package/dist/lens/print/PrintReport.d.ts

@@ -0,0 +1,12 @@
+import type { PrintReport as PrintReportModel } from '../runtime/print';
+/**
+ * The printed document itself, driven by a report rather than by runtime state,
+ * so a story and a visual-regression run can render exactly what a printer
+ * would receive. `PrintReport` is the same document wired to the live print
+ * state.
+ */
+export declare function PrintReportView({ report }: {
+    report: PrintReportModel;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function PrintReport(): import("react").ReactPortal | null;
+//# sourceMappingURL=PrintReport.d.ts.map