hikoutei 0.2.0

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

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

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

@@ -0,0 +1,29 @@
+/** 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[];
+}
+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

@@ -0,0 +1 @@
+{"version":3,"file":"observationOperation.d.ts","sourceRoot":"","sources":["../../../../../../../src/adapter/sheets/providers/apps-script-gateway/operations/observation/observationOperation.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAE1E,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;AAOxF,QAAA,MAAM,2BAA2B;;;;CAIvB,CAAC;AAEX,UAAU,gCAAgC;IACxC,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,CAOA;AAED,iEAAiE;AACjE,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,uBAAuB,GAAG,gCAAgC,GAClE,6BAA6B,CAAC,mCAAmC,EAAE,mBAAmB,CAAC,CAOzF;AAED,uFAAuF;AACvF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,uBAAuB,GAAG,gCAAgC,GAClE,6BAA6B,CAC9B,sCAAsC,EACtC,oBAAoB,CACrB,CAOA"}

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

@@ -0,0 +1,538 @@
+/** Thin-Gateway operations for anchors and normalized Sheet snapshots. */
+import { CELL_OBSERVATION_KINDS, NORMALIZED_CELL_KINDS, } from "../../../../../../shared/encoding/constants.js";
+import { PRESENCE_KINDS } from "../../../../../../shared/state/constants.js";
+import { isRecord } from "../../../../../../shared/encoding/typeGuards.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 { requireSyncGatewayNonNegativeSafeInteger, requireSyncGatewayPositiveSafeInteger, requireSyncGatewayProjection, requireSyncGatewaySnapshotReadMode, requireSyncGatewayText, } from "../../../../../../application/sync/gateway/validation.js";
+import { decodeOptionalSyncGatewayTiming } from "../../protocol/timing.js";
+import { invalidOperationRequest, invalidOperationResponse, } from "../../errors.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);
+    return {
+        fn: OBSERVATION_OPERATION_SOURCE,
+        args: { mode: OBSERVATION_OPERATION_MODES.ENSURE_ANCHORS, ...request },
+        decode: decodeEnsureRowAnchorsResult,
+    };
+}
+/** Builds the normalized, read-only Sheet snapshot operation. */
+export function createReadSnapshotOperation(request) {
+    validateObservationRequest(request);
+    return {
+        fn: OBSERVATION_OPERATION_SOURCE,
+        args: { mode: OBSERVATION_OPERATION_MODES.READ_SNAPSHOT, ...request },
+        decode: decodeSnapshot,
+    };
+}
+/** Builds one operation that assigns anchors and reads the snapshot under one lock. */
+export function createObserveSnapshotOperation(request) {
+    validateObservationRequest(request);
+    return {
+        fn: OBSERVATION_OPERATION_SOURCE,
+        args: { mode: OBSERVATION_OPERATION_MODES.OBSERVE_SNAPSHOT, ...request },
+        decode: decodeObservedSnapshot,
+    };
+}
+function validateObservationRequest(request) {
+    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) {
+    const record = requireRecord(value, "combined observation result");
+    const timing = decodeOptionalSyncGatewayTiming(record.timing, "observation timing");
+    const result = {
+        anchors: decodeEnsureRowAnchorsResult(record.anchors),
+        snapshot: decodeSnapshot(record.snapshot),
+    };
+    return timing === undefined ? result : { ...result, timing };
+}
+function decodeSnapshot(value) {
+    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);
+    const headers = decodeStringArray(record.headers, "snapshot headers");
+    const rows = decodeSnapshotRows(record.rows);
+    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) {
+    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),
+        };
+    });
+}
+function decodeSnapshotCells(value, rowIndex) {
+    const record = requireRecord(value, "snapshot row[" + rowIndex + "].cells");
+    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 (value === null)
+        return null;
+    const record = requireRecord(value, label + " normalizedCell");
+    const kind = requireSyncGatewayText(record.kind, label + ".kind", SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE);
+    if (kind === NORMALIZED_CELL_KINDS.STRING && typeof record.value === "string") {
+        return { kind: NORMALIZED_CELL_KINDS.STRING, value: record.value };
+    }
+    if (kind === NORMALIZED_CELL_KINDS.NUMBER && typeof record.value === "number" && Number.isFinite(record.value)) {
+        return { kind: NORMALIZED_CELL_KINDS.NUMBER, value: record.value };
+    }
+    if (kind === NORMALIZED_CELL_KINDS.BOOLEAN && typeof record.value === "boolean") {
+        return { kind: NORMALIZED_CELL_KINDS.BOOLEAN, value: record.value };
+    }
+    if (kind === NORMALIZED_CELL_KINDS.DATE && typeof record.value === "string") {
+        return { kind: NORMALIZED_CELL_KINDS.DATE, value: record.value };
+    }
+    return invalidOperationResponse("Apps Script observation operation", label + " normalizedCell is invalid");
+}
+function decodePresenceString(value, label) {
+    if (value === null)
+        return { kind: PRESENCE_KINDS.ABSENT };
+    return {
+        kind: PRESENCE_KINDS.PRESENT,
+        value: requireSyncGatewayText(value, label, SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
+    };
+}
+function decodePresenceNonNegativeInteger(value, label) {
+    if (value === null)
+        return { kind: PRESENCE_KINDS.ABSENT };
+    return {
+        kind: PRESENCE_KINDS.PRESENT,
+        value: requireSyncGatewayNonNegativeSafeInteger(value, label, SYNC_GATEWAY_ERROR_CODES.INVALID_GATEWAY_RESPONSE),
+    };
+}
+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 Object.values(CELL_OBSERVATION_KINDS).includes(value);
+}
+function requireRecord(value, label) {
+    if (!isRecord(value)) {
+        return invalidOperationResponse("Apps Script observation operation", label + " must be an object");
+    }
+    return value;
+}
+/**
+ * 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 lockStartedAt = Date.now();
+  var 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");
+    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_(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 {
+    lock.releaseLock();
+  }
+
+  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;
+      }
+    });
+    return {
+      assigned: assigned,
+      existing: existing,
+      duplicateAnchors: duplicateAnchorsForRows_(values, targetLayout.checkboxIndexes, anchorsByRow),
+    };
+  }
+
+  function observeSnapshot_(targetSheet, targetLayout, unusedCheckboxHeaders, request) {
+    var lastRowStartedAt = Date.now();
+    var lastRow = Math.max(targetSheet.getLastRow(), 1);
+    phase_("last_row_read", lastRowStartedAt);
+    var valuesReadStartedAt = Date.now();
+    var range = targetSheet.getRange(1, targetLayout.startColumn, lastRow, targetLayout.columnCount);
+    var values = range.getValues();
+    phase_("values_read", valuesReadStartedAt);
+    var metadataReadStartedAt = Date.now();
+    var anchorsByRow = readAnchorIndex_(targetSheet);
+    phase_("anchor_metadata_read", metadataReadStartedAt);
+    var anchorAssignmentStartedAt = Date.now();
+    var anchorResult = ensureAnchorsFromValues_(
+      targetSheet,
+      targetLayout,
+      values.slice(1),
+      anchorsByRow,
+    );
+    phase_("anchor_assignment", anchorAssignmentStartedAt);
+    var snapshotStartedAt = Date.now();
+    var snapshot = readSnapshot_(targetSheet, targetLayout, unusedCheckboxHeaders, request, {
+      lastRow: lastRow,
+      range: range,
+      values: values,
+      anchorsByRow: anchorsByRow,
+    });
+    phase_("snapshot_build", snapshotStartedAt);
+    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 = stableHash_(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 : stableHash_(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 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(""); }
+  function stableHash_(value) { return sha256Hex_(stableEncode_(value)); }
+  function stableEncode_(value) {
+    if (value === null) return "n";
+    if (value === true) return "b1";
+    if (value === false) return "b0";
+    if (typeof value === "number") return stableEncodeNumber_(value);
+    if (typeof value === "string") return stableEncodeString_(value);
+    if (isObject_(value) && value.kind === "date" && typeof value.value === "string") return "d24:" + value.value;
+    if (Array.isArray(value)) return "a" + value.length + "[" + value.map(stableEncode_).join("") + "]";
+    if (isObject_(value)) {
+      var entries = Object.keys(value).map(function (key) { var normalized = normalizeScalarString_(key); return { key: normalized, bytes: utf8Bytes_(normalized), value: value[key] }; });
+      entries.sort(function (left, right) { return compareBytes_(left.bytes, right.bytes); });
+      return "o" + entries.length + "{" + entries.map(function (entry) { return "s" + entry.bytes.length + ":" + entry.key + stableEncode_(entry.value); }).join("") + "}";
+    }
+    throw new Error("stable value is unsupported");
+  }
+  function stableEncodeNumber_(value) { if (!isFinite(value)) throw new Error("stable number is not finite"); var decimal = value === 0 ? "0" : String(value).replace(/e\+/, "e").replace(/e(-?)0+(\d+)/, "e$1$2"); return "f" + utf8ByteLength_(decimal) + ":" + decimal; }
+  function stableEncodeString_(value) { var normalized = normalizeScalarString_(value); return "s" + utf8ByteLength_(normalized) + ":" + normalized; }
+  function utf8Bytes_(value) { return Utilities.newBlob(value).getBytes(); }
+  function utf8ByteLength_(value) { return utf8Bytes_(value).length; }
+  function compareBytes_(left, right) { var count = Math.min(left.length, right.length); for (var index = 0; index < count; index += 1) { var a = left[index] < 0 ? left[index] + 256 : left[index]; var b = right[index] < 0 ? right[index] + 256 : right[index]; if (a !== b) return a - b; } return left.length - right.length; }
+}`;
+//# sourceMappingURL=observationOperation.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,12 @@
+/** 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

@@ -0,0 +1 @@
+{"version":3,"file":"tableReadOperation.d.ts","sourceRoot":"","sources":["../../../../../../../src/adapter/sheets/providers/apps-script-gateway/operations/read/tableReadOperation.ts"],"names":[],"mappings":"AAAA,qEAAqE;AAYrE,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,2DAA2D,CAAC;AACnE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAIxF,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"}