hikoutei 0.10.1-dev → 0.10.3-dev

package/dist/sheets/providers/google-sheets-api/model/readPlan.js

@@ -1,184 +0,0 @@
-/**
- * Pure read planning for the unified read engine (design/unified-read-engine.md).
- *
- * Every read lane (polling observation, preflight base, verification/probe)
- * historically built its own A1 ranges with unbounded row extent
- * (`X2:X1048576`), so each lane's largest single request grew with the
- * accumulated data and the 30k-row burst stress pushed all three lanes into
- * the 10 s read timeout at once. This module is the SINGLE planner those
- * lanes route through: given an authoritative committed row bound
- * (`gridProperties.rowCount` from the sheet's own enumeration), a column
- * span, and an evidence class, it emits row bands that never exceed the
- * shared per-range cell cap or the per-request byte estimate, and packs the
- * bands into at most `MAX_READ_RANGES_PER_REQUEST` ranges per request.
- *
- * Safety rules baked into the planning contract:
- * - The bound is an upper bound on what a read can return (content ≤ grid
- *   rows always holds at snapshot time); a too-low cached bound can never
- *   truncate coverage because the LAST band of every banded column stays
- *   open-ended (`<start>:<end>1048576`) unless the caller proves the row
- * * extent itself (explicit row sets and the verification spans, which are
- *   bounded by their own maximum row number).
- * - Byte estimates are deliberately conservative (each class constant is
- *   ≥ 2× the measured live average) and a per-class telemetry-calibrated
- *   multiplier only ever GROWS them: a mispredict shrinks the next pass's
- *   bands, it never loops or grows one request.
- * - Small tabs collapse to exactly one open-ended band per column, i.e. the
- *   byte-identical historical ranges; chunking activates only when the
- *   authoritative bound exceeds one chunk.
- */
-/** Current hard grid limit of a real spreadsheet (1-based). */
-export const SHEET_MAX_ROW = 1_048_576;
-/**
- * Hard cap on cells per requested range, shared by EVERY lane (the API's
- * ~10 000-cell request-shape limit with margin; previously only the
- * verification lane enforced it).
- */
-export const MAX_READ_CELLS_PER_RANGE = 9_500;
-/**
- * Hard cap on ranges per `spreadsheets.get`, shared by every lane (unifies
- * the former `MAX_OBSERVATION_BAND_RANGES` / `MAX_VERIFY_RANGES_PER_REQUEST`).
- */
-export const MAX_READ_RANGES_PER_REQUEST = 40;
-/**
- * Per-BAND ESTIMATE target in bytes: one band plans to at most this many
- * estimated bytes (the chunking gate). A planning threshold, not a transport
- * guarantee: the constants below are conservative and the calibration
- * multiplier shrinks future bands whenever measured bytes/cell exceed the
- * estimate.
- */
-export const READ_SOFT_TARGET_BYTES = 3_000_000;
-/**
- * Per-request ESTIMATE ceiling: packed requests add bands until the summed
- * estimate would exceed this (each individual band is already ≤ the soft
- * target, so a request holds 1-2 near-maximal bands). With the ≥ 2× safety
- * margin baked into BYTES_PER_CELL the REAL response lands well under the
- * figure that streamed past the 10 s budget at the observed average.
- */
-export const READ_HARD_MAX_BYTES = 5_000_000;
-/**
- * Cell-evidence classes → conservative per-cell JSON byte estimates.
- * Each value is ≥ 2× the measured live `responseBytes ÷ cellsRequested`
- * average for its wire mask (~107–210 B/cell preflight/observation classes,
- * ~163 B/cell-band row-checks).
- * ponytail: fixture-scale calibration; recalibrate from live telemetry if
- * planning mispredicts > 2×.
- */
-export const READ_BYTES_PER_CELL = {
-    "values-only": 120,
-    "row-checks": 400,
-    "values+formats": 400,
-    "rendering-complete": 450,
-};
-/** Safety margin applied to the observed bytes/cell ratio. */
-const CALIBRATION_SAFETY = 1.5;
-/** Ceiling for one class's multiplier (bounds a pathological sample's damage). */
-const CALIBRATION_MAX_RATIO = 20;
-/** Builds a fresh provider-instance calibration tracker. */
-export function createReadCalibration() {
-    const ratios = new Map();
-    return {
-        ratioFor: (evidence) => ratios.get(evidence) ?? 1,
-        observe: (evidence, cellsRequested, responseBytes) => {
-            if (cellsRequested <= 0 || responseBytes <= 0)
-                return;
-            const observed = responseBytes / cellsRequested / READ_BYTES_PER_CELL[evidence];
-            const next = Math.min(CALIBRATION_MAX_RATIO, Math.max(ratios.get(evidence) ?? 1, observed * CALIBRATION_SAFETY));
-            ratios.set(evidence, next);
-        },
-    };
-}
-/** Estimated bytes for one planned band under the current calibration. */
-export function estimatedRangeBytes(item, evidence, calibration) {
-    return item.cells * READ_BYTES_PER_CELL[evidence] * calibration.ratioFor(evidence);
-}
-/** Rows one band of `columnCount` columns may request under both caps. */
-export function rowsPerBand(columnCount, evidence, calibration) {
-    const cellBudget = Math.floor(READ_SOFT_TARGET_BYTES /
-        (READ_BYTES_PER_CELL[evidence] * calibration.ratioFor(evidence)));
-    return Math.max(1, Math.floor(Math.min(MAX_READ_CELLS_PER_RANGE, cellBudget) / Math.max(1, columnCount)));
-}
-/**
- * Plans the row bands for one column span: contiguous chunks of at most
- * `rowsPerBand` rows and `MAX_READ_CELLS_PER_RANGE` cells each. The final
- * band stays OPEN (`:1048576`) so a stale-low bound can never truncate
- * coverage — unless the caller proved the extent via `exactLastRow`. A span
- * that fits one chunk collapses to the byte-identical historical single
- * open-ended range.
- */
-export function planRowBands(plan) {
-    const { quote, firstLetter, lastLetter, columnCount, fromRow, rowBound, exactLastRow, evidence, calibration } = plan;
-    const lastRow = exactLastRow ?? rowBound;
-    if (lastRow === undefined || lastRow < fromRow) {
-        // No bound (legacy/unenumerated transport) or nothing to read: the
-        // historical single open band; cells 0 keeps it out of byte packing
-        // (it was never chunkable without a bound anyway).
-        return [{
-                range: `${quote}${firstLetter}${fromRow}:${lastLetter}${SHEET_MAX_ROW}`,
-                cells: rowBound !== undefined && rowBound >= fromRow
-                    ? (Math.min(rowBound, lastRow ?? rowBound) - fromRow + 1) * columnCount
-                    : 0,
-            }];
-    }
-    const rows = rowsPerBand(columnCount, evidence, calibration);
-    const items = [];
-    let start = fromRow;
-    while (start + rows - 1 < lastRow) {
-        const end = start + rows - 1;
-        items.push({
-            range: `${quote}${firstLetter}${start}:${lastLetter}${end}`,
-            cells: rows * columnCount,
-        });
-        start = end + 1;
-    }
-    const remainingRows = lastRow - start + 1;
-    const openEnded = exactLastRow === undefined;
-    items.push({
-        range: `${quote}${firstLetter}${start}:${lastLetter}${openEnded ? SHEET_MAX_ROW : lastRow}`,
-        cells: remainingRows * columnCount,
-    });
-    return items;
-}
-/**
- * Greedily packs planned bands into paced requests: each request holds at
- * most `MAX_READ_RANGES_PER_REQUEST` ranges and stays within the
- * `READ_HARD_MAX_BYTES` estimate (individual bands are chunked to the
- * softer 3 MB target, so one oversized tab spreads across requests while
- * small tabs of one logical read still share a single request — the
- * historical single-request shape).
- */
-export function packReadRequests(items, evidence, calibration) {
-    const requests = [];
-    let current = [];
-    let currentBytes = 0;
-    for (const item of items) {
-        const bytes = estimatedRangeBytes(item, evidence, calibration);
-        if (current.length > 0 &&
-            (current.length + 1 > MAX_READ_RANGES_PER_REQUEST ||
-                currentBytes + bytes > READ_HARD_MAX_BYTES)) {
-            requests.push(current);
-            current = [];
-            currentBytes = 0;
-        }
-        current.push(item);
-        currentBytes += bytes;
-    }
-    if (current.length > 0)
-        requests.push(current);
-    return requests;
-}
-/**
- * Resolves one title's authoritative row bound from an enumeration (the
- * committed `gridProperties.rowCount`, exact) falling back to the
- * provider-instance bounds cache (refreshed by every engine response), so
- * lanes that enumerated never pay for a second metadata call.
- */
-export function authoritativeRowBound(sheets, boundsCache, title) {
-    for (const sheet of sheets) {
-        if (sheet.title === title) {
-            return sheet.gridProperties?.rowCount ?? boundsCache.get(title);
-        }
-    }
-    return boundsCache.get(title);
-}
-//# sourceMappingURL=readPlan.js.map

