hikoutei 0.10.1-dev → 0.10.3-dev

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

@@ -1 +0,0 @@
-{"version":3,"file":"readEngine.d.ts","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/operations/readEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAOH,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EAEb,YAAY,EACb,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAIL,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACxB,MAAM,aAAa,CAAC;AAErB;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,2BAA2B,EACjC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,GACZ,SAAS,CAwDX;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,2BAA2B,EACjC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,GACZ,aAAa,CAMf;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,2BAA2B,EACjC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/sheets/providers/google-sheets-api/operations/readEngine.js

@@ -1,124 +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 { enumerateSheetProperties } from "../model/preflightContext.js";
-import { parseSpreadsheetDocument } from "../model/preflightParsing.js";
-import { createRawResponseMeta, credentialBinding, runRead, } 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 function createBandedGet(deps, pacing, fields, evidence, label) {
-    return async (requests) => {
-        const sheetsByTitle = new Map();
-        const grids = new Map();
-        let executed = 0;
-        let bytes = 0;
-        for (const request of requests) {
-            if (request.length === 0)
-                continue;
-            const ranges = request.map((item) => item.range);
-            const cells = request.reduce((total, item) => total + item.cells, 0);
-            // The RAW document is measured INSIDE the paced task (the awaited-call
-            // ordering the historical reads proved): runRead emits its telemetry
-            // event when the task resolves, so a later measurement would land one
-            // event too late.
-            const rawMeta = createRawResponseMeta(deps);
-            const raw = await runRead(deps, async (credentialIndex) => {
-                const response = await deps.transport.getSpreadsheet({
-                    spreadsheetId: deps.spreadsheetId,
-                    ranges,
-                    fields,
-                    ...(deps.readTimeoutMs === undefined ? {} : { timeoutMs: deps.readTimeoutMs }),
-                    ...credentialBinding(credentialIndex),
-                });
-                rawMeta.onRawResponse?.(response);
-                return response;
-            }, pacing, rawMeta.meta);
-            executed += 1;
-            const document = parseSpreadsheetDocument(raw, label);
-            for (const sheet of document.sheets) {
-                // Last-seen properties win (fresher grid metadata); consumers only
-                // read identity/merges from this list, grid data lives in `grids`.
-                sheetsByTitle.set(sheet.title, sheet);
-                const rowCount = sheet.gridProperties?.rowCount;
-                if (rowCount !== undefined)
-                    deps.sheetRowBounds.set(sheet.title, rowCount);
-            }
-            for (const [sheetId, list] of document.grids) {
-                const existing = grids.get(sheetId);
-                if (existing === undefined)
-                    grids.set(sheetId, [...list]);
-                else
-                    existing.push(...list);
-            }
-            if (rawMeta.meta.responseBytes !== undefined) {
-                bytes += rawMeta.meta.responseBytes;
-                deps.readCalibration.observe(evidence, cells, rawMeta.meta.responseBytes);
-            }
-        }
-        const document = {
-            sheets: [...sheetsByTitle.values()],
-            grids,
-            requests: executed,
-            bytes,
-        };
-        return document;
-    };
-}
-/**
- * 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 function createEngineRuntime(deps, pacing, label) {
-    return {
-        makeGet: (fields, evidence) => createBandedGet(deps, pacing, fields, evidence, label),
-        rowBounds: deps.sheetRowBounds,
-        calibration: deps.readCalibration,
-    };
-}
-/**
- * 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 async function ensureSheetRowBounds(deps, pacing, titles) {
-    if (titles.every((title) => deps.sheetRowBounds.has(title)))
-        return;
-    const enumeration = createRawResponseMeta(deps);
-    const sheets = await runRead(deps, (credentialIndex) => enumerateSheetProperties(deps.transport, deps.spreadsheetId, deps.readTimeoutMs, enumeration.onRawResponse, credentialIndex), pacing, enumeration.meta);
-    for (const sheet of sheets) {
-        const rowCount = sheet.gridProperties?.rowCount;
-        if (rowCount !== undefined)
-            deps.sheetRowBounds.set(sheet.title, rowCount);
-    }
-}
-//# sourceMappingURL=readEngine.js.map

package/dist/sheets/providers/google-sheets-api/operations/readEngine.js.map

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

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

@@ -1,90 +0,0 @@
-/**
- * Unified write engine executor (mirrors the read side's `readEngine.ts`).
- *
- * Every provider write path (fast-append single/multi, apply target + inline
- * receipt follow-up, combined multi-route apply) runs the SAME mechanics:
- * build the batch (model/batchBuilder), pace one `batchUpdate` start on the
- * WRITE limiter (`runWrite`), and validate the reply
- * (`requireValidBatchUpdateReply`) so a malformed 2xx never closes effects.
- * `executeBatchUpdate` is the single implementation of that sequence; the
- * builders and the post-write result encoding stay with the callers because
- * their contents and bookkeeping differ per operation.
- *
- * `executePreparedWrite` is the single implementation of the receipt-tab
- * initialization guard: a read-ahead preflight can observe the shared receipt
- * tab absent before a concurrent write creates it, and two stale preflights
- * would otherwise both emit a duplicate `addSheet` (the second fails 400).
- * When the unit needs initialization, refresh + write run as ONE atomic
- * section on the per-spreadsheet `receiptInitLock`; steady state (receipt
- * present at preflight) never takes the lock. Callers keep their own
- * eligibility guard: a deterministic no-op batch must not take the refresh,
- * whose write-lane admission can be refused under saturation and would turn
- * the no-op into a delivery-uncertain requeue.
- *
- * `groupByRouteKey` is the single implementation of multi-route grouping:
- * items are bucketed by their canonical route key, first-seen group order and
- * per-group order preserved (the grouped plan order drives the combined byte
- * budget and the result walk, so both must stay stable).
- */
-import type { BuiltApplyBatch } from "../model/batchBuilder.js";
-import type { PreflightContext } from "../model/preflightContext.js";
-import { type GoogleSheetsApiProviderDeps } from "./shared.js";
-/** Per-operation effect counts attached to one write event's telemetry. */
-export interface WriteBatchTelemetry {
-    /** Effects requested for the whole operation (pre-budget). */
-    readonly requestedEffects: number;
-    /** Effects included in the written batch (the budget-fitting prefix). */
-    readonly includedEffects: number;
-}
-/**
- * Sends one built batch as ONE paced `batchUpdate` and validates the reply.
- *
- * `BuiltApplyBatch` is the shared return shape of every batch builder (apply,
- * append, and their combined variants), and the batch contents here are
- * exactly what the caller's builder produced: the engine never rebuilds or
- * reorders requests. A malformed or short reply throws the existing
- * delivery-uncertain invalid-state classification, so a 2xx that cannot be
- * matched request-for-request never closes effects. Zero-request batches must
- * be skipped by the caller (no transport call and no telemetry event for an
- * empty batch, exactly like before).
- */
-export declare function executeBatchUpdate(deps: GoogleSheetsApiProviderDeps, batch: BuiltApplyBatch, telemetry: WriteBatchTelemetry): Promise<void>;
-/**
- * Runs one prepared write unit behind the receipt-init guard.
- *
- * `context` is whatever the write closure needs (a single route's
- * `PreflightContext` or a multi-route list). When `needsReceiptInit` is true,
- * `refresh` re-reads the shared receipt tab under the `receiptInitLock` and
- * `write` runs against the REFRESHED context inside the same lock section;
- * otherwise `write` runs against the preflight context with no lock. Failure
- * behavior is unchanged: a refused refresh admission or a rejected write
- * propagates with its own classification, and the tail lock still releases
- * for the next holder.
- */
-export declare function executePreparedWrite<C, R>(deps: GoogleSheetsApiProviderDeps, unit: {
-    readonly context: C;
-    readonly needsReceiptInit: boolean;
-    readonly refresh: (context: C) => Promise<C>;
-    readonly write: (context: C) => Promise<R>;
-}): Promise<R>;
-/**
- * Refreshes the shared receipt tab through the FIRST route's context and
- * returns the route list with that context replaced (multi-route units).
- *
- * Provisioning guarantees one definition per tab, so every route of one
- * combined batch sees the SAME receipt-tab presence at preflight; refreshing
- * the first context is sufficient and later writers append instead of
- * re-emitting `addSheet`. An empty route list is returned unchanged (nothing
- * to refresh or write).
- */
-export declare function refreshFirstRouteContext<R extends {
-    readonly context: PreflightContext;
-}>(deps: GoogleSheetsApiProviderDeps, routes: readonly R[]): Promise<readonly R[]>;
-/** True when a preflight context observed the shared receipt tab absent. */
-export declare function receiptInitNeeded(context: PreflightContext): boolean;
-/**
- * Buckets items by their canonical route key (see `routeKeyOf` in
- * applyEffects): first-seen group order and per-group order are preserved.
- */
-export declare function groupByRouteKey<T>(items: readonly T[], keyOf: (item: T) => string): readonly (readonly T[])[];
-//# sourceMappingURL=writeEngine.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"writeEngine.d.ts","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/operations/writeEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAIL,KAAK,2BAA2B,EACjC,MAAM,aAAa,CAAC;AAErB,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,2BAA2B,EACjC,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAC7C,IAAI,EAAE,2BAA2B,EACjC,IAAI,EAAE;IACJ,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CAC5C,GACA,OAAO,CAAC,CAAC,CAAC,CAIZ;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,CAAC,SAAS;IAAE,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,EAEhD,IAAI,EAAE,2BAA2B,EACjC,MAAM,EAAE,SAAS,CAAC,EAAE,GACnB,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAMvB;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAEpE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACzB,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAY3B"}

package/dist/sheets/providers/google-sheets-api/operations/writeEngine.js

@@ -1,112 +0,0 @@
-/**
- * Unified write engine executor (mirrors the read side's `readEngine.ts`).
- *
- * Every provider write path (fast-append single/multi, apply target + inline
- * receipt follow-up, combined multi-route apply) runs the SAME mechanics:
- * build the batch (model/batchBuilder), pace one `batchUpdate` start on the
- * WRITE limiter (`runWrite`), and validate the reply
- * (`requireValidBatchUpdateReply`) so a malformed 2xx never closes effects.
- * `executeBatchUpdate` is the single implementation of that sequence; the
- * builders and the post-write result encoding stay with the callers because
- * their contents and bookkeeping differ per operation.
- *
- * `executePreparedWrite` is the single implementation of the receipt-tab
- * initialization guard: a read-ahead preflight can observe the shared receipt
- * tab absent before a concurrent write creates it, and two stale preflights
- * would otherwise both emit a duplicate `addSheet` (the second fails 400).
- * When the unit needs initialization, refresh + write run as ONE atomic
- * section on the per-spreadsheet `receiptInitLock`; steady state (receipt
- * present at preflight) never takes the lock. Callers keep their own
- * eligibility guard: a deterministic no-op batch must not take the refresh,
- * whose write-lane admission can be refused under saturation and would turn
- * the no-op into a delivery-uncertain requeue.
- *
- * `groupByRouteKey` is the single implementation of multi-route grouping:
- * items are bucketed by their canonical route key, first-seen group order and
- * per-group order preserved (the grouped plan order drives the combined byte
- * budget and the result walk, so both must stay stable).
- */
-import { PRESENCE_KINDS } from "../../../../contracts/state/index.js";
-import { refreshReceiptForWrite } from "./preflightOp.js";
-import { credentialBinding, requireValidBatchUpdateReply, runWrite, } from "./shared.js";
-/**
- * Sends one built batch as ONE paced `batchUpdate` and validates the reply.
- *
- * `BuiltApplyBatch` is the shared return shape of every batch builder (apply,
- * append, and their combined variants), and the batch contents here are
- * exactly what the caller's builder produced: the engine never rebuilds or
- * reorders requests. A malformed or short reply throws the existing
- * delivery-uncertain invalid-state classification, so a 2xx that cannot be
- * matched request-for-request never closes effects. Zero-request batches must
- * be skipped by the caller (no transport call and no telemetry event for an
- * empty batch, exactly like before).
- */
-export async function executeBatchUpdate(deps, batch, telemetry) {
-    const response = await runWrite(deps, (credentialIndex) => deps.transport.batchUpdate({
-        spreadsheetId: deps.spreadsheetId,
-        requests: batch.requests,
-        ...credentialBinding(credentialIndex),
-    }), {
-        requestCount: batch.requests.length,
-        bodyBytes: batch.bytes,
-        ...telemetry,
-    });
-    requireValidBatchUpdateReply(response, batch.requests.length);
-}
-/**
- * Runs one prepared write unit behind the receipt-init guard.
- *
- * `context` is whatever the write closure needs (a single route's
- * `PreflightContext` or a multi-route list). When `needsReceiptInit` is true,
- * `refresh` re-reads the shared receipt tab under the `receiptInitLock` and
- * `write` runs against the REFRESHED context inside the same lock section;
- * otherwise `write` runs against the preflight context with no lock. Failure
- * behavior is unchanged: a refused refresh admission or a rejected write
- * propagates with its own classification, and the tail lock still releases
- * for the next holder.
- */
-export async function executePreparedWrite(deps, unit) {
-    if (!unit.needsReceiptInit)
-        return unit.write(unit.context);
-    return deps.receiptInitLock.run(async () => unit.write(await unit.refresh(unit.context)));
-}
-/**
- * Refreshes the shared receipt tab through the FIRST route's context and
- * returns the route list with that context replaced (multi-route units).
- *
- * Provisioning guarantees one definition per tab, so every route of one
- * combined batch sees the SAME receipt-tab presence at preflight; refreshing
- * the first context is sufficient and later writers append instead of
- * re-emitting `addSheet`. An empty route list is returned unchanged (nothing
- * to refresh or write).
- */
-export async function refreshFirstRouteContext(deps, routes) {
-    const first = routes[0];
-    if (first === undefined)
-        return routes;
-    const refreshed = await refreshReceiptForWrite(deps, first.context);
-    return routes.map((route, index) => index === 0 ? { ...route, context: refreshed } : route);
-}
-/** True when a preflight context observed the shared receipt tab absent. */
-export function receiptInitNeeded(context) {
-    return context.receiptSheetId.kind === PRESENCE_KINDS.ABSENT;
-}
-/**
- * Buckets items by their canonical route key (see `routeKeyOf` in
- * applyEffects): first-seen group order and per-group order are preserved.
- */
-export function groupByRouteKey(items, keyOf) {
-    const groups = new Map();
-    for (const item of items) {
-        const key = keyOf(item);
-        const group = groups.get(key);
-        if (group === undefined) {
-            groups.set(key, [item]);
-        }
-        else {
-            group.push(item);
-        }
-    }
-    return [...groups.values()];
-}
-//# sourceMappingURL=writeEngine.js.map

package/dist/sheets/providers/google-sheets-api/operations/writeEngine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"writeEngine.js","sourceRoot":"","sources":["../../../../../../../../src/sheets/providers/google-sheets-api/operations/writeEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAGpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,QAAQ,GAET,MAAM,aAAa,CAAC;AAUrB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,IAAiC,EACjC,KAAsB,EACtB,SAA8B;IAE9B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,eAAe,EAAE,EAAE,CACxD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;QACzB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,GAAG,iBAAiB,CAAC,eAAe,CAAC;KACtC,CAAC,EAAE;QACJ,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM;QACnC,SAAS,EAAE,KAAK,CAAC,KAAK;QACtB,GAAG,SAAS;KACb,CAAC,CAAC;IACH,4BAA4B,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,IAAiC,EACjC,IAKC;IAED,IAAI,CAAC,IAAI,CAAC,gBAAgB;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5D,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CACzC,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAG5C,IAAiC,EACjC,MAAoB;IAEpB,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACxB,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACvC,MAAM,SAAS,GAAG,MAAM,sBAAsB,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACpE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACjC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAC5D,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,iBAAiB,CAAC,OAAyB;IACzD,OAAO,OAAO,CAAC,cAAc,CAAC,IAAI,KAAK,cAAc,CAAC,MAAM,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAmB,EACnB,KAA0B;IAE1B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAe,CAAC;IACtC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QACxB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AAC9B,CAAC"}

package/dist/sheets/providers/google-sheets-api/transport/quotaGovernor.d.ts

@@ -1,229 +0,0 @@
-/**
- * Adaptive quota governor layered ON TOP of the request-start limiters.
- *
- * The interval limiters (`RequestStartLimiter`, `ReadQoSScheduler`) space
- * request STARTS but have no notion of the per-minute quota budget, and a
- * remote 429 never feeds back into their pacing. This module adds the two
- * missing pieces, both of which gate request STARTS only and never touch
- * CAS/fencing, prepared-state, batch building, or result encoding:
- *
- * 1. `RollingQuotaBudget` — a sliding-window per-minute TOTAL request-start
- *    budget per lane (reads vs writes). It composes with (does not replace)
- *    the interval limiters: a start must pass BOTH the budget and its lane's
- *    interval pacing. Admission is BOUNDED with the same semantics as the
- *    interval limiters: a refused caller reserves nothing, so a refusal can
- *    never advance the budget window or the pacing horizon.
- *
- * 2. `QuotaPacingGovernor` — AIMD pacing feedback. When a transport response
- *    is classified as quota-limited (HTTP 429 / `RESOURCE_EXHAUSTED`), the
- *    offending lane's pacing interval doubles (multiplicative decrease,
- *    capped at a multiple of the base). After a sustained quiet period
- *    (enough successful request starts, or enough elapsed time since the
- *    last quota event), the interval steps back down ~10% at a time
- *    (additive increase) and never falls below the base. With no 429 ever
- *    observed the governor stays `nominal` at 1x and pacing is byte-for-byte
- *    the pre-governor behavior.
- *
- * Why a per-minute budget at all: the binding Google quota for our
- * deployment is the per-user READ rate (60/min); a measured 30k-effect
- * burst peaked near 69/min of reads, producing 429s and a delivery-uncertain
- * requeue spiral. The interval pacing alone (75/min at the 800 ms default)
- * cannot hold a per-minute ceiling because concurrent lock-free readers each
- * reserve successive interval slots without any rate cap per window.
- */
-import { type Presence } from "../../../../contracts/state/index.js";
-/** Lanes the governor paces: the shared read timeline and the write lane. */
-export declare const QUOTA_GOVERNOR_LANES: {
-    readonly READ: "read";
-    readonly WRITE: "write";
-};
-/** Union type derived from the governor lane table. */
-export type QuotaGovernorLane = (typeof QUOTA_GOVERNOR_LANES)[keyof typeof QUOTA_GOVERNOR_LANES];
-/** Lifecycle states of one lane's AIMD pacing. */
-export declare const QUOTA_PACING_STATES: {
-    readonly NOMINAL: "nominal";
-    readonly BACKOFF: "backoff";
-    readonly RECOVERY: "recovery";
-};
-/**
- * Discriminated AIMD pacing state of ONE lane.
- *
- * `nominal` — never backed off (or fully recovered); multiplier is exactly 1.
- * `backoff` — at least one quota event, no recovery step taken yet.
- * `recovery` — at least one recovery step taken, still above the base.
- * The state carries the counters the next transition reads; there is no
- * sentinel `null` for "not backed off" — `nominal` is its own variant.
- */
-export type QuotaPacingState = {
-    readonly status: typeof QUOTA_PACING_STATES.NOMINAL;
-    readonly multiplier: 1;
-} | {
-    readonly status: typeof QUOTA_PACING_STATES.BACKOFF;
-    readonly multiplier: number;
-    /** Clock instant of the most recent quota-limited response. */
-    readonly lastQuotaEventAt: number;
-    /** Successful request starts recorded since that event. */
-    readonly quietStarts: number;
-} | {
-    readonly status: typeof QUOTA_PACING_STATES.RECOVERY;
-    readonly multiplier: number;
-    readonly lastQuotaEventAt: number;
-    readonly quietStarts: number;
-};
-export interface QuotaPacingGovernorOptions {
-    /** Configured base pacing interval for both lanes. */
-    readonly baseIntervalMs: number;
-    /** Injectable clock for deterministic tests; defaults to Date.now. */
-    readonly now?: () => number;
-}
-/**
- * AIMD pacing feedback for the two request-start lanes.
- *
- * `intervalMsFor(lane)` is polled by the lane's limiter at each reservation,
- * so a doubled multiplier doubles the effective spacing on the NEXT start
- * without reconstructing the limiter. `recordRequestStart` and
- * `recordQuotaLimited` are the only state inputs; both are fire-and-forget
- * bookkeeping that can never throw out of the admission path.
- */
-export declare class QuotaPacingGovernor {
-    private readonly baseIntervalMs;
-    private readonly now;
-    private readonly lanes;
-    constructor(options: QuotaPacingGovernorOptions);
-    /** Effective pacing interval for one lane: base x AIMD multiplier. */
-    intervalMsFor(lane: QuotaGovernorLane): number;
-    /**
-     * Multiplicative decrease: one quota-limited (429) response doubles this
-     * lane's multiplier, capped at `QUOTA_BACKOFF_MAX_MULTIPLIER` of base.
-     */
-    recordQuotaLimited(lane: QuotaGovernorLane): void;
-    /**
-     * Additive increase: one successful request start on this lane. After a
-     * sustained quiet period (RECOVERY_SUCCESS_THRESHOLD starts, or
-     * RECOVERY_QUIET_MS elapsed since the last quota event) the multiplier
-     * steps down by ~10% and needs a FRESH quiet period before the next step,
-     * so recovery is gradual and a single 429 cannot be answered with a
-     * immediate undo. Landing on exactly 1x returns the lane to `nominal`.
-     */
-    recordRequestStart(lane: QuotaGovernorLane): void;
-    /**
-     * Elapsed-time-only quiet recovery, applied lazily at every state
-     * observation: with no traffic on the lane, `recordRequestStart` never
-     * runs, so a backed-off lane would otherwise stay in backoff forever.
-     */
-    private recoverByElapsed;
-    /** One additive-increase step: ~10% down, clamped at nominal (1x). */
-    private stepDown;
-    /** Read-only snapshot of one lane's pacing state (for telemetry/tests). */
-    stateFor(lane: QuotaGovernorLane): QuotaPacingState;
-}
-/**
- * Returns true when a classified transport outcome proves the request was
- * quota-limited remotely (HTTP 429 or the allowlisted `RESOURCE_EXHAUSTED`
- * google.rpc code; either marker alone is sufficient because a proxy-emitted
- * 429 can carry no body and a body can omit the status line evidence).
- */
-export declare function isQuotaLimitedOutcome(outcome: {
-    readonly httpStatus: Presence<number>;
-    readonly code: Presence<string>;
-}): boolean;
-export interface RollingQuotaBudgetOptions {
-    /**
-     * Maximum admitted request starts per window for this lane.
-     * `Number.POSITIVE_INFINITY` disables the budget (used by tests that pin
-     * pacing separately and simulate high rates over near-zero wall time).
-     */
-    readonly maxStartsPerWindow: number;
-    /** Sliding window length in ms (Google quotas are per-minute). */
-    readonly windowMs: number;
-    /** Injectable clock for deterministic tests; defaults to Date.now. */
-    readonly now?: () => number;
-    /** Injectable sleep used while waiting for the next budget slot. */
-    readonly sleep?: (ms: number) => Promise<void>;
-}
-/**
- * Opaque handle for ONE provisional budget reservation returned by
- * `waitForSlot`. Passed back to {@link RollingQuotaBudget.rollback} when a
- * downstream admission gate refuses after the budget already reserved, so a
- * refused request never keeps consuming budget. The token is matched by
- * OBJECT IDENTITY, never by its timestamp, so a rollback can never release
- * a different (live) reservation, and a repeated rollback is a no-op.
- */
-export interface BudgetReservation {
-    /** Internal: the reserved start time, read only by the owning budget. */
-    readonly reservedAt: number;
-}
-/** Admitted result of `RollingQuotaBudget.waitForSlot` (adds the rollback token). */
-export type RollingQuotaBudgetAdmission = {
-    readonly status: "admitted";
-    readonly waitedMs: number;
-    readonly reservation: BudgetReservation;
-} | {
-    readonly status: "refused";
-    readonly waitedMs: number;
-    readonly nextStartAt: number;
-};
-/**
- * Sliding-window per-minute request-start budget for ONE lane.
- *
- * Reservations, not completed requests, occupy the window: an admitted
- * caller records the slot it will start at, so a burst of concurrent
- * callers arriving in the same tick each consumes one of the remaining
- * budget slots and the deep ones are refused by the bounded wait, exactly
- * like the interval limiters. A budget refusal records NOTHING, so the
- * window can never be poisoned forward by refused callers.
- *
- * A budget ADMISSION reserves provisionally: a caller that later has to
- * refuse on a downstream gate (e.g. the pacing lane) hands the reservation
- * token to `rollback`, which removes exactly that entry. Rollback never
- * advances (or otherwise touches) the window and can never free a live
- * reservation belonging to another caller.
- *
- * The earliest legal start when the window already holds `max` reservations
- * is `starts[n - max] + windowMs`: at that instant all but the `max - 1`
- * newest reservations have aged out, so admitting keeps the count at `max`.
- */
-export declare class RollingQuotaBudget {
-    private readonly maxStartsPerWindow;
-    private readonly windowMs;
-    private readonly now;
-    private readonly sleep;
-    /**
-     * Reserved start times, kept in chronological (non-decreasing `reservedAt`)
-     * order at all times. Rollback splices its own entry out (order survives)
-     * and every new reservation is inserted at its sorted position rather than
-     * blindly appended: a rolled-back older slot must never let a later caller
-     * land BEHIND a queued future reservation, or the prefix expiry scan would
-     * stop at the future entry and retain the trailing expired one forever,
-     * leaking budget capacity.
-     */
-    private starts;
-    constructor(options: RollingQuotaBudgetOptions);
-    /** Number of reservations (admitted, possibly still sleeping) in window. */
-    reservedCount(): number;
-    /**
-     * Bounded admission to one budget slot: waits only when the predicted
-     * slot is at most `maxWaitMs` out, otherwise returns `refused` having
-     * reserved nothing. The decision and the reservation happen synchronously
-     * before any await, so concurrent callers can never double-book one slot.
-     */
-    waitForSlot(maxWaitMs: number): Promise<RollingQuotaBudgetAdmission>;
-    /**
-     * Inserts one reservation keeping {@link starts} chronologically ordered.
-     * The common case (slot at or after every existing entry) is a plain push;
-     * only an out-of-order arrival after a rollback walks back from the tail,
-     * which is bounded by the window budget (a few hundred entries per minute).
-     */
-    private insertReservation;
-    /**
-     * Rolls back one PROVISIONAL budget reservation returned by `waitForSlot`
-     * whose caller never reached request start (e.g. a downstream pacing-lane
-     * refusal). Invariants: the removal is matched by object identity, so it
-     * can never release a different live reservation; a token that was already
-     * rolled back or aged out of the window is a no-op (no double release);
-     * rollback never advances the window (remaining reservations and their
-     * timestamps are untouched).
-     */
-    rollback(reservation: BudgetReservation): void;
-}
-//# sourceMappingURL=quotaGovernor.d.ts.map

package/dist/sheets/providers/google-sheets-api/transport/quotaGovernor.d.ts.map

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