@sheetxl/query 0.7.23-beta.1

package/types/src/markdown/renderMovable.d.ts

@@ -0,0 +1,35 @@
+import { IMovable } from '@sheetxl/sdk';
+import { MarkdownBuilder } from './MarkdownBuilder';
+/**
+ * `## Movables (3)` over `  C3:F12  chart  Chart 1 — column` rows — the pictures, charts, shapes
+ * and slicers floating over the report's range.
+ *
+ * @remarks
+ * **The one class of sheet content that appears in no other section.** Everything else these
+ * reports describe lives in cells and is reachable by address; a movable floats over the grid and
+ * is invisible to every values, region and rule listing — so without this section a report about
+ * a dashboard sheet says the sheet is nearly empty, which is true of its cells and false of what
+ * anyone looking at it sees.
+ *
+ * Rows are `anchor · type · prose`, and both leading columns are arguments rather than labels: the
+ * address is what `getRange()` takes, and the type is exactly what `getMovables({ type })` filters
+ * on — the filter compares this same string.
+ *
+ * Listed in z-order, which is the order the collection returns them in and the order they paint,
+ * so where two movables overlap the later row is the one on top. Hidden movables are listed and
+ * marked; they are the ones a reader cannot otherwise learn about.
+ */
+export declare function appendMovables(md: MarkdownBuilder, movables: readonly IMovable[]): void;
+/**
+ * Renders one movable's report — what it is, where it is anchored, and whether anyone can see it.
+ *
+ * @remarks
+ * The listing carries the identity; this adds what does not fit on a row: the pixel bounds, the
+ * anchor behavior that decides what an insert does to this object, and the display note in full.
+ *
+ * **A movable has no name-based lookup**, so unlike a table this report leads with the anchor —
+ * the address is how a reader gets back to it (`range.getMovables()`), and the name is the first
+ * fact rather than the title.
+ */
+export declare function renderMovable(movable: IMovable): string;
+//# sourceMappingURL=renderMovable.d.ts.map

package/types/src/markdown/renderMovable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderMovable.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderMovable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAsIpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,CA4BvF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAiCvD"}

package/types/src/markdown/renderNames.d.ts

@@ -0,0 +1,32 @@
+import { INamedCollection } from '@sheetxl/sdk';
+import { AppendNamesOptions } from './appendSections';
+/**
+ * Options for {@link renderNames}.
+ */
+export interface RenderNamesOptions extends AppendNamesOptions {
+}
+/**
+ * Renders the name manager — every named item in the collection, grouped by kind.
+ *
+ * @remarks
+ * **The standalone form of the roster, and the one place grouping by kind is right.** The workbook
+ * report carries a single defined-name section, deliberately unsplit: its job is triage, and a
+ * triage sort is only worth anything as one ordered reading. This report has the opposite job —
+ * "what exists, and what is it" — and a reader here has already chosen to look at names rather
+ * than at the book. So the split lands here and nowhere else.
+ *
+ * **What it holds is decided by where the collection came from.** `wb.getNames()` is every named
+ * item at any scope; `sheet.getNames()` is what is visible FROM that sheet, with shadowing already
+ * resolved. Both render through this entry unchanged — the scope question was answered by the call
+ * that produced the collection, which is exactly why there is no scope option here to get wrong.
+ *
+ * Hidden names are included. Existing never hides (the same house rule that puts hidden sheets in
+ * the workbook roster), and this is the report that has to be complete: a hidden broken name with
+ * dependents is precisely the row a debugging agent must see, and the triage sort surfaces it.
+ *
+ * Synchronous, like every renderer: the dependents column is read off COMPILED formulas, so the
+ * caller settles the engine first — `renderMarkdown` settles its workbook argument before
+ * dispatching here.
+ */
+export declare function renderNames(names: INamedCollection, options?: RenderNamesOptions): string;
+//# sourceMappingURL=renderNames.d.ts.map

package/types/src/markdown/renderNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderNames.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderNames.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EAAe,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGxE;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;CAAG;AAmBjE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,MAAM,CA8BR"}

package/types/src/markdown/renderRanges.d.ts