package/dist/sheets/providers/google-sheets-api/model/readPlan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"readPlan.js","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/readPlan.ts"],"names":[],"mappings":"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"}

package/dist/sheets/providers/google-sheets-api/model/receiptCursor.d.ts

@@ -1,102 +0,0 @@
-/**
- * Per-provider receipt READ cursor plus cumulative receipt memo.
- *
- * The hidden receipt tab is append-only machine data (each write batch appends
- * its receipt rows at the tab tail; humans never edit it), so a dispatch does
- * not need to re-read the whole tab to decide idempotency: it needs only the
- * receipts appended since the last verified coverage. This cursor records the
- * LAST receipt row this provider instance has verified as covered — either by
- * parsing it in a previous receipt read, or by writing it in a batch that got
- * a valid `batchUpdate` reply — so the next dispatch reads only the tail band
- * starting AT that row (the row doubles as a sentinel proving the cursor is
- * still inside the tab).
- *
- * Because the cursor advances on every successful read, a band alone cannot
- * answer idempotency for effects that have not been re-dispatched for several
- * batches: their receipt rows fall BELOW the next cursor. The cursor
- * therefore also owns a cumulative memo — every receipt row this instance has
- * ever parsed (bands and full reads alike) — and preflight contexts expose
- * the memo, not just the current band, as their `receipts` view. Receipt
- * lookups never depend on where the cursor happens to sit.
- *
- * Safety contract:
- * - The cursor advances ONLY from a successful receipt READ, to the tail row
- *   that read parsed. It is never advanced from a write: receipts appended
- *   after the previous read therefore stay inside the next band, are merged
- *   into the memo there, and remain replay-recognizable for as long as this
- *   instance lives.
- * - Every row at or below the cursor was parsed by this instance since the
- *   last reset (append-only tab + snapshot-atomic reads), so memo coverage
- *   is exactly "everything the cursor has passed". A concurrent or
- *   cross-process append can only grow the tab at the tail, which the next
- *   band (starting AT the cursor sentinel) re-reads.
- * - A kill -9 loses the whole cursor AND the memo (instance memory): the next
- *   process starts with no cursor and performs the historical FULL
- *   `A1:F1048576` receipt read, byte-identical to the pre-cursor behavior.
- * - Cursor missing (< 2), sentinel blank (tab truncated/cleared), or a
- *   clipped grid → reset (cursor + memo dropped together) and fall back to
- *   one full receipt read, which re-establishes both.
- * - Memo growth is bounded: past `MAX_MEMO_RECEIPTS` the cursor resets, so
- *   the instance degrades to the pre-cursor full-read behavior instead of
- *   growing unbounded memory.
- *
- * Why instance memory instead of a SQLite column under the writer fence:
- * durable-then-ack coupling only buys savings across a process restart (one
- * full receipt read paid once per restart), while every multi-process and
- * crash-desync case above is already proven safe by the append-only +
- * shift-not-overwrite invariants plus the probe rule that a live cursor
- * after the base read proves complete memo coverage (a receipt miss is then
- * provable and decides `unapplied` from the band), while any coverage the
- * read itself invalidated falls back to one full receipt read (see
- * `readEffectPostconditions`). Keeping the cursor
- * inside the provider also keeps the Sheets adapter free of storage-schema
- * ownership (a fence-coupled cursor would require outbox-kernel, contracts,
- * and storage API changes far outside this optimization's scope).
- */
-import type { PreflightReceipt } from "./preflightContext.js";
-/**
- * Ceiling for the cumulative receipt memo. Beyond it the cursor resets and
- * the instance falls back to the historical per-dispatch full receipt read.
- * ponytail: 200k receipts ≈ tens of MB of small records; upgrade path if a
- * real deployment exceeds this is an acknowledged-effect watermark in
- * SQLite (durable cursor + durable coverage).
- */
-export declare const MAX_MEMO_RECEIPTS = 200000;
-export declare class ReceiptReadCursor {
-    /** Last receipt row (1-based) verified as covered; 0 means "no cursor". */
-    private lastVerifiedRow;
-    /** Every receipt parsed by this instance since the last reset. */
-    private readonly memo;
-    /**
-     * Row (1-based) to START a banded receipt read at, or `undefined` when a
-     * full read is required (no usable cursor yet). The band starts AT the
-     * cursor row so the known-applied receipt there acts as a sentinel against
-     * tab truncation; row 1 is the header, so a cursor below 2 can never prove
-     * coverage of a data row and the full read stays.
-     */
-    bandStartRow(): number | undefined;
-    /** Monotonic advance; understating the verified tail is always safe. */
-    advanceTo(verifiedRow: number): void;
-    /**
-     * Merges one parsed read's receipts into the cumulative memo. Re-parsing
-     * the same row (the band sentinel is read again every dispatch) is a no-op
-     * when the values agree; a different value under an already-covered
-     * effectId means the append-only tab was rewritten from under this
-     * instance and fails closed exactly like an in-band duplicate.
-     */
-    mergeParsed(receipts: ReadonlyMap<string, PreflightReceipt>): boolean;
-    /** True when the memo has grown past its ceiling (caller must reset). */
-    isOverCapacity(): boolean;
-    /** True when the next merge could only exceed the ceiling: force a full read. */
-    isAtCapacity(): boolean;
-    /** True when this instance has covered no receipt row yet. */
-    isEmpty(): boolean;
-    /** The cumulative receipt coverage every scoped/full read's context exposes. */
-    memoView(): ReadonlyMap<string, PreflightReceipt>;
-    /**
-     * Drops the cursor AND the memo together so the next read performs the
-     * historical full receipt read; coverage and cursor must never disagree.
-     */
-    reset(): void;
-}
-//# sourceMappingURL=receiptCursor.d.ts.map

