lakeql 0.1.8 → 0.2.0

package/dist/chunk-LWF5FKHB.js

@@ -0,0 +1,1175 @@
+import { isIntervalValue, LakeqlError, isTimestampValue, compareTimestampValues, evaluate, matches, jsonSafeValue } from './chunk-WGHR35QU.js';
+
+// ../core/dist/expr-utils.js
+function collectExprColumns(expr, columns) {
+  if (!expr)
+    return;
+  switch (expr.kind) {
+    case "column":
+      columns.add(expr.name);
+      return;
+    case "literal":
+      return;
+    case "compare":
+      collectExprColumns(expr.left, columns);
+      collectExprColumns(expr.right, columns);
+      return;
+    case "in":
+      collectExprColumns(expr.target, columns);
+      for (const value of expr.values)
+        collectExprColumns(value, columns);
+      return;
+    case "between":
+      collectExprColumns(expr.target, columns);
+      collectExprColumns(expr.low, columns);
+      collectExprColumns(expr.high, columns);
+      return;
+    case "null-check":
+      collectExprColumns(expr.target, columns);
+      return;
+    case "logical":
+      for (const operand of expr.operands)
+        collectExprColumns(operand, columns);
+      return;
+    case "not":
+      collectExprColumns(expr.operand, columns);
+      return;
+    case "like":
+      collectExprColumns(expr.target, columns);
+      return;
+    case "call":
+      for (const arg of expr.args)
+        collectExprColumns(arg, columns);
+      return;
+    case "arithmetic":
+      collectExprColumns(expr.left, columns);
+      collectExprColumns(expr.right, columns);
+      return;
+    case "case":
+      for (const branch of expr.whens) {
+        collectExprColumns(branch.when, columns);
+        collectExprColumns(branch.value, columns);
+      }
+      collectExprColumns(expr.else, columns);
+      return;
+  }
+}
+
+// ../core/dist/object-key.js
+var PROTOTYPE_MUTATION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPrototypeMutationKey(key) {
+  return PROTOTYPE_MUTATION_KEYS.has(key);
+}
+
+// ../core/dist/window-snapshot.js
+function isWindowExprSnapshot(value) {
+  if (!isRecord(value))
+    return false;
+  const fn = value.fn;
+  const validFn = typeof fn === "string" || isRecord(fn) && typeof fn.aggregate === "string" && Object.keys(fn).length === 1;
+  return validFn && Array.isArray(value.args) && value.args.every(isExprSnapshot) && isRecord(value.over) && Array.isArray(value.over.partitionBy) && value.over.partitionBy.every(isExprSnapshot) && Array.isArray(value.over.orderBy) && value.over.orderBy.every(isWindowOrderTermSnapshot) && (value.over.frame === void 0 || isWindowFrameSnapshot(value.over.frame)) && (value.filter === void 0 || isExprSnapshot(value.filter)) && (value.ignoreNulls === void 0 || typeof value.ignoreNulls === "boolean") && (value.distinct === void 0 || typeof value.distinct === "boolean");
+}
+function isWindowOrderTermSnapshot(value) {
+  return isRecord(value) && isExprSnapshot(value.expr) && (value.direction === void 0 || value.direction === "asc" || value.direction === "desc") && (value.nulls === void 0 || value.nulls === "first" || value.nulls === "last");
+}
+function isWindowFrameSnapshot(value) {
+  return isRecord(value) && (value.mode === "rows" || value.mode === "range" || value.mode === "groups") && isWindowFrameBoundSnapshot(value.start) && isWindowFrameBoundSnapshot(value.end) && (value.exclude === "no-others" || value.exclude === "current-row" || value.exclude === "group" || value.exclude === "ties");
+}
+function isWindowFrameBoundSnapshot(value) {
+  return isRecord(value) && (value.kind === "unbounded-preceding" || value.kind === "preceding" || value.kind === "current-row" || value.kind === "following" || value.kind === "unbounded-following") && (value.offset === void 0 || isExprSnapshot(value.offset));
+}
+function isExprSnapshot(value) {
+  if (!isRecord(value) || typeof value.kind !== "string")
+    return false;
+  switch (value.kind) {
+    case "literal":
+      return isWindowSnapshotValue(value.value) || isIntervalValue(value.value);
+    case "column":
+      return typeof value.name === "string";
+    case "compare":
+      return (value.op === "eq" || value.op === "ne" || value.op === "lt" || value.op === "lte" || value.op === "gt" || value.op === "gte") && isExprSnapshot(value.left) && isExprSnapshot(value.right);
+    case "in":
+      return typeof value.negated === "boolean" && isExprSnapshot(value.target) && Array.isArray(value.values) && value.values.every(isExprSnapshot);
+    case "between":
+      return isExprSnapshot(value.target) && isExprSnapshot(value.low) && isExprSnapshot(value.high);
+    case "null-check":
+      return typeof value.negated === "boolean" && isExprSnapshot(value.target);
+    case "logical":
+      return (value.op === "and" || value.op === "or") && Array.isArray(value.operands) && value.operands.every(isExprSnapshot);
+    case "not":
+      return isExprSnapshot(value.operand);
+    case "like":
+      return typeof value.caseInsensitive === "boolean" && isExprSnapshot(value.target) && typeof value.pattern === "string";
+    case "call":
+      return typeof value.fn === "string" && Array.isArray(value.args) && value.args.every(isExprSnapshot);
+    case "arithmetic":
+      return (value.op === "add" || value.op === "sub" || value.op === "mul" || value.op === "div" || value.op === "mod") && isExprSnapshot(value.left) && isExprSnapshot(value.right);
+    case "case":
+      return Array.isArray(value.whens) && value.whens.every((branch) => isRecord(branch) && isExprSnapshot(branch.when) && isExprSnapshot(branch.value)) && (value.else === void 0 || isExprSnapshot(value.else));
+    default:
+      return false;
+  }
+}
+function isWindowSnapshotValue(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../core/dist/manifest.js
+function createTaskManifest(input) {
+  const normalizedTasks = input.tasks.map(normalizeTaskInput);
+  const snapshot = input.snapshot ?? snapshotFromTasks(normalizedTasks);
+  const tasks = normalizedTasks.map((task, index) => ({
+    id: taskId(input.jobId, index, task),
+    input: task,
+    outputRole: input.outputRole ?? "rows"
+  }));
+  const planFingerprint = fingerprint({
+    version: 1,
+    snapshot,
+    tasks: tasks.map((task) => task.input)
+  });
+  return {
+    version: 1,
+    jobId: input.jobId,
+    planFingerprint,
+    snapshot,
+    tasks
+  };
+}
+function createOutputManifest(input) {
+  return {
+    version: 1,
+    jobId: input.jobId,
+    planFingerprint: input.planFingerprint,
+    entries: input.entries.map(normalizeOutputEntry)
+  };
+}
+async function createOutputManifestFromCheckpoints(input) {
+  const entries = [];
+  for await (const checkpoint of input.checkpoints.list(input.jobId)) {
+    if (checkpoint.outputs !== void 0) {
+      entries.push(...checkpoint.outputs);
+    } else if (checkpoint.output !== void 0) {
+      entries.push(checkpoint.output);
+    }
+  }
+  entries.sort((left, right) => left.taskId.localeCompare(right.taskId) || left.outputPath.localeCompare(right.outputPath));
+  return createOutputManifest({
+    jobId: input.jobId,
+    planFingerprint: input.planFingerprint,
+    entries
+  });
+}
+async function writeOutputManifest(store, path, manifest) {
+  const bytes = new TextEncoder().encode(`${stableStringify(manifest)}
+`);
+  await store.put(path, bytes, { contentType: "application/json" });
+  const head = await store.head(path);
+  const result = {
+    path,
+    byteSize: head?.size ?? bytes.byteLength
+  };
+  if (head?.etag !== void 0)
+    result.etag = head.etag;
+  return result;
+}
+async function readOutputManifest(store, path) {
+  const bytes = await store.get(path);
+  if (!bytes) {
+    throw new LakeqlError("LAKEQL_OBJECT_NOT_FOUND", `No output manifest at ${path}`, { path });
+  }
+  try {
+    return parseOutputManifest(JSON.parse(new TextDecoder().decode(bytes)));
+  } catch (cause) {
+    if (cause instanceof LakeqlError)
+      throw cause;
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest is invalid JSON", {
+      path,
+      cause
+    });
+  }
+}
+function createBookmark(init) {
+  const position = {
+    fileIndex: init.position.fileIndex,
+    rowGroup: init.position.rowGroup,
+    rowOffset: init.position.rowOffset
+  };
+  if (init.position.taskId !== void 0)
+    position.taskId = init.position.taskId;
+  if (init.position.outputManifestCursor !== void 0) {
+    position.outputManifestCursor = init.position.outputManifestCursor;
+  }
+  const bookmark = {
+    version: 1,
+    planFingerprint: init.planFingerprint,
+    snapshot: init.snapshot,
+    position
+  };
+  if (init.query !== void 0)
+    bookmark.query = normalizeBookmarkQuery(init.query);
+  if (init.writeState !== void 0)
+    bookmark.writeState = normalizeBookmarkWriteState(init.writeState);
+  if (init.operatorState !== void 0) {
+    bookmark.operatorState = normalizeBookmarkOperatorState(init.operatorState);
+  }
+  return bookmark;
+}
+function assertBookmarkMatches(bookmark, planFingerprint) {
+  if (bookmark.planFingerprint !== planFingerprint) {
+    throw new LakeqlError("LAKEQL_BOOKMARK_STALE", "Bookmark does not match the current query plan", {
+      bookmarkPlanFingerprint: bookmark.planFingerprint,
+      planFingerprint
+    });
+  }
+}
+async function signPaginationToken(bookmark, secret) {
+  const payload = stableStringify(bookmark);
+  const signature = await hmac(payload, secret);
+  return `${base64UrlEncode(new TextEncoder().encode(payload))}.${signature}`;
+}
+async function verifyPaginationToken(token, secret) {
+  const [payloadPart, signaturePart, extra] = token.split(".");
+  if (!payloadPart || !signaturePart || extra !== void 0) {
+    throwInvalidBookmark("Pagination token must contain a payload and signature");
+  }
+  const payloadBytes = base64UrlDecode(payloadPart);
+  const payload = new TextDecoder().decode(payloadBytes);
+  const expected = await hmac(payload, secret);
+  if (!constantTimeEqual(signaturePart, expected)) {
+    throwInvalidBookmark("Pagination token signature is invalid");
+  }
+  const parsed = JSON.parse(payload);
+  return parseBookmark(parsed);
+}
+var MemoryCheckpointAdapter = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  taskJobs = /* @__PURE__ */ new Map();
+  async get(taskId2) {
+    const checkpoint = this.checkpoints.get(taskId2);
+    return checkpoint ? cloneCheckpoint(checkpoint) : void 0;
+  }
+  async put(checkpoint) {
+    this.checkpoints.set(checkpoint.taskId, cloneCheckpoint(checkpoint));
+    this.taskJobs.set(checkpoint.taskId, jobIdFromTaskId(checkpoint.taskId));
+  }
+  async *list(jobId) {
+    const checkpoints = [...this.checkpoints.values()].sort((a, b) => a.taskId.localeCompare(b.taskId));
+    for (const checkpoint of checkpoints) {
+      if (jobId !== void 0 && this.taskJobs.get(checkpoint.taskId) !== jobId)
+        continue;
+      yield cloneCheckpoint(checkpoint);
+    }
+  }
+};
+function memoryCheckpointAdapter() {
+  return new MemoryCheckpointAdapter();
+}
+async function advanceTaskCheckpoint(checkpoints, input) {
+  const checkpoint = transitionTaskCheckpoint(await checkpoints.get(input.taskId), input);
+  await checkpoints.put(checkpoint);
+  return checkpoint;
+}
+function transitionTaskCheckpoint(existing, input) {
+  if (!existing)
+    return createCheckpoint(input);
+  if (existing.taskId !== input.taskId) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Task checkpoint id does not match transition", {
+      existingTaskId: existing.taskId,
+      taskId: input.taskId
+    });
+  }
+  if (existing.state === input.nextState && existing.idempotencyKey === input.idempotencyKey) {
+    return cloneCheckpoint(existing);
+  }
+  const stale = input.staleTimeoutMs !== void 0 && input.nowMs - existing.updatedAtMs > input.staleTimeoutMs;
+  if (existing.idempotencyKey !== input.idempotencyKey && !stale) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Task transition idempotency key mismatch", {
+      taskId: input.taskId,
+      existingIdempotencyKey: existing.idempotencyKey,
+      idempotencyKey: input.idempotencyKey
+    });
+  }
+  if (!transitionAllowed(existing.state, input.nextState, stale)) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Task state transition is not allowed", {
+      taskId: input.taskId,
+      from: existing.state,
+      to: input.nextState
+    });
+  }
+  const checkpoint = createCheckpoint(input);
+  if (checkpoint.output === void 0 && checkpoint.outputs === void 0 && existing.output !== void 0 && stateRank(input.nextState) > stateRank(existing.state)) {
+    checkpoint.output = normalizeOutputEntry(existing.output);
+  }
+  if (checkpoint.output === void 0 && checkpoint.outputs === void 0 && existing.outputs !== void 0 && stateRank(input.nextState) > stateRank(existing.state)) {
+    checkpoint.outputs = existing.outputs.map(normalizeOutputEntry);
+  }
+  return checkpoint;
+}
+function stableStringify(value) {
+  return JSON.stringify(toStableJson(value));
+}
+function fingerprint(value) {
+  return `fp_${fnv1a64(stableStringify(value)).toString(16).padStart(16, "0")}`;
+}
+function normalizeTaskInput(task) {
+  const normalized = {
+    path: task.path,
+    rowGroupRanges: [...task.rowGroupRanges].map((range) => ({ start: range.start, end: range.end })).sort((a, b) => a.start - b.start || a.end - b.end),
+    partitionValues: sortRecord(task.partitionValues)
+  };
+  if (task.etag !== void 0)
+    normalized.etag = task.etag;
+  if (task.size !== void 0)
+    normalized.size = task.size;
+  if (task.rowGroupCount !== void 0)
+    normalized.rowGroupCount = task.rowGroupCount;
+  if (task.projectedColumns !== void 0)
+    normalized.projectedColumns = [...task.projectedColumns].sort();
+  if (task.residualPredicate !== void 0)
+    normalized.residualPredicate = task.residualPredicate;
+  if (task.window !== void 0) {
+    normalized.window = task.window.available === true ? {
+      topology: task.window.topology,
+      available: true,
+      bucketCount: task.window.bucketCount,
+      partitionBy: task.window.partitionBy
+    } : {
+      topology: task.window.topology,
+      available: false,
+      bucketCount: 1,
+      reason: task.window.reason
+    };
+  }
+  return normalized;
+}
+function normalizeOutputEntry(entry) {
+  const normalized = {
+    taskId: entry.taskId,
+    outputPath: entry.outputPath,
+    partitionValues: sortRecord(entry.partitionValues),
+    rowCount: entry.rowCount,
+    byteSize: entry.byteSize
+  };
+  if (entry.contentHash !== void 0)
+    normalized.contentHash = entry.contentHash;
+  if (entry.etag !== void 0)
+    normalized.etag = entry.etag;
+  if (entry.iceberg !== void 0) {
+    normalized.iceberg = {
+      recordCount: entry.iceberg.recordCount,
+      fileSizeInBytes: entry.iceberg.fileSizeInBytes,
+      partitionValues: sortRecord(entry.iceberg.partitionValues)
+    };
+  }
+  return normalized;
+}
+function parseOutputManifest(value) {
+  if (!isRecord2(value) || value.version !== 1 || typeof value.jobId !== "string" || value.jobId.length === 0 || typeof value.planFingerprint !== "string" || value.planFingerprint.length === 0 || !Array.isArray(value.entries)) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest has invalid required fields");
+  }
+  return createOutputManifest({
+    jobId: value.jobId,
+    planFingerprint: value.planFingerprint,
+    entries: value.entries.map(parseOutputEntry)
+  });
+}
+function parseOutputEntry(value) {
+  if (!isRecord2(value) || typeof value.taskId !== "string" || value.taskId.length === 0 || typeof value.outputPath !== "string" || value.outputPath.length === 0 || !isStringRecord(value.partitionValues) || !isNonNegativeInteger(value.rowCount) || !isNonNegativeInteger(value.byteSize)) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest entry is invalid");
+  }
+  const entry = {
+    taskId: value.taskId,
+    outputPath: value.outputPath,
+    partitionValues: value.partitionValues,
+    rowCount: value.rowCount,
+    byteSize: value.byteSize
+  };
+  if (value.contentHash !== void 0) {
+    if (typeof value.contentHash !== "string" || value.contentHash.length === 0) {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest content hash is invalid");
+    }
+    entry.contentHash = value.contentHash;
+  }
+  if (value.etag !== void 0) {
+    if (typeof value.etag !== "string" || value.etag.length === 0) {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest etag is invalid");
+    }
+    entry.etag = value.etag;
+  }
+  if (value.iceberg !== void 0)
+    entry.iceberg = parseOutputIcebergMetadata(value.iceberg);
+  return entry;
+}
+function parseOutputIcebergMetadata(value) {
+  if (!isRecord2(value) || !isNonNegativeInteger(value.recordCount) || !isNonNegativeInteger(value.fileSizeInBytes) || !isStringRecord(value.partitionValues)) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest Iceberg metadata is invalid");
+  }
+  return {
+    recordCount: value.recordCount,
+    fileSizeInBytes: value.fileSizeInBytes,
+    partitionValues: value.partitionValues
+  };
+}
+function snapshotFromTasks(tasks) {
+  return fingerprint(tasks.map((task) => ({
+    path: task.path,
+    etag: task.etag ?? null,
+    size: task.size ?? null
+  })));
+}
+function taskId(jobId, index, task) {
+  return `${jobId}-task-${String(index).padStart(6, "0")}-${fingerprint(task).slice(3, 11)}`;
+}
+function jobIdFromTaskId(taskId2) {
+  const marker = "-task-";
+  const index = taskId2.indexOf(marker);
+  return index === -1 ? "" : taskId2.slice(0, index);
+}
+function createCheckpoint(input) {
+  const checkpoint = {
+    taskId: input.taskId,
+    state: input.nextState,
+    idempotencyKey: input.idempotencyKey,
+    updatedAtMs: input.nowMs
+  };
+  if (input.output !== void 0)
+    checkpoint.output = normalizeOutputEntry(input.output);
+  if (input.outputs !== void 0) {
+    checkpoint.outputs = input.outputs.map(normalizeOutputEntry);
+  }
+  return checkpoint;
+}
+function transitionAllowed(from, to, stale) {
+  if (stale && to === "running")
+    return true;
+  return stateRank(to) === stateRank(from) + 1;
+}
+function stateRank(state) {
+  const order = [
+    "planned",
+    "running",
+    "output-written",
+    "manifest-recorded",
+    "complete"
+  ];
+  return order.indexOf(state);
+}
+function toStableJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    if (typeof value === "number" && !Number.isFinite(value))
+      return String(value);
+    return value;
+  }
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value instanceof Date)
+    return value.toISOString();
+  if (value instanceof Uint8Array)
+    return base64UrlEncode(value);
+  if (Array.isArray(value))
+    return value.map(toStableJson);
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const [key, inner] of Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) {
+      if (inner !== void 0)
+        out[key] = toStableJson(inner);
+    }
+    return out;
+  }
+  return String(value);
+}
+function sortRecord(record) {
+  const out = {};
+  for (const key of Object.keys(record).sort())
+    out[key] = record[key] ?? "";
+  return out;
+}
+function sortValueRecord(record, message) {
+  const out = {};
+  for (const key of Object.keys(record).sort()) {
+    assertSafeRecordKey(key, message);
+    const value = record[key];
+    if (value !== void 0)
+      out[key] = value;
+  }
+  return out;
+}
+function assertSafeRecordKey(key, message) {
+  if (key.length === 0 || isPrototypeMutationKey(key))
+    throwInvalidBookmark(message);
+}
+function isStringRecord(value) {
+  return isRecord2(value) && Object.values(value).every((inner) => typeof inner === "string");
+}
+function fnv1a64(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (const byte of new TextEncoder().encode(input)) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash;
+}
+async function hmac(payload, secret) {
+  const keyBytes = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  const key = await crypto.subtle.importKey("raw", bytesToArrayBuffer(keyBytes), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, bytesToArrayBuffer(new TextEncoder().encode(payload)));
+  return base64UrlEncode(new Uint8Array(signature));
+}
+function bytesToArrayBuffer(bytes) {
+  const copy = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(copy).set(bytes);
+  return copy;
+}
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function base64UrlDecode(value) {
+  const padded = value.replaceAll("-", "+").replaceAll("_", "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1)
+    bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function constantTimeEqual(left, right) {
+  const length = Math.max(left.length, right.length);
+  let diff = left.length ^ right.length;
+  for (let index = 0; index < length; index += 1) {
+    diff |= (left.charCodeAt(index) || 0) ^ (right.charCodeAt(index) || 0);
+  }
+  return diff === 0;
+}
+function parseBookmark(value) {
+  if (!isRecord2(value) || value.version !== 1)
+    throwInvalidBookmark("Bookmark version is invalid");
+  if (typeof value.planFingerprint !== "string" || typeof value.snapshot !== "string") {
+    throwInvalidBookmark("Bookmark identity is invalid");
+  }
+  const position = value.position;
+  const fileIndex = isRecord2(position) ? position.fileIndex : void 0;
+  const rowGroup = isRecord2(position) ? position.rowGroup : void 0;
+  const rowOffset = isRecord2(position) ? position.rowOffset : void 0;
+  if (!isRecord2(position) || !isNonNegativeInteger(fileIndex) || !isNonNegativeInteger(rowGroup) || !isNonNegativeInteger(rowOffset)) {
+    throwInvalidBookmark("Bookmark position is invalid");
+  }
+  const bookmark = {
+    version: 1,
+    planFingerprint: value.planFingerprint,
+    snapshot: value.snapshot,
+    position: parseBookmarkPosition(position, fileIndex, rowGroup, rowOffset)
+  };
+  if (value.query !== void 0)
+    bookmark.query = parseBookmarkQuery(value.query);
+  if (value.writeState !== void 0)
+    bookmark.writeState = parseBookmarkWriteState(value.writeState);
+  if (value.operatorState !== void 0) {
+    bookmark.operatorState = parseBookmarkOperatorState(value.operatorState);
+  }
+  return bookmark;
+}
+function normalizeBookmarkWriteState(state) {
+  const normalized = {};
+  if (state.taskState !== void 0)
+    normalized.taskState = state.taskState;
+  if (state.idempotencyKey !== void 0)
+    normalized.idempotencyKey = state.idempotencyKey;
+  if (state.multipart !== void 0) {
+    normalized.multipart = {
+      uploadId: state.multipart.uploadId,
+      path: state.multipart.path,
+      parts: state.multipart.parts.map((part) => ({
+        partNumber: part.partNumber,
+        etag: part.etag,
+        byteSize: part.byteSize
+      })).sort((left, right) => left.partNumber - right.partNumber)
+    };
+  }
+  return normalized;
+}
+function normalizeBookmarkOperatorState(state) {
+  const normalized = {};
+  if (state.limitEmitted !== void 0)
+    normalized.limitEmitted = state.limitEmitted;
+  if (state.groupBy !== void 0)
+    normalized.groupBy = cloneInlineOrSpillState(state.groupBy);
+  if (state.topK !== void 0)
+    normalized.topK = cloneInlineOrSpillState(state.topK);
+  if (state.sort !== void 0)
+    normalized.sort = cloneInlineOrSpillState(state.sort);
+  if (state.sketches !== void 0) {
+    normalized.sketches = {};
+    for (const [key, value] of Object.entries(state.sketches).sort(([a], [b]) => a.localeCompare(b))) {
+      assertSafeRecordKey(key, "Bookmark sketches state is invalid");
+      normalized.sketches[key] = cloneBytes(value);
+    }
+  }
+  return normalized;
+}
+function cloneInlineOrSpillState(value) {
+  return value instanceof Uint8Array ? cloneBytes(value) : { spillRef: value.spillRef };
+}
+function cloneBytes(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy;
+}
+function normalizeBookmarkQuery(query) {
+  const normalized = { source: query.source };
+  if (query.select !== void 0)
+    normalized.select = [...query.select];
+  if (query.projections !== void 0) {
+    normalized.projections = sortValueRecord(query.projections, "Bookmark projections are invalid");
+  }
+  if (query.where !== void 0)
+    normalized.where = query.where;
+  if (query.distinct !== void 0)
+    normalized.distinct = query.distinct;
+  if (query.windows !== void 0) {
+    normalized.windows = sortValueRecord(query.windows, "Bookmark windows are invalid");
+    for (const expr of Object.values(normalized.windows)) {
+      if (!isWindowExprSnapshot(expr))
+        throwInvalidBookmark("Bookmark windows are invalid");
+    }
+  }
+  if (query.qualify !== void 0)
+    normalized.qualify = query.qualify;
+  if (query.orderBy !== void 0) {
+    normalized.orderBy = query.orderBy.map((term) => {
+      const normalizedTerm = {
+        column: term.column
+      };
+      if (term.direction !== void 0)
+        normalizedTerm.direction = term.direction;
+      if (term.nulls !== void 0)
+        normalizedTerm.nulls = term.nulls;
+      return normalizedTerm;
+    });
+  }
+  if (query.limit !== void 0)
+    normalized.limit = query.limit;
+  if (query.offset !== void 0)
+    normalized.offset = query.offset;
+  if (query.batchSize !== void 0)
+    normalized.batchSize = query.batchSize;
+  if (query.hive !== void 0)
+    normalized.hive = query.hive;
+  return normalized;
+}
+function parseBookmarkOperatorState(value) {
+  if (!isRecord2(value))
+    throwInvalidBookmark("Bookmark operator state is invalid");
+  const state = {};
+  if (value.limitEmitted !== void 0) {
+    state.limitEmitted = parseBookmarkNonNegativeInteger(value.limitEmitted, "limitEmitted");
+  }
+  if (value.groupBy !== void 0)
+    state.groupBy = parseInlineOrSpillState(value.groupBy);
+  if (value.topK !== void 0)
+    state.topK = parseInlineOrSpillState(value.topK);
+  if (value.sort !== void 0)
+    state.sort = parseInlineOrSpillState(value.sort);
+  if (value.sketches !== void 0) {
+    if (!isRecord2(value.sketches))
+      throwInvalidBookmark("Bookmark sketches state is invalid");
+    state.sketches = {};
+    for (const [key, inner] of Object.entries(value.sketches)) {
+      assertSafeRecordKey(key, "Bookmark sketches state is invalid");
+      state.sketches[key] = parseBase64UrlBytes(inner, "Bookmark sketches state is invalid");
+    }
+  }
+  return state;
+}
+function parseInlineOrSpillState(value) {
+  if (typeof value === "string")
+    return parseBase64UrlBytes(value, "Bookmark operator state is invalid");
+  if (!isRecord2(value) || typeof value.spillRef !== "string" || value.spillRef.length === 0) {
+    throwInvalidBookmark("Bookmark operator state is invalid");
+  }
+  return { spillRef: value.spillRef };
+}
+function parseBookmarkWriteState(value) {
+  if (!isRecord2(value))
+    throwInvalidBookmark("Bookmark write state is invalid");
+  const state = {};
+  if (value.taskState !== void 0) {
+    if (!isTaskState(value.taskState))
+      throwInvalidBookmark("Bookmark write task state is invalid");
+    state.taskState = value.taskState;
+  }
+  if (value.idempotencyKey !== void 0) {
+    if (typeof value.idempotencyKey !== "string" || value.idempotencyKey.length === 0) {
+      throwInvalidBookmark("Bookmark write idempotency key is invalid");
+    }
+    state.idempotencyKey = value.idempotencyKey;
+  }
+  if (value.multipart !== void 0)
+    state.multipart = parseMultipartWriteState(value.multipart);
+  return normalizeBookmarkWriteState(state);
+}
+function parseMultipartWriteState(value) {
+  if (!isRecord2(value))
+    throwInvalidBookmark("Bookmark multipart state is invalid");
+  if (typeof value.uploadId !== "string" || value.uploadId.length === 0) {
+    throwInvalidBookmark("Bookmark multipart upload id is invalid");
+  }
+  if (typeof value.path !== "string" || value.path.length === 0) {
+    throwInvalidBookmark("Bookmark multipart path is invalid");
+  }
+  if (!Array.isArray(value.parts))
+    throwInvalidBookmark("Bookmark multipart parts are invalid");
+  return {
+    uploadId: value.uploadId,
+    path: value.path,
+    parts: value.parts.map(parseMultipartPart)
+  };
+}
+function parseMultipartPart(value) {
+  if (!isRecord2(value))
+    throwInvalidBookmark("Bookmark multipart part is invalid");
+  if (!isPositiveInteger(value.partNumber)) {
+    throwInvalidBookmark("Bookmark multipart part number is invalid");
+  }
+  if (typeof value.etag !== "string" || value.etag.length === 0) {
+    throwInvalidBookmark("Bookmark multipart part etag is invalid");
+  }
+  if (!isNonNegativeInteger(value.byteSize)) {
+    throwInvalidBookmark("Bookmark multipart part byte size is invalid");
+  }
+  return {
+    partNumber: value.partNumber,
+    etag: value.etag,
+    byteSize: value.byteSize
+  };
+}
+function parseBase64UrlBytes(value, message) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]*$/u.test(value))
+    throwInvalidBookmark(message);
+  try {
+    return base64UrlDecode(value);
+  } catch {
+    throwInvalidBookmark(message);
+  }
+}
+function parseBookmarkQuery(value) {
+  if (!isRecord2(value) || typeof value.source !== "string" || value.source.length === 0) {
+    throwInvalidBookmark("Bookmark query is invalid");
+  }
+  const query = { source: value.source };
+  if (value.select !== void 0)
+    query.select = parseStringArray(value.select, "select");
+  if (value.projections !== void 0) {
+    if (!isRecord2(value.projections))
+      throwInvalidBookmark("Bookmark projections are invalid");
+    query.projections = {};
+    for (const [key, expr] of Object.entries(value.projections)) {
+      assertSafeRecordKey(key, "Bookmark projections are invalid");
+      query.projections[key] = parseBookmarkExpr(expr);
+    }
+  }
+  if (value.where !== void 0)
+    query.where = parseBookmarkExpr(value.where);
+  if (value.distinct !== void 0) {
+    if (typeof value.distinct !== "boolean")
+      throwInvalidBookmark("Bookmark distinct is invalid");
+    query.distinct = value.distinct;
+  }
+  if (value.windows !== void 0) {
+    if (!isRecord2(value.windows))
+      throwInvalidBookmark("Bookmark windows are invalid");
+    query.windows = {};
+    for (const [key, expr] of Object.entries(value.windows)) {
+      assertSafeRecordKey(key, "Bookmark windows are invalid");
+      if (!isWindowExprSnapshot(expr))
+        throwInvalidBookmark("Bookmark windows are invalid");
+      query.windows[key] = expr;
+    }
+  }
+  if (value.qualify !== void 0)
+    query.qualify = parseBookmarkExpr(value.qualify);
+  if (value.orderBy !== void 0)
+    query.orderBy = parseBookmarkOrderBy(value.orderBy);
+  if (value.limit !== void 0)
+    query.limit = parseBookmarkNonNegativeInteger(value.limit, "limit");
+  if (value.offset !== void 0)
+    query.offset = parseBookmarkNonNegativeInteger(value.offset, "offset");
+  if (value.batchSize !== void 0) {
+    if (!isPositiveInteger(value.batchSize))
+      throwInvalidBookmark("Bookmark batch size is invalid");
+    query.batchSize = value.batchSize;
+  }
+  if (value.hive !== void 0) {
+    if (typeof value.hive !== "boolean")
+      throwInvalidBookmark("Bookmark hive flag is invalid");
+    query.hive = value.hive;
+  }
+  return query;
+}
+function parseStringArray(value, field) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throwInvalidBookmark(`Bookmark ${field} is invalid`);
+  }
+  return [...value];
+}
+function parseBookmarkOrderBy(value) {
+  if (!Array.isArray(value))
+    throwInvalidBookmark("Bookmark orderBy is invalid");
+  return value.map((term) => {
+    if (!isRecord2(term) || typeof term.column !== "string" || term.column.length === 0) {
+      throwInvalidBookmark("Bookmark orderBy is invalid");
+    }
+    const parsed = { column: term.column };
+    if (term.direction !== void 0) {
+      if (term.direction !== "asc" && term.direction !== "desc") {
+        throwInvalidBookmark("Bookmark orderBy direction is invalid");
+      }
+      parsed.direction = term.direction;
+    }
+    if (term.nulls !== void 0) {
+      if (term.nulls !== "first" && term.nulls !== "last") {
+        throwInvalidBookmark("Bookmark orderBy nulls is invalid");
+      }
+      parsed.nulls = term.nulls;
+    }
+    return parsed;
+  });
+}
+function parseBookmarkExpr(value) {
+  if (!isRecord2(value) || typeof value.kind !== "string") {
+    throwInvalidBookmark("Bookmark where expression is invalid");
+  }
+  return value;
+}
+function parseBookmarkNonNegativeInteger(value, field) {
+  if (!isNonNegativeInteger(value))
+    throwInvalidBookmark(`Bookmark ${field} is invalid`);
+  return value;
+}
+function parseBookmarkPosition(position, fileIndex, rowGroup, rowOffset) {
+  const parsed = {
+    fileIndex,
+    rowGroup,
+    rowOffset
+  };
+  if (position.taskId !== void 0) {
+    if (typeof position.taskId !== "string")
+      throwInvalidBookmark("Bookmark task id is invalid");
+    parsed.taskId = position.taskId;
+  }
+  if (position.outputManifestCursor !== void 0) {
+    if (!isNonNegativeInteger(position.outputManifestCursor)) {
+      throwInvalidBookmark("Bookmark output manifest cursor is invalid");
+    }
+    parsed.outputManifestCursor = position.outputManifestCursor;
+  }
+  return parsed;
+}
+function cloneCheckpoint(checkpoint) {
+  const clone = {
+    taskId: checkpoint.taskId,
+    state: checkpoint.state,
+    idempotencyKey: checkpoint.idempotencyKey,
+    updatedAtMs: checkpoint.updatedAtMs
+  };
+  if (checkpoint.output !== void 0)
+    clone.output = normalizeOutputEntry(checkpoint.output);
+  if (checkpoint.outputs !== void 0)
+    clone.outputs = checkpoint.outputs.map(normalizeOutputEntry);
+  return clone;
+}
+function throwInvalidBookmark(message) {
+  throw new LakeqlError("LAKEQL_BOOKMARK_INVALID", message);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isTaskState(value) {
+  return value === "planned" || value === "running" || value === "output-written" || value === "manifest-recorded" || value === "complete";
+}
+
+// ../core/dist/window-query.js
+function windowReadColumns(input) {
+  const columns = /* @__PURE__ */ new Set();
+  const windowAliases = new Set(Object.keys(input.windows ?? {}));
+  for (const column of input.select ?? []) {
+    if (column !== "*" && !windowAliases.has(column))
+      columns.add(column);
+  }
+  for (const term of input.orderBy ?? []) {
+    if (!windowAliases.has(term.column))
+      columns.add(term.column);
+  }
+  for (const expr of Object.values(input.projections ?? {}))
+    collectExprColumns(expr, columns);
+  for (const expr of Object.values(input.windows ?? {}))
+    collectWindowColumns(expr, columns);
+  collectExprColumns(input.where, columns);
+  collectExprColumns(input.qualify, columns);
+  for (const alias of windowAliases)
+    columns.delete(alias);
+  return columns.size === 0 ? void 0 : [...columns].sort();
+}
+function windowExpressions(windows) {
+  const exprs = [];
+  for (const expr of Object.values(windows ?? {})) {
+    exprs.push(...expr.over.partitionBy);
+    exprs.push(...expr.over.orderBy.map((term) => term.expr));
+    exprs.push(...expr.args);
+    if (expr.filter !== void 0)
+      exprs.push(expr.filter);
+    if (expr.over.frame?.start.offset !== void 0)
+      exprs.push(expr.over.frame.start.offset);
+    if (expr.over.frame?.end.offset !== void 0)
+      exprs.push(expr.over.frame.end.offset);
+  }
+  return exprs;
+}
+function collectWindowColumns(expr, columns) {
+  for (const part of expr.over.partitionBy)
+    collectExprColumns(part, columns);
+  for (const term of expr.over.orderBy)
+    collectExprColumns(term.expr, columns);
+  for (const arg of expr.args)
+    collectExprColumns(arg, columns);
+  collectExprColumns(expr.filter, columns);
+  if (expr.over.frame !== void 0) {
+    collectExprColumns(expr.over.frame.start.offset, columns);
+    collectExprColumns(expr.over.frame.end.offset, columns);
+  }
+}
+function compatibleWindowSortGroups(items) {
+  const groups = [];
+  const ordered = [...items].sort((left, right) => right.expr.over.orderBy.length - left.expr.over.orderBy.length);
+  for (const item of ordered) {
+    const group = groups.find((candidate) => windowSortSpecsCompatible(candidate.sortExpr, item.expr));
+    if (group === void 0) {
+      groups.push({ sortExpr: item.expr, items: [item] });
+      continue;
+    }
+    if (group.sortExpr.over.orderBy.length < item.expr.over.orderBy.length) {
+      group.sortExpr = item.expr;
+    }
+    group.items.push(item);
+  }
+  return groups;
+}
+function windowSortGroupCount(windows) {
+  const sortGroups = /* @__PURE__ */ new Set();
+  for (const group of compatibleWindowSortGroups(Object.values(windows).map((expr) => ({ expr })))) {
+    sortGroups.add(stableStringify({
+      partitionBy: group.sortExpr.over.partitionBy,
+      orderBy: group.sortExpr.over.orderBy
+    }));
+  }
+  return sortGroups.size;
+}
+function windowTaskPlanForWindows(windows, plannedBucketCount) {
+  const partitionSpecs = Object.values(windows).map((expr) => expr.over.partitionBy);
+  if (partitionSpecs.length === 0 || partitionSpecs.every((spec) => spec.length === 0)) {
+    return {
+      topology: "window-partition-fanout",
+      available: false,
+      bucketCount: 1,
+      reason: "window query has one global semantic partition"
+    };
+  }
+  if (partitionSpecs.some((spec) => spec.length === 0)) {
+    return {
+      topology: "window-partition-fanout",
+      available: false,
+      bucketCount: 1,
+      reason: "window query mixes global and partitioned windows"
+    };
+  }
+  const [first, ...rest] = partitionSpecs;
+  const firstKey = stableStringify(first ?? []);
+  if (rest.some((spec) => stableStringify(spec) !== firstKey)) {
+    return {
+      topology: "window-partition-fanout",
+      available: false,
+      bucketCount: 1,
+      reason: "window partition specs are not identical"
+    };
+  }
+  return {
+    topology: "window-partition-fanout",
+    available: true,
+    bucketCount: Math.max(1, Math.min(64, plannedBucketCount)),
+    partitionBy: first ?? []
+  };
+}
+function windowSortSpecsCompatible(left, right) {
+  if (stableExprListKey(left.over.partitionBy) !== stableExprListKey(right.over.partitionBy)) {
+    return false;
+  }
+  return orderTermsPrefixOf(left.over.orderBy, right.over.orderBy) || orderTermsPrefixOf(right.over.orderBy, left.over.orderBy);
+}
+function orderTermsPrefixOf(prefix, full) {
+  if (prefix.length > full.length)
+    return false;
+  for (let index = 0; index < prefix.length; index += 1) {
+    if (stableOrderTermKey(prefix[index]) !== stableOrderTermKey(full[index]))
+      return false;
+  }
+  return true;
+}
+function stableExprListKey(exprs) {
+  return stableStringify(exprs);
+}
+function stableOrderTermKey(term) {
+  return stableStringify(term);
+}
+
+// ../core/dist/scalar-order.js
+function compareOrderedScalars(left, right, term = {}, context = "orderBy") {
+  const direction = term.direction ?? "asc";
+  const nulls = term.nulls ?? (direction === "asc" ? "last" : "first");
+  const leftNull = left === null || left === void 0;
+  const rightNull = right === null || right === void 0;
+  if (leftNull || rightNull) {
+    if (leftNull && rightNull)
+      return 0;
+    const nullOrder = nulls === "first" ? -1 : 1;
+    return leftNull ? nullOrder : -nullOrder;
+  }
+  const comparison = compareNonNullScalars(left, right, context, term.column);
+  return direction === "desc" ? -comparison : comparison;
+}
+function compareAggregateScalars(left, right) {
+  if (left === null || right === null) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare null aggregate values");
+  }
+  return compareNonNullScalars(left, right, "aggregate");
+}
+function numericAggregateValue(op, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${op} window aggregate requires numeric input`, {
+      aggregate: op
+    });
+  }
+  return value;
+}
+function isSortableScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || isTimestampValue(value);
+}
+function compareNonNullScalars(left, right, context, column) {
+  if (!isSortableScalar(left) || !isSortableScalar(right)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${context} values must be scalar`, {
+      ...column === void 0 ? {} : { column }
+    });
+  }
+  if (typeof left === "number" && !Number.isFinite(left) || typeof right === "number" && !Number.isFinite(right)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${context} numeric values must be finite`, {
+      ...column === void 0 ? {} : { column }
+    });
+  }
+  if (isTimestampValue(left) || isTimestampValue(right)) {
+    if (!isTimestampValue(left) || !isTimestampValue(right)) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${context} timestamp values must have matching types`, {
+        ...column === void 0 ? {} : { column }
+      });
+    }
+    return compareTimestampValues(left, right);
+  }
+  if (typeof left !== typeof right) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${context} values must have matching types`, {
+      ...column === void 0 ? {} : { column }
+    });
+  }
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+
+// ../core/dist/window-utils.js
+function normalizedWindowName(fn) {
+  return typeof fn === "string" ? fn : fn.aggregate;
+}
+function isAggregateWindow(fn) {
+  return typeof fn === "object" && fn !== null && "aggregate" in fn;
+}
+function requireExactWindowAggregate(op) {
+  if (op === "approx_count_distinct") {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "approx_count_distinct is not supported as a window aggregate because window results are exact", { aggregate: op });
+  }
+}
+function partitionRows(rows, expr) {
+  return rows.map((row, originalIndex) => ({
+    row,
+    originalIndex,
+    partitionKey: expr.over.partitionBy.map((part) => evaluate(part, row)),
+    orderKey: expr.over.orderBy.map((term) => evaluate(term.expr, row))
+  }));
+}
+function sortWindowRows(rows, orderBy) {
+  rows.sort((left, right) => compareWindowRows(left, right, orderBy));
+}
+function compareWindowRows(left, right, orderBy) {
+  const partition = compareKeyValues(left.partitionKey, right.partitionKey, defaultOrderTerm());
+  if (partition !== 0)
+    return partition;
+  for (let index = 0; index < orderBy.length; index += 1) {
+    const term = orderBy[index] ?? defaultOrderTerm();
+    const comparison = compareWindowValues(left.orderKey[index], right.orderKey[index], term);
+    if (comparison !== 0)
+      return comparison;
+  }
+  return left.originalIndex - right.originalIndex;
+}
+function samePartition(left, right) {
+  return stableKey(left.partitionKey) === stableKey(right.partitionKey);
+}
+function samePeer(left, right) {
+  return samePartition(left, right) && stableKey(left.orderKey) === stableKey(right.orderKey);
+}
+function partitionSpans(rows) {
+  const spans = [];
+  let start = 0;
+  while (start < rows.length) {
+    let end = start + 1;
+    while (end < rows.length && samePartition(rows[start], rows[end])) {
+      end += 1;
+    }
+    spans.push({ start, end });
+    start = end;
+  }
+  return spans;
+}
+function filterRow(expr, row) {
+  return expr.filter === void 0 || matches(expr.filter, row);
+}
+function stableKey(values) {
+  return JSON.stringify(values.map(jsonSafeValue));
+}
+function compareKeyValues(left, right, term) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const comparison = compareWindowValues(left[index], right[index], term);
+    if (comparison !== 0)
+      return comparison;
+  }
+  return 0;
+}
+function compareWindowValues(left, right, term) {
+  return compareOrderedScalars(left, right, term, "Window ORDER BY");
+}
+function defaultOrderTerm() {
+  return { expr: { kind: "literal", value: null }, direction: "asc", nulls: "last" };
+}
+
+export { MemoryCheckpointAdapter, advanceTaskCheckpoint, assertBookmarkMatches, collectExprColumns, collectWindowColumns, compareAggregateScalars, compareOrderedScalars, compareWindowRows, compatibleWindowSortGroups, createBookmark, createOutputManifest, createOutputManifestFromCheckpoints, createTaskManifest, filterRow, fingerprint, isAggregateWindow, isPrototypeMutationKey, isSortableScalar, isWindowExprSnapshot, memoryCheckpointAdapter, normalizedWindowName, numericAggregateValue, partitionRows, partitionSpans, readOutputManifest, requireExactWindowAggregate, samePeer, signPaginationToken, sortWindowRows, stableKey, stableStringify, transitionTaskCheckpoint, verifyPaginationToken, windowExpressions, windowReadColumns, windowSortGroupCount, windowSortSpecsCompatible, windowTaskPlanForWindows, writeOutputManifest };