@@ -0,0 +1,33 @@
+import { ICellRanges } from '@sheetxl/sdk';
+/**
+ * Options for {@link renderRanges}.
+ */
+export interface RenderRangesOptions {
+    /**
+     * Cap on listed ranges; the report notes truncation when exceeded.
+     *
+     * @defaultValue 100
+     */
+    maxRanges?: number;
+}
+/**
+ * Renders an {@link ICellRanges} — the discontiguous collection the calculation graph answers with.
+ *
+ * @remarks
+ * **The flat half of the dependency graph.** `getPrecedents()` / `getDependents()` and their
+ * `getDirect*` twins all return this, on cells, ranges and defined names alike, and the flat list is
+ * what a tree branch cut at the depth bound is recovered with. So it prints the tree's rows without
+ * the hop structure — same label, same payload, through {@link describeNodeLabel} and
+ * {@link describeNode} — and a reader comparing the two shapes is comparing the same text.
+ *
+ * **Qualification is the tree's rule.** A collection standing on one sheet names it once, in the
+ * heading, and leaves its rows bare; one that spans sheets qualifies every row instead, because an
+ * unqualified address below a crossing reads as the sheet the report is about. Name members carry a
+ * name rather than an address, so they are never qualified and never the reason the rest is.
+ *
+ * **An empty collection renders as `(0)` and `none`.** The graph calls return `null` rather than an
+ * empty collection, which the run layer already summarizes — but a producer that hands back an empty
+ * one must not fall through to "no renderer", which reads as a broken report rather than an answer.
+ */
+export declare function renderRanges(ranges: ICellRanges, options?: RenderRangesOptions): string;
+//# sourceMappingURL=renderRanges.d.ts.map

package/types/src/markdown/renderRanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderRanges.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderRanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAMhD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CA0CvF"}

package/types/src/markdown/renderRecords.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Options for {@link renderRecords}.
+ */
+export interface RenderRecordsOptions {
+    /**
+     * Cap on rendered cells; the report notes truncation when exceeded.
+     *
+     * @defaultValue 1000
+     */
+    maxCells?: number;
+}
+/**
+ * Whether a value is a *plain* object — an object literal or a `JSON.parse` result, nothing else.
+ *
+ * @remarks
+ * The prototype test is what keeps this renderer away from everything it has no business rendering.
+ * Every SDK object is a class instance, so its prototype is never `Object.prototype`; it therefore
+ * cannot match here even if its brand were somehow missing, and it keeps the one-line summary that
+ * an opaque object deserves. What is left is exactly the data a script *built* — which is the case
+ * this renderer exists for.
+ */
+export declare const isPlainRecord: (target: unknown) => target is Record<string, unknown>;
+/**
+ * Renders plain records — an array of object literals, or a single one — as a table.
+ *
+ * @remarks
+ * An array of records is the shape a script *builds*: `sheets.map(s => ({ name: …, rows: … }))`.
+ * It is data the author composed deliberately, not an SDK object's internals, so the reasoning that
+ * makes a one-line summary right for an opaque object is exactly backwards here — the structure IS
+ * the answer, and the reader asked for it. Rendered as a table rather than dumped as JSON because
+ * uniform keys are columns, and a column is what makes a set of records scannable.
+ *
+ * Columns are the union of every shown record's keys in first-seen order, so a ragged set still
+ * renders: a record missing a key gets a blank, which reads as absent rather than as a shape the
+ * data does not have. A nested value falls back to compact JSON — one level of structure is worth
+ * showing inline, a whole object graph is not.
+ */
+export declare function renderRecords(records: Record<string, unknown> | readonly Record<string, unknown>[], options?: RenderRecordsOptions): string;
+//# sourceMappingURL=renderRecords.d.ts.map

package/types/src/markdown/renderRecords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderRecords.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderRecords.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,OAAO,KAAG,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAI/E,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACrE,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAuDR"}

package/types/src/markdown/renderRegions.d.ts