package/dist/sheets/providers/google-sheets-api/model/receiptCursor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"receiptCursor.d.ts","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/receiptCursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC,qBAAa,iBAAiB;IAC5B,2EAA2E;IAC3E,OAAO,CAAC,eAAe,CAAK;IAC5B,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuC;IAE5D;;;;;;OAMG;IACI,YAAY,IAAI,MAAM,GAAG,SAAS;IAIzC,wEAAwE;IACjE,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAM3C;;;;;;OAMG;IACI,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,OAAO;IAgB5E,yEAAyE;IAClE,cAAc,IAAI,OAAO;IAIhC,iFAAiF;IAC1E,YAAY,IAAI,OAAO;IAI9B,8DAA8D;IACvD,OAAO,IAAI,OAAO;IAIzB,gFAAgF;IACzE,QAAQ,IAAI,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAIxD;;;OAGG;IACI,KAAK,IAAI,IAAI;CAIrB"}

package/dist/sheets/providers/google-sheets-api/model/receiptCursor.js

@@ -1,132 +0,0 @@
-/**
- * Per-provider receipt READ cursor plus cumulative receipt memo.
- *
- * The hidden receipt tab is append-only machine data (each write batch appends
- * its receipt rows at the tab tail; humans never edit it), so a dispatch does
- * not need to re-read the whole tab to decide idempotency: it needs only the
- * receipts appended since the last verified coverage. This cursor records the
- * LAST receipt row this provider instance has verified as covered — either by
- * parsing it in a previous receipt read, or by writing it in a batch that got
- * a valid `batchUpdate` reply — so the next dispatch reads only the tail band
- * starting AT that row (the row doubles as a sentinel proving the cursor is
- * still inside the tab).
- *
- * Because the cursor advances on every successful read, a band alone cannot
- * answer idempotency for effects that have not been re-dispatched for several
- * batches: their receipt rows fall BELOW the next cursor. The cursor
- * therefore also owns a cumulative memo — every receipt row this instance has
- * ever parsed (bands and full reads alike) — and preflight contexts expose
- * the memo, not just the current band, as their `receipts` view. Receipt
- * lookups never depend on where the cursor happens to sit.
- *
- * Safety contract:
- * - The cursor advances ONLY from a successful receipt READ, to the tail row
- *   that read parsed. It is never advanced from a write: receipts appended
- *   after the previous read therefore stay inside the next band, are merged
- *   into the memo there, and remain replay-recognizable for as long as this
- *   instance lives.
- * - Every row at or below the cursor was parsed by this instance since the
- *   last reset (append-only tab + snapshot-atomic reads), so memo coverage
- *   is exactly "everything the cursor has passed". A concurrent or
- *   cross-process append can only grow the tab at the tail, which the next
- *   band (starting AT the cursor sentinel) re-reads.
- * - A kill -9 loses the whole cursor AND the memo (instance memory): the next
- *   process starts with no cursor and performs the historical FULL
- *   `A1:F1048576` receipt read, byte-identical to the pre-cursor behavior.
- * - Cursor missing (< 2), sentinel blank (tab truncated/cleared), or a
- *   clipped grid → reset (cursor + memo dropped together) and fall back to
- *   one full receipt read, which re-establishes both.
- * - Memo growth is bounded: past `MAX_MEMO_RECEIPTS` the cursor resets, so
- *   the instance degrades to the pre-cursor full-read behavior instead of
- *   growing unbounded memory.
- *
- * Why instance memory instead of a SQLite column under the writer fence:
- * durable-then-ack coupling only buys savings across a process restart (one
- * full receipt read paid once per restart), while every multi-process and
- * crash-desync case above is already proven safe by the append-only +
- * shift-not-overwrite invariants plus the probe rule that a live cursor
- * after the base read proves complete memo coverage (a receipt miss is then
- * provable and decides `unapplied` from the band), while any coverage the
- * read itself invalidated falls back to one full receipt read (see
- * `readEffectPostconditions`). Keeping the cursor
- * inside the provider also keeps the Sheets adapter free of storage-schema
- * ownership (a fence-coupled cursor would require outbox-kernel, contracts,
- * and storage API changes far outside this optimization's scope).
- */
-/**
- * Ceiling for the cumulative receipt memo. Beyond it the cursor resets and
- * the instance falls back to the historical per-dispatch full receipt read.
- * ponytail: 200k receipts ≈ tens of MB of small records; upgrade path if a
- * real deployment exceeds this is an acknowledged-effect watermark in
- * SQLite (durable cursor + durable coverage).
- */
-export const MAX_MEMO_RECEIPTS = 200_000;
-export class ReceiptReadCursor {
-    /** Last receipt row (1-based) verified as covered; 0 means "no cursor". */
-    lastVerifiedRow = 0;
-    /** Every receipt parsed by this instance since the last reset. */
-    memo = new Map();
-    /**
-     * Row (1-based) to START a banded receipt read at, or `undefined` when a
-     * full read is required (no usable cursor yet). The band starts AT the
-     * cursor row so the known-applied receipt there acts as a sentinel against
-     * tab truncation; row 1 is the header, so a cursor below 2 can never prove
-     * coverage of a data row and the full read stays.
-     */
-    bandStartRow() {
-        return this.lastVerifiedRow >= 2 ? this.lastVerifiedRow : undefined;
-    }
-    /** Monotonic advance; understating the verified tail is always safe. */
-    advanceTo(verifiedRow) {
-        if (Number.isSafeInteger(verifiedRow) && verifiedRow > this.lastVerifiedRow) {
-            this.lastVerifiedRow = verifiedRow;
-        }
-    }
-    /**
-     * Merges one parsed read's receipts into the cumulative memo. Re-parsing
-     * the same row (the band sentinel is read again every dispatch) is a no-op
-     * when the values agree; a different value under an already-covered
-     * effectId means the append-only tab was rewritten from under this
-     * instance and fails closed exactly like an in-band duplicate.
-     */
-    mergeParsed(receipts) {
-        for (const [effectId, receipt] of receipts) {
-            const known = this.memo.get(effectId);
-            if (known !== undefined) {
-                if (known.payloadHash !== receipt.payloadHash ||
-                    known.visibleHash !== receipt.visibleHash ||
-                    known.visibleRevision !== receipt.visibleRevision) {
-                    return false;
-                }
-                continue;
-            }
-            this.memo.set(effectId, receipt);
-        }
-        return true;
-    }
-    /** True when the memo has grown past its ceiling (caller must reset). */
-    isOverCapacity() {
-        return this.memo.size > MAX_MEMO_RECEIPTS;
-    }
-    /** True when the next merge could only exceed the ceiling: force a full read. */
-    isAtCapacity() {
-        return this.memo.size >= MAX_MEMO_RECEIPTS;
-    }
-    /** True when this instance has covered no receipt row yet. */
-    isEmpty() {
-        return this.memo.size === 0;
-    }
-    /** The cumulative receipt coverage every scoped/full read's context exposes. */
-    memoView() {
-        return this.memo;
-    }
-    /**
-     * Drops the cursor AND the memo together so the next read performs the
-     * historical full receipt read; coverage and cursor must never disagree.
-     */
-    reset() {
-        this.lastVerifiedRow = 0;
-        this.memo.clear();
-    }
-}
-//# sourceMappingURL=receiptCursor.js.map

