@loaders.gl/scan 5.0.0-alpha.3

package/dist/index.cjs

@@ -0,0 +1,3485 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  AddressedVectorTableScanSource: () => AddressedVectorTableScanSource,
+  FEDERATED_TABLE_QUERY_CAPABILITIES: () => FEDERATED_TABLE_QUERY_CAPABILITIES,
+  FederatedTableScanSource: () => FederatedTableScanSource,
+  VectorFeatureTableScanSource: () => VectorFeatureTableScanSource,
+  VectorTileTableScanSource: () => VectorTileTableScanSource,
+  createScanEngine: () => createScanEngine,
+  createScanQueryMetadata: () => createScanQueryMetadata,
+  executeTableScanBatches: () => executeTableScanBatches,
+  filterTableBatch: () => filterTableBatch,
+  intersectPointCloudBounds: () => intersectPointCloudBounds,
+  makeTableScanBatch: () => makeTableScanBatch,
+  parseSQLPredicate: () => parseSQLPredicate,
+  projectTableBatch: () => projectTableBatch,
+  projectTableSchema: () => projectTableSchema,
+  registerScanBackend: () => registerScanBackend,
+  selectPointCloudScanTiles: () => selectPointCloudScanTiles,
+  truncateTableBatch: () => truncateTableBatch,
+  validatePointCloudQueryOptions: () => validatePointCloudQueryOptions
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../loader-utils/src/lib/scan-utils/columnar-predicate.ts
+function getColumnarPredicateColumns(predicate) {
+  return [...new Set(getColumnarPredicatePaths(predicate).map((path) => path[0]))];
+}
+function getColumnarPredicatePath(property) {
+  return typeof property.property === "string" ? [property.property] : [...property.property];
+}
+function getColumnarPredicatePaths(predicate) {
+  const paths = /* @__PURE__ */ new Map();
+  visitColumnarPredicate(predicate, (child) => {
+    if ("property" in child.args[0]) {
+      const path = getColumnarPredicatePath(child.args[0]);
+      paths.set(path.join("\0"), path);
+    }
+  });
+  return [...paths.values()];
+}
+function validateColumnarPredicate(predicate, availableColumns) {
+  visitColumnarPredicate(predicate, (child) => {
+    if (child.op === "and" || child.op === "or") {
+      if (child.args.length < 2)
+        throw new Error(`Columnar predicate ${child.op} requires at least two child predicates`);
+      return;
+    }
+    if (child.op === "not") return;
+    const leaf = child;
+    const path = getColumnarPredicatePath(leaf.args[0]);
+    if (!path.length || path.some((component) => !component)) {
+      throw new Error("Columnar predicate property path must contain non-empty strings");
+    }
+    if (!availableColumns.has(path[0]))
+      throw new Error(`Columnar predicate column not found: ${path.join(".")}`);
+    if (leaf.op === "in" && leaf.args[1].length === 0) {
+      throw new Error("Columnar predicate in requires at least one value");
+    }
+  });
+}
+function isColumnarPredicateParameter(value) {
+  const parameterValue = value;
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "parameter") && typeof parameterValue.parameter === "string" && parameterValue.parameter.length > 0;
+}
+function filterColumnarRowIndices(predicate, columns, rowCount) {
+  if (!predicate) return Array.from({ length: rowCount }, (_, index) => index);
+  const result = [];
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    if (evaluateColumnarPredicate(predicate, columns, rowIndex) === true) result.push(rowIndex);
+  }
+  return result;
+}
+function evaluateColumnarPredicate(predicate, columns, rowIndex) {
+  if (predicate.op === "and" || predicate.op === "or") {
+    const results = predicate.args.map(
+      (child) => evaluateColumnarPredicate(child, columns, rowIndex)
+    );
+    return predicate.op === "and" ? results.includes(false) ? false : results.includes(null) ? null : true : results.includes(true) ? true : results.includes(null) ? null : false;
+  }
+  if (predicate.op === "not") {
+    const value2 = evaluateColumnarPredicate(predicate.args[0], columns, rowIndex);
+    return value2 === null ? null : !value2;
+  }
+  const leaf = predicate;
+  const value = getColumnarValue(columns, getColumnarPredicatePath(leaf.args[0]), rowIndex);
+  if (leaf.op === "isNull") return value === null || value === void 0;
+  if (value === null || value === void 0) return null;
+  if (leaf.op === "in")
+    return leaf.args[1].some((candidate) => compareColumnarValues(value, candidate) === 0);
+  const comparison = compareColumnarValues(value, leaf.args[1]);
+  return leaf.op === "=" ? comparison === 0 : leaf.op === "<>" ? comparison !== 0 : leaf.op === "<" ? comparison < 0 : leaf.op === "<=" ? comparison <= 0 : leaf.op === ">" ? comparison > 0 : comparison >= 0;
+}
+function visitColumnarPredicate(predicate, visitor) {
+  visitor(predicate);
+  if (predicate.op === "and" || predicate.op === "or")
+    predicate.args.forEach((child) => visitColumnarPredicate(child, visitor));
+  else if (predicate.op === "not") visitColumnarPredicate(predicate.args[0], visitor);
+}
+function getColumnarValue(columns, path, rowIndex) {
+  var _a;
+  let value = (_a = columns[path[0]]) == null ? void 0 : _a[rowIndex];
+  for (let index = 1; index < path.length && value != null; index++) value = value[path[index]];
+  return value;
+}
+function compareColumnarValues(left, right) {
+  if (left instanceof Uint8Array && right instanceof Uint8Array) return compareBytes(left, right);
+  if (left instanceof Uint8Array || right instanceof Uint8Array)
+    throw new Error("Columnar binary predicates require binary values on both sides");
+  if (left instanceof Date || right instanceof Date) {
+    if (!(left instanceof Date) || !(right instanceof Date))
+      throw new Error("Columnar date predicates require date values on both sides");
+    return compareNumbers(left.getTime(), right.getTime());
+  }
+  const leftType = typeof left;
+  const rightType = typeof right;
+  const numeric = (leftType === "number" || leftType === "bigint") && (rightType === "number" || rightType === "bigint");
+  if (!numeric && leftType !== rightType)
+    throw new Error(`Columnar predicate cannot compare ${leftType} with ${rightType}`);
+  if (!numeric && leftType !== "string" && leftType !== "boolean")
+    throw new Error(`Columnar predicate does not support ${leftType} values`);
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareNumbers(left, right) {
+  if (!Number.isFinite(left) || !Number.isFinite(right))
+    throw new Error("Non-finite values cannot be ordered by a columnar predicate");
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareBytes(left, right) {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0; index < length; index++)
+    if (left[index] !== right[index]) return left[index] < right[index] ? -1 : 1;
+  return left.length - right.length;
+}
+
+// ../loader-utils/src/lib/scan-utils/scan-query-metadata.ts
+var import_crs = require("@math.gl/crs");
+function emitScanExecutionTelemetry(callback, telemetry) {
+  if (!callback) return;
+  try {
+    callback(telemetry);
+  } catch {
+  }
+}
+function createScanQueryMetadata(options) {
+  validateScanExecutionSupport(options.queryType, options.execution);
+  const schema = Object.freeze({
+    fields: Object.freeze(
+      options.schema.fields.map(
+        (field) => Object.freeze({ ...field, metadata: Object.freeze({ ...field.metadata }) })
+      )
+    ),
+    metadata: Object.freeze({ ...options.schema.metadata })
+  });
+  const columns = schema.fields.map(
+    (field) => {
+      var _a;
+      return Object.freeze({
+        name: field.name,
+        type: field.type,
+        nullable: field.nullable !== false,
+        role: ((_a = options.columnRoles) == null ? void 0 : _a[field.name]) || "attribute",
+        title: getNonEmptyMetadataValue(field.metadata, "title"),
+        description: getNonEmptyMetadataValue(field.metadata, "description"),
+        metadata: field.metadata || Object.freeze({})
+      });
+    }
+  );
+  return Object.freeze({
+    sourceType: options.sourceType,
+    queryType: options.queryType,
+    execution: Object.freeze({ ...options.execution }),
+    name: options.name,
+    description: options.description,
+    schema,
+    columns: Object.freeze(columns),
+    capabilities: Object.freeze({ ...options.capabilities }),
+    spatial: options.spatial ? Object.freeze({
+      ...options.spatial,
+      bounds: options.spatial.bounds ? Object.freeze({
+        minimum: Object.freeze([...options.spatial.bounds.minimum]),
+        maximum: Object.freeze([...options.spatial.bounds.maximum])
+      }) : void 0,
+      coordinateReferenceSystems: options.spatial.coordinateReferenceSystems ? Object.freeze([...options.spatial.coordinateReferenceSystems]) : void 0,
+      spatialReference: options.spatial.spatialReference ? (0, import_crs.createSpatialReference)(options.spatial.spatialReference) : void 0
+    }) : void 0,
+    statistics: options.statistics ? Object.freeze({ ...options.statistics }) : void 0,
+    levels: options.levels ? Object.freeze(
+      options.levels.map(
+        (level) => Object.freeze({
+          ...level,
+          scale: level.scale ? Object.freeze([...level.scale]) : void 0
+        })
+      )
+    ) : void 0
+  });
+}
+function validateScanExecutionSupport(queryType, execution) {
+  if (execution.status === "metadata-only") {
+    if (!execution.reason.trim()) {
+      throw new Error("Metadata-only scan support requires a concrete reason");
+    }
+    return;
+  }
+  const validMethods = {
+    table: ["read", "query"],
+    raster: ["getRaster"],
+    "point-cloud": ["scan"]
+  };
+  if (!validMethods[queryType].includes(execution.method)) {
+    throw new Error(
+      `Scan execution method "${execution.method}" is not valid for ${queryType} queries`
+    );
+  }
+}
+function getNonEmptyMetadataValue(metadata, key) {
+  const value = metadata == null ? void 0 : metadata[key];
+  return value || void 0;
+}
+
+// ../loader-utils/src/lib/scan-utils/table-query.ts
+function planTableQuery(sourceColumnNames, options = {}) {
+  validateTableQueryOptions(sourceColumnNames, options);
+  const outputColumnNames = options.columns ? [...options.columns] : [...sourceColumnNames];
+  const predicateColumnNames = options.predicate ? getColumnarPredicateColumns(options.predicate) : [];
+  const requiredColumnNames = /* @__PURE__ */ new Set([...outputColumnNames, ...predicateColumnNames]);
+  const scanColumnNames = sourceColumnNames.filter(
+    (columnName) => requiredColumnNames.has(columnName)
+  );
+  const steps = [
+    Object.freeze({ kind: "scan", columns: Object.freeze(scanColumnNames) })
+  ];
+  if (options.predicate) {
+    steps.push(Object.freeze({ kind: "filter", predicate: options.predicate }));
+  }
+  steps.push(Object.freeze({ kind: "project", columns: Object.freeze(outputColumnNames) }));
+  if (options.limit !== void 0) {
+    steps.push(Object.freeze({ kind: "limit", limit: options.limit }));
+  }
+  return Object.freeze(steps);
+}
+function validateTableQueryOptions(sourceColumnNames, options) {
+  const availableColumnNames = new Set(sourceColumnNames);
+  const outputColumnNames = options.columns ?? sourceColumnNames;
+  const seenColumnNames = /* @__PURE__ */ new Set();
+  for (const columnName of outputColumnNames) {
+    if (!availableColumnNames.has(columnName)) {
+      throw new Error(`Table query column not found: ${columnName}`);
+    }
+    if (seenColumnNames.has(columnName)) {
+      throw new Error(`Table query column was selected more than once: ${columnName}`);
+    }
+    seenColumnNames.add(columnName);
+  }
+  validateTableQueryLimit(options.limit);
+  if (options.predicate) {
+    validateColumnarPredicate(options.predicate, availableColumnNames);
+  }
+}
+function validateTableQueryLimit(limit) {
+  if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 0)) {
+    throw new Error("Table query limit must be a non-negative safe integer.");
+  }
+}
+
+// ../loader-utils/src/lib/scan-utils/table-scan-batch.ts
+function makeTableScanBatch(table) {
+  return { ...table, batchType: "data", length: table.data.numRows };
+}
+async function* executeTableScanBatches(readBatches, options = {}, operators = {}) {
+  var _a;
+  validateTableQueryLimit(options.limit);
+  const startedAt = Date.now();
+  let sourcesRead = 0;
+  let batchesRead = 0;
+  let rowsRead = 0;
+  let rowsTested = 0;
+  let rowsRetained = 0;
+  let rowsReturned = 0;
+  let bytesFetched = 0;
+  let status = "early-terminated";
+  let earlyTerminationReason;
+  let executionError;
+  let remaining = options.limit === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, options.limit);
+  try {
+    if (remaining <= 0) {
+      earlyTerminationReason = "limit";
+      return;
+    }
+    sourcesRead = 1;
+    for await (const batch of readBatches(
+      options.signal,
+      (byteLength) => bytesFetched += byteLength
+    )) {
+      if (remaining <= 0) {
+        earlyTerminationReason = "limit";
+        return;
+      }
+      batchesRead++;
+      rowsRead += batch.length;
+      const filteredBatch = (operators.filter || filterTableBatch)(batch, options.predicate);
+      if (options.predicate) {
+        rowsTested += batch.length;
+        rowsRetained += filteredBatch.length;
+      }
+      const projectedBatch = (operators.project || projectTableBatch)(
+        filteredBatch,
+        options.columns
+      );
+      if (projectedBatch.length <= remaining) {
+        remaining -= projectedBatch.length;
+        rowsReturned += projectedBatch.length;
+        yield projectedBatch;
+      } else {
+        const outputBatch = truncateTableBatch(projectedBatch, remaining);
+        rowsReturned += outputBatch.length;
+        earlyTerminationReason = "limit";
+        yield outputBatch;
+        return;
+      }
+    }
+    status = "completed";
+  } catch (error) {
+    status = ((_a = options.signal) == null ? void 0 : _a.aborted) ? "cancelled" : "failed";
+    executionError = error;
+    throw error;
+  } finally {
+    if (status === "early-terminated" && !earlyTerminationReason) {
+      earlyTerminationReason = "consumer-return";
+    }
+    emitScanExecutionTelemetry(
+      options.onTelemetry,
+      Object.freeze({
+        status,
+        sourcesPlanned: 1,
+        sourcesRead,
+        batchesRead,
+        batchesDecoded: batchesRead,
+        rowsRead,
+        rowsTested: rowsTested || void 0,
+        rowsRetained: rowsRetained || void 0,
+        rowsReturned,
+        bytesRead: bytesFetched,
+        bytesFetched,
+        filesOpened: sourcesRead,
+        tasksOpened: sourcesRead,
+        durationMilliseconds: Date.now() - startedAt,
+        earlyTerminationReason,
+        ...executionError === void 0 ? {} : { error: executionError }
+      })
+    );
+  }
+}
+function truncateTableBatch(batch, length) {
+  if (batch.shape === "object-row-table" || batch.shape === "array-row-table") {
+    return { ...batch, data: batch.data.slice(0, length), length };
+  }
+  if (batch.shape === "columnar-table") {
+    return {
+      ...batch,
+      data: Object.fromEntries(
+        Object.entries(batch.data).map(([name, values]) => [
+          name,
+          Array.from(values).slice(0, length)
+        ])
+      ),
+      length
+    };
+  }
+  if (batch.shape === "arrow-table") return { ...batch, data: batch.data.slice(0, length), length };
+  return { ...batch, features: batch.features.slice(0, length), length };
+}
+function projectTableBatch(batch, columns) {
+  if (columns === void 0) return batch;
+  const schema = projectTableSchema(batch, columns);
+  if (batch.shape === "object-row-table") {
+    return {
+      ...batch,
+      schema,
+      data: batch.data.map((row) => Object.fromEntries(columns.map((column) => [column, row[column]])))
+    };
+  }
+  if (batch.shape === "columnar-table") {
+    return {
+      ...batch,
+      schema,
+      data: Object.fromEntries(columns.map((column) => [column, batch.data[column]]))
+    };
+  }
+  if (batch.shape === "arrow-table")
+    return { ...batch, schema, data: batch.data.select([...columns]) };
+  return batch;
+}
+function projectTableSchema(batch, columns) {
+  if (!batch.schema) return void 0;
+  const fieldsByName = new Map(batch.schema.fields.map((field) => [field.name, field]));
+  return {
+    ...batch.schema,
+    fields: columns.flatMap((column) => {
+      const field = fieldsByName.get(column);
+      return field ? [field] : [];
+    })
+  };
+}
+function filterTableBatch(batch, predicate) {
+  var _a;
+  if (!predicate || batch.shape !== "object-row-table") return batch;
+  const rows = batch.data;
+  const columnNames = new Set(((_a = batch.schema) == null ? void 0 : _a.fields.map((field) => field.name)) || []);
+  validateColumnarPredicate(predicate, columnNames);
+  const columns = Object.fromEntries(
+    [...columnNames].map((name) => [name, rows.map((row) => row[name])])
+  );
+  const rowIndices = filterColumnarRowIndices(predicate, columns, rows.length);
+  return { ...batch, data: rowIndices.map((rowIndex) => rows[rowIndex]), length: rowIndices.length };
+}
+
+// ../loader-utils/src/lib/scan-utils/relational-query.ts
+function planRelationalQuery(sourceColumnNames, options = {}) {
+  var _a, _b, _c, _d, _e, _f;
+  const available = new Set(sourceColumnNames);
+  const expressionNames = /* @__PURE__ */ new Set();
+  for (const expression of options.expressions || []) {
+    if (!expression.name) throw new Error("Relational expression names must be non-empty.");
+    if (available.has(expression.name) || expressionNames.has(expression.name)) {
+      throw new Error(`Relational expression duplicates column: ${expression.name}`);
+    }
+    expressionNames.add(expression.name);
+  }
+  const aggregateNames = new Set((options.aggregates || []).map((aggregate) => aggregate.name));
+  const requiredColumns = /* @__PURE__ */ new Set();
+  const availableColumns = new Set(sourceColumnNames);
+  for (const expression of options.expressions || []) {
+    const definition = expression.expression;
+    if (definition.op === "column") {
+      validateRelationalColumnReference(definition.column, availableColumns);
+      if (available.has(definition.column)) requiredColumns.add(definition.column);
+    }
+    if ("left" in definition) {
+      validateRelationalColumnReference(definition.left, availableColumns);
+      validateRelationalColumnReference(definition.right, availableColumns);
+      if (available.has(definition.left)) requiredColumns.add(definition.left);
+      if (available.has(definition.right)) requiredColumns.add(definition.right);
+    }
+    availableColumns.add(expression.name);
+  }
+  for (const key of options.orderBy || []) requiredColumns.add(key.column);
+  for (const key of options.groupBy || []) requiredColumns.add(key);
+  for (const aggregate of options.aggregates || []) {
+    if (aggregate.column) requiredColumns.add(aggregate.column);
+  }
+  const outputColumns = (_a = options.columns) == null ? void 0 : _a.filter(
+    (column) => !expressionNames.has(column) && !aggregateNames.has(column)
+  );
+  const tablePlan = [
+    ...planTableQuery(sourceColumnNames, {
+      ...options,
+      columns: outputColumns,
+      predicate: options.predicate
+    })
+  ];
+  const scanStep = tablePlan[0];
+  if ((scanStep == null ? void 0 : scanStep.kind) === "scan") {
+    const scanColumns = new Set(scanStep.columns);
+    for (const column of requiredColumns) {
+      if (available.has(column)) scanColumns.add(column);
+    }
+    tablePlan[0] = Object.freeze({ kind: "scan", columns: Object.freeze([...scanColumns]) });
+  }
+  for (const expression of expressionNames) available.add(expression);
+  for (const aggregate of aggregateNames) available.add(aggregate);
+  for (const key of options.orderBy || []) {
+    if (!available.has(key.column))
+      throw new Error(`Relational order column not found: ${key.column}`);
+  }
+  for (const key of options.groupBy || []) {
+    if (!available.has(key)) throw new Error(`Relational group column not found: ${key}`);
+  }
+  for (const aggregate of options.aggregates || []) {
+    if (!aggregate.name) throw new Error("Relational aggregate names must be non-empty.");
+    if (aggregate.function !== "count" && !aggregate.column) {
+      throw new Error(`Relational aggregate ${aggregate.function} requires a column.`);
+    }
+    if (aggregate.column && !available.has(aggregate.column)) {
+      throw new Error(`Relational aggregate column not found: ${aggregate.column}`);
+    }
+  }
+  const relationalSteps = [];
+  if ((_b = options.expressions) == null ? void 0 : _b.length)
+    relationalSteps.push({ kind: "expression", detail: options.expressions });
+  if ((_c = options.orderBy) == null ? void 0 : _c.length) relationalSteps.push({ kind: "order", detail: options.orderBy });
+  if (((_d = options.aggregates) == null ? void 0 : _d.length) || ((_e = options.groupBy) == null ? void 0 : _e.length)) {
+    relationalSteps.push({
+      kind: "aggregate",
+      detail: { groupBy: options.groupBy, aggregates: options.aggregates }
+    });
+  }
+  if ((_f = options.union) == null ? void 0 : _f.length) relationalSteps.push({ kind: "union", detail: options.union });
+  if (options.join) relationalSteps.push({ kind: "join", detail: options.join });
+  return { tablePlan, relationalSteps: Object.freeze(relationalSteps) };
+}
+function validateRelationalColumnReference(columnName, availableColumns) {
+  if (!availableColumns.has(columnName)) {
+    throw new Error(`Relational expression column not found: ${columnName}`);
+  }
+}
+
+// ../loader-utils/src/lib/scan-utils/point-cloud-query.ts
+function validatePointCloudQueryOptions(sourceColumnNames, options) {
+  validateTableQueryOptions(sourceColumnNames, options);
+  validatePointCloudBounds(options.bounds);
+  validateHierarchyLevel(options.minimumLevel, "minimumLevel");
+  validateHierarchyLevel(options.maximumLevel, "maximumLevel");
+  if (options.minimumLevel !== void 0 && options.maximumLevel !== void 0 && options.minimumLevel > options.maximumLevel) {
+    throw new Error("Point cloud query minimumLevel cannot exceed maximumLevel.");
+  }
+  if (options.targetSpacing !== void 0 && (!Number.isFinite(options.targetSpacing) || options.targetSpacing <= 0)) {
+    throw new Error("Point cloud query targetSpacing must be a positive finite number.");
+  }
+}
+async function* selectPointCloudScanTiles(rootTile, loadChildren, options = {}) {
+  const pendingTiles = [rootTile];
+  const minimumLevel = options.minimumLevel ?? 0;
+  while (pendingTiles.length > 0) {
+    throwIfPointCloudScanAborted(options.signal);
+    const tile = pendingTiles.shift();
+    if (options.bounds && !intersectPointCloudBounds(tile.bounds, options.bounds)) {
+      continue;
+    }
+    const satisfiesMinimumLevel = tile.level >= minimumLevel;
+    if (satisfiesMinimumLevel) {
+      yield tile;
+    }
+    const reachedMaximumLevel = options.maximumLevel !== void 0 && tile.level >= options.maximumLevel;
+    const reachedTargetSpacing = satisfiesMinimumLevel && options.targetSpacing !== void 0 && tile.geometricError <= options.targetSpacing;
+    if (reachedMaximumLevel || reachedTargetSpacing) {
+      continue;
+    }
+    const children = [...await loadChildren(tile)].sort(
+      (left, right) => left.id.localeCompare(right.id)
+    );
+    pendingTiles.push(...children);
+  }
+}
+function intersectPointCloudBounds(left, right) {
+  for (let dimension = 0; dimension < 3; dimension++) {
+    if (left.maximum[dimension] < right.minimum[dimension] || left.minimum[dimension] > right.maximum[dimension]) {
+      return false;
+    }
+  }
+  return true;
+}
+function validatePointCloudBounds(bounds) {
+  if (!bounds) {
+    return;
+  }
+  for (let dimension = 0; dimension < 3; dimension++) {
+    const minimum = bounds.minimum[dimension];
+    const maximum = bounds.maximum[dimension];
+    if (!Number.isFinite(minimum) || !Number.isFinite(maximum)) {
+      throw new Error("Point cloud query bounds must contain finite coordinates.");
+    }
+    if (minimum > maximum) {
+      throw new Error("Point cloud query bounds minimum cannot exceed maximum.");
+    }
+  }
+}
+function validateHierarchyLevel(level, name) {
+  if (level !== void 0 && (!Number.isSafeInteger(level) || level < 0)) {
+    throw new Error(`Point cloud query ${name} must be a non-negative safe integer.`);
+  }
+}
+function throwIfPointCloudScanAborted(signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    throw new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// ../loader-utils/src/lib/scan-utils/table-query-explain.ts
+function explainTableQuery(sourceColumnNames, options, capabilities) {
+  const plan = planTableQuery(sourceColumnNames, options);
+  const outputColumns = options.columns ? [...options.columns] : [...sourceColumnNames];
+  const predicateColumns = options.predicate ? getColumnarPredicateColumns(options.predicate) : [];
+  const requiredColumns = [...plan[0].kind === "scan" ? plan[0].columns : []];
+  return Object.freeze({
+    sourceColumns: Object.freeze([...sourceColumnNames]),
+    outputColumns: Object.freeze(outputColumns),
+    requiredColumns: Object.freeze(requiredColumns),
+    predicateColumns: Object.freeze(predicateColumns),
+    plan,
+    capabilities: Object.freeze({ ...capabilities }),
+    operators: Object.freeze({
+      projection: createOperatorExplanation(options.columns !== void 0, capabilities.projection),
+      predicate: createOperatorExplanation(options.predicate !== void 0, capabilities.predicate),
+      limit: createOperatorExplanation(options.limit !== void 0, capabilities.limit)
+    })
+  });
+}
+function createOperatorExplanation(enabled, support) {
+  return Object.freeze({ enabled, support });
+}
+
+// ../sql/src/sql-predicate-types.ts
+function isSQLPredicateParameter(value) {
+  return isColumnarPredicateParameter(value);
+}
+
+// ../sql/src/sql-predicate-schema.ts
+var MAXIMUM_PREDICATE_DEPTH = 64;
+var MAXIMUM_PREDICATE_NODES = 4096;
+function validateSQLPredicate(value) {
+  const state = { nodes: 0 };
+  validatePredicateNode(value, "$", 0, state);
+}
+function validatePredicateNode(value, path, depth, state) {
+  if (depth > MAXIMUM_PREDICATE_DEPTH) {
+    throw new Error(`SQL predicate ${path} exceeds the maximum nesting depth`);
+  }
+  state.nodes++;
+  if (state.nodes > MAXIMUM_PREDICATE_NODES) {
+    throw new Error("SQL predicate exceeds the maximum node count");
+  }
+  if (!isRecord(value) || !hasExactKeys(value, ["op", "args"])) {
+    throw new Error(`SQL predicate ${path} must contain only op and args`);
+  }
+  if (typeof value.op !== "string" || !Array.isArray(value.args)) {
+    throw new Error(`SQL predicate ${path} requires string op and array args`);
+  }
+  switch (value.op) {
+    case "and":
+    case "or":
+      if (value.args.length < 2) {
+        throw new Error(`SQL predicate ${path}.${value.op} requires at least two arguments`);
+      }
+      for (let index = 0; index < value.args.length; index++) {
+        validatePredicateNode(value.args[index], `${path}.args[${index}]`, depth + 1, state);
+      }
+      return;
+    case "not":
+      if (value.args.length !== 1) {
+        throw new Error(`SQL predicate ${path}.not requires exactly one argument`);
+      }
+      validatePredicateNode(value.args[0], `${path}.args[0]`, depth + 1, state);
+      return;
+    case "isNull":
+      if (value.args.length !== 1) {
+        throw new Error(`SQL predicate ${path}.isNull requires exactly one argument`);
+      }
+      validatePredicateProperty(value.args[0], `${path}.args[0]`);
+      return;
+    case "in":
+      if (value.args.length !== 2 || !Array.isArray(value.args[1]) || value.args[1].length === 0) {
+        throw new Error(`SQL predicate ${path}.in requires a property and non-empty value list`);
+      }
+      validatePredicateProperty(value.args[0], `${path}.args[0]`);
+      value.args[1].forEach(
+        (item, index) => validatePredicateValue(item, `${path}.args[1][${index}]`)
+      );
+      return;
+    case "=":
+    case "<>":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      if (value.args.length !== 2) {
+        throw new Error(`SQL predicate ${path}.${value.op} requires exactly two arguments`);
+      }
+      validatePredicateProperty(value.args[0], `${path}.args[0]`);
+      validatePredicateValue(value.args[1], `${path}.args[1]`);
+      return;
+    default:
+      throw new Error(`SQL predicate ${path} has unsupported operator ${JSON.stringify(value.op)}`);
+  }
+}
+function validatePredicateProperty(value, path) {
+  if (!isRecord(value) || !hasAllowedKeys(value, ["property", "quoted"]) || typeof value.property !== "string" || value.property.length === 0 || value.quoted !== void 0 && typeof value.quoted !== "boolean") {
+    throw new Error(`SQL predicate ${path} requires a non-empty property reference`);
+  }
+}
+function validatePredicateValue(value, path) {
+  if (isSQLPredicateParameter(value)) {
+    return;
+  }
+  if (typeof value === "boolean" || typeof value === "bigint" || typeof value === "string" || value instanceof Uint8Array) {
+    return;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return;
+  }
+  if (value instanceof Date && Number.isFinite(value.getTime())) {
+    return;
+  }
+  throw new Error(`SQL predicate ${path} contains an unsupported scalar value`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, expectedKeys) {
+  const keys = Object.keys(value);
+  return keys.length === expectedKeys.length && expectedKeys.every((key) => keys.includes(key));
+}
+function hasAllowedKeys(value, allowedKeys) {
+  return Object.keys(value).every((key) => allowedKeys.includes(key));
+}
+
+// ../sql/src/sql-utils.ts
+var arrow5 = __toESM(require("apache-arrow"), 1);
+
+// ../schema-utils/src/lib/schema/data-type.ts
+function getDataTypeFromValue(value, defaultNumberType = "float32") {
+  if (value instanceof Date) {
+    return "date-millisecond";
+  }
+  if (typeof value === "number") {
+    return defaultNumberType;
+  }
+  if (typeof value === "boolean") {
+    return "bool";
+  }
+  if (typeof value === "string") {
+    return "utf8";
+  }
+  if (value === null || value === "undefined") {
+    return "null";
+  }
+  return "null";
+}
+function getDataTypeFromArray(array) {
+  let type = getDataTypeFromTypedArray(array);
+  if (type !== "null") {
+    return { type, nullable: false };
+  }
+  if (array.length > 0) {
+    type = getDataTypeFromValue(array[0]);
+    return { type, nullable: true };
+  }
+  return { type: "null", nullable: true };
+}
+function getDataTypeFromTypedArray(array) {
+  switch (array.constructor) {
+    case Int8Array:
+      return "int8";
+    case Uint8Array:
+    case Uint8ClampedArray:
+      return "uint8";
+    case Int16Array:
+      return "int16";
+    case Uint16Array:
+      return "uint16";
+    case Int32Array:
+      return "int32";
+    case Uint32Array:
+      return "uint32";
+    case Float32Array:
+      return "float32";
+    case Float64Array:
+      return "float64";
+    default:
+      return "null";
+  }
+}
+function getArrayTypeFromDataType(type, nullable) {
+  if (!nullable) {
+    switch (type) {
+      case "int8":
+        return Int8Array;
+      case "uint8":
+        return Uint8Array;
+      case "int16":
+        return Int16Array;
+      case "uint16":
+        return Uint16Array;
+      case "int32":
+        return Int32Array;
+      case "uint32":
+        return Uint32Array;
+      case "float32":
+        return Float32Array;
+      case "float64":
+        return Float64Array;
+      default:
+        break;
+    }
+  }
+  return Array;
+}
+
+// ../schema-utils/src/lib/schema/convert-arrow-schema.ts
+var arrow = __toESM(require("apache-arrow"), 1);
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function convertSchemaToArrow(schema, options) {
+  return deserializeArrowSchema(schema, options);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function deserializeArrowSchema(schema, options) {
+  return new arrow.Schema(
+    schema.fields.map((field) => deserializeArrowField(field, options)),
+    deserializeArrowMetadata(schema.metadata)
+  );
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function deserializeArrowField(field, options) {
+  return new arrow.Field(
+    field.name,
+    deserializeArrowType(field.type, options),
+    field.nullable,
+    deserializeArrowMetadata(field.metadata)
+  );
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  switch (arrowType.constructor) {
+    case arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function deserializeArrowType(dataType, options) {
+  if (typeof dataType === "object") {
+    switch (dataType.type) {
+      case "decimal":
+        return new arrow.Decimal(dataType.scale, dataType.precision, dataType.bitWidth);
+      case "map": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return new arrow.Map_(children[0], dataType.keysSorted);
+      }
+      case "list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        return new arrow.List(field);
+      }
+      case "fixed-size-list": {
+        const child = deserializeArrowField(dataType.children[0], options);
+        return new arrow.FixedSizeList(dataType.listSize, child);
+      }
+      case "fixed-size-binary":
+        return new arrow.FixedSizeBinary(dataType.byteWidth);
+      case "struct": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return new arrow.Struct(children);
+      }
+      case "dictionary": {
+        return new arrow.Dictionary(
+          deserializeArrowType(dataType.dictionary, options),
+          deserializeArrowDictionaryKeyType(dataType.indices),
+          dataType.id,
+          dataType.isOrdered
+        );
+      }
+      default:
+        throw new Error("array type not supported");
+    }
+  }
+  switch (dataType) {
+    case "null":
+      return new arrow.Null();
+    case "binary":
+      return makeVariableWidthArrowType("BinaryView", new arrow.Binary(), options);
+    case "binary-view":
+      return makeRequiredArrowViewType("BinaryView");
+    case "bool":
+      return new arrow.Bool();
+    case "int8":
+      return new arrow.Int8();
+    case "int16":
+      return new arrow.Int16();
+    case "int32":
+      return new arrow.Int32();
+    case "int64":
+      return new arrow.Int64();
+    case "uint8":
+      return new arrow.Uint8();
+    case "uint16":
+      return new arrow.Uint16();
+    case "uint32":
+      return new arrow.Uint32();
+    case "uint64":
+      return new arrow.Uint64();
+    case "float16":
+      return new arrow.Float16();
+    case "float32":
+      return new arrow.Float32();
+    case "float64":
+      return new arrow.Float64();
+    case "utf8":
+      return makeVariableWidthArrowType("Utf8View", new arrow.Utf8(), options);
+    case "utf8-view":
+      return makeRequiredArrowViewType("Utf8View");
+    case "date-day":
+      return new arrow.DateDay();
+    case "date-millisecond":
+      return new arrow.DateMillisecond();
+    case "time-second":
+      return new arrow.TimeSecond();
+    case "time-millisecond":
+      return new arrow.TimeMillisecond();
+    case "time-microsecond":
+      return new arrow.TimeMicrosecond();
+    case "time-nanosecond":
+      return new arrow.TimeNanosecond();
+    case "timestamp-second":
+      return new arrow.TimestampSecond();
+    case "timestamp-millisecond":
+      return new arrow.TimestampMillisecond();
+    case "timestamp-microsecond":
+      return new arrow.TimestampMicrosecond();
+    case "timestamp-nanosecond":
+      return new arrow.TimestampNanosecond();
+    case "interval-daytime":
+      return new arrow.IntervalDayTime();
+    case "interval-yearmonth":
+      return new arrow.IntervalYearMonth();
+    default:
+      throw new Error("array type not supported");
+  }
+}
+function getArrowViewConstructors() {
+  return arrow;
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getArrowViewConstructors()[viewTypeName];
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard == null ? void 0 : guard(arrowType));
+}
+function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
+  const viewTypeMode = (options == null ? void 0 : options.viewTypes) || "never";
+  if (viewTypeMode === "never") {
+    return fallbackType;
+  }
+  const constructor = getArrowViewConstructors()[viewTypeName];
+  if (constructor) {
+    return new constructor();
+  }
+  if (viewTypeMode === "require") {
+    throw new Error(
+      `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+    );
+  }
+  return fallbackType;
+}
+function makeRequiredArrowViewType(viewTypeName) {
+  const constructor = getArrowViewConstructors()[viewTypeName];
+  if (!constructor) {
+    throw new Error(
+      `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+    );
+  }
+  return new constructor();
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+function deserializeArrowDictionaryKeyType(keyType) {
+  switch (keyType) {
+    case "int8":
+      return new arrow.Int8();
+    case "int16":
+      return new arrow.Int16();
+    case "int32":
+      return new arrow.Int32();
+    case "uint8":
+      return new arrow.Uint8();
+    case "uint16":
+      return new arrow.Uint16();
+    case "uint32":
+      return new arrow.Uint32();
+    default:
+      throw new Error(`schema dictionary index type not supported: ${keyType}`);
+  }
+}
+
+// ../schema-utils/src/lib/schema/deduce-table-schema.ts
+function deduceTableSchema(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return deduceSchemaFromRows(table.data);
+    case "geojson-table":
+      return deduceSchemaFromGeoJSON(table.features);
+    case "columnar-table":
+      return deduceSchemaFromColumns(table.data);
+    case "arrow-table":
+    default:
+      throw new Error("Deduce schema");
+  }
+}
+function deduceSchemaFromColumns(columnarTable) {
+  const fields = [];
+  for (const [columnName, column] of Object.entries(columnarTable)) {
+    const field = deduceFieldFromColumn(column, columnName);
+    fields.push(field);
+  }
+  return { fields, metadata: {} };
+}
+function deduceSchemaFromRows(rowTable) {
+  if (!rowTable.length) {
+    throw new Error("deduce from empty table");
+  }
+  const fields = [];
+  const row0 = rowTable[0];
+  for (const [columnName, value] of Object.entries(row0)) {
+    fields.push(deduceFieldFromValue(value, columnName));
+  }
+  return { fields, metadata: {} };
+}
+function deduceSchemaFromGeoJSON(features) {
+  if (!features.length) {
+    throw new Error("deduce from empty table");
+  }
+  const fields = [];
+  const row0 = features[0].properties || {};
+  for (const [columnName, value] of Object.entries(row0)) {
+    fields.push(deduceFieldFromValue(value, columnName));
+  }
+  return { fields, metadata: {} };
+}
+function deduceFieldFromColumn(column, name) {
+  if (ArrayBuffer.isView(column)) {
+    const type = getDataTypeFromArray(column);
+    return {
+      name,
+      type: type.type || "null",
+      nullable: type.nullable
+      // metadata: {}
+    };
+  }
+  if (Array.isArray(column) && column.length > 0) {
+    const value = column[0];
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+      // metadata: {},
+    };
+  }
+  throw new Error("empty table");
+}
+function deduceFieldFromValue(value, name) {
+  const type = getDataTypeFromValue(value);
+  return {
+    name,
+    type,
+    nullable: true
+    // metadata: {}
+  };
+}
+
+// ../schema-utils/src/lib/table/tables/make-table.ts
+var arrow2 = __toESM(require("apache-arrow"), 1);
+function makeTableFromData(data) {
+  let table;
+  switch (getTableShapeFromData(data)) {
+    case "array-row-table":
+      table = { shape: "array-row-table", data };
+      break;
+    case "object-row-table":
+      table = { shape: "object-row-table", data };
+      break;
+    case "columnar-table":
+      table = { shape: "columnar-table", data };
+      break;
+    case "arrow-table":
+      table = { shape: "arrow-table", data };
+      break;
+    default:
+      throw new Error("table");
+  }
+  const schema = deduceTableSchema(table);
+  return { ...table, schema };
+}
+function getTableShapeFromData(data) {
+  if (data instanceof arrow2.Table) {
+    return "arrow-table";
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      throw new Error("cannot deduce type of empty table");
+    }
+    const firstRow = data[0];
+    if (Array.isArray(firstRow)) {
+      return "array-row-table";
+    }
+    if (firstRow && typeof firstRow === "object") {
+      return "object-row-table";
+    }
+  }
+  if (data && typeof data === "object") {
+    return "columnar-table";
+  }
+  throw new Error("invalid table");
+}
+
+// ../schema-utils/src/lib/table/tables/table-accessors.ts
+function getTableLength(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return table.data.length;
+    case "geojson-table":
+      return table.features.length;
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.numRows;
+    case "columnar-table":
+      for (const column of Object.values(table.data)) {
+        return column.length || 0;
+      }
+      return 0;
+    default:
+      throw new Error("table");
+  }
+}
+function getTableNumCols(table) {
+  if (table.schema) {
+    return table.schema.fields.length;
+  }
+  if (getTableLength(table) === 0) {
+    throw new Error("empty table");
+  }
+  switch (table.shape) {
+    case "array-row-table":
+      return table.data[0].length;
+    case "object-row-table":
+      return Object.keys(table.data[0]).length;
+    case "geojson-table":
+      return Object.keys(table.features[0]).length;
+    case "columnar-table":
+      return Object.keys(table.data).length;
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.numCols;
+    default:
+      throw new Error("table");
+  }
+}
+function getTableCell(table, rowIndex, columnName) {
+  var _a;
+  switch (table.shape) {
+    case "array-row-table":
+      const columnIndex = getTableColumnIndex(table, columnName);
+      return table.data[rowIndex][columnIndex];
+    case "object-row-table":
+      return table.data[rowIndex][columnName];
+    case "geojson-table":
+      return table.features[rowIndex][columnName];
+    case "columnar-table":
+      const column = table.data[columnName];
+      return column[rowIndex];
+    case "arrow-table":
+      const arrowTable = table.data;
+      const arrowColumnIndex = arrowTable.schema.fields.findIndex(
+        (field) => field.name === columnName
+      );
+      return (_a = arrowTable.getChildAt(arrowColumnIndex)) == null ? void 0 : _a.get(rowIndex);
+    default:
+      throw new Error("todo");
+  }
+}
+function getTableCellAt(table, rowIndex, columnIndex) {
+  var _a;
+  switch (table.shape) {
+    case "array-row-table":
+      return table.data[rowIndex][columnIndex];
+    case "object-row-table":
+      const columnName1 = getTableColumnName(table, columnIndex);
+      return table.data[rowIndex][columnName1];
+    case "geojson-table":
+      const columnName2 = getTableColumnName(table, columnIndex);
+      return table.features[rowIndex][columnName2];
+    case "columnar-table":
+      const columnName3 = getTableColumnName(table, columnIndex);
+      const column = table.data[columnName3];
+      return column[rowIndex];
+    case "arrow-table":
+      const arrowTable = table.data;
+      return (_a = arrowTable.getChildAt(columnIndex)) == null ? void 0 : _a.get(rowIndex);
+    default:
+      throw new Error("todo");
+  }
+}
+function getTableColumnIndex(table, columnName) {
+  var _a;
+  const columnIndex = (_a = table.schema) == null ? void 0 : _a.fields.findIndex((field) => field.name === columnName);
+  if (columnIndex === void 0) {
+    throw new Error(columnName);
+  }
+  return columnIndex;
+}
+function getTableColumnName(table, columnIndex) {
+  var _a, _b;
+  const columnName = (_b = (_a = table.schema) == null ? void 0 : _a.fields[columnIndex]) == null ? void 0 : _b.name;
+  if (!columnName) {
+    throw new Error(`${columnIndex}`);
+  }
+  return columnName;
+}
+function getTableRowAsObject(table, rowIndex, target, copy) {
+  switch (table.shape) {
+    case "object-row-table":
+      return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
+    case "array-row-table":
+      if (table.schema) {
+        const objectRow2 = target || {};
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          objectRow2[table.schema.fields[i].name] = table.data[rowIndex][i];
+        }
+        return objectRow2;
+      }
+      throw new Error("no schema");
+    case "geojson-table":
+      if (table.schema) {
+        const objectRow2 = target || {};
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          objectRow2[table.schema.fields[i].name] = table.features[rowIndex][table.schema.fields[i].name];
+        }
+        return objectRow2;
+      }
+      throw new Error("no schema");
+    case "columnar-table":
+      if (table.schema) {
+        const objectRow2 = target || {};
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          objectRow2[table.schema.fields[i].name] = table.data[table.schema.fields[i].name][rowIndex];
+        }
+        return objectRow2;
+      } else {
+        const objectRow2 = target || {};
+        for (const [name, column] of Object.entries(table.data)) {
+          objectRow2[name] = column[rowIndex];
+        }
+        return objectRow2;
+      }
+    case "arrow-table":
+      const arrowTable = table.data;
+      const objectRow = target || {};
+      const row = arrowTable.get(rowIndex);
+      const schema = arrowTable.schema;
+      for (let i = 0; i < schema.fields.length; i++) {
+        objectRow[schema.fields[i].name] = row == null ? void 0 : row[schema.fields[i].name];
+      }
+      return objectRow;
+    default:
+      throw new Error("shape");
+  }
+}
+function getTableRowAsArray(table, rowIndex, target, copy) {
+  switch (table.shape) {
+    case "array-row-table":
+      return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+    case "object-row-table":
+      if (table.schema) {
+        const arrayRow2 = target || [];
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          arrayRow2[i] = table.data[rowIndex][table.schema.fields[i].name];
+        }
+        return arrayRow2;
+      }
+      return Object.values(table.data[rowIndex]);
+    case "geojson-table":
+      if (table.schema) {
+        const arrayRow2 = target || [];
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          arrayRow2[i] = table.features[rowIndex][table.schema.fields[i].name];
+        }
+        return arrayRow2;
+      }
+      return Object.values(table.features[rowIndex]);
+    case "columnar-table":
+      if (table.schema) {
+        const arrayRow2 = target || [];
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          arrayRow2[i] = table.data[table.schema.fields[i].name][rowIndex];
+        }
+        return arrayRow2;
+      } else {
+        const arrayRow2 = target || [];
+        let i = 0;
+        for (const column of Object.values(table.data)) {
+          arrayRow2[i] = column[rowIndex];
+          i++;
+        }
+        return arrayRow2;
+      }
+    case "arrow-table":
+      const arrowTable = table.data;
+      const arrayRow = target || [];
+      const row = arrowTable.get(rowIndex);
+      const schema = arrowTable.schema;
+      for (let i = 0; i < schema.fields.length; i++) {
+        arrayRow[i] = row == null ? void 0 : row[schema.fields[i].name];
+      }
+      return arrayRow;
+    default:
+      throw new Error("shape");
+  }
+}
+
+// ../schema-utils/src/lib/table/tables/table-column.ts
+function makeColumnFromField(field, length) {
+  const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
+  return new ArrayType(length);
+}
+
+// ../schema-utils/src/lib/table/tables/convert-arrow-table.ts
+var arrow4 = __toESM(require("apache-arrow"), 1);
+
+// ../schema-utils/src/lib/table/batches/make-arrow-batch-iterator.ts
+var arrow3 = __toESM(require("apache-arrow"), 1);
+function* makeArrowRecordBatchIterator(table, options) {
+  const arrowSchema = convertSchemaToArrow(table.schema);
+  const length = getTableLength(table);
+  const numColumns = getTableNumCols(table);
+  const batchSize = (options == null ? void 0 : options.batchSize) || length;
+  const builders = arrowSchema == null ? void 0 : arrowSchema.fields.map(
+    (arrowField) => arrow3.makeBuilder({
+      type: arrowField.type,
+      nullValues: [null, void 0]
+    })
+  );
+  const structField = new arrow3.Struct(arrowSchema.fields);
+  let batchLength = 0;
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    for (let columnIndex = 0; columnIndex < numColumns; ++columnIndex) {
+      const value = getTableCellAt(table, rowIndex, columnIndex);
+      const builder = builders[columnIndex];
+      builder.append(value);
+    }
+    batchLength++;
+    if (batchLength >= batchSize) {
+      const datas = builders.map((builder) => builder.flush());
+      const structData = new arrow3.Data(structField, 0, batchLength, 0, void 0, datas);
+      yield new arrow3.RecordBatch(arrowSchema, structData);
+      batchLength = 0;
+    }
+  }
+  if (batchLength > 0) {
+    const datas = builders.map((builder) => builder.flush());
+    const structData = new arrow3.Data(structField, 0, batchLength, 0, void 0, datas);
+    yield new arrow3.RecordBatch(arrowSchema, structData);
+    batchLength = 0;
+  }
+  builders.map((builder) => builder.finish());
+}
+
+// ../schema-utils/src/lib/table/tables/convert-arrow-table.ts
+function convertTableToArrow(table, options) {
+  switch (table.shape) {
+    case "arrow-table":
+      return table.data;
+    case "columnar-table":
+    // TODO - optimized implementation is possible
+    // return convertColumnarTableToArrow(table, options);
+    // fall through
+    default:
+      const arrowBatchIterator = makeArrowRecordBatchIterator(table, options);
+      return new arrow4.Table(arrowBatchIterator);
+  }
+}
+
+// ../schema-utils/src/lib/table/tables/convert-table.ts
+function convertTable(table, shape) {
+  switch (shape) {
+    case "object-row-table":
+      return convertToObjectRowTable(table);
+    case "array-row-table":
+      return convertToArrayRowTable(table);
+    case "columnar-table":
+      return convertToColumnarTable(table);
+    case "arrow-table":
+      return convertToArrowTable(table);
+    default:
+      throw new Error(shape);
+  }
+}
+function convertToColumnarTable(table) {
+  const schema = table.schema || deduceTableSchema(table);
+  const fields = schema.fields;
+  if (table.shape === "columnar-table") {
+    return { ...table, schema };
+  }
+  const length = getTableLength(table);
+  const columns = {};
+  for (const field of fields) {
+    const column = makeColumnFromField(field, length);
+    columns[field.name] = column;
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      column[rowIndex] = getTableCell(table, rowIndex, field.name);
+    }
+  }
+  return {
+    shape: "columnar-table",
+    schema,
+    data: columns
+  };
+}
+function convertToArrayRowTable(table) {
+  if (table.shape === "array-row-table") {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsArray(table, rowIndex);
+  }
+  return {
+    shape: "array-row-table",
+    schema: table.schema,
+    data
+  };
+}
+function convertToObjectRowTable(table) {
+  if (table.shape === "object-row-table") {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsObject(table, rowIndex);
+  }
+  return {
+    shape: "object-row-table",
+    schema: table.schema,
+    data
+  };
+}
+function convertToArrowTable(table) {
+  const schema = table.schema || deduceTableSchema(table);
+  const arrowTable = convertTableToArrow({ ...table, schema });
+  return {
+    shape: "arrow-table",
+    schema,
+    data: arrowTable
+  };
+}
+
+// ../schema-utils/src/lib/table/batches/convert-batches.ts
+function convertBatch(batch, shape) {
+  switch (shape) {
+    case "object-row-table":
+      return { ...batch, ...convertTable(batch, "object-row-table") };
+    case "array-row-table":
+      return { ...batch, ...convertTable(batch, "array-row-table") };
+    case "columnar-table":
+      return { ...batch, ...convertTable(batch, "columnar-table") };
+    case "arrow-table":
+      return { ...batch, ...convertTable(batch, "arrow-table") };
+    default:
+      throw new Error(shape);
+  }
+}
+
+// ../sql/src/sql-utils.ts
+function convertRowsToArrowTable(rows) {
+  const table = rows.length > 0 ? makeTableFromData(rows) : { shape: "object-row-table", schema: { fields: [], metadata: {} }, data: rows };
+  const schema = deducePrimitiveAwareSchema(table);
+  if (table.data.length === 0 || schema.fields.length === 0) {
+    return {
+      shape: "arrow-table",
+      schema,
+      data: new arrow5.Table(new arrow5.Schema([]))
+    };
+  }
+  return {
+    shape: "arrow-table",
+    schema,
+    data: arrow5.tableFromJSON(table.data)
+  };
+}
+function deducePrimitiveAwareSchema(table) {
+  return {
+    ...table.schema,
+    fields: table.schema.fields.map((field) => {
+      if (field.type !== "null") {
+        return field;
+      }
+      const columnValues = table.data.map((row) => row[field.name]);
+      const inferredType = getDataTypeFromArray(columnValues);
+      return { ...field, type: inferredType.type, nullable: inferredType.nullable };
+    })
+  };
+}
+
+// ../sql/src/table-query-capabilities.ts
+var ARROW_TABLE_QUERY_CAPABILITIES = Object.freeze({
+  projection: "residual",
+  predicate: "residual",
+  limit: "residual",
+  streaming: false,
+  cancellation: true,
+  expressions: "residual",
+  orderBy: "residual",
+  aggregates: "residual"
+});
+var SQL_DATA_SOURCE_TABLE_QUERY_CAPABILITIES = Object.freeze({
+  projection: "pushdown",
+  predicate: "pushdown",
+  limit: "pushdown",
+  streaming: false,
+  cancellation: false,
+  expressions: "pushdown",
+  orderBy: "pushdown",
+  aggregates: "pushdown"
+});
+
+// ../sql/src/query-arrow-table.ts
+var arrow6 = __toESM(require("apache-arrow"), 1);
+
+// ../sql/src/table-query.ts
+function planTableQuery2(sourceColumnNames, options = {}) {
+  if (options.predicate) {
+    validateSQLPredicate(options.predicate);
+  }
+  return planTableQuery(sourceColumnNames, options);
+}
+function getSQLPredicateColumnNames(predicate) {
+  return getColumnarPredicateColumns(predicate);
+}
+
+// ../sql/src/query-arrow-table.ts
+function explainArrowTableQuery(sourceTable, options = {}) {
+  if (options.predicate) {
+    validateSQLPredicate(options.predicate);
+  }
+  return explainTableQuery(
+    sourceTable.data.schema.fields.map((field) => field.name),
+    options,
+    ARROW_TABLE_QUERY_CAPABILITIES
+  );
+}
+function queryArrowTable(sourceTable, options = {}) {
+  var _a, _b;
+  throwIfAborted(options.signal);
+  if (options.join) {
+    validateArrowJoinQuery(sourceTable, options);
+  }
+  if (options.join && hasRelationalOperatorsExceptJoin(options)) {
+    throw new Error("Arrow joins cannot yet be combined with other relational operators.");
+  }
+  if (options.join && !hasRelationalOperatorsExceptJoin(options)) {
+    return queryArrowJoin(sourceTable, options);
+  }
+  if (hasRelationalOperators(options)) {
+    return queryArrowTableRelational(sourceTable, options);
+  }
+  const sourceData = sourceTable.data;
+  const plan = planTableQuery2(
+    sourceData.schema.fields.map((field) => field.name),
+    options
+  );
+  const scannedData = sourceData.select([...getScanStep(plan).columns]);
+  const projectedData = scannedData.select([...getProjectStep(plan).columns]);
+  const predicate = (_a = getFilterStep(plan)) == null ? void 0 : _a.predicate;
+  const limit = ((_b = getLimitStep(plan)) == null ? void 0 : _b.limit) ?? Number.POSITIVE_INFINITY;
+  if (!predicate) {
+    return wrapArrowTable(projectedData.slice(0, limit));
+  }
+  const predicateColumns = getPredicateColumns(scannedData, getSQLPredicateColumnNames(predicate));
+  const matchingRowIndices = [];
+  for (let rowIndex = 0; rowIndex < scannedData.numRows && matchingRowIndices.length < limit; rowIndex++) {
+    throwIfAborted(options.signal);
+    if (evaluatePredicate(predicate, predicateColumns, rowIndex) === true) {
+      matchingRowIndices.push(rowIndex);
+    }
+  }
+  if (matchingRowIndices.length === 0) {
+    return wrapArrowTable(projectedData.slice(0, 0));
+  }
+  const outputColumns = {};
+  for (const field of projectedData.schema.fields) {
+    const sourceColumn = projectedData.getChild(field.name);
+    if (!sourceColumn) {
+      throw new Error(`Arrow query could not read column "${field.name}".`);
+    }
+    const values = matchingRowIndices.map((rowIndex) => sourceColumn.get(rowIndex));
+    outputColumns[field.name] = arrow6.vectorFromArray(values, sourceColumn.type);
+  }
+  return wrapArrowTable(new arrow6.Table(projectedData.schema, outputColumns));
+}
+function queryArrowTableRelational(sourceTable, options) {
+  var _a, _b, _c, _d, _e, _f;
+  const sourceData = sourceTable.data;
+  const sourceColumnNames = sourceData.schema.fields.map((field) => field.name);
+  const relationalPlan = planRelationalQuery(sourceColumnNames, options);
+  const scanStep = relationalPlan.tablePlan.find((step) => step.kind === "scan");
+  if (!scanStep || scanStep.kind !== "scan") {
+    throw new Error("Arrow relational query plan is missing a scan step.");
+  }
+  const scannedTable = wrapArrowTable(sourceData.select([...scanStep.columns]));
+  const filteredTable = queryArrowTable(scannedTable, {
+    predicate: options.predicate,
+    columns: scanStep.columns,
+    signal: options.signal
+  });
+  let rows = arrowTableToRows(filteredTable.data);
+  for (const child of options.union || []) {
+    const childTable = (_a = options.tables) == null ? void 0 : _a[child.source];
+    if (!childTable) throw new Error(`Arrow union source not found: ${child.source}`);
+    const childResult = queryArrowTable(childTable, {
+      ...child.query || {},
+      columns: getUnionChildColumns(sourceColumnNames, options),
+      signal: options.signal
+    });
+    rows = rows.concat(arrowTableToRows(childResult.data));
+  }
+  for (const expression of options.expressions || []) {
+    for (const row of rows) {
+      row[expression.name] = evaluateRelationalExpression(expression, row);
+    }
+  }
+  if (((_b = options.groupBy) == null ? void 0 : _b.length) || ((_c = options.aggregates) == null ? void 0 : _c.length)) {
+    rows = aggregateRows(rows, options.groupBy || [], options.aggregates || []);
+  }
+  if ((_d = options.orderBy) == null ? void 0 : _d.length) {
+    const orderBy = options.orderBy;
+    rows = rows.map((row, index) => ({ row, index })).sort((left, right) => compareRows(left.row, right.row, orderBy) || left.index - right.index).map((entry) => entry.row);
+  }
+  const outputColumns = options.columns || (((_e = options.groupBy) == null ? void 0 : _e.length) || ((_f = options.aggregates) == null ? void 0 : _f.length) ? [...options.groupBy || [], ...(options.aggregates || []).map((aggregate) => aggregate.name)] : sourceColumnNames);
+  const outputRows = rows.map((row) => {
+    const output = {};
+    for (const columnName of outputColumns) {
+      if (!(columnName in row)) {
+        throw new Error(`Arrow relational query column not found: ${columnName}`);
+      }
+      output[columnName] = row[columnName];
+    }
+    return output;
+  });
+  const limit = options.limit === void 0 ? outputRows.length : options.limit;
+  const limitedRows = outputRows.slice(0, limit);
+  return limitedRows.length ? convertRowsToArrowTable(limitedRows) : createEmptyRelationalResult(sourceData, outputColumns, options);
+}
+function getUnionChildColumns(sourceColumnNames, options) {
+  var _a, _b;
+  const expressionNames = new Set((options.expressions || []).map((expression) => expression.name));
+  const aggregateNames = new Set((options.aggregates || []).map((aggregate) => aggregate.name));
+  const outputColumns = options.columns || (((_a = options.groupBy) == null ? void 0 : _a.length) || ((_b = options.aggregates) == null ? void 0 : _b.length) ? [...options.groupBy || [], ...(options.aggregates || []).map((aggregate) => aggregate.name)] : sourceColumnNames);
+  const requiredColumns = new Set(
+    outputColumns.filter((column) => !expressionNames.has(column) && !aggregateNames.has(column))
+  );
+  for (const expression of options.expressions || []) {
+    const definition = expression.expression;
+    if (definition.op === "column") requiredColumns.add(definition.column);
+    if ("left" in definition) {
+      requiredColumns.add(definition.left);
+      requiredColumns.add(definition.right);
+    }
+  }
+  for (const key of options.orderBy || []) {
+    if (!expressionNames.has(key.column) && !aggregateNames.has(key.column)) {
+      requiredColumns.add(key.column);
+    }
+  }
+  for (const column of options.groupBy || []) requiredColumns.add(column);
+  for (const aggregate of options.aggregates || []) {
+    if (aggregate.column) requiredColumns.add(aggregate.column);
+  }
+  return sourceColumnNames.filter((column) => requiredColumns.has(column));
+}
+function hasRelationalOperators(options) {
+  var _a, _b, _c, _d, _e;
+  return Boolean(
+    ((_a = options.expressions) == null ? void 0 : _a.length) || ((_b = options.orderBy) == null ? void 0 : _b.length) || ((_c = options.groupBy) == null ? void 0 : _c.length) || ((_d = options.aggregates) == null ? void 0 : _d.length) || ((_e = options.union) == null ? void 0 : _e.length) || options.join
+  );
+}
+function hasRelationalOperatorsExceptJoin(options) {
+  var _a, _b, _c, _d, _e;
+  return Boolean(
+    ((_a = options.expressions) == null ? void 0 : _a.length) || ((_b = options.orderBy) == null ? void 0 : _b.length) || ((_c = options.groupBy) == null ? void 0 : _c.length) || ((_d = options.aggregates) == null ? void 0 : _d.length) || ((_e = options.union) == null ? void 0 : _e.length)
+  );
+}
+function queryArrowJoin(sourceTable, options) {
+  var _a;
+  const join = options.join;
+  if (!join) throw new Error("Arrow join query is missing a join definition.");
+  const childTable = (_a = options.tables) == null ? void 0 : _a[join.child.source];
+  if (!childTable) throw new Error(`Arrow join source not found: ${join.child.source}`);
+  const leftResult = queryArrowTable(sourceTable, {
+    predicate: options.predicate,
+    columns: void 0,
+    signal: options.signal
+  });
+  const rightResult = queryArrowTable(childTable, {
+    ...join.child.query || {},
+    signal: options.signal
+  });
+  const leftRows = arrowTableToRows(leftResult.data);
+  const rightRows = arrowTableToRows(rightResult.data);
+  const rightPrefix = `${join.child.source}.`;
+  const defaultOutputColumns = [
+    ...sourceTable.data.schema.fields.map((field) => field.name),
+    ...rightResult.data.schema.fields.map((field) => `${rightPrefix}${field.name}`)
+  ];
+  const rows = [];
+  for (const leftRow of leftRows) {
+    for (const rightRow of rightRows) {
+      if (leftRow[join.left] !== null && leftRow[join.left] !== void 0 && rightRow[join.right] !== null && rightRow[join.right] !== void 0 && compareSortValues(leftRow[join.left], rightRow[join.right]) === 0) {
+        rows.push({
+          ...leftRow,
+          ...Object.fromEntries(
+            Object.entries(rightRow).map(([key, value]) => [`${rightPrefix}${key}`, value])
+          )
+        });
+      }
+    }
+  }
+  const outputColumns = options.columns || defaultOutputColumns;
+  const outputRows = rows.map(
+    (row) => Object.fromEntries(outputColumns.map((column) => [column, row[column]]))
+  );
+  const limitedRows = outputRows.slice(0, options.limit);
+  return limitedRows.length ? convertRowsToArrowTable(limitedRows) : createEmptyRelationalResult(
+    sourceTable.data,
+    outputColumns,
+    options,
+    new Map(
+      rightResult.data.schema.fields.map((field) => [
+        `${rightPrefix}${field.name}`,
+        new arrow6.Field(
+          `${rightPrefix}${field.name}`,
+          field.type,
+          field.nullable,
+          field.metadata
+        )
+      ])
+    )
+  );
+}
+function validateArrowJoinQuery(sourceTable, options) {
+  var _a, _b, _c;
+  const join = options.join;
+  if (!join) return;
+  const sourceColumnNames = sourceTable.data.schema.fields.map((field) => field.name);
+  const childTable = (_a = options.tables) == null ? void 0 : _a[join.child.source];
+  if (!childTable) throw new Error(`Arrow join source not found: ${join.child.source}`);
+  const childColumnNames = childTable.data.schema.fields.map((field) => field.name);
+  if (!sourceColumnNames.includes(join.left)) {
+    throw new Error(`Arrow join column not found: ${join.left}`);
+  }
+  if (!childColumnNames.includes(join.right)) {
+    throw new Error(`Arrow join column not found: ${join.right}`);
+  }
+  const childPrefix = `${join.child.source}.`;
+  const rootColumns = (_b = options.columns) == null ? void 0 : _b.filter((column) => !column.startsWith(childPrefix));
+  planTableQuery2(sourceColumnNames, {
+    predicate: options.predicate,
+    columns: (rootColumns == null ? void 0 : rootColumns.length) ? rootColumns : void 0,
+    limit: options.limit,
+    signal: options.signal
+  });
+  const childQuery = join.child.query || {};
+  planTableQuery2(childColumnNames, childQuery);
+  const childOutputColumns = childQuery.columns || childColumnNames;
+  if (!childOutputColumns.includes(join.right)) {
+    throw new Error(`Arrow join child projection must include: ${join.right}`);
+  }
+  const projectedChildColumns = ((_c = options.columns) == null ? void 0 : _c.filter((column) => column.startsWith(childPrefix))) || [];
+  const seenChildColumns = /* @__PURE__ */ new Set();
+  for (const projectedColumn of projectedChildColumns) {
+    const childColumn = projectedColumn.slice(childPrefix.length);
+    if (!childColumnNames.includes(childColumn)) {
+      throw new Error(`Arrow join column not found: ${projectedColumn}`);
+    }
+    if (seenChildColumns.has(childColumn)) {
+      throw new Error(`Arrow query column was selected more than once: ${projectedColumn}`);
+    }
+    seenChildColumns.add(childColumn);
+    if (!childOutputColumns.includes(childColumn)) {
+      throw new Error(`Arrow join child projection does not include: ${childColumn}`);
+    }
+  }
+}
+function arrowTableToRows(data) {
+  const columns = data.schema.fields.map((field) => ({
+    name: field.name,
+    vector: data.getChild(field.name)
+  }));
+  return Array.from({ length: data.numRows }, (_, rowIndex) => {
+    const row = {};
+    for (const column of columns) {
+      if (!column.vector) throw new Error(`Arrow relational query could not read ${column.name}`);
+      row[column.name] = column.vector.get(rowIndex);
+    }
+    return row;
+  });
+}
+function evaluateRelationalExpression(expression, row) {
+  const definition = expression.expression;
+  if (definition.op === "literal") return definition.value;
+  if (definition.op === "column") return row[definition.column];
+  const left = row[definition.left];
+  const right = row[definition.right];
+  if (left === null || left === void 0 || right === null || right === void 0) return null;
+  if (typeof left !== "number" || typeof right !== "number") {
+    throw new Error(`Arrow relational expression ${expression.name} requires numeric operands.`);
+  }
+  switch (definition.op) {
+    case "add":
+      return left + right;
+    case "subtract":
+      return left - right;
+    case "multiply":
+      return left * right;
+    case "divide":
+      return right === 0 ? null : left / right;
+  }
+}
+function compareRows(left, right, orderBy) {
+  for (const key of orderBy) {
+    const leftValue = left[key.column];
+    const rightValue = right[key.column];
+    const nulls = key.nulls || "last";
+    if (leftValue === null || leftValue === void 0 || rightValue === null || rightValue === void 0) {
+      if (leftValue === rightValue) continue;
+      const nullResult = leftValue === null || leftValue === void 0 ? -1 : 1;
+      return nulls === "first" ? nullResult : -nullResult;
+    }
+    const result = compareSortValues(leftValue, rightValue);
+    if (result) return (key.direction === "desc" ? -1 : 1) * result;
+  }
+  return 0;
+}
+function compareSortValues(left, right) {
+  if (left instanceof Date && right instanceof Date)
+    return compareNumbers2(left.getTime(), right.getTime());
+  if (typeof left === "bigint" && typeof right === "bigint")
+    return left === right ? 0 : left < right ? -1 : 1;
+  if (typeof left === "number" && typeof right === "number") return compareNumbers2(left, right);
+  if (typeof left === "string" && typeof right === "string")
+    return left === right ? 0 : left < right ? -1 : 1;
+  if (typeof left === "boolean" && typeof right === "boolean") return Number(left) - Number(right);
+  throw new Error(
+    `Arrow relational order cannot compare ${getValueType(left)} with ${getValueType(right)}.`
+  );
+}
+function aggregateRows(rows, groupBy, aggregates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = serializeGroupKey(groupBy.map((column) => row[column]));
+    const group = groups.get(key) || [];
+    group.push(row);
+    groups.set(key, group);
+  }
+  if (!groupBy.length && !rows.length) groups.set("[]", []);
+  return [...groups.values()].map((group) => {
+    var _a;
+    const output = {};
+    for (const column of groupBy) output[column] = ((_a = group[0]) == null ? void 0 : _a[column]) ?? null;
+    for (const aggregate of aggregates)
+      output[aggregate.name] = evaluateAggregate(aggregate, group);
+    return output;
+  });
+}
+function serializeGroupKey(values) {
+  return values.map((value) => {
+    if (value === null || value === void 0) return "null:";
+    if (value instanceof Date) return `date:${value.getTime()}`;
+    if (value instanceof Uint8Array) return `bytes:${Array.from(value).join(".")}`;
+    return `${typeof value}:${String(value)}`;
+  }).join("");
+}
+function createEmptyRelationalResult(sourceData, outputColumns, options, additionalFields) {
+  const sourceFields = new Map(sourceData.schema.fields.map((field) => [field.name, field]));
+  const expressions = new Map(
+    (options.expressions || []).map((expression) => [expression.name, expression])
+  );
+  const aggregates = new Map(
+    (options.aggregates || []).map((aggregate) => [aggregate.name, aggregate])
+  );
+  const fields = outputColumns.map((columnName) => {
+    const sourceField = sourceFields.get(columnName);
+    if (sourceField) return sourceField;
+    const additionalField = additionalFields == null ? void 0 : additionalFields.get(columnName);
+    if (additionalField) return additionalField;
+    const expression = expressions.get(columnName);
+    if (expression)
+      return new arrow6.Field(columnName, getExpressionType(expression, sourceFields), true);
+    const aggregate = aggregates.get(columnName);
+    if (aggregate)
+      return new arrow6.Field(columnName, getAggregateType(aggregate, sourceFields), true);
+    return new arrow6.Field(columnName, new arrow6.Utf8(), true);
+  });
+  const columns = {};
+  for (const field of fields) columns[field.name] = arrow6.vectorFromArray([], field.type);
+  return wrapArrowTable(new arrow6.Table(new arrow6.Schema(fields), columns));
+}
+function getExpressionType(expression, sourceFields) {
+  var _a;
+  if (expression.expression.op === "literal") {
+    const value = expression.expression.value;
+    if (typeof value === "boolean") return new arrow6.Bool();
+    if (typeof value === "number") return new arrow6.Float64();
+    return new arrow6.Utf8();
+  }
+  if (expression.expression.op === "column") {
+    return ((_a = sourceFields.get(expression.expression.column)) == null ? void 0 : _a.type) || new arrow6.Utf8();
+  }
+  return new arrow6.Float64();
+}
+function getAggregateType(aggregate, sourceFields) {
+  var _a;
+  if (aggregate.function === "count") return new arrow6.Int32();
+  return aggregate.column ? ((_a = sourceFields.get(aggregate.column)) == null ? void 0 : _a.type) || new arrow6.Float64() : new arrow6.Float64();
+}
+function evaluateAggregate(aggregate, rows) {
+  if (aggregate.function === "count")
+    return aggregate.column ? rows.filter((row) => row[aggregate.column] != null).length : rows.length;
+  const values = rows.map((row) => row[aggregate.column]).filter((value) => value != null);
+  if (!values.length) return null;
+  if (!values.every((value) => typeof value === "number"))
+    throw new Error(`Arrow aggregate ${aggregate.function} requires numeric values.`);
+  const numericValues = values;
+  switch (aggregate.function) {
+    case "sum":
+      return numericValues.reduce((sum, value) => sum + value, 0);
+    case "avg":
+      return numericValues.reduce((sum, value) => sum + value, 0) / numericValues.length;
+    case "min":
+      return Math.min(...numericValues);
+    case "max":
+      return Math.max(...numericValues);
+  }
+}
+function getPredicateColumns(sourceTable, columnNames) {
+  const columns = {};
+  for (const columnName of columnNames) {
+    const column = sourceTable.getChild(columnName);
+    if (!column) {
+      throw new Error(`Arrow query column not found: ${columnName}`);
+    }
+    columns[columnName] = column;
+  }
+  return columns;
+}
+function evaluatePredicate(predicate, columns, rowIndex) {
+  if (isLogicalPredicate(predicate)) {
+    const values = predicate.args.map((child) => evaluatePredicate(child, columns, rowIndex));
+    return predicate.op === "and" ? evaluateAnd(values) : evaluateOr(values);
+  }
+  if (isNotPredicate(predicate)) {
+    const value2 = evaluatePredicate(predicate.args[0], columns, rowIndex);
+    return value2 === null ? null : !value2;
+  }
+  const value = getColumnValue(columns, predicate.args[0].property, rowIndex);
+  if (isNullPredicate(predicate)) {
+    return value === null;
+  }
+  if (isInPredicate(predicate)) {
+    return evaluateIn(value, predicate.args[1]);
+  }
+  return evaluateComparison(value, predicate);
+}
+function getColumnValue(columns, columnName, rowIndex) {
+  const column = columns[columnName];
+  if (!column) {
+    throw new Error(`Arrow query could not read predicate column "${columnName}".`);
+  }
+  return column.get(rowIndex);
+}
+function evaluateAnd(values) {
+  if (values.includes(false)) {
+    return false;
+  }
+  return values.includes(null) ? null : true;
+}
+function evaluateOr(values) {
+  if (values.includes(true)) {
+    return true;
+  }
+  return values.includes(null) ? null : false;
+}
+function evaluateIn(value, candidates) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  for (const candidate of candidates) {
+    if (compareValues(value, candidate) === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function evaluateComparison(value, predicate) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  const comparison = compareValues(value, predicate.args[1]);
+  switch (predicate.op) {
+    case "=":
+      return comparison === 0;
+    case "<>":
+      return comparison !== 0;
+    case "<":
+      return comparison < 0;
+    case "<=":
+      return comparison <= 0;
+    case ">":
+      return comparison > 0;
+    case ">=":
+      return comparison >= 0;
+  }
+}
+function compareValues(left, right) {
+  if (isSQLPredicateParameter(right)) {
+    throw new Error(
+      `Arrow query parameter ":${right.parameter}" must be bound before query execution.`
+    );
+  }
+  if (left instanceof Date && right instanceof Date) {
+    return compareNumbers2(left.getTime(), right.getTime());
+  }
+  if (left instanceof Uint8Array && right instanceof Uint8Array) {
+    return compareBinary(left, right);
+  }
+  if (typeof left === "bigint" && typeof right === "bigint") {
+    return left === right ? 0 : left < right ? -1 : 1;
+  }
+  if (typeof left === "bigint" && typeof right === "number" && Number.isSafeInteger(right)) {
+    return compareValues(left, BigInt(right));
+  }
+  if (typeof left === "number" && typeof right === "bigint" && Number.isSafeInteger(left)) {
+    return compareValues(BigInt(left), right);
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    return compareNumbers2(left, right);
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return left === right ? 0 : left < right ? -1 : 1;
+  }
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return Number(left) - Number(right);
+  }
+  throw new Error(
+    `Arrow query cannot compare ${getValueType(left)} with ${getValueType(right)} values.`
+  );
+}
+function compareNumbers2(left, right) {
+  if (!Number.isFinite(left) || !Number.isFinite(right)) {
+    throw new Error("Arrow query cannot compare non-finite numbers.");
+  }
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+function compareBinary(left, right) {
+  const commonLength = Math.min(left.length, right.length);
+  for (let index = 0; index < commonLength; index++) {
+    if (left[index] !== right[index]) {
+      return left[index] < right[index] ? -1 : 1;
+    }
+  }
+  return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
+}
+function getValueType(value) {
+  if (value instanceof Date) {
+    return "Date";
+  }
+  if (value instanceof Uint8Array) {
+    return "Uint8Array";
+  }
+  return typeof value;
+}
+function isLogicalPredicate(predicate) {
+  return predicate.op === "and" || predicate.op === "or";
+}
+function isNotPredicate(predicate) {
+  return predicate.op === "not";
+}
+function isNullPredicate(predicate) {
+  return predicate.op === "isNull";
+}
+function isInPredicate(predicate) {
+  return predicate.op === "in";
+}
+function getScanStep(plan) {
+  const step = plan.find((candidate) => candidate.kind === "scan");
+  if (!step) {
+    throw new Error("Arrow query plan is missing a scan step.");
+  }
+  return step;
+}
+function getFilterStep(plan) {
+  return plan.find((candidate) => candidate.kind === "filter");
+}
+function getProjectStep(plan) {
+  const step = plan.find(
+    (candidate) => candidate.kind === "project"
+  );
+  if (!step) {
+    throw new Error("Arrow query plan is missing a project step.");
+  }
+  return step;
+}
+function getLimitStep(plan) {
+  return plan.find((candidate) => candidate.kind === "limit");
+}
+function throwIfAborted(signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    const error = new Error("Arrow query was aborted.");
+    error.name = "AbortError";
+    throw error;
+  }
+}
+function wrapArrowTable(data) {
+  return {
+    shape: "arrow-table",
+    schema: convertArrowToSchema(data.schema),
+    data
+  };
+}
+
+// ../sql/src/parse-sql-predicate.ts
+var MAXIMUM_SQL_LENGTH = 65536;
+var MAXIMUM_SQL_TOKENS = 4096;
+var MAXIMUM_EXPRESSION_DEPTH = 64;
+function parseSQLPredicate(source, options = {}) {
+  const parser = new SQLPredicateParser(
+    source,
+    options.parameters ?? {},
+    options.preserveParameters === true
+  );
+  const predicate = parser.parse();
+  validateSQLPredicate(predicate);
+  return predicate;
+}
+var SQLPredicateParser = class {
+  /** Token stream parsed by this parser instance. */
+  tokens;
+  /** Named scalar parameters available to the expression. */
+  parameters;
+  /** Whether named parameters remain references in the parsed AST. */
+  preserveParameters;
+  /** Current index in the token stream. */
+  position = 0;
+  constructor(source, parameters, preserveParameters) {
+    this.tokens = tokenizeSQLPredicate(source);
+    this.parameters = parameters;
+    this.preserveParameters = preserveParameters;
+  }
+  /** Parses the complete token stream. */
+  parse() {
+    const predicate = this.parseOr(0);
+    this.takeSymbol(";");
+    const token = this.peek();
+    if (token) {
+      throw new Error(`SQL predicate contains unexpected token ${JSON.stringify(token.value)}`);
+    }
+    return predicate;
+  }
+  /** Parses left-associative disjunction. */
+  parseOr(depth) {
+    let predicate = this.parseAnd(depth + 1);
+    while (this.takeKeyword("OR")) {
+      predicate = combineLogicalPredicate("or", predicate, this.parseAnd(depth + 1));
+    }
+    return predicate;
+  }
+  /** Parses left-associative conjunction. */
+  parseAnd(depth) {
+    let predicate = this.parseNot(depth + 1);
+    while (this.takeKeyword("AND")) {
+      predicate = combineLogicalPredicate("and", predicate, this.parseNot(depth + 1));
+    }
+    return predicate;
+  }
+  /** Parses boolean negation and parenthesized predicates. */
+  parseNot(depth) {
+    this.assertDepth(depth);
+    if (this.takeKeyword("NOT")) {
+      return { op: "not", args: [this.parseNot(depth + 1)] };
+    }
+    if (this.takeSymbol("(")) {
+      const predicate = this.parseOr(depth + 1);
+      this.expectSymbol(")");
+      return predicate;
+    }
+    return this.parseLeaf();
+  }
+  /** Parses one comparison, membership, or null predicate. */
+  parseLeaf() {
+    var _a, _b;
+    const property = this.parseProperty();
+    if (this.takeKeyword("IS")) {
+      const negated = this.takeKeyword("NOT");
+      this.expectKeyword("NULL");
+      const predicate = { op: "isNull", args: [property] };
+      return negated ? { op: "not", args: [predicate] } : predicate;
+    }
+    const negatedMembership = this.takeKeyword("NOT");
+    if (negatedMembership || this.peekKeyword("IN")) {
+      this.expectKeyword("IN");
+      this.expectSymbol("(");
+      if (((_a = this.peek()) == null ? void 0 : _a.kind) === "symbol" && ((_b = this.peek()) == null ? void 0 : _b.value) === ")") {
+        throw new Error("SQL predicate IN requires at least one scalar value");
+      }
+      const values = [this.parseValue()];
+      while (this.takeSymbol(",")) {
+        values.push(this.parseValue());
+      }
+      this.expectSymbol(")");
+      const predicate = { op: "in", args: [property, values] };
+      return negatedMembership ? { op: "not", args: [predicate] } : predicate;
+    }
+    const token = this.take();
+    if ((token == null ? void 0 : token.kind) !== "symbol" || !["=", "!=", "<>", "<", "<=", ">", ">="].includes(token.value)) {
+      throw new Error("SQL predicate expected a comparison, IN, or IS NULL operator");
+    }
+    const operator = token.value === "!=" ? "<>" : token.value;
+    return {
+      op: operator,
+      args: [property, this.parseValue()]
+    };
+  }
+  /** Parses an identifier into a property reference. */
+  parseProperty() {
+    const token = this.take();
+    if ((token == null ? void 0 : token.kind) !== "identifier") {
+      throw new Error("SQL predicate expected a column identifier");
+    }
+    return token.quoted ? { property: token.value, quoted: true } : { property: token.value };
+  }
+  /** Parses one scalar literal or named parameter. */
+  parseValue() {
+    const negative = this.takeSymbol("-");
+    const token = this.take();
+    if (!token) {
+      throw new Error("SQL predicate expected a scalar value");
+    }
+    if (negative && token.kind !== "number") {
+      throw new Error("SQL predicate only permits unary minus on numeric literals");
+    }
+    if (token.kind === "number") {
+      return parseNumericLiteral(negative ? `-${token.value}` : token.value);
+    }
+    if (negative) {
+      throw new Error("SQL predicate expected a numeric literal after unary minus");
+    }
+    if (token.kind === "string") {
+      return token.value;
+    }
+    if (token.kind === "parameter") {
+      if (this.preserveParameters) {
+        return { parameter: token.value };
+      }
+      if (!Object.hasOwn(this.parameters, token.value)) {
+        throw new Error(`SQL predicate parameter ":${token.value}" requires a value`);
+      }
+      const value = this.parameters[token.value];
+      validateParameterValue(value, token.value);
+      return value;
+    }
+    if (token.kind === "identifier" && /^(TRUE|FALSE)$/i.test(token.value)) {
+      return /^TRUE$/i.test(token.value);
+    }
+    if (token.kind === "identifier" && /^NULL$/i.test(token.value)) {
+      throw new Error("SQL predicate comparisons with NULL must use IS NULL or IS NOT NULL");
+    }
+    throw new Error(`SQL predicate does not support scalar token ${JSON.stringify(token.value)}`);
+  }
+  /** Rejects excessively nested inputs before recursion can exhaust the stack. */
+  assertDepth(depth) {
+    if (depth > MAXIMUM_EXPRESSION_DEPTH) {
+      throw new Error("SQL predicate nesting exceeds its safe limit");
+    }
+  }
+  /** Consumes one required keyword. */
+  expectKeyword(keyword) {
+    if (!this.takeKeyword(keyword)) {
+      throw new Error(`SQL predicate expected ${keyword}`);
+    }
+  }
+  /** Returns whether the next token is a keyword without consuming it. */
+  peekKeyword(keyword) {
+    const token = this.peek();
+    return (token == null ? void 0 : token.kind) === "identifier" && token.value.toUpperCase() === keyword;
+  }
+  /** Consumes one optional keyword. */
+  takeKeyword(keyword) {
+    if (!this.peekKeyword(keyword)) {
+      return false;
+    }
+    this.position++;
+    return true;
+  }
+  /** Consumes one required symbol. */
+  expectSymbol(symbol) {
+    if (!this.takeSymbol(symbol)) {
+      throw new Error(`SQL predicate expected ${JSON.stringify(symbol)}`);
+    }
+  }
+  /** Consumes one optional symbol. */
+  takeSymbol(symbol) {
+    const token = this.peek();
+    if ((token == null ? void 0 : token.kind) !== "symbol" || token.value !== symbol) {
+      return false;
+    }
+    this.position++;
+    return true;
+  }
+  /** Consumes and returns the next token. */
+  take() {
+    const token = this.tokens[this.position];
+    if (token) {
+      this.position++;
+    }
+    return token;
+  }
+  /** Returns the next token without consuming it. */
+  peek() {
+    return this.tokens[this.position];
+  }
+};
+function combineLogicalPredicate(operator, left, right) {
+  return left.op === operator ? { op: operator, args: [...left.args, right] } : { op: operator, args: [left, right] };
+}
+function parseNumericLiteral(source) {
+  if (/^-?\d+$/.test(source)) {
+    const bigint = BigInt(source);
+    if (bigint > BigInt(Number.MAX_SAFE_INTEGER) || bigint < BigInt(Number.MIN_SAFE_INTEGER)) {
+      return bigint;
+    }
+  }
+  const number = Number(source);
+  if (!Number.isFinite(number)) {
+    throw new Error("SQL predicate numeric literals must be finite");
+  }
+  return number;
+}
+function validateParameterValue(value, name) {
+  const probe = { op: "=", args: [{ property: "_" }, value] };
+  try {
+    validateSQLPredicate(probe);
+  } catch {
+    throw new Error(`SQL predicate parameter ":${name}" has an unsupported value`);
+  }
+}
+function tokenizeSQLPredicate(source) {
+  if (typeof source !== "string" || source.trim().length === 0 || source.length > MAXIMUM_SQL_LENGTH) {
+    throw new Error("SQL predicate requires a non-empty, safely bounded expression");
+  }
+  const tokens = [];
+  let position = 0;
+  while (position < source.length) {
+    const character = source[position];
+    if (/\s/.test(character)) {
+      position++;
+      continue;
+    }
+    if (character === "'") {
+      const result = readQuotedToken(source, position, "'", "'");
+      tokens.push({ kind: "string", value: result.value });
+      position = result.position;
+    } else if (character === '"') {
+      const result = readQuotedToken(source, position, '"', '"');
+      tokens.push({ kind: "identifier", value: result.value, quoted: true });
+      position = result.position;
+    } else if (character === ":") {
+      const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(position + 1));
+      if (!match) {
+        throw new Error(`SQL predicate contains an invalid parameter at character ${position}`);
+      }
+      tokens.push({ kind: "parameter", value: match[0] });
+      position += match[0].length + 1;
+    } else {
+      const numberMatch = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/.exec(source.slice(position));
+      const identifierMatch = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*/.exec(
+        source.slice(position)
+      );
+      if (numberMatch) {
+        tokens.push({ kind: "number", value: numberMatch[0] });
+        position += numberMatch[0].length;
+      } else if (identifierMatch) {
+        tokens.push({ kind: "identifier", value: identifierMatch[0] });
+        position += identifierMatch[0].length;
+      } else {
+        const twoCharacters = source.slice(position, position + 2);
+        if (["<=", ">=", "<>", "!="].includes(twoCharacters)) {
+          tokens.push({ kind: "symbol", value: twoCharacters });
+          position += 2;
+        } else if ("(),;-=<>".includes(character)) {
+          tokens.push({ kind: "symbol", value: character });
+          position++;
+        } else {
+          throw new Error(`SQL predicate contains an unsupported token at character ${position}`);
+        }
+      }
+    }
+    if (tokens.length > MAXIMUM_SQL_TOKENS) {
+      throw new Error("SQL predicate exceeds its safe token limit");
+    }
+  }
+  return tokens;
+}
+function readQuotedToken(source, start, quote, escapedQuote) {
+  let value = "";
+  let position = start + 1;
+  while (position < source.length) {
+    if (source[position] !== quote) {
+      value += source[position++];
+      continue;
+    }
+    if (source[position + 1] === escapedQuote) {
+      value += quote;
+      position += 2;
+      continue;
+    }
+    return { value, position: position + 1 };
+  }
+  throw new Error(`SQL predicate contains an unterminated quoted value at character ${start}`);
+}
+
+// dist/scan-engine.js
+var scanBackendLoaders = /* @__PURE__ */ new Map();
+var arrowScanBackend = Object.freeze({
+  name: "arrow",
+  query: queryArrowTable,
+  queryAsync: async (sourceTable, options) => queryArrowTable(sourceTable, options),
+  explain: explainArrowTableQuery
+});
+scanBackendLoaders.set("arrow", () => arrowScanBackend);
+function registerScanBackend(name, loader) {
+  if (!name || !loader) {
+    throw new Error("A scan backend name and loader are required");
+  }
+  scanBackendLoaders.set(name, loader);
+}
+async function createScanEngine(options = {}) {
+  const backendName = options.backend || "arrow";
+  const loader = scanBackendLoaders.get(backendName);
+  if (!loader) {
+    throw new Error(`Scan backend "${backendName}" is not registered. The built-in backend is "arrow".`);
+  }
+  const backend = await loader();
+  if (backend.name !== backendName) {
+    throw new Error(`Scan backend loader returned "${backend.name}" while "${backendName}" was requested.`);
+  }
+  const query = backend.query.bind(backend);
+  const explain = backend.explain.bind(backend);
+  const queryAsync = backend.queryAsync ? backend.queryAsync.bind(backend) : async (sourceTable, queryOptions) => backend.query.call(backend, sourceTable, queryOptions);
+  return Object.freeze({ ...backend, query, explain, queryAsync });
+}
+
+// dist/federated-table-scan-source.js
+var arrow7 = __toESM(require("apache-arrow"), 1);
+var FEDERATED_TABLE_QUERY_CAPABILITIES = Object.freeze({
+  predicate: "residual",
+  projection: "pushdown+residual",
+  limit: "pushdown+residual",
+  streaming: true,
+  cancellation: true
+});
+var nextFederatedSourceId = 0;
+var FederatedTableScanSource = class {
+  /** Shared manager used as the authoritative named-source registry. */
+  dataSourceManager;
+  /** Immutable sources in physical append order. */
+  sources;
+  /** Schema reconciliation policy. */
+  schemaPolicy;
+  /** Optional caller-declared normalized output schema. */
+  outputSchema;
+  /** Optional display name reported through scan metadata. */
+  name;
+  /** Human-readable description reported through scan metadata. */
+  description;
+  /** Stable id used to isolate this adapter's manager subscriptions. */
+  instanceId = nextFederatedSourceId++;
+  /** Monotonic id used to isolate overlapping operations on this adapter. */
+  nextOperationId = 0;
+  /** Creates an ordered federated source backed by one shared DataSourceManager. */
+  constructor(dataSourceManager, options) {
+    if (!options.sources.length) {
+      throw new Error("Federated table scans require at least one source.");
+    }
+    if (options.schemaPolicy && options.schemaPolicy !== "strict" && options.schemaPolicy !== "union") {
+      throw new Error(`Unsupported federated schema policy: ${options.schemaPolicy}`);
+    }
+    this.dataSourceManager = dataSourceManager;
+    this.sources = Object.freeze(options.sources.map(cloneSourceEntry));
+    this.schemaPolicy = options.schemaPolicy || "strict";
+    this.outputSchema = options.outputSchema ? cloneSchema(options.outputSchema) : void 0;
+    this.name = options.name;
+    this.description = options.description || `${this.sources.length} ordered table sources`;
+  }
+  /** Discovers and reconciles every child schema without reading federated result batches. */
+  async getQueryMetadata(options = {}) {
+    const consumerId = this.createConsumerId("metadata");
+    try {
+      const plan = await this.resolvePlan(consumerId, options.signal);
+      return createScanQueryMetadata({
+        sourceType: "federated-table",
+        queryType: "table",
+        execution: { status: "supported", method: "read" },
+        name: this.name,
+        description: this.description,
+        schema: plan.schema,
+        capabilities: { table: FEDERATED_TABLE_QUERY_CAPABILITIES },
+        statistics: getFederatedStatistics(plan.sources)
+      });
+    } finally {
+      this.dataSourceManager.unsubscribe({ consumerId });
+    }
+  }
+  /** Explains source resolution, schema reconciliation, and the global table query. */
+  async explain(options = {}) {
+    const consumerId = this.createConsumerId("explain");
+    try {
+      const plan = await this.resolvePlan(consumerId, options.signal);
+      const explanation = explainTableQuery(plan.schema.fields.map((field) => field.name), options, FEDERATED_TABLE_QUERY_CAPABILITIES);
+      return Object.freeze({
+        ...explanation,
+        schemaPolicy: this.schemaPolicy,
+        sources: Object.freeze(plan.sources.map((source) => createSourceExplanation(source, plan.schema)))
+      });
+    } finally {
+      this.dataSourceManager.unsubscribe({ consumerId });
+    }
+  }
+  /**
+   * Emits source and batch ordered Arrow results with one global limit and batch provenance.
+   *
+   * Returning early from the iterator closes the active child iterator and releases every manager
+   * subscription. Later sources are never read once the global limit has been satisfied.
+   */
+  async *read(options = {}) {
+    var _a, _b;
+    const consumerId = this.createConsumerId("read");
+    const startedAt = Date.now();
+    const telemetry = {
+      status: "early-terminated",
+      sourcesPlanned: this.sources.length,
+      sourcesRead: 0,
+      batchesRead: 0,
+      rowsRead: 0,
+      rowsTested: 0,
+      rowsRetained: 0,
+      rowsReturned: 0,
+      bytesFetched: 0,
+      filesOpened: 0,
+      tasksOpened: 0,
+      rowsPruned: 0,
+      durationMilliseconds: 0,
+      sources: []
+    };
+    try {
+      const plan = await this.resolvePlan(consumerId, options.signal);
+      const scanStep = planTableQuery(plan.schema.fields.map((field) => field.name), options)[0];
+      let remaining = options.limit ?? Number.POSITIVE_INFINITY;
+      if (remaining <= 0) {
+        telemetry.earlyTerminationReason = "limit";
+        return;
+      }
+      for (const resolvedSource of plan.sources) {
+        throwIfAborted2(options.signal);
+        if (remaining <= 0) {
+          telemetry.earlyTerminationReason = "limit";
+          return;
+        }
+        const sourceStartedAt = Date.now();
+        let childTelemetry;
+        let sourceCompleted = false;
+        let sourceError;
+        let sourceBatchesDecoded = 0;
+        let sourceRowsRead = 0;
+        let sourceRowsTested = 0;
+        let sourceRowsRetained = 0;
+        let sourceRowsReturned = 0;
+        const sourceReadOptions = createSourceReadOptions(resolvedSource, scanStep.columns, remaining, options, (value) => {
+          childTelemetry = value;
+        });
+        const sourceResidualPredicate = getSourceResidualPredicate(resolvedSource);
+        let sourceRemaining = ((_a = resolvedSource.entry.query) == null ? void 0 : _a.limit) ?? Number.POSITIVE_INFINITY;
+        telemetry.sourcesRead++;
+        let sourceBatchIndex = 0;
+        try {
+          for await (const batch of resolvedSource.source.read(sourceReadOptions)) {
+            throwIfAborted2(options.signal);
+            if (remaining <= 0) {
+              telemetry.earlyTerminationReason = "limit";
+              return;
+            }
+            if (sourceRemaining <= 0)
+              break;
+            if (batch.batchType !== "data")
+              continue;
+            telemetry.batchesRead++;
+            telemetry.rowsRead += batch.length;
+            sourceBatchesDecoded++;
+            sourceRowsRead += batch.length;
+            if (batch.length <= 0)
+              continue;
+            const physicalTable = convertBatch(batch.schema ? batch : { ...batch, schema: resolvedSource.metadata.schema }, "arrow-table");
+            const sourceResult = queryArrowTable(physicalTable, {
+              predicate: sourceResidualPredicate,
+              limit: Number.isFinite(sourceRemaining) ? sourceRemaining : void 0,
+              signal: options.signal
+            });
+            if (sourceResidualPredicate) {
+              sourceRowsTested += physicalTable.data.numRows;
+              sourceRowsRetained += sourceResult.data.numRows;
+            }
+            sourceRemaining -= sourceResult.data.numRows;
+            const currentSourceBatchIndex = sourceBatchIndex++;
+            if (!sourceResult.data.numRows)
+              continue;
+            const canonicalTable = createCanonicalArrowTable(plan.schema, resolvedSource, sourceResult);
+            const result = queryArrowTable(canonicalTable, {
+              predicate: options.predicate,
+              columns: options.columns,
+              limit: Number.isFinite(remaining) ? remaining : void 0,
+              signal: options.signal
+            });
+            if (options.predicate) {
+              telemetry.rowsTested += canonicalTable.data.numRows;
+              telemetry.rowsRetained += result.data.numRows;
+            }
+            const resultLength = result.data.numRows;
+            if (!resultLength)
+              continue;
+            const provenance = Object.freeze({
+              sourceId: resolvedSource.entry.dataSourceId,
+              sourceIndex: resolvedSource.sourceIndex,
+              sourceBatchIndex: currentSourceBatchIndex,
+              sourceMetadata: batch.metadata
+            });
+            telemetry.rowsReturned += resultLength;
+            sourceRowsReturned += resultLength;
+            yield {
+              batchType: "data",
+              shape: "arrow-table",
+              schema: convertArrowToSchema(result.data.schema),
+              data: result.data,
+              length: resultLength,
+              metadata: provenance,
+              sourceId: provenance.sourceId,
+              sourceIndex: provenance.sourceIndex,
+              sourceBatchIndex: provenance.sourceBatchIndex
+            };
+            remaining -= resultLength;
+          }
+          sourceCompleted = true;
+        } catch (error) {
+          sourceError = error;
+          throw error;
+        } finally {
+          const sourceTelemetry = createSourceTelemetry({
+            resolvedSource,
+            childTelemetry,
+            sourceStartedAt,
+            sourceCompleted,
+            sourceError,
+            signal: options.signal,
+            batchesDecoded: sourceBatchesDecoded,
+            rowsRead: sourceRowsRead,
+            rowsTested: sourceRowsTested,
+            rowsRetained: sourceRowsRetained,
+            rowsReturned: sourceRowsReturned
+          });
+          telemetry.sources.push(sourceTelemetry);
+          telemetry.bytesFetched += sourceTelemetry.bytesFetched || 0;
+          telemetry.filesOpened += sourceTelemetry.filesOpened || 0;
+          telemetry.tasksOpened += sourceTelemetry.tasksOpened || 0;
+          telemetry.rowsPruned += sourceTelemetry.rowsPruned || 0;
+        }
+      }
+      telemetry.status = "completed";
+    } catch (error) {
+      telemetry.status = ((_b = options.signal) == null ? void 0 : _b.aborted) ? "cancelled" : "failed";
+      telemetry.error = error;
+      throw error;
+    } finally {
+      this.dataSourceManager.unsubscribe({ consumerId });
+      telemetry.durationMilliseconds = Date.now() - startedAt;
+      if (telemetry.status === "early-terminated" && !telemetry.earlyTerminationReason) {
+        telemetry.earlyTerminationReason = "consumer-return";
+      }
+      emitScanExecutionTelemetry(options.onTelemetry, Object.freeze({
+        ...telemetry,
+        batchesDecoded: telemetry.batchesRead,
+        sources: Object.freeze([...telemetry.sources])
+      }));
+    }
+  }
+  /** Resolves managed sources, discovers their schemas, and creates one compatibility plan. */
+  async resolvePlan(consumerId, signal) {
+    const sources = [];
+    for (let sourceIndex = 0; sourceIndex < this.sources.length; sourceIndex++) {
+      throwIfAborted2(signal);
+      const entry = this.sources[sourceIndex];
+      const source = await resolveManagedSource(this.dataSourceManager, entry.dataSourceId, consumerId, String(sourceIndex), signal);
+      if (typeof source.getQueryMetadata !== "function" || typeof source.read !== "function") {
+        throw new Error(`Managed source does not implement TableScanSource: ${entry.dataSourceId}`);
+      }
+      const metadata = await source.getQueryMetadata({ signal });
+      if (metadata.execution.status !== "supported" || metadata.execution.method !== "read") {
+        throw new Error(`Federated table source does not support read(): ${entry.dataSourceId}`);
+      }
+      if (metadata.queryType !== "table") {
+        throw new Error(`Federated source is not a table source: ${entry.dataSourceId}`);
+      }
+      const fields = resolveMappedFields(entry, metadata);
+      sources.push({
+        entry,
+        source,
+        metadata,
+        sourceIndex,
+        fields,
+        sourceNameByOutputName: new Map(fields.map((field) => [field.outputName, field.sourceName]))
+      });
+    }
+    return Object.freeze({
+      schema: reconcileSchemas(sources, this.schemaPolicy, this.outputSchema),
+      sources: Object.freeze(sources)
+    });
+  }
+  /** Returns a collision-free manager consumer id for one operation. */
+  createConsumerId(operation) {
+    return `federated-table:${this.instanceId}:${operation}:${this.nextOperationId++}`;
+  }
+};
+function cloneSourceEntry(entry) {
+  if (!entry.dataSourceId) {
+    throw new Error("Federated table source ids must be non-empty.");
+  }
+  return Object.freeze({
+    dataSourceId: entry.dataSourceId,
+    query: entry.query ? Object.freeze({
+      ...entry.query,
+      columns: entry.query.columns ? Object.freeze([...entry.query.columns]) : void 0
+    }) : void 0,
+    columnMapping: entry.columnMapping ? Object.freeze({ ...entry.columnMapping }) : void 0
+  });
+}
+function resolveMappedFields(entry, metadata) {
+  var _a;
+  const sourceFields = new Map(metadata.schema.fields.map((field) => [field.name, field]));
+  for (const sourceName of Object.keys(entry.columnMapping || {})) {
+    if (!sourceFields.has(sourceName)) {
+      throw new Error(`Federated column mapping source not found in ${entry.dataSourceId}: ${sourceName}`);
+    }
+  }
+  const selectedNames = ((_a = entry.query) == null ? void 0 : _a.columns) || metadata.schema.fields.map((field) => field.name);
+  if (!selectedNames.length) {
+    throw new Error(`Federated source projection must not be empty: ${entry.dataSourceId}`);
+  }
+  const outputNames = /* @__PURE__ */ new Set();
+  return Object.freeze(selectedNames.map((sourceName) => {
+    var _a2;
+    const field = sourceFields.get(sourceName);
+    if (!field) {
+      throw new Error(`Federated source column not found in ${entry.dataSourceId}: ${sourceName}`);
+    }
+    const outputName = ((_a2 = entry.columnMapping) == null ? void 0 : _a2[sourceName]) ?? sourceName;
+    if (!outputName) {
+      throw new Error(`Federated output column names must be non-empty: ${sourceName}`);
+    }
+    if (outputNames.has(outputName)) {
+      throw new Error(`Federated column mapping creates duplicate output column in ${entry.dataSourceId}: ${outputName}`);
+    }
+    outputNames.add(outputName);
+    return Object.freeze({ sourceName, outputName, field });
+  }));
+}
+function reconcileSchemas(sources, schemaPolicy, outputSchema) {
+  const outputFields = /* @__PURE__ */ new Map();
+  const firstSourceNames = sources[0].fields.map((field) => field.outputName);
+  for (const source of sources) {
+    const sourceNames = new Set(source.fields.map((field) => field.outputName));
+    if (schemaPolicy === "strict") {
+      const missing = firstSourceNames.filter((name) => !sourceNames.has(name));
+      const extra = source.fields.map((field) => field.outputName).filter((name) => !firstSourceNames.includes(name));
+      if (missing.length || extra.length) {
+        throw new Error(`Federated strict schema mismatch for ${source.entry.dataSourceId}: missing [${missing.join(", ")}], extra [${extra.join(", ")}]`);
+      }
+    }
+    for (const mappedField of source.fields) {
+      const current = outputFields.get(mappedField.outputName);
+      if (current) {
+        if (!outputSchema && !areDataTypesEqual(current.type, mappedField.field.type)) {
+          throw new Error(`Federated column type mismatch for ${mappedField.outputName}: ${formatDataType(current.type)} versus ${formatDataType(mappedField.field.type)} in ${source.entry.dataSourceId}`);
+        }
+        current.nullable = Boolean(current.nullable || mappedField.field.nullable);
+        current.presentCount++;
+      } else {
+        outputFields.set(mappedField.outputName, {
+          ...mappedField.field,
+          name: mappedField.outputName,
+          metadata: mappedField.field.metadata ? { ...mappedField.field.metadata } : void 0,
+          presentCount: 1
+        });
+      }
+    }
+  }
+  const fields = [...outputFields.values()].map(({ presentCount, ...field }) => ({
+    ...field,
+    nullable: Boolean(field.nullable || presentCount < sources.length)
+  }));
+  const inferredSchema = { fields, metadata: {} };
+  return outputSchema ? validateAndCloneOutputSchema(outputSchema, sources, inferredSchema, schemaPolicy) : inferredSchema;
+}
+function validateAndCloneOutputSchema(outputSchema, sources, inferredSchema, schemaPolicy) {
+  const outputFields = /* @__PURE__ */ new Map();
+  for (const field of outputSchema.fields) {
+    if (!field.name || outputFields.has(field.name)) {
+      throw new Error(`Federated output schema contains an invalid or duplicate field: ${field.name}`);
+    }
+    outputFields.set(field.name, field);
+  }
+  const inferredNames = new Set(inferredSchema.fields.map((field) => field.name));
+  const missingFromContract = [...inferredNames].filter((name) => !outputFields.has(name));
+  const absentFromSources = outputSchema.fields.map((field) => field.name).filter((name) => !inferredNames.has(name));
+  if (missingFromContract.length || schemaPolicy === "strict" && absentFromSources.length) {
+    throw new Error(`Federated output schema mismatch: missing [${missingFromContract.join(", ")}], absent [${absentFromSources.join(", ")}]`);
+  }
+  for (const outputField of outputSchema.fields) {
+    const presentFields = sources.flatMap((source) => source.fields.filter((field) => field.outputName === outputField.name).map((field) => ({ sourceId: source.entry.dataSourceId, field: field.field })));
+    if (!presentFields.length) {
+      if (!outputField.nullable) {
+        throw new Error(`Federated output field is absent from every source and must be nullable: ${outputField.name}`);
+      }
+      continue;
+    }
+    for (const presentField of presentFields) {
+      if (presentField.field.nullable && !outputField.nullable) {
+        throw new Error(`Federated output field cannot remove nullability for ${outputField.name} in ${presentField.sourceId}`);
+      }
+      if (!isLosslessDataTypeCast(presentField.field.type, outputField.type)) {
+        throw new Error(`Unsupported federated normalization for ${outputField.name}: ${formatDataType(presentField.field.type)} to ${formatDataType(outputField.type)} in ${presentField.sourceId}`);
+      }
+    }
+    if (presentFields.length < sources.length && !outputField.nullable) {
+      throw new Error(`Federated union field must be nullable when absent from a source: ${outputField.name}`);
+    }
+  }
+  return cloneSchema(outputSchema);
+}
+function createSourceReadOptions(source, requiredOutputColumns, remaining, options, onTelemetry) {
+  var _a, _b;
+  const sourceResidualPredicate = getSourceResidualPredicate(source);
+  const requiredSourceColumns = requiredOutputColumns.map((outputName) => source.sourceNameByOutputName.get(outputName)).filter((sourceName) => Boolean(sourceName));
+  if (sourceResidualPredicate) {
+    requiredSourceColumns.push(...getColumnarPredicateColumns(sourceResidualPredicate));
+  }
+  if (!requiredSourceColumns.length) {
+    requiredSourceColumns.push(source.fields[0].sourceName);
+  }
+  const sourceLimit = (_a = source.entry.query) == null ? void 0 : _a.limit;
+  const globalLimitCanBePushed = options.predicate === void 0 && Number.isFinite(remaining);
+  const limit = globalLimitCanBePushed ? Math.min(sourceLimit ?? Number.POSITIVE_INFINITY, remaining) : sourceLimit;
+  return {
+    ...source.entry.query,
+    columns: Object.freeze([...new Set(requiredSourceColumns)]),
+    predicate: sourceResidualPredicate ? void 0 : (_b = source.entry.query) == null ? void 0 : _b.predicate,
+    limit: sourceResidualPredicate ? void 0 : Number.isFinite(limit) ? limit : void 0,
+    signal: options.signal,
+    onTelemetry
+  };
+}
+function getSourceResidualPredicate(source) {
+  var _a, _b;
+  return ((_a = source.metadata.capabilities.table) == null ? void 0 : _a.predicate) === "unsupported" ? (_b = source.entry.query) == null ? void 0 : _b.predicate : void 0;
+}
+function createCanonicalArrowTable(schema, source, physicalTable) {
+  const arrowSchema = convertSchemaToArrow(schema);
+  const columns = {};
+  for (const field of arrowSchema.fields) {
+    const sourceName = source.sourceNameByOutputName.get(field.name);
+    const vector = sourceName ? physicalTable.data.getChild(sourceName) : null;
+    const mappedField = source.fields.find((sourceField) => sourceField.outputName === field.name);
+    columns[field.name] = vector ? mappedField && !areDataTypesEqual(mappedField.field.type, schema.fields.find((schemaField) => schemaField.name === field.name).type) ? arrow7.vectorFromArray(Array.from(vector), field.type) : vector : arrow7.vectorFromArray(Array.from({ length: physicalTable.data.numRows }, () => null), field.type);
+  }
+  return {
+    shape: "arrow-table",
+    schema,
+    data: new arrow7.Table(arrowSchema, columns)
+  };
+}
+function createSourceTelemetry(options) {
+  var _a;
+  const { resolvedSource, childTelemetry } = options;
+  const status = (childTelemetry == null ? void 0 : childTelemetry.status) || (((_a = options.signal) == null ? void 0 : _a.aborted) ? "cancelled" : options.sourceError ? "failed" : options.sourceCompleted ? "completed" : "early-terminated");
+  const details = childTelemetry ? Object.freeze(Object.fromEntries(Object.entries(childTelemetry).filter(([key]) => ![
+    "status",
+    "sourcesPlanned",
+    "sourcesRead",
+    "batchesRead",
+    "batchesDecoded",
+    "rowsRead",
+    "rowsTested",
+    "rowsRetained",
+    "rowsReturned",
+    "bytesRead",
+    "bytesFetched",
+    "filesOpened",
+    "tasksOpened",
+    "rowsPruned",
+    "durationMilliseconds",
+    "sources",
+    "details",
+    "error"
+  ].includes(key)))) : void 0;
+  return Object.freeze({
+    sourceId: resolvedSource.entry.dataSourceId,
+    sourceType: resolvedSource.metadata.sourceType,
+    sourceIndex: resolvedSource.sourceIndex,
+    status,
+    filesOpened: childTelemetry == null ? void 0 : childTelemetry.filesOpened,
+    tasksOpened: childTelemetry == null ? void 0 : childTelemetry.tasksOpened,
+    bytesFetched: (childTelemetry == null ? void 0 : childTelemetry.bytesFetched) ?? (childTelemetry == null ? void 0 : childTelemetry.bytesRead),
+    batchesDecoded: (childTelemetry == null ? void 0 : childTelemetry.batchesDecoded) ?? options.batchesDecoded,
+    rowsRead: (childTelemetry == null ? void 0 : childTelemetry.rowsRead) ?? options.rowsRead,
+    rowsTested: (childTelemetry == null ? void 0 : childTelemetry.rowsTested) || options.rowsTested || void 0,
+    rowsRetained: (childTelemetry == null ? void 0 : childTelemetry.rowsRetained) || options.rowsRetained || void 0,
+    rowsReturned: options.rowsReturned,
+    rowsPruned: childTelemetry == null ? void 0 : childTelemetry.rowsPruned,
+    durationMilliseconds: Date.now() - options.sourceStartedAt,
+    details: (childTelemetry == null ? void 0 : childTelemetry.details) ?? (details && Object.keys(details).length ? details : void 0),
+    error: (childTelemetry == null ? void 0 : childTelemetry.error) ?? options.sourceError
+  });
+}
+function getFederatedStatistics(sources) {
+  if (sources.some((source) => {
+    var _a, _b, _c;
+    return ((_a = source.entry.query) == null ? void 0 : _a.predicate) || ((_b = source.entry.query) == null ? void 0 : _b.limit) !== void 0 || ((_c = source.metadata.statistics) == null ? void 0 : _c.rowCount) === void 0;
+  })) {
+    return void 0;
+  }
+  const counts = sources.map((source) => source.metadata.statistics.rowCount);
+  return {
+    rowCount: counts.some((count) => typeof count === "bigint") ? counts.reduce((sum, count) => sum + BigInt(count), 0n) : counts.reduce((sum, count) => sum + Number(count), 0)
+  };
+}
+function createSourceExplanation(source, outputSchema) {
+  const normalizedTypes = Object.fromEntries(source.fields.filter((field) => {
+    const outputField = outputSchema.fields.find((schemaField) => schemaField.name === field.outputName);
+    return outputField && !areDataTypesEqual(outputField.type, field.field.type);
+  }).map((field) => [
+    field.outputName,
+    outputSchema.fields.find((schemaField) => schemaField.name === field.outputName).type
+  ]));
+  return Object.freeze({
+    sourceId: source.entry.dataSourceId,
+    sourceIndex: source.sourceIndex,
+    sourceType: source.metadata.sourceType,
+    sourceColumns: Object.freeze(source.fields.map((field) => field.sourceName)),
+    outputColumns: Object.freeze(source.fields.map((field) => field.outputName)),
+    columnMapping: Object.freeze({ ...source.entry.columnMapping }),
+    normalizedTypes: Object.freeze(normalizedTypes)
+  });
+}
+function isLosslessDataTypeCast(sourceType, outputType) {
+  if (areDataTypesEqual(sourceType, outputType) || sourceType === "null")
+    return true;
+  if (typeof sourceType === "object" && sourceType.type === "dictionary") {
+    return isLosslessDataTypeCast(sourceType.dictionary, outputType);
+  }
+  if (sourceType === "utf8-view" && outputType === "utf8")
+    return true;
+  if (sourceType === "binary-view" && outputType === "binary")
+    return true;
+  const sourceInteger = getIntegerType(sourceType);
+  const outputInteger = getIntegerType(outputType);
+  if (sourceInteger && outputInteger) {
+    return sourceInteger.signed === outputInteger.signed && sourceInteger.bits <= outputInteger.bits || !sourceInteger.signed && outputInteger.signed && sourceInteger.bits < outputInteger.bits;
+  }
+  const sourceFloatBits = getFloatBits(sourceType);
+  const outputFloatBits = getFloatBits(outputType);
+  if (sourceFloatBits && outputFloatBits)
+    return sourceFloatBits <= outputFloatBits;
+  return Boolean(sourceInteger && sourceInteger.bits <= 32 && outputFloatBits === 64);
+}
+function getIntegerType(dataType) {
+  const types = {
+    int: { signed: true, bits: 32 },
+    int8: { signed: true, bits: 8 },
+    int16: { signed: true, bits: 16 },
+    int32: { signed: true, bits: 32 },
+    int64: { signed: true, bits: 64 },
+    uint8: { signed: false, bits: 8 },
+    uint16: { signed: false, bits: 16 },
+    uint32: { signed: false, bits: 32 },
+    uint64: { signed: false, bits: 64 }
+  };
+  return typeof dataType === "string" ? types[dataType] || null : null;
+}
+function getFloatBits(dataType) {
+  const types = { float: 32, float16: 16, float32: 32, float64: 64 };
+  return typeof dataType === "string" ? types[dataType] || null : null;
+}
+function cloneSchema(schema) {
+  return convertArrowToSchema(convertSchemaToArrow(schema));
+}
+function areDataTypesEqual(left, right) {
+  return formatDataType(left) === formatDataType(right);
+}
+function formatDataType(dataType) {
+  return typeof dataType === "string" ? dataType : JSON.stringify(canonicalizeValue(dataType));
+}
+function canonicalizeValue(value) {
+  if (ArrayBuffer.isView(value)) {
+    return Array.from(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(canonicalizeValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, child]) => [key, canonicalizeValue(child)]));
+  }
+  return value;
+}
+function resolveManagedSource(dataSourceManager, dataSourceId, consumerId, requestId, signal) {
+  let resolveDeferredSource;
+  let rejectDeferredSource;
+  const deferredSource = new Promise((resolve, reject) => {
+    resolveDeferredSource = resolve;
+    rejectDeferredSource = reject;
+  });
+  let sourceGeneration = 0;
+  const acceptSource = (source) => {
+    const generation = ++sourceGeneration;
+    if (source) {
+      void Promise.resolve(source).then((result) => {
+        if (generation === sourceGeneration)
+          resolveDeferredSource(result);
+      }, (error) => {
+        if (generation === sourceGeneration)
+          rejectDeferredSource(error);
+      });
+    }
+  };
+  const managedSource = dataSourceManager.subscribe({
+    dataSourceId,
+    consumerId,
+    requestId,
+    onChange: acceptSource
+  });
+  if (managedSource === void 0) {
+    throw new Error(`Federated table source is not registered: ${dataSourceId}`);
+  }
+  acceptSource(managedSource || null);
+  return waitForPromise(deferredSource, signal);
+}
+async function waitForPromise(promise, signal) {
+  if (!signal)
+    return await promise;
+  throwIfAborted2(signal);
+  return await new Promise((resolve, reject) => {
+    const abort = () => reject(getAbortReason(signal));
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+function throwIfAborted2(signal) {
+  if (signal == null ? void 0 : signal.aborted)
+    throw getAbortReason(signal);
+}
+function getAbortReason(signal) {
+  return signal.reason || new DOMException("Request aborted", "AbortError");
+}
+
+// dist/vector-table-scan-source.js
+var AddressedVectorTableScanSource = class {
+  /** Stable adapter type reported by `getQueryMetadata()`. */
+  sourceType;
+  /** Optional display name shown by query controls. */
+  name;
+  /** Human-readable description of the bound physical selection. */
+  description;
+  /** Spatial extent of the bound physical selection. */
+  spatial;
+  tablePromise = null;
+  /** Creates a table-scan view over one immutable physical selection. */
+  constructor(options, defaults) {
+    this.sourceType = options.sourceType || defaults.sourceType;
+    this.name = options.name;
+    this.description = options.description || defaults.description;
+    this.spatial = defaults.spatial;
+  }
+  /** Discovers the addressed result schema and portable residual-query capabilities. */
+  async getQueryMetadata(options = {}) {
+    const table = await this.getTable(options.signal);
+    const schema = table.schema || convertArrowToSchema(table.data.schema);
+    return createScanQueryMetadata({
+      sourceType: this.sourceType,
+      queryType: "table",
+      execution: { status: "supported", method: "read" },
+      name: this.name,
+      description: this.description,
+      schema,
+      capabilities: {
+        table: ARROW_TABLE_QUERY_CAPABILITIES,
+        bounds: "unsupported",
+        levelOfDetail: "unsupported"
+      },
+      columnRoles: inferVectorColumnRoles(schema.fields.map((field) => field.name)),
+      spatial: this.spatial,
+      statistics: { rowCount: table.data.numRows }
+    });
+  }
+  /** Applies the portable Arrow query to the addressed feature table. */
+  async query(options = {}) {
+    const table = await this.getTable(options.signal);
+    return queryArrowTable(table, options);
+  }
+  /** Explains the residual Arrow plan after resolving the addressed feature table. */
+  async explain(options = {}) {
+    const table = await this.getTable(options.signal);
+    return explainArrowTableQuery(table, options);
+  }
+  /** Emits the portable query result as one bounded Arrow batch. */
+  async *read(options = {}) {
+    const result = await this.query(options);
+    yield makeTableScanBatch(result);
+  }
+  /** Resolves and caches the addressed table while allowing failed loads to be retried. */
+  async getTable(signal) {
+    throwIfAborted3(signal);
+    if (!this.tablePromise) {
+      this.tablePromise = this.loadTable().then((table) => {
+        if (!table) {
+          throw new Error("The addressed vector selection did not return a feature table.");
+        }
+        if (table.shape !== "arrow-table") {
+          throw new Error('The addressed vector selection must return an Arrow table. Configure the source with shape "arrow-table".');
+        }
+        return table;
+      }).catch((error) => {
+        this.tablePromise = null;
+        throw error;
+      });
+    }
+    return await waitForPromise2(this.tablePromise, signal);
+  }
+};
+var VectorTileTableScanSource = class extends AddressedVectorTableScanSource {
+  /** Specialized tile source that owns tile addressing and decoding. */
+  source;
+  /** Immutable tile address bound to this table view. */
+  tile;
+  /** Creates a portable table view over one vector tile. */
+  constructor(source, options) {
+    const tile = Object.freeze({
+      ...options.tile,
+      layers: cloneAndFreezeLayers(options.tile.layers)
+    });
+    super(options, {
+      sourceType: "vector-tile-table",
+      description: `Vector tile ${tile.z}/${tile.x}/${tile.y}`,
+      spatial: {
+        bounds: getWGS84TileBounds(tile),
+        coordinateReferenceSystems: ["EPSG:4326"]
+      }
+    });
+    this.source = source;
+    this.tile = tile;
+  }
+  /** Loads the bound vector tile using the source's requested Arrow output shape. */
+  loadTable(signal) {
+    return this.source.getVectorTile({ ...this.tile, signal });
+  }
+};
+var VectorFeatureTableScanSource = class extends AddressedVectorTableScanSource {
+  /** Specialized vector source that owns service request construction and parsing. */
+  source;
+  /** Immutable bounded feature request bound to this table view. */
+  request;
+  /** Creates a portable table view over one bounded vector-service request. */
+  constructor(source, options) {
+    const request = Object.freeze({
+      ...options.request,
+      layers: cloneAndFreezeLayers(options.request.layers),
+      boundingBox: Object.freeze([
+        Object.freeze([...options.request.boundingBox[0]]),
+        Object.freeze([...options.request.boundingBox[1]])
+      ])
+    });
+    const coordinateReferenceSystems = typeof request.crs === "string" ? [request.crs] : void 0;
+    super(options, {
+      sourceType: "vector-feature-table",
+      description: `Vector feature request for ${normalizeLayers(request.layers).join(", ")}`,
+      spatial: {
+        bounds: {
+          minimum: Object.freeze([...request.boundingBox[0]]),
+          maximum: Object.freeze([...request.boundingBox[1]])
+        },
+        coordinateReferenceSystems
+      }
+    });
+    this.source = source;
+    this.request = request;
+  }
+  /** Loads the bound service request through the source's Arrow feature output. */
+  loadTable(signal) {
+    return this.source.getFeatures({
+      ...this.request,
+      format: "arrow",
+      signal
+    });
+  }
+};
+function getWGS84TileBounds(tile) {
+  const scale = 2 ** tile.z;
+  return {
+    minimum: [tile.x / scale * 360 - 180, tileYToLatitude(tile.y + 1, scale)],
+    maximum: [(tile.x + 1) / scale * 360 - 180, tileYToLatitude(tile.y, scale)]
+  };
+}
+function tileYToLatitude(tileY, scale) {
+  return Math.atan(Math.sinh(Math.PI * (1 - 2 * tileY / scale))) * 180 / Math.PI;
+}
+function inferVectorColumnRoles(columnNames) {
+  return Object.fromEntries(columnNames.map((columnName) => [
+    columnName,
+    columnName.toLowerCase() === "geometry" ? "geometry" : "attribute"
+  ]));
+}
+function normalizeLayers(layers) {
+  return Array.isArray(layers) ? layers : [layers];
+}
+function cloneAndFreezeLayers(layers) {
+  return Array.isArray(layers) ? Object.freeze([...layers]) : layers;
+}
+async function waitForPromise2(promise, signal) {
+  if (!signal) {
+    return await promise;
+  }
+  throwIfAborted3(signal);
+  return await new Promise((resolve, reject) => {
+    const abort = () => reject(getAbortReason2(signal));
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+function throwIfAborted3(signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    throw getAbortReason2(signal);
+  }
+}
+function getAbortReason2(signal) {
+  return signal.reason || new DOMException("Request aborted", "AbortError");
+}
+//# sourceMappingURL=index.cjs.map