@@ -0,0 +1,70 @@
+import { ICellRegion, ICellRegions } from '@sheetxl/sdk';
+import { RegionPayload } from './describeRegionPayload';
+import { MarkdownBuilder } from './MarkdownBuilder';
+import { ProfileRegionOptions } from './profileRegion';
+/**
+ * Options for {@link renderRegions}.
+ */
+export interface RenderRegionsOptions extends ProfileRegionOptions {
+    /**
+     * Cap on listed regions; the report notes truncation when exceeded.
+     *
+     * @defaultValue 200
+     */
+    maxRegions?: number;
+    /**
+     * Cap on regions **profiled** in a `Contentful` listing — the rest list address and size only.
+     *
+     * @remarks
+     * Lower than {@link maxRegions} on purpose: listing a region is one line and one lookup, while
+     * profiling it scans its cells. A sheet with 400 stray labels should still list all 400 without
+     * paying 400 scans, and the listing says plainly which ones went undescribed so the reader can
+     * ask for the rest rather than assume there was nothing to say.
+     *
+     * @defaultValue 12
+     */
+    maxProfiled?: number;
+    /**
+     * How to recover the regions the cap ate — appended to the overflow line.
+     *
+     * @remarks
+     * A cap is a report-length decision, and "raise it" is the one recovery that does not scale:
+     * the reader who needs all 400 regions needs them in a loop, not in a longer listing. Sections
+     * that know the query behind the listing — a sheet report's feature partition knows its sheet
+     * and its feature — pass the call that returns the whole set, so the next step is an SDK query
+     * rather than a knob.
+     *
+     * @defaultValue a pointer at narrowing the range
+     */
+    recovery?: string;
+}
+/**
+ * Appends an aligned region listing — shared by the standalone regions report and the sheet
+ * report's per-feature sections, so the two can never list regions differently.
+ *
+ * @remarks
+ * Aligned listing rather than a pipe table (grep's rationale): rows are addresses, and the
+ * follow-up call — a `values`/`stats` read of one region — consumes the address directly.
+ */
+export declare function appendRegionList(md: MarkdownBuilder, regions: readonly ICellRegion[], options?: RenderRegionsOptions & {
+    payload?: RegionPayload;
+    profile?: boolean;
+}): void;
+/**
+ * Renders a partition — the unit `getRegions` returns, so an agent addresses structure instead
+ * of guessing ranges.
+ *
+ * @remarks
+ * **The heading names the features**, because the partition carries them: a region is uniform
+ * *with respect to those*, and a listing that does not say which ones is a column of addresses
+ * whose meaning the reader has to already know. It goes in the heading rather than per row
+ * because it is the same answer on every row — that is what a partition IS.
+ *
+ * **Each row carries its payload**, through the same describers a sheet report's feature sections
+ * use — so `getRegions('formula')` answers with the authored formulas rather than with a column of
+ * addresses the reader then has to go and read one by one. The two paths into a partition listing
+ * cannot describe it differently, and a refined partition joins one payload per requested feature,
+ * which is the tuple such a call was made to see.
+ */
+export declare function renderRegions(regions: ICellRegions, options?: RenderRegionsOptions): string;
+//# sourceMappingURL=renderRegions.d.ts.map

package/types/src/markdown/renderRegions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderRegions.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderRegions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAG/E,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IAChE;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,OAAO,CAAC,EAAE,oBAAoB,GAAG;IAAE,OAAO,CAAC,EAAE,aAAa,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9E,IAAI,CAmDN;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAwBR"}

package/types/src/markdown/renderResult.d.ts

@@ -0,0 +1,35 @@
+import { IWorkbook } from '@sheetxl/sdk';
+import { Renderer } from './registry';
+/**
+ * A run result rendered for the reader.
+ *
+ * @remarks
+ * `rendered: false` marks the last-resort branch — a value nothing renders, summarized in one
+ * line — so a host can append its own escape-hatch hint (the CLI points at `--json`).
+ */
+export interface RenderedResult {
+    /** The markdown (or one-line summary) — `undefined` only for an `undefined` result (void run). */
+    text?: string;
+    /** False when the value hit the "no renderer" summary rather than a real rendering. */
+    rendered: boolean;
+}
+/**
+ * Renders a run's result value — the final expression of a snippet, or a script's return value.
+ *
+ * @param workbook The workbook the run executed against — settled before rendering, exactly as
+ * {@link renderMarkdown} requires.
+ *
+ * @remarks
+ * The registry pass-through IS the default — `run -e "wb"` answers with the workbook report,
+ * which is the whole reason a separate `describe` verb is unnecessary. Strings pass through as
+ * markdown (a script that formatted its own answer), any renderable SDK object dispatches through
+ * the renderer registry, and plain data (a `getValues()` array) renders as a bare value grid.
+ * Anything with no renderer gets a ONE-LINE summary — never a structure dump, which is what a
+ * host's raw/JSON affordance is for. Only an `undefined` result is silent.
+ *
+ * Shared by every transport that returns a result: the CLI's `run` printout, the MCP `run` tool,
+ * and the webview executing against an attended session — one ladder, so the same expression answers
+ * identically everywhere.
+ */
+export declare function renderResult(workbook: IWorkbook | null, result: unknown, options?: Renderer.Options): Promise<RenderedResult>;
+//# sourceMappingURL=renderResult.d.ts.map

package/types/src/markdown/renderResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderResult.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAU,MAAM,cAAc,CAAC;AAGtD,OAAO,EAAmC,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE5E;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,kGAAkG;IAClG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uFAAuF;IACvF,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,SAAS,GAAG,IAAI,EAC1B,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,GACzB,OAAO,CAAC,cAAc,CAAC,CAgBzB"}