package/dist/sheets/providers/google-sheets-api/model/receiptCursor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"receiptCursor.js","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/receiptCursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAEzC,MAAM,OAAO,iBAAiB;IAC5B,2EAA2E;IACnE,eAAe,GAAG,CAAC,CAAC;IAC5B,kEAAkE;IACjD,IAAI,GAAG,IAAI,GAAG,EAA4B,CAAC;IAE5D;;;;;;OAMG;IACI,YAAY;QACjB,OAAO,IAAI,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,wEAAwE;IACjE,SAAS,CAAC,WAAmB;QAClC,IAAI,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YAC5E,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACrC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,QAA+C;QAChE,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;YAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACtC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,IAAI,KAAK,CAAC,WAAW,KAAK,OAAO,CAAC,WAAW;oBACzC,KAAK,CAAC,WAAW,KAAK,OAAO,CAAC,WAAW;oBACzC,KAAK,CAAC,eAAe,KAAK,OAAO,CAAC,eAAe,EAAE,CAAC;oBACtD,OAAO,KAAK,CAAC;gBACf,CAAC;gBACD,SAAS;YACX,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yEAAyE;IAClE,cAAc;QACnB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAC5C,CAAC;IAED,iFAAiF;IAC1E,YAAY;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,iBAAiB,CAAC;IAC7C,CAAC;IAED,8DAA8D;IACvD,OAAO;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,gFAAgF;IACzE,QAAQ;QACb,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;OAGG;IACI,KAAK;QACV,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;CACF"}

