hikoutei 0.3.4 → 0.3.6

package/dist/adapter/sheets/providers/apps-script-gateway/operations/effect/effectOperationScript.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effectOperationScript.js","sourceRoot":"","sources":["../../../../../../../src/adapter/sheets/providers/apps-script-gateway/operations/effect/effectOperationScript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAE3F,yFAAyF;AACzF,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqyB/C,+BAA+B;EAC/B,CAAC"}

package/dist/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.d.ts

@@ -1,31 +0,0 @@
-/** Thin-Gateway operations for anchors and normalized Sheet snapshots. */
-import type { EnsureSyncRowAnchorsRequest, EnsureSyncRowAnchorsResult, ReadSyncSnapshotRequest, SyncObservedSnapshot, SyncGatewaySnapshot } from "../../../../../../application/sync/gateway/syncGateway.js";
-import type { AppsScriptOperationDefinition } from "../../transport/operationClient.js";
-declare const OBSERVATION_OPERATION_MODES: {
-    readonly ENSURE_ANCHORS: "ensureRowAnchors";
-    readonly READ_SNAPSHOT: "readSnapshot";
-    readonly OBSERVE_SNAPSHOT: "observeSnapshot";
-};
-interface ObservationOperationRouteOptions {
-    readonly checkboxHeaders?: readonly string[];
-    /** Local-only schema evidence used to validate decoded snapshot headers. */
-    readonly expectedHeaders?: readonly string[];
-}
-type ObservationOperationRequest = (EnsureSyncRowAnchorsRequest | ReadSyncSnapshotRequest) & ObservationOperationRouteOptions;
-export type AppsScriptEnsureRowAnchorsOperationArgs = {
-    readonly mode: typeof OBSERVATION_OPERATION_MODES.ENSURE_ANCHORS;
-} & ObservationOperationRequest;
-export type AppsScriptReadSnapshotOperationArgs = {
-    readonly mode: typeof OBSERVATION_OPERATION_MODES.READ_SNAPSHOT;
-} & ObservationOperationRequest;
-export type AppsScriptObserveSnapshotOperationArgs = {
-    readonly mode: typeof OBSERVATION_OPERATION_MODES.OBSERVE_SNAPSHOT;
-} & ObservationOperationRequest;
-/** Builds the metadata-anchor assignment operation used before observation. */
-export declare function createEnsureRowAnchorsOperation(request: EnsureSyncRowAnchorsRequest & ObservationOperationRouteOptions): AppsScriptOperationDefinition<AppsScriptEnsureRowAnchorsOperationArgs, EnsureSyncRowAnchorsResult>;
-/** Builds the normalized, read-only Sheet snapshot operation. */
-export declare function createReadSnapshotOperation(request: ReadSyncSnapshotRequest & ObservationOperationRouteOptions): AppsScriptOperationDefinition<AppsScriptReadSnapshotOperationArgs, SyncGatewaySnapshot>;
-/** Builds one operation that assigns anchors and reads the snapshot under one lock. */
-export declare function createObserveSnapshotOperation(request: ReadSyncSnapshotRequest & ObservationOperationRouteOptions): AppsScriptOperationDefinition<AppsScriptObserveSnapshotOperationArgs, SyncObservedSnapshot>;
-export {};
-//# sourceMappingURL=observationOperation.d.ts.map

package/dist/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observationOperation.d.ts","sourceRoot":"","sources":["../../../../../../../src/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAG1E,OAAO,KAAK,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,2DAA2D,CAAC;AAwBnE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAQxF,QAAA,MAAM,2BAA2B;;;;CAIvB,CAAC;AAEX,UAAU,gCAAgC;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,4EAA4E;IAC5E,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED,KAAK,2BAA2B,GAC9B,CAAC,2BAA2B,GAAG,uBAAuB,CAAC,GAAG,gCAAgC,CAAC;AAE7F,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,CAAC,IAAI,EAAE,OAAO,2BAA2B,CAAC,cAAc,CAAC;CAClE,GAAG,2BAA2B,CAAC;AAEhC,MAAM,MAAM,mCAAmC,GAAG;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,2BAA2B,CAAC,aAAa,CAAC;CACjE,GAAG,2BAA2B,CAAC;AAEhC,MAAM,MAAM,sCAAsC,GAAG;IACnD,QAAQ,CAAC,IAAI,EAAE,OAAO,2BAA2B,CAAC,gBAAgB,CAAC;CACpE,GAAG,2BAA2B,CAAC;AAEhC,+EAA+E;AAC/E,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,2BAA2B,GAAG,gCAAgC,GACtE,6BAA6B,CAC9B,uCAAuC,EACvC,0BAA0B,CAC3B,CAQA;AAED,iEAAiE;AACjE,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,uBAAuB,GAAG,gCAAgC,GAClE,6BAA6B,CAAC,mCAAmC,EAAE,mBAAmB,CAAC,CAQzF;AAED,uFAAuF;AACvF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,uBAAuB,GAAG,gCAAgC,GAClE,6BAA6B,CAC9B,sCAAsC,EACtC,oBAAoB,CACrB,CAQA"}