package/types/src/markdown/renderSheet.d.ts

@@ -0,0 +1,29 @@
+import { ISheet } from '@sheetxl/sdk';
+import { AppendFeatureOptions } from './appendSections';
+/**
+ * Options for {@link renderSheet}.
+ */
+export interface RenderSheetOptions extends AppendFeatureOptions {
+}
+/**
+ * Renders a markdown report of a sheet: counts, one section per feature partition, and the
+ * sheet-level objects (named ranges, hidden headers, tables).
+ *
+ * @remarks
+ * **No `Values` section** — that one belongs to {@link renderCellRange}, where the caller named
+ * bounds, and it is the only output in these reports that scales with the number of cells.
+ *
+ * Everything here is bounded by the sheet's structure instead: one section per feature
+ * partition, and a profile per contentful block that reports computed shape (types, bounds,
+ * aggregates, distinct counts) plus the text that names a block — a 1×1 prints its value, a
+ * table its header labels. Blocks × series, both capped, so this report cannot grow with the
+ * data. Altitude governs content: this one says where things are and what each block is; the
+ * range report reads one.
+ *
+ * This is the whole-sheet form of the same stats a cell range reports — which is exactly why
+ * {@link renderCellRange} does not list the partitions again. The addresses here are what it is
+ * then asked for, so the two calls compose into the whole read: this one to find the blocks,
+ * that one to read one.
+ */
+export declare function renderSheet(sheet: ISheet, options?: RenderSheetOptions): string;
+//# sourceMappingURL=renderSheet.d.ts.map

package/types/src/markdown/renderSheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderSheet.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderSheet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAC;AAI1B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;CAAG;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAmC/E"}

package/types/src/markdown/renderStats.d.ts

@@ -0,0 +1,18 @@
+import { IRangeStats } from '@sheetxl/sdk';
+/**
+ * Renders a stats report — occupancy, numeric aggregates, and the type breakdown.
+ *
+ * @remarks
+ * `getCounts` answers "how much of each feature"; this answers "what are the values like".
+ * Null aggregates (no numbers in the range) are elided rather than printed as null.
+ *
+ * Errors are population for a report, never faults: aggregates are taken over the numeric
+ * cells (`onError: 'ignore'` — the stats object's own default policy is `'throw'`, which
+ * would make the range that most needs a stats report the one that returns nothing), and the
+ * error count is its own line item so nothing degrades silently.
+ *
+ * Aggregates print through {@link encodeNumber} — a derived mean carries no number format, so
+ * without the display cap an `Average` publishes the full 17-digit float of its own division.
+ */
+export declare function renderStats(stats: IRangeStats): string;
+//# sourceMappingURL=renderStats.d.ts.map

package/types/src/markdown/renderStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderStats.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderStats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAe5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAgCtD"}

package/types/src/markdown/renderStyle.d.ts

@@ -0,0 +1,12 @@
+import { IStyle } from '@sheetxl/sdk';
+/**
+ * Renders a style report: the named style it derives from, plus its direct overrides.
+ *
+ * @remarks
+ * The property listing comes from `toJSON()` — the style's own serialization of what is
+ * directly set — rather than walking each sub-object's API, so the report stays complete as
+ * the style model grows. No direct properties means the style is entirely inherited; the
+ * report says so instead of enumerating absence (the closed-world contract).
+ */
+export declare function renderStyle(style: IStyle): string;
+//# sourceMappingURL=renderStyle.d.ts.map

package/types/src/markdown/renderStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderStyle.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderStyle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAI3C;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBjD"}

package/types/src/markdown/renderTable.d.ts

@@ -0,0 +1,12 @@
+import { ITable } from '@sheetxl/sdk';
+import { MarkdownBuilder } from './MarkdownBuilder';
+/**
+ * Appends one table's details — shared by the sheet report's Tables section and the standalone
+ * table report, so the two can never describe a table differently.
+ */
+export declare function appendTableDetails(md: MarkdownBuilder, table: ITable): void;
+/**
+ * Renders a table report.
+ */
+export declare function renderTable(table: ITable): string;
+//# sourceMappingURL=renderTable.d.ts.map

package/types/src/markdown/renderTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderTable.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG3C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAY3E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASjD"}

package/types/src/markdown/renderValues.d.ts