package/dist/sheets/providers/google-sheets-api/model/rowCheckFormula.d.ts

@@ -1,35 +0,0 @@
-/**
- * Row-check formula builder for the User_Input check column.
- *
- * The provider writes ONE deterministic formula per created row into the
- * check column (the column directly after the registered range): a `&`
- * concatenation of one length-prefixed, type-tagged TOKEN term per user
- * data column of the row, joined by the shared delimiter. Each term is
- * `IF(ISNUMBER(ref),"n",IF(ISLOGICAL(ref),"b","s"))&LEN(ref)&":"&ref`,
- * mirroring the contracts leaf (`sheets/rowCheck.ts` →
- * {@link renderRowCheckCell}) token-for-token, so the computed string is
- * injective over the row's data vector (delimiter collisions and blank
- * permutations are encoded by the length prefix, not skipped) while the
- * formula stays compact enough that the narrow polling read keeps its
- * payload advantage.
- *
- * The Sheet's recalculation engine maintains the cell afterwards, so any
- * human edit to a data column of that row changes the visible check string
- * without a system write, and every system `updateCells` write to the row
- * (which preserves neighboring formulas — proven) recalcs on the next read.
- * The polling gate compares that computed string against the value derived
- * from canonical SQLite state (contracts `sheets/rowCheck.ts`) and only
- * escalates mismatched rows to targeted full-field reads.
- *
- * Branch equivalences the renderer mirrors: a blank or empty-string cell
- * concatenates to "" with LEN 0 under the `s` tag (`s0:`); a date cell
- * ISNUMBER-concatenates its bare serial; a boolean concatenates to
- * TRUE/FALSE under the `b` tag; an error or an unsupported render propagates
- * (or disagrees) as a MISMATCH — the safe direction. `ponytail`: ~70
- * formula chars per column; a Sheet's ~10k formula cap ceilings this at
- * roughly 140 data columns — beyond that, hash the row server-side instead
- * of encoding it.
- */
-/** Returns the row-check formula text (with leading `=`) for one row. */
-export declare function buildRowCheckFormula(firstDataColumn: number, lastDataColumn: number, rowNumber: number): string;
-//# sourceMappingURL=rowCheckFormula.d.ts.map