package/dist/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.js

@@ -1,560 +0,0 @@
-/** Thin-Gateway operations for anchors and normalized Sheet snapshots. */
-import { APPS_SCRIPT_STABLE_CODEC_SOURCE } from "../shared/appsScriptStableCodecSource.js";
-import { CELL_OBSERVATION_KINDS, } from "../../../../../../shared/encoding/constants.js";
-import { isNormalizedCell } from "../../../../../../shared/encoding/normalizedCell.js";
-import { SYNC_GATEWAY_ERROR_CODES, } from "../../../../../../application/sync/gateway/errors.js";
-import { SYNC_GATEWAY_PROJECTIONS, SYNC_GATEWAY_PROTOCOL_VERSIONS, SYNC_GATEWAY_SNAPSHOT_READ_MODES, } from "../../../../../../application/sync/gateway/constants.js";
-import { decodeSyncGatewayPresenceNonNegativeSafeInteger as decodePresenceNonNegativeInteger, decodeSyncGatewayPresenceString as decodePresenceString, requireSyncGatewayNonNegativeSafeInteger, requireSyncGatewayPositiveSafeInteger, requireSyncGatewayProjection, requireSyncGatewaySnapshotReadMode, requireSyncGatewayText, } from "../../../../../../application/sync/gateway/validation.js";
-import { decodeOptionalSyncGatewayTiming } from "../../protocol/timing.js";
-import { invalidOperationRequest, invalidOperationResponse, } from "../../errors.js";
-import { requireOperationRecord } from "../../validation.js";
-const OBSERVATION_OPERATION_MODES = {
-    ENSURE_ANCHORS: "ensureRowAnchors",
-    READ_SNAPSHOT: "readSnapshot",
-    OBSERVE_SNAPSHOT: "observeSnapshot",
-};
-/** Builds the metadata-anchor assignment operation used before observation. */
-export function createEnsureRowAnchorsOperation(request) {
-    validateObservationRequest(request);
-    const { expectedHeaders: _expectedHeaders, ...wireRequest } = request;
-    return {
-        fn: OBSERVATION_OPERATION_SOURCE,
-        args: { mode: OBSERVATION_OPERATION_MODES.ENSURE_ANCHORS, ...wireRequest },
-        decode: decodeEnsureRowAnchorsResult,
-    };
-}
-/** Builds the normalized, read-only Sheet snapshot operation. */
-export function createReadSnapshotOperation(request) {
-    validateObservationRequest(request);
-    const { expectedHeaders, ...wireRequest } = request;
-    return {
-        fn: READ_SNAPSHOT_OPERATION_SOURCE,
-        args: { mode: OBSERVATION_OPERATION_MODES.READ_SNAPSHOT, ...wireRequest },
-        decode: (value) => decodeSnapshot(value, request, expectedHeaders),
-    };
-}
-/** Builds one operation that assigns anchors and reads the snapshot under one lock. */
-export function createObserveSnapshotOperation(request) {
-    validateObservationRequest(request);
-    const { expectedHeaders, ...wireRequest } = request;
-    return {
-        fn: OBSERVATION_OPERATION_SOURCE,
-        args: { mode: OBSERVATION_OPERATION_MODES.OBSERVE_SNAPSHOT, ...wireRequest },
-        decode: (value) => decodeObservedSnapshot(value, request, expectedHeaders),
-    };
-}
-function validateObservationRequest(request) {
-    if (request.authority !== undefined &&
-        (!Number.isSafeInteger(request.authority.epoch) || request.authority.epoch < 1 ||
-            request.authority.token.trim().length === 0)) {
-        invalidOperationRequest("Apps Script observation operation", "authority is invalid");
-    }
-    requireSyncGatewayText(request.physicalSheetId, "Apps Script observation physicalSheetId", SYNC_GATEWAY_ERROR_CODES.INVALID_EFFECT_PAYLOAD);
-    requireSyncGatewayText(request.sheetName, "Apps Script observation sheetName", SYNC_GATEWAY_ERROR_CODES.INVALID_EFFECT_PAYLOAD);
-    requireSyncGatewayText(request.registeredRange, "Apps Script observation registeredRange", SYNC_GATEWAY_ERROR_CODES.INVALID_EFFECT_PAYLOAD);
-    requireSyncGatewayProjection(request.projection, "Apps Script observation projection", SYNC_GATEWAY_ERROR_CODES.INVALID_EFFECT_PAYLOAD);
-    requireSyncGatewayPositiveSafeInteger(request.schemaVersion, "Apps Script observation schemaVersion", SYNC_GATEWAY_ERROR_CODES.INVALID_EFFECT_PAYLOAD);
-    if (request.checkboxHeaders !== undefined && !Array.isArray(request.checkboxHeaders)) {
-        invalidOperationRequest("Apps Script observation operation", "checkboxHeaders must be an array");
-    }
-    if ("readMode" in request && request.readMode !== undefined) {
-        const readMode = requireSyncGatewaySnapshotReadMode(request.readMode, "Apps Script observation readMode", SYNC_GATEWAY_ERROR_CODES.INVALID_EFFECT_PAYLOAD);
-        if (readMode === SYNC_GATEWAY_SNAPSHOT_READ_MODES.USER_INPUT &&
-            request.projection !== SYNC_GATEWAY_PROJECTIONS.USER_INPUT) {
-            invalidOperationRequest("Apps Script observation operation", "user_input readMode requires the user_input projection");
-        }
-    }
-}
-function decodeEnsureRowAnchorsResult(value) {
-    const record = requireRecord(value, "anchor result");
-    return {
-        assigned: requireSyncGatewayNonNegativeSafeInteger(record.assigned, "anchor result assigned", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-        existing: requireSyncGatewayNonNegativeSafeInteger(record.existing, "anchor result existing", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-        duplicateAnchors: decodeDuplicateAnchors(record.duplicateAnchors),
-    };
-}
-function decodeObservedSnapshot(value, expectedRoute, expectedHeaders) {
-    const record = requireRecord(value, "combined observation result");
-    const timing = decodeOptionalSyncGatewayTiming(record.timing, "observation timing");
-    const result = {
-        anchors: decodeEnsureRowAnchorsResult(record.anchors),
-        snapshot: decodeSnapshot(record.snapshot, expectedRoute, expectedHeaders),
-    };
-    return timing === undefined ? result : { ...result, timing };
-}
-function decodeSnapshot(value, expectedRoute, expectedHeaders) {
-    const record = requireRecord(value, "snapshot result");
-    const protocolVersion = requireSyncGatewayText(record.protocolVersion, "snapshot protocolVersion", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE);
-    if (protocolVersion !== SYNC_GATEWAY_PROTOCOL_VERSIONS.V1) {
-        return invalidOperationResponse("Apps Script observation operation", "snapshot protocolVersion is unsupported");
-    }
-    const projection = requireSyncGatewayProjection(record.projection, "snapshot projection", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE);
-    if (expectedRoute !== undefined &&
-        (record.sheetName !== expectedRoute.sheetName ||
-            record.registeredRange !== expectedRoute.registeredRange ||
-            record.projection !== expectedRoute.projection ||
-            record.schemaVersion !== expectedRoute.schemaVersion)) {
-        return invalidOperationResponse("Apps Script observation operation", "snapshot route does not match the requested registered projection");
-    }
-    const headers = decodeStringArray(record.headers, "snapshot headers");
-    if (expectedHeaders !== undefined &&
-        (headers.length !== expectedHeaders.length || headers.some((header, index) => header !== expectedHeaders[index]))) {
-        return invalidOperationResponse("Apps Script observation operation", "snapshot headers do not match the registered schema");
-    }
-    const rows = decodeSnapshotRows(record.rows, expectedHeaders);
-    return {
-        protocolVersion,
-        sheetName: requireSyncGatewayText(record.sheetName, "snapshot sheetName", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-        registeredRange: requireSyncGatewayText(record.registeredRange, "snapshot registeredRange", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-        projection,
-        schemaVersion: requireSyncGatewayPositiveSafeInteger(record.schemaVersion, "snapshot schemaVersion", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-        headers,
-        rows,
-        snapshotHash: requireSyncGatewayText(record.snapshotHash, "snapshot snapshotHash", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-        unanchoredRows: decodePositiveIntegerArray(record.unanchoredRows, "snapshot unanchoredRows"),
-        duplicateAnchors: decodeDuplicateAnchors(record.duplicateAnchors),
-    };
-}
-function decodeSnapshotRows(value, expectedHeaders) {
-    if (!Array.isArray(value)) {
-        return invalidOperationResponse("Apps Script observation operation", "snapshot rows must be an array");
-    }
-    return value.map((entry, index) => {
-        const record = requireRecord(entry, "snapshot row[" + index + "]");
-        return {
-            rowNumber: requireSyncGatewayPositiveSafeInteger(record.rowNumber, "snapshot row[" + index + "].rowNumber", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-            physicalAnchor: decodePresenceString(record.physicalAnchor, "snapshot row[" + index + "].physicalAnchor"),
-            visibleRevision: decodePresenceNonNegativeInteger(record.visibleRevision, "snapshot row[" + index + "].visibleRevision"),
-            visibleHash: decodePresenceString(record.visibleHash, "snapshot row[" + index + "].visibleHash"),
-            cells: decodeSnapshotCells(record.cells, index, expectedHeaders),
-        };
-    });
-}
-function decodeSnapshotCells(value, rowIndex, expectedHeaders) {
-    const record = requireRecord(value, "snapshot row[" + rowIndex + "].cells");
-    if (expectedHeaders !== undefined) {
-        const expected = new Set(expectedHeaders);
-        const actual = Object.keys(record);
-        if (actual.length !== expected.size || actual.some((fieldName) => !expected.has(fieldName))) {
-            return invalidOperationResponse("Apps Script observation operation", "snapshot row[" + rowIndex + "].cells do not match the registered schema");
-        }
-    }
-    const cells = {};
-    for (const [fieldName, rawCell] of Object.entries(record)) {
-        const cell = requireRecord(rawCell, "snapshot cell " + fieldName);
-        const cellKind = requireSyncGatewayText(cell.cellKind, "snapshot cell " + fieldName + " cellKind", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE);
-        if (!isCellObservationKind(cellKind)) {
-            return invalidOperationResponse("Apps Script observation operation", "snapshot cell " + fieldName + " kind is unsupported");
-        }
-        cells[fieldName] = {
-            cellKind,
-            normalizedCell: decodeNormalizedCell(cell.normalizedCell, fieldName),
-            formulaHash: decodePresenceString(cell.formulaHash, fieldName + ".formulaHash"),
-            mergeRange: decodePresenceString(cell.mergeRange, fieldName + ".mergeRange"),
-            errorCode: decodePresenceString(cell.errorCode, fieldName + ".errorCode"),
-            stableHash: decodePresenceString(cell.stableHash, fieldName + ".stableHash"),
-        };
-    }
-    return cells;
-}
-function decodeNormalizedCell(value, label) {
-    if (isNormalizedCell(value))
-        return value;
-    return invalidOperationResponse("Apps Script observation operation", label + " normalizedCell is invalid");
-}
-function decodeDuplicateAnchors(value) {
-    if (!Array.isArray(value)) {
-        return invalidOperationResponse("Apps Script observation operation", "duplicateAnchors must be an array");
-    }
-    return value.map((entry, index) => {
-        const record = requireRecord(entry, "duplicateAnchors[" + index + "]");
-        return {
-            anchor: requireSyncGatewayText(record.anchor, "duplicateAnchors[" + index + "].anchor", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
-            rowNumbers: decodePositiveIntegerArray(record.rowNumbers, "duplicateAnchors[" + index + "].rowNumbers"),
-        };
-    });
-}
-function decodePositiveIntegerArray(value, label) {
-    if (!Array.isArray(value)) {
-        return invalidOperationResponse("Apps Script observation operation", label + " must be an array");
-    }
-    return value.map((entry, index) => requireSyncGatewayPositiveSafeInteger(entry, label + "[" + index + "]", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE));
-}
-function decodeStringArray(value, label) {
-    if (!Array.isArray(value)) {
-        return invalidOperationResponse("Apps Script observation operation", label + " must be an array");
-    }
-    const values = value.map((entry, index) => requireSyncGatewayText(entry, label + "[" + index + "]", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE));
-    if (new Set(values).size !== values.length) {
-        return invalidOperationResponse("Apps Script observation operation", label + " contains a duplicate");
-    }
-    return values;
-}
-function isCellObservationKind(value) {
-    return value === CELL_OBSERVATION_KINDS.BLANK ||
-        value === CELL_OBSERVATION_KINDS.LITERAL ||
-        value === CELL_OBSERVATION_KINDS.FORMULA ||
-        value === CELL_OBSERVATION_KINDS.MERGED ||
-        value === CELL_OBSERVATION_KINDS.ERROR;
-}
-function requireRecord(value, label) {
-    return requireOperationRecord(value, label, "Apps Script observation operation");
-}
-/**
- * Self-contained V8 operation source. Observation only reads the registered
- * range, while anchor assignment is the sole metadata mutation in this path.
- */
-const OBSERVATION_OPERATION_SOURCE = String.raw `function (spreadsheet, args) {
-  var ANCHOR_KEY = "typed_sheets_sync_anchor";
-  var MODES = { ENSURE: "ensureRowAnchors", SNAPSHOT: "readSnapshot", OBSERVE: "observeSnapshot" };
-  var phases = [];
-  var operationStartedAt = Date.now();
-  var lock = null;
-  if (args && args.mode === MODES.ENSURE) {
-    var lockStartedAt = Date.now();
-    lock = LockService.getScriptLock();
-    if (!lock.tryLock(20000)) throw new Error("Could not acquire the sync observation gateway lock");
-    phase_("lock_acquire", lockStartedAt);
-  }
-  try {
-    var validationStartedAt = Date.now();
-    requireObject_(args, "observation operation args");
-    if (args.mode !== MODES.OBSERVE) {
-      assertAuthority_(spreadsheet, args.mode !== MODES.SNAPSHOT);
-    }
-    phase_("validate_input", validationStartedAt);
-    var sheetLookupStartedAt = Date.now();
-    var sheet = spreadsheet.getSheetByName(args.sheetName);
-    if (sheet === null) throw new Error("Registered sync sheet does not exist: " + args.sheetName);
-    phase_("sheet_lookup", sheetLookupStartedAt);
-    var layoutStartedAt = Date.now();
-    var layout = readLayout_(sheet, args.registeredRange);
-    phase_("layout_read", layoutStartedAt);
-    if (args.mode === MODES.ENSURE) return ensureAnchors_(sheet, layout, args.checkboxHeaders);
-    if (args.mode === MODES.SNAPSHOT) return readSnapshot_(sheet, layout, args.checkboxHeaders, args);
-    if (args.mode === MODES.OBSERVE) {
-      var observed = observeSnapshot_(spreadsheet, sheet, layout, args.checkboxHeaders, args);
-      observed.timing = {
-        operationKinds: [],
-        operationCounts: { append: 0, update: 0, delete: 0 },
-        durationMs: Date.now() - operationStartedAt,
-        phases: phases,
-      };
-      return observed;
-    }
-    throw new Error("unsupported observation operation mode");
-  } finally {
-    if (lock !== null) lock.releaseLock();
-  }
-
-  function assertAuthority_(targetSpreadsheet, allowAdvance) {
-    if (args.authority === undefined) return;
-    if (!args.authority || typeof args.authority.epoch !== "number" ||
-        Math.floor(args.authority.epoch) !== args.authority.epoch || args.authority.epoch < 1 ||
-        typeof args.authority.token !== "string" || args.authority.token.length === 0) {
-      throw new Error("observation authority is invalid");
-    }
-    var key = "typed_sheets_authority:" + targetSpreadsheet.getId();
-    var properties = PropertiesService.getScriptProperties();
-    var raw = properties.getProperty(key);
-    var current = raw === null ? null : JSON.parse(raw);
-    if (current !== null && (current.epoch > args.authority.epoch ||
-        current.epoch === args.authority.epoch && current.token !== args.authority.token)) {
-      throw new Error("observation authority fence is stale");
-    }
-    if (allowAdvance && (current === null || args.authority.epoch > current.epoch)) {
-      properties.setProperty(key, JSON.stringify({ epoch: args.authority.epoch, token: args.authority.token }));
-    }
-  }
-
-  function readLayout_(targetSheet, registeredRange) {
-    var parsed = parseRange_(registeredRange);
-    var headerValues = targetSheet.getRange(1, parsed.startColumn, 1, parsed.columnCount).getValues()[0];
-    var headers = [];
-    var positions = Object.create(null);
-    headerValues.forEach(function (header, index) {
-      if (typeof header !== "string" || header.trim() === "") throw new Error("registered header is invalid");
-      if (positions[header] !== undefined) throw new Error("registered headers contain a duplicate");
-      headers.push(header);
-      positions[header] = index;
-    });
-    var checkboxIndexes = Object.create(null);
-    (args.checkboxHeaders || []).forEach(function (header) {
-      var index = headers.indexOf(header);
-      if (index < 0) throw new Error("checkbox header is not registered: " + header);
-      checkboxIndexes[index] = true;
-    });
-    return { startColumn: parsed.startColumn, columnCount: parsed.columnCount, headers: headers, positions: positions, checkboxIndexes: checkboxIndexes };
-  }
-
-  function ensureAnchors_(targetSheet, targetLayout) {
-    var lastRow = targetSheet.getLastRow();
-    var anchorsByRow = readAnchorIndex_(targetSheet);
-    var values = lastRow > 1
-      ? targetSheet.getRange(2, targetLayout.startColumn, lastRow - 1, targetLayout.columnCount).getValues()
-      : [];
-    return ensureAnchorsFromValues_(targetSheet, targetLayout, values, anchorsByRow);
-  }
-
-  function ensureAnchorsFromValues_(targetSheet, targetLayout, values, anchorsByRow) {
-    var assigned = 0;
-    var existing = 0;
-    values.forEach(function (row, offset) {
-      if (isBlankRow_(row, targetLayout.checkboxIndexes)) return;
-      var rowNumber = offset + 2;
-      var anchors = anchorsByRow[rowNumber] || [];
-      if (anchors.length > 1) throw new Error("row has multiple sync anchors: " + rowNumber);
-      if (anchors.length === 0) {
-        var anchor = "sync-anchor:" + Utilities.getUuid();
-        targetSheet.getRange(rowNumber + ":" + rowNumber).addDeveloperMetadata(
-          ANCHOR_KEY, anchor, SpreadsheetApp.DeveloperMetadataVisibility.PROJECT,
-        );
-        anchorsByRow[rowNumber] = [anchor];
-        assigned += 1;
-      } else {
-        existing += 1;
-      }
-    });
-    // Developer Metadata writes are buffered like sheet value writes. Both
-    // callers hold the observation script lock while assigning anchors, so
-    // flush here while the lock is still held: a later observation that
-    // acquires the lock must see the committed anchors, otherwise it would
-    // read stale metadata and assign a second anchor to the same row.
-    if (assigned > 0) SpreadsheetApp.flush();
-    return {
-      assigned: assigned,
-      existing: existing,
-      duplicateAnchors: duplicateAnchorsForRows_(values, targetLayout.checkboxIndexes, anchorsByRow),
-    };
-  }
-
-  function observeSnapshot_(targetSpreadsheet, targetSheet, targetLayout, unusedCheckboxHeaders, request) {
-    var anchorLockStartedAt = Date.now();
-    var anchorLock = LockService.getScriptLock();
-    if (!anchorLock.tryLock(20000)) throw new Error("Could not acquire the sync observation gateway lock");
-    var anchorResult;
-    var snapshot;
-    try {
-      assertAuthority_(targetSpreadsheet, true);
-      anchorResult = ensureAnchors_(targetSheet, targetLayout);
-      // phase_ expects a start timestamp; passing the lock acquisition time
-      // records the anchor mutation barrier as its elapsed duration.
-      phase_("anchor_mutation_barrier", anchorLockStartedAt);
-      var snapshotStartedAt = Date.now();
-      // The script lock stays held through the snapshot read: releasing it
-      // after anchor assignment would let a concurrent effect mutate the
-      // sheet between the two phases and produce a mixed snapshot.
-      snapshot = readSnapshot_(targetSheet, targetLayout, unusedCheckboxHeaders, request);
-      phase_("snapshot_build", snapshotStartedAt);
-    } finally {
-      anchorLock.releaseLock();
-    }
-    return {
-      anchors: anchorResult,
-      snapshot: snapshot,
-    };
-  }
-
-  function readSnapshot_(targetSheet, targetLayout, unusedCheckboxHeaders, request, prepared) {
-    var lastRow = prepared ? prepared.lastRow : Math.max(targetSheet.getLastRow(), 1);
-    var range = prepared && prepared.range
-      ? prepared.range
-      : targetSheet.getRange(1, targetLayout.startColumn, lastRow, targetLayout.columnCount);
-    var values = prepared && prepared.values ? prepared.values : range.getValues();
-    var lightweight = request.readMode === "user_input";
-    var formulasStartedAt = Date.now();
-    var formulas = lightweight ? null : range.getFormulas();
-    phase_("formulas_read", formulasStartedAt);
-    var displayValuesStartedAt = Date.now();
-    var displayValues = lightweight ? null : range.getDisplayValues();
-    phase_("display_values_read", displayValuesStartedAt);
-    var mergedRangesStartedAt = Date.now();
-    var merged = lightweight ? null : mergedCellMap_(range);
-    phase_("merged_ranges_read", mergedRangesStartedAt);
-    var anchorsByRow = prepared && prepared.anchorsByRow
-      ? prepared.anchorsByRow
-      : readAnchorIndex_(targetSheet);
-    var rows = [];
-    var unanchoredRows = [];
-    var anchorRows = Object.create(null);
-    var rowNormalizationStartedAt = Date.now();
-    for (var rowIndex = 1; rowIndex < values.length; rowIndex += 1) {
-      if (isBlankRow_(values[rowIndex], targetLayout.checkboxIndexes)) continue;
-      var rowNumber = rowIndex + 1;
-      var anchors = anchorsByRow[rowNumber] || [];
-      var anchor = anchors.length === 1 ? anchors[0] : null;
-      if (anchors.length > 1) throw new Error("row has multiple sync anchors: " + rowNumber);
-      if (anchor === null) unanchoredRows.push(rowNumber);
-      else {
-        if (!anchorRows[anchor]) anchorRows[anchor] = [];
-        anchorRows[anchor].push(rowNumber);
-      }
-      var cells = Object.create(null);
-      targetLayout.headers.forEach(function (header, columnIndex) {
-        var coordinate = rowNumber + ":" + (targetLayout.startColumn + columnIndex);
-        cells[header] = normalizeCellObservation_(
-          values[rowIndex][columnIndex],
-          lightweight ? "" : formulas[rowIndex][columnIndex],
-          lightweight ? String(values[rowIndex][columnIndex]) : displayValues[rowIndex][columnIndex],
-          lightweight ? null : merged[coordinate] || null,
-          lightweight,
-        );
-      });
-      rows.push({
-        rowNumber: rowNumber,
-        physicalAnchor: anchor,
-        visibleRevision: null,
-        visibleHash: null,
-        cells: cells,
-      });
-    }
-    phase_("row_normalization", rowNormalizationStartedAt);
-    var duplicateAnchorStartedAt = Date.now();
-    var duplicateAnchors = [];
-    Object.keys(anchorRows).sort().forEach(function (anchor) {
-      if (anchorRows[anchor].length > 1) duplicateAnchors.push({ anchor: anchor, rowNumbers: anchorRows[anchor] });
-    });
-    phase_("duplicate_anchor_scan", duplicateAnchorStartedAt);
-    var snapshot = {
-      protocolVersion: "typed-sheets-sync-v1",
-      sheetName: request.sheetName,
-      registeredRange: request.registeredRange,
-      projection: request.projection,
-      schemaVersion: request.schemaVersion,
-      headers: targetLayout.headers,
-      rows: rows,
-    };
-    var snapshotHashStartedAt = Date.now();
-    var snapshotHash = codecStableHash_(snapshot);
-    phase_("snapshot_hash", snapshotHashStartedAt);
-    return {
-      protocolVersion: snapshot.protocolVersion,
-      sheetName: snapshot.sheetName,
-      registeredRange: snapshot.registeredRange,
-      projection: snapshot.projection,
-      schemaVersion: snapshot.schemaVersion,
-      headers: snapshot.headers,
-      rows: snapshot.rows,
-      snapshotHash: snapshotHash,
-      unanchoredRows: unanchoredRows,
-      duplicateAnchors: duplicateAnchors,
-    };
-  }
-
-  function duplicateAnchorsForRows_(values, checkboxIndexes, anchorsByRow) {
-    var grouped = Object.create(null);
-    values.forEach(function (row, offset) {
-      if (isBlankRow_(row, checkboxIndexes)) return;
-      var anchors = anchorsByRow[offset + 2] || [];
-      anchors.forEach(function (anchor) {
-        if (!grouped[anchor]) grouped[anchor] = [];
-        grouped[anchor].push(offset + 2);
-      });
-    });
-    return Object.keys(grouped).sort().filter(function (anchor) { return grouped[anchor].length > 1; }).map(function (anchor) {
-      return { anchor: anchor, rowNumbers: grouped[anchor] };
-    });
-  }
-
-  function readAnchorIndex_(targetSheet) {
-    var anchorsByRow = Object.create(null);
-    targetSheet.createDeveloperMetadataFinder()
-      .withKey(ANCHOR_KEY)
-      .withLocationType(SpreadsheetApp.DeveloperMetadataLocationType.ROW)
-      .find()
-      .forEach(function (metadata) {
-        var row = metadata.getLocation().getRow();
-        if (row === null) return;
-        var rowNumber = row.getRow();
-        if (!anchorsByRow[rowNumber]) anchorsByRow[rowNumber] = [];
-        anchorsByRow[rowNumber].push(String(metadata.getValue()));
-      });
-    Object.keys(anchorsByRow).forEach(function (rowNumber) {
-      anchorsByRow[rowNumber].sort();
-    });
-    return anchorsByRow;
-  }
-
-  function phase_(name, phaseStartedAt) {
-    phases.push({ phase: name, durationMs: Date.now() - phaseStartedAt });
-  }
-
-  function parseRange_(value) {
-    if (typeof value !== "string" || !/^[A-Z]+:[A-Z]+$/.test(value)) throw new Error("registeredRange must be an uppercase whole-column range");
-    var parts = value.split(":");
-    var startColumn = columnNumber_(parts[0]);
-    var endColumn = columnNumber_(parts[1]);
-    if (endColumn < startColumn) throw new Error("registeredRange end precedes start");
-    return { startColumn: startColumn, columnCount: endColumn - startColumn + 1 };
-  }
-
-  function columnNumber_(letters) {
-    var value = 0;
-    for (var index = 0; index < letters.length; index += 1) value = value * 26 + letters.charCodeAt(index) - 64;
-    return value;
-  }
-
-  function isBlankRow_(row, checkboxIndexes) {
-    return row.every(function (cell, index) {
-      if (checkboxIndexes[index]) return cell === "" || cell === null || cell === false;
-      return cell === "" || cell === null;
-    });
-  }
-
-  function normalizeCellObservation_(rawValue, formula, displayValue, mergeRange, lightweight) {
-    var formulaHash = formula ? sha256Hex_(formula) : null;
-    if (mergeRange !== null) return { cellKind: "merged", normalizedCell: null, formulaHash: formulaHash, mergeRange: mergeRange, errorCode: null, stableHash: null };
-    if (isDisplayedSheetError_(displayValue)) return { cellKind: "error", normalizedCell: null, formulaHash: formulaHash, mergeRange: null, errorCode: String(displayValue), stableHash: null };
-    if (formula) return { cellKind: "formula", normalizedCell: null, formulaHash: formulaHash, mergeRange: null, errorCode: null, stableHash: null };
-    var normalized;
-    if (rawValue === "" || rawValue === null) normalized = null;
-    else if (isDate_(rawValue)) normalized = { kind: "date", value: rawValue.toISOString() };
-    else if (typeof rawValue === "string") normalized = { kind: "string", value: normalizeScalarString_(rawValue) };
-    else if (typeof rawValue === "number" && isFinite(rawValue)) normalized = { kind: "number", value: rawValue };
-    else if (typeof rawValue === "boolean") normalized = { kind: "boolean", value: rawValue };
-    else return { cellKind: "error", normalizedCell: null, formulaHash: null, mergeRange: null, errorCode: "unsupported_cell_value", stableHash: null };
-    return { cellKind: normalized === null ? "blank" : "literal", normalizedCell: normalized, formulaHash: null, mergeRange: null, errorCode: null, stableHash: lightweight ? null : codecStableHash_(normalized) };
-  }
-
-  function mergedCellMap_(targetRange) {
-    var result = Object.create(null);
-    targetRange.getMergedRanges().forEach(function (mergedRange) {
-      var a1 = mergedRange.getA1Notation();
-      var startRow = mergedRange.getRow();
-      var startColumn = mergedRange.getColumn();
-      for (var rowOffset = 0; rowOffset < mergedRange.getNumRows(); rowOffset += 1) {
-        for (var columnOffset = 0; columnOffset < mergedRange.getNumColumns(); columnOffset += 1) {
-          result[(startRow + rowOffset) + ":" + (startColumn + columnOffset)] = a1;
-        }
-      }
-    });
-    return result;
-  }
-
-  function isDisplayedSheetError_(value) { return typeof value === "string" && /^#(REF!|DIV\/0!|N\/A|VALUE!|NAME\?|NUM!|ERROR!|NULL!)$/.test(value); }
-  function isDate_(value) { return Object.prototype.toString.call(value) === "[object Date]" && !isNaN(value.getTime()); }
-  function isCanonicalDate_(value) { if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)) return false; var parsed = new Date(value); return !isNaN(parsed.getTime()) && parsed.toISOString() === value; }
-  function isObject_(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
-  function requireObject_(value, label) { if (!isObject_(value)) throw new Error(label + " must be an object"); return value; }
-  function normalizeScalarString_(value) { return value.normalize("NFC"); }
-  function sha256Hex_(value) { return Utilities.computeDigest(Utilities.DigestAlgorithm.SHA_256, value, Utilities.Charset.UTF_8).map(function (byte) { var unsigned = byte < 0 ? byte + 256 : byte; return ("0" + unsigned.toString(16)).slice(-2); }).join(""); }
-${APPS_SCRIPT_STABLE_CODEC_SOURCE}
-}`;
-/** Builds the read-only snapshot source without the mutation coordination lock. */
-const READ_SNAPSHOT_OPERATION_SOURCE = withoutObservationLock(OBSERVATION_OPERATION_SOURCE);
-function withoutObservationLock(source) {
-    // The read-only operation shares helper functions with the combined
-    // observation source, but its mode never enters the anchor mutation path.
-    // Remove the platform lock and mutation-barrier symbols from the generated
-    // read source so the lock-free contract remains explicit and testable.
-    const withoutLockService = source.replaceAll("LockService", "RemoteMutationBarrier");
-    const withoutRelease = withoutLockService.replaceAll("lock.releaseLock", "mutationLockRelease");
-    const withoutFlush = withoutRelease.replaceAll("SpreadsheetApp.flush()", "remoteVisibilityBarrier()");
-    if (withoutFlush.includes("LockService") ||
-        withoutFlush.includes("lock.releaseLock") ||
-        withoutFlush.includes("SpreadsheetApp.flush")) {
-        throw new Error("could not build the lock-free observation source");
-    }
-    return withoutFlush;
-}
-//# sourceMappingURL=observationOperation.js.map

package/dist/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"observationOperation.js","sourceRoot":"","sources":["../../../../../../../src/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.ts"],"names":[],"mappings":"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"}

package/dist/adapter/sheets/providers/apps-script-gateway/operations/read/tableReadOperation.d.ts

@@ -1,12 +0,0 @@
-/** Lightweight table reads for polling user-visible Sheet values. */
-import type { SyncTableRowsResult } from "../../../../../../application/sync/gateway/syncGateway.js";
-import type { AppsScriptOperationDefinition } from "../../transport/operationClient.js";
-/** Request for one registered table's raw values. */
-export interface AppsScriptReadTableRowsRequest {
-    readonly sheetName: string;
-    readonly registeredRange: string;
-    readonly headers: readonly string[];
-}
-/** Builds a read-only operation that performs one range `getValues()` call. */
-export declare function createReadTableRowsOperation(request: AppsScriptReadTableRowsRequest): AppsScriptOperationDefinition<AppsScriptReadTableRowsRequest, SyncTableRowsResult>;
-//# sourceMappingURL=tableReadOperation.d.ts.map

package/dist/adapter/sheets/providers/apps-script-gateway/operations/read/tableReadOperation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tableReadOperation.d.ts","sourceRoot":"","sources":["../../../../../../../src/adapter/sheets/providers/apps-script-gateway/operations/read/tableReadOperation.ts"],"names":[],"mappings":"AAAA,qEAAqE;AAWrE,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,2DAA2D,CAAC;AACnE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAKxF,qDAAqD;AACrD,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,+EAA+E;AAC/E,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,8BAA8B,GACtC,6BAA6B,CAAC,8BAA8B,EAAE,mBAAmB,CAAC,CAOpF"}