@@ -0,0 +1,28 @@
+import { IRange, Scalar } from '@sheetxl/sdk';
+/**
+ * Options for {@link renderValues}.
+ */
+export interface RenderValuesOptions {
+    /**
+     * Cap on rendered values; the report notes truncation when exceeded.
+     *
+     * @defaultValue 1000
+     */
+    maxCells?: number;
+}
+/**
+ * Renders a pure value grid — an {@link IRange} or a raw `Scalar[][]`.
+ *
+ * @remarks
+ * **No row or column labels.** `IRange` is SheetXL's stateless value layer and `Scalar[][]` is a
+ * plain array; neither knows a sheet, so neither has an address. Printing `A`/`1` labels over
+ * them would assert a position that is not part of the data — the values may have come from
+ * `D7:F9`, from a transposed copy, or from a function that never touched a sheet. Row/column
+ * labels are exactly what a *cell* range has and these do not, which is why they are a separate
+ * renderer rather than an option on one.
+ *
+ * The `'` string prefix is kept, so the encoding is the same one every other read uses: a bare
+ * `10/23/95` is a formatted number, `'10/23/95` is text.
+ */
+export declare function renderValues(values: IRange | readonly (readonly Scalar[])[], options?: RenderValuesOptions): string;
+//# sourceMappingURL=renderValues.d.ts.map

package/types/src/markdown/renderValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderValues.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderValues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAMnD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EAC/C,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAoCR"}

package/types/src/markdown/renderWorkbook.d.ts

@@ -0,0 +1,50 @@
+import { IWorkbook } from '@sheetxl/sdk';
+import { AppendFeatureOptions, AppendNamesOptions } from './appendSections';
+/**
+ * Options for {@link renderWorkbook}.
+ */
+export interface RenderWorkbookOptions extends AppendFeatureOptions, Pick<AppendNamesOptions, 'maxNames'> {
+    /**
+     * Cap on sheets expanded into per-sheet sections below the roster; the rest stay roster-only
+     * and the report says how to render one in full.
+     *
+     * @defaultValue 8
+     */
+    maxSheets?: number;
+}
+/**
+ * Renders a markdown summary of a workbook: identity, the sheet roster, what is broken, and each
+ * sheet's structure.
+ *
+ * @remarks
+ * **The workbook report's job is routing** — *which sheet do I go to, and is anything broken?*
+ * Every line earns its place against that, which is why the roster is a table of routing facts
+ * (used range, cell/formula/error counts) rather than a list of names, and why errors get a
+ * section at this altitude: a broken book must not read clean.
+ *
+ * **Below the roster, each sheet's own sections render inline** — the same `Type`/partition/
+ * object sections a sheet report carries, one heading level down, through the same functions so
+ * the two can never disagree. One shape at every size; scale is absorbed by caps, not by a mode
+ * switch: on a small book the first call answers structure outright, on a large one every capped
+ * list states its overflow and the recovery (`maxSheets` sheets expanded, {@link
+ * MAX_REGIONS_PER_SHEET} regions per feature and {@link MAX_PROFILED_PER_SHEET} profiled —
+ * tighter than a sheet report's own defaults, because here they share the budget with the whole
+ * book). Like the sheet report, the expansion carries no `Values` section — that one is
+ * {@link renderCellRange}'s. A contentful profile is computed shape, bounded by blocks × series
+ * rather than by cells.
+ *
+ * Two kinds of broken, kept apart deliberately: an **error** is a successfully calculated error
+ * VALUE (`#DIV/0!` from `=1/0` — the `Error` kind), a **calc failure** is the engine failing to
+ * evaluate at all (mostly circular references — `CalcError`). A book with zero of one and three
+ * of the other is still badly broken, so each gets its own section and neither hides the other.
+ *
+ * Sheet ids are a session concept, not a document concept, and are not stable across runs — they
+ * do not appear here. Hidden sheets are marked inline where they exist rather than summarized in
+ * an always-zero count line: a hidden sheet with data is a classic miss, and the mark is what
+ * surfaces it.
+ *
+ * Pure rendering — the agent-priming preamble the pre-migration SDK report carried
+ * (`PROMPT_STRING`) belongs to the host that primes the agent, not to the report.
+ */
+export declare function renderWorkbook(workbook: IWorkbook, options?: RenderWorkbookOptions): string;
+//# sourceMappingURL=renderWorkbook.d.ts.map

package/types/src/markdown/renderWorkbook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderWorkbook.d.ts","sourceRoot":"","sources":["../../../../src/markdown/renderWorkbook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAGpF,OAAO,EAEL,KAAK,oBAAoB,EAAE,KAAK,kBAAkB,EACnD,MAAM,kBAAkB,CAAC;AAkB1B;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB,EACjE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC;IACpC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAwBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,EACnB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,MAAM,CA0IR"}