package/dist/sheets/providers/google-sheets-api/model/rowCheckFormula.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rowCheckFormula.d.ts","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/rowCheckFormula.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AASH,yEAAyE;AACzE,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAChB,MAAM,CAMR"}

package/dist/sheets/providers/google-sheets-api/model/rowCheckFormula.js

@@ -1,57 +0,0 @@
-/**
- * Row-check formula builder for the User_Input check column.
- *
- * The provider writes ONE deterministic formula per created row into the
- * check column (the column directly after the registered range): a `&`
- * concatenation of one length-prefixed, type-tagged TOKEN term per user
- * data column of the row, joined by the shared delimiter. Each term is
- * `IF(ISNUMBER(ref),"n",IF(ISLOGICAL(ref),"b","s"))&LEN(ref)&":"&ref`,
- * mirroring the contracts leaf (`sheets/rowCheck.ts` →
- * {@link renderRowCheckCell}) token-for-token, so the computed string is
- * injective over the row's data vector (delimiter collisions and blank
- * permutations are encoded by the length prefix, not skipped) while the
- * formula stays compact enough that the narrow polling read keeps its
- * payload advantage.
- *
- * The Sheet's recalculation engine maintains the cell afterwards, so any
- * human edit to a data column of that row changes the visible check string
- * without a system write, and every system `updateCells` write to the row
- * (which preserves neighboring formulas — proven) recalcs on the next read.
- * The polling gate compares that computed string against the value derived
- * from canonical SQLite state (contracts `sheets/rowCheck.ts`) and only
- * escalates mismatched rows to targeted full-field reads.
- *
- * Branch equivalences the renderer mirrors: a blank or empty-string cell
- * concatenates to "" with LEN 0 under the `s` tag (`s0:`); a date cell
- * ISNUMBER-concatenates its bare serial; a boolean concatenates to
- * TRUE/FALSE under the `b` tag; an error or an unsupported render propagates
- * (or disagrees) as a MISMATCH — the safe direction. `ponytail`: ~70
- * formula chars per column; a Sheet's ~10k formula cap ceilings this at
- * roughly 140 data columns — beyond that, hash the row server-side instead
- * of encoding it.
- */
-import { SYNC_ROW_CHECK_DELIMITER, SYNC_ROW_CHECK_LENGTH_SEPARATOR, SYNC_ROW_CHECK_TOKEN_TAGS, } from "../../../../contracts/sheets/rowCheck.js";
-import { columnLetters } from "./valueNormalization.js";
-/** Returns the row-check formula text (with leading `=`) for one row. */
-export function buildRowCheckFormula(firstDataColumn, lastDataColumn, rowNumber) {
-    const terms = [];
-    for (let column = firstDataColumn; column <= lastDataColumn; column += 1) {
-        terms.push(buildRowCheckTerm(`${columnLetters(column)}${rowNumber}`));
-    }
-    return `=${terms.join(`&"${SYNC_ROW_CHECK_DELIMITER}"&`)}`;
-}
-/**
- * One column's token term for cell `ref`, generated from the shared
- * delimiter/tag constants so the formula and the SQLite-side renderer can
- * never drift apart silently. Text is the fallback tag (a blank or
- * empty-string cell renders exactly like the renderer's zero-length `s`
- * token); errors propagate through LEN/concatenation.
- */
-function buildRowCheckTerm(ref) {
-    const text = SYNC_ROW_CHECK_TOKEN_TAGS.STRING;
-    const number = SYNC_ROW_CHECK_TOKEN_TAGS.NUMBER;
-    const bool = SYNC_ROW_CHECK_TOKEN_TAGS.BOOLEAN;
-    return `IF(ISNUMBER(${ref}),"${number}",IF(ISLOGICAL(${ref}),"${bool}","${text}"))`
-        + `&LEN(${ref})&"${SYNC_ROW_CHECK_LENGTH_SEPARATOR}"&${ref}`;
-}
-//# sourceMappingURL=rowCheckFormula.js.map

package/dist/sheets/providers/google-sheets-api/model/rowCheckFormula.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rowCheckFormula.js","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/rowCheckFormula.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,yBAAyB,GAC1B,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD,yEAAyE;AACzE,MAAM,UAAU,oBAAoB,CAClC,eAAuB,EACvB,cAAsB,EACtB,SAAiB;IAEjB,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,IAAI,MAAM,GAAG,eAAe,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,IAAI,CAAC,EAAE,CAAC;QACzE,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,wBAAwB,IAAI,CAAC,EAAE,CAAC;AAC7D,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,GAAW;IACpC,MAAM,IAAI,GAAG,yBAAyB,CAAC,MAAM,CAAC;IAC9C,MAAM,MAAM,GAAG,yBAAyB,CAAC,MAAM,CAAC;IAChD,MAAM,IAAI,GAAG,yBAAyB,CAAC,OAAO,CAAC;IAC/C,OAAO,eAAe,GAAG,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,MAAM,IAAI,KAAK;UAC/E,QAAQ,GAAG,MAAM,+BAA+B,KAAK,GAAG,EAAE,CAAC;AACjE,CAAC"}

package/dist/sheets/providers/google-sheets-api/model/sheetIdAllocator.d.ts

@@ -1,16 +0,0 @@
-/**
- * Deterministic sheet-id allocation for the direct Sheets provider.
- *
- * The provider self-assigns numeric sheet ids when it creates tabs (the
- * provisioned projection tabs and the hidden receipt tab). The allocator is
- * deterministic and fail-closed: it picks the smallest positive 31-bit id
- * not already used by any tab, so repeated provision attempts against the
- * same spreadsheet never drift and a colliding id can never be emitted.
- */
-/**
- * Returns the smallest positive 31-bit sheet id that collides with none of
- * the supplied ids. Fails closed when no free id remains (unreachable for
- * any real spreadsheet, but the contract must not invent an invalid id).
- */
-export declare function allocateSheetId(existing: ReadonlySet<number> | readonly number[]): number;
-//# sourceMappingURL=sheetIdAllocator.d.ts.map

package/dist/sheets/providers/google-sheets-api/model/sheetIdAllocator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sheetIdAllocator.d.ts","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/sheetIdAllocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,MAAM,EAAE,GAChD,MAAM,CAQR"}

package/dist/sheets/providers/google-sheets-api/model/sheetIdAllocator.js

@@ -1,29 +0,0 @@
-/**
- * Deterministic sheet-id allocation for the direct Sheets provider.
- *
- * The provider self-assigns numeric sheet ids when it creates tabs (the
- * provisioned projection tabs and the hidden receipt tab). The allocator is
- * deterministic and fail-closed: it picks the smallest positive 31-bit id
- * not already used by any tab, so repeated provision attempts against the
- * same spreadsheet never drift and a colliding id can never be emitted.
- */
-import { invalidProviderState } from "../errors.js";
-/** Smallest positive 31-bit signed integer accepted by the Sheets API. */
-const MIN_SHEET_ID = 1;
-const MAX_SHEET_ID = 0x7fffffff;
-/**
- * Returns the smallest positive 31-bit sheet id that collides with none of
- * the supplied ids. Fails closed when no free id remains (unreachable for
- * any real spreadsheet, but the contract must not invent an invalid id).
- */
-export function allocateSheetId(existing) {
-    const used = existing instanceof Set
-        ? existing
-        : new Set(existing);
-    for (let candidate = MIN_SHEET_ID; candidate <= MAX_SHEET_ID; candidate += 1) {
-        if (!used.has(candidate))
-            return candidate;
-    }
-    invalidProviderState("no free sheet id remains for tab creation");
-}
-//# sourceMappingURL=sheetIdAllocator.js.map

package/dist/sheets/providers/google-sheets-api/model/sheetIdAllocator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sheetIdAllocator.js","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/model/sheetIdAllocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,0EAA0E;AAC1E,MAAM,YAAY,GAAG,CAAC,CAAC;AACvB,MAAM,YAAY,GAAG,UAAU,CAAC;AAEhC;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,QAAiD;IAEjD,MAAM,IAAI,GAAG,QAAQ,YAAY,GAAG;QAClC,CAAC,CAAC,QAAQ;QACV,CAAC,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtB,KAAK,IAAI,SAAS,GAAG,YAAY,EAAE,SAAS,IAAI,YAAY,EAAE,SAAS,IAAI,CAAC,EAAE,CAAC;QAC7E,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,OAAO,SAAS,CAAC;IAC7C,CAAC;IACD,oBAAoB,CAAC,2CAA2C,CAAC,CAAC;AACpE,CAAC"}

package/dist/sheets/providers/google-sheets-api/operations/readEngine.d.ts

@@ -1,50 +0,0 @@
-/**
- * Unified read engine executor (design/unified-read-engine.md §3).
- *
- * Runs an already-packed band plan as SEQUENTIAL paced `spreadsheets.get`
- * requests on the lane's request-start class and reassembles the replies
- * into one logical document: every requested range's GridData in request
- * order, concatenated per sheet id, so lanes consume band replies through
- * the SAME accessors (`resolveGridCell`, `synthesizeScopedTargetGrid`,
- * `pickRegisteredGrid`) that serve today's multi-range replies. Each band
- * is one server snapshot and consumes exactly one `runRead` slot, so:
- * - telemetry emits ONE event per band with the RAW-document `responseBytes`
- *   (sink-gated exactly like the historical reads) — per-lane, per-band
- *   bytes are observable without any extra plumbing;
- * - a timeout or rejection fails ONE band with the existing
- *   delivery-uncertain classification instead of an all-or-nothing
- *   multi-megabyte single request;
- * - every response's `sheets.properties.gridProperties.rowCount` refreshes
- *   the provider-instance authoritative bounds cache (a ranged GET returns
- *   properties for the intersecting sheets), and `responseBytes ÷
- *   cellsRequested` feeds the per-evidence calibration multiplier, so a
- *   mispredicted band size shrinks the NEXT pass's bands.
- */
-import type { BandedGet, EngineRuntime, ReadEvidence } from "../model/readPlan.js";
-import { type GoogleSheetsApiProviderDeps, type RequestStartPacing } from "./shared.js";
-/**
- * Builds the executor for ONE logical read: fixed field mask, evidence
- * class, pacing lane, and telemetry label. The returned closure owns no
- * state — bounds/calibration updates land on the shared `deps` carriers.
- */
-export declare function createBandedGet(deps: GoogleSheetsApiProviderDeps, pacing: RequestStartPacing, fields: string, evidence: ReadEvidence, label: string): BandedGet;
-/**
- * Builds the model-facing engine runtime for one logical read on one lane:
- * the fields/evidence → executor factory plus the shared bounds cache and
- * calibration tracker. Model functions receive this instead of a raw
- * transport, which is what lets a single logical read expand into
- * sequential paced band requests WITHOUT the model layer importing the
- * operations layer.
- */
-export declare function createEngineRuntime(deps: GoogleSheetsApiProviderDeps, pacing: RequestStartPacing, label: string): EngineRuntime;
-/**
- * Ensures every listed tab has an authoritative row bound in the
- * provider-instance cache, settling cold titles with ONE range-less
- * metadata enumeration (`gridProperties.rowCount` is metadata-only). The
- * cache is refreshed by every subsequent engine response's sheet
- * properties, so the enumeration is a once-per-title-per-instance cost —
- * the polling lane has no per-dispatch enumeration of its own and this is
- * where its committed upper bound comes from.
- */
-export declare function ensureSheetRowBounds(deps: GoogleSheetsApiProviderDeps, pacing: RequestStartPacing, titles: readonly string[]): Promise<void>;
-//# sourceMappingURL=readEngine.d.ts.map