lakeql 0.1.0

package/dist/index.js

@@ -0,0 +1 @@
+export { AggregationBuilder, CacheApiCache, ERROR_CODES, IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, LaQLError, Lake, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, ObjectStoreIcebergCommitCatalog, PACKAGE, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, advanceTaskCheckpoint, and, applyIcebergDeletes, assertBookmarkMatches, asyncBufferFromStore, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, classifyPredicate, col, createBookmark, createParquetLake as createLake, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, encodeJsonLine, eq, evaluate, fingerprint, fn, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, isIn, isLaQLError, isNotNull, isNull, jsonSafeValue, like, lit, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planFiles, planRowGroups, planRowGroupsFromMetadata, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, rowGroupMayMatch, scanBatches, scanPlannedIcebergRows, scanRows, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, signPaginationToken, stableStringify, throwIfAborted, transitionTaskCheckpoint, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './chunk-VRJ72DGA.js';

package/dist/node.d.ts

@@ -0,0 +1,27 @@
+import { ObjectInfo, ObjectStore, ConditionalObjectStore } from './index.js';
+export { AggregateExpr, AggregateGroupSnapshot, AggregateOp, AggregateOperatorState, AggregateOptions, AggregateResult, AggregateSnapshotValue, AggregateSpec, AggregateStateSnapshot, AggregationBuilder, ApplyIcebergDeletesOptions, BBoxIndex, BetweenExpr, Bookmark, BookmarkInit, BookmarkPosition, BookmarkQuery, BroadcastJoinOptions, CacheAdapter, CacheApiCache, CacheApiCacheOptions, CacheEntry, CallExpr, CheckpointAdapter, CheckpointStore, Clock, ColumnExpr, ColumnInput, CompareExpr, CompareOp, ConditionalPutOptions, CreateParquetTableAsOptions, CreateParquetTableAsQuery, CreateParquetTableAsResult, CsvStreamOptions, DecodedIcebergDeletes, DecodedIcebergParquetDeletes, ERROR_CODES, EngineFilePlan, EngineTable, ErrorDetails, ExplainJson, ExplainResult, Expr, IcebergAppendFile, IcebergAppendOptions, IcebergAppendOutputManifestOptions, IcebergAppendResult, IcebergCatalog, IcebergCommitCatalog, IcebergCommitInput, IcebergCommitResult, IcebergDeleteFile, IcebergDeletionVector, IcebergEnginePlan, IcebergEngineTable, IcebergEqualityDelete, IcebergField, IcebergGlueCatalogOptions, IcebergNessieCatalogOptions, IcebergParquetDeleteFile, IcebergParquetDeleteFileContent, IcebergPartitionField, IcebergPartitionSpec, IcebergPlan, IcebergPositionDelete, IcebergReadMode, IcebergRestCatalog, IcebergRestCatalogOptions, IcebergRowBatch, IcebergSortOrder, IcebergTable, IcebergTableIdentifier, IcebergUnsupportedCatalog, IdGenerator, InExpr, IndexPruneResult, IndexValue, InsertValidationRules, JoinType, JsonExpr, JsonOrderByTerm, JsonQueryV1, LaQLError, LaQLErrorCode, Lake, LakeConfig, LikeExpr, ListOptions, LiteralExpr, LoadIcebergEngineTableOptions, LoadIcebergTableFromObjectStoreOptions, LoadIcebergTableFromRestOptions, LoadIcebergTableOptions, LoadParquetEngineTableOptions, LoadTableOptions, LockAdapter, LogHook, LogicalExpr, LookupJoinFunction, LookupJoinOptions, Manifest, ManifestDeleteFile, ManifestFile, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, MemorySpillAdapterOptions, MetadataFile, MetricsHook, MinMaxColumnIndex, NotExpr, NullCheckExpr, ObjectHead, ObjectStoreIcebergCommitCatalog, ObjectStoreReadControls, OperatorSnapshotValue, OrderByTerm, OutputManifest, OutputManifestEntry, PACKAGE, ParquetEnginePlan, ParquetEngineTable, ParquetLakeConfig, ParquetMetadata, ParquetRowBatch, ParquetRowGroupPlan, ParquetScanAdapter, PartitionedParquetOutputEntryOptions, PathQueryInit, PlanIcebergFilesOptions, PlanParquetRowGroupsOptions, PlannedIcebergFile, PlannedParquetRowGroup, PredicatePlan, PredicatePlanOptions, ProjectIcebergRowOptions, PutOptions, QueryBudget, QueryBuilder, QueryPolicy, QueryPolicyContext, QueryResult, QueryRunOptions, QueryStats, QueueAdapter, ReadParquetBatchOptions, ReadParquetOptions, ResumableBatchOptions, ResumedQuery, Row, RuntimeSubstrate, Scalar, ScanAdapter, ScanBatch, ScanEngineOptions, ScanOptions, ScanPlannedIcebergRowsOptions, ScanTaskPlan, ScanTaskPlanOptions, SidecarFileIndex, SliceOptions, SliceResult, Snapshot, SortOperatorState, SortOptions, SortResult, SortRunState, SpillAdapter, SpillRef, SpillUsage, SqlBoolean, TaskCheckpoint, TaskInput, TaskManifest, TaskManifestTask, TaskState, TaskTransitionInput, TopKOperatorState, TopKOptions, TopKResult, ValueInput, WriteParquetOptions, WriteParquetRowsOptions, WritePartitionedParquetFile, WritePartitionedParquetResult, WritePartitionedParquetTaskOptions, WritePartitionedParquetTaskResult, advanceTaskCheckpoint, and, applyIcebergDeletes, assertBookmarkMatches, asyncBufferFromStore, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, classifyPredicate, col, createBookmark, createLake, createOutputManifest, createOutputManifestFromCheckpoints, createLake as createParquetLake, createParquetTableAs, createTaskManifest, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, encodeJsonLine, eq, evaluate, fingerprint, fn, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, isIn, isLaQLError, isNotNull, isNull, jsonSafeValue, like, lit, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planFiles, planRowGroups, planRowGroupsFromMetadata, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, rowGroupMayMatch, scanBatches, scanPlannedIcebergRows, scanRows, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, signPaginationToken, stableStringify, throwIfAborted, transitionTaskCheckpoint, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './index.js';
+import 'hyparquet/src/types.js';
+import 'hyparquet';
+import 'hyparquet-writer';
+
+interface HttpStoreOptions {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: HeadersInit;
+    objects?: ObjectInfo[];
+}
+declare function httpStore(options: HttpStoreOptions): ObjectStore;
+
+interface S3StoreOptions {
+    endpoint: string;
+    bucket: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    fetch?: typeof fetch;
+    now?: () => Date;
+}
+declare function s3Store(options: S3StoreOptions): ConditionalObjectStore;
+
+export { ConditionalObjectStore, ObjectInfo, ObjectStore, httpStore, s3Store };

package/dist/node.js

@@ -0,0 +1,422 @@
+import { LaQLError } from './chunk-VRJ72DGA.js';
+export { AggregationBuilder, CacheApiCache, ERROR_CODES, IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, LaQLError, Lake, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, ObjectStoreIcebergCommitCatalog, PACKAGE, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, advanceTaskCheckpoint, and, applyIcebergDeletes, assertBookmarkMatches, asyncBufferFromStore, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, classifyPredicate, col, createBookmark, createParquetLake as createLake, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, encodeJsonLine, eq, evaluate, fingerprint, fn, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, isIn, isLaQLError, isNotNull, isNull, jsonSafeValue, like, lit, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planFiles, planRowGroups, planRowGroupsFromMetadata, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, rowGroupMayMatch, scanBatches, scanPlannedIcebergRows, scanRows, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, signPaginationToken, stableStringify, throwIfAborted, transitionTaskCheckpoint, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './chunk-VRJ72DGA.js';
+import { AwsClient } from 'aws4fetch';
+import { XMLParser } from 'fast-xml-parser';
+
+// ../http/dist/index.js
+function httpStore(options) {
+  return new HttpObjectStore(options);
+}
+var HttpObjectStore = class {
+  baseUrl;
+  fetchImpl;
+  headers;
+  objects;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.endsWith("/") ? options.baseUrl : `${options.baseUrl}/`;
+    this.fetchImpl = options.fetch ?? fetch.bind(globalThis);
+    this.headers = options.headers;
+    this.objects = options.objects;
+  }
+  async get(path) {
+    const response = await this.fetchPath(path, { method: "GET" });
+    if (response.status === 404)
+      return null;
+    assertOk(response, path);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  async getRange(path, range) {
+    if (range.offset < 0 || range.length < 0) {
+      throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `Invalid range for ${path}`, { path, range });
+    }
+    const response = await this.fetchPath(path, {
+      method: "GET",
+      headers: { Range: `bytes=${range.offset}-${range.offset + range.length - 1}` }
+    });
+    assertOk(response, path);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (response.status !== 206 && bytes.length > range.length) {
+      return bytes.subarray(range.offset, range.offset + range.length);
+    }
+    return bytes;
+  }
+  async put(path, body, options) {
+    const headers = new Headers(this.headers);
+    if (options?.contentType)
+      headers.set("content-type", options.contentType);
+    const response = await this.fetchPath(path, { method: "PUT", headers, body: bodyInit(body) });
+    assertOk(response, path);
+  }
+  async delete(path) {
+    const response = await this.fetchPath(path, { method: "DELETE" });
+    assertOk(response, path);
+  }
+  async *list(prefix, options) {
+    if (!this.objects) {
+      throw new LaQLError("LAQL_UNSUPPORTED_PUSHDOWN", "HTTP store list requires an object index", {
+        prefix
+      });
+    }
+    let emitted = 0;
+    for (const object of this.objects.filter((candidate) => candidate.path.startsWith(prefix)).sort((a, b) => a.path.localeCompare(b.path))) {
+      if (options?.limit !== void 0 && emitted >= options.limit)
+        return;
+      yield object;
+      emitted += 1;
+    }
+  }
+  async head(path) {
+    const response = await this.fetchPath(path, {
+      method: "GET",
+      headers: { Range: "bytes=0-0" }
+    });
+    if (response.status === 404)
+      return null;
+    assertOk(response, path);
+    await response.arrayBuffer().catch(() => void 0);
+    const total = parseContentRangeTotal(response.headers.get("content-range"));
+    const contentLength = response.headers.get("content-length");
+    const size = total ?? (contentLength ? Number(contentLength) : Number.NaN);
+    if (!Number.isFinite(size)) {
+      throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `Missing size for ${path}`, { path });
+    }
+    const head = { size };
+    const etag = response.headers.get("etag");
+    const lastModified = response.headers.get("last-modified");
+    const contentType = response.headers.get("content-type");
+    if (etag !== null)
+      head.etag = etag;
+    if (lastModified !== null)
+      head.lastModified = new Date(lastModified);
+    if (contentType !== null)
+      head.contentType = contentType;
+    return head;
+  }
+  fetchPath(path, init) {
+    const headers = new Headers(this.headers);
+    if (init.headers) {
+      for (const [key, value] of new Headers(init.headers))
+        headers.set(key, value);
+    }
+    return this.fetchImpl(this.urlForPath(path), { ...init, headers });
+  }
+  urlForPath(path) {
+    const base = new URL(this.baseUrl);
+    const url = new URL(encodeObjectPath(path), base);
+    if (url.origin !== base.origin || !url.pathname.startsWith(base.pathname)) {
+      throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path escapes HTTP base URL: ${path}`, {
+        path,
+        baseUrl: this.baseUrl
+      });
+    }
+    return url;
+  }
+};
+function encodeObjectPath(path) {
+  if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//iu.test(path) || path.startsWith("/")) {
+    throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path must be relative: ${path}`, {
+      path
+    });
+  }
+  if (path === "")
+    return "";
+  return path.split("/").map((segment) => {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path has invalid encoding: ${path}`, {
+        path
+      });
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path contains traversal: ${path}`, {
+        path
+      });
+    }
+    return encodeURIComponent(segment);
+  }).join("/");
+}
+function parseContentRangeTotal(header) {
+  if (!header)
+    return void 0;
+  const match = /\/(\d+)\s*$/.exec(header);
+  if (!match)
+    return void 0;
+  const total = Number(match[1]);
+  return Number.isFinite(total) ? total : void 0;
+}
+function assertOk(response, path) {
+  if (response.ok || response.status === 206)
+    return;
+  if (response.status === 404) {
+    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `No object at ${path}`, { path });
+  }
+  throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `HTTP object request failed for ${path}`, {
+    path,
+    status: response.status
+  });
+}
+function bodyInit(body) {
+  if (body instanceof Uint8Array) {
+    const copy = new Uint8Array(body.byteLength);
+    copy.set(body);
+    return copy.buffer;
+  }
+  return body;
+}
+function s3Store(options) {
+  return new S3ObjectStore(options);
+}
+var S3ObjectStore = class {
+  options;
+  fetchImpl;
+  now;
+  aws;
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    const awsOptions = {
+      accessKeyId: options.accessKeyId,
+      secretAccessKey: options.secretAccessKey,
+      region: options.region,
+      service: "s3",
+      retries: 0
+    };
+    if (options.sessionToken !== void 0)
+      awsOptions.sessionToken = options.sessionToken;
+    this.aws = new AwsClient(awsOptions);
+  }
+  async get(path) {
+    const response = await this.request("GET", path);
+    if (response.status === 404)
+      return null;
+    assertOk2(response, path);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  async getRange(path, range) {
+    const response = await this.request("GET", path, {
+      Range: `bytes=${range.offset}-${range.offset + range.length - 1}`
+    });
+    assertOk2(response, path);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  async put(path, body, options) {
+    const headers = {};
+    if (options?.contentType)
+      headers["content-type"] = options.contentType;
+    const response = await this.request("PUT", path, headers, body);
+    assertOk2(response, path);
+  }
+  async conditionalPut(path, body, options) {
+    const headers = {};
+    if (options.contentType)
+      headers["content-type"] = options.contentType;
+    if (options.expectedEtag === null)
+      headers["if-none-match"] = "*";
+    else
+      headers["if-match"] = options.expectedEtag;
+    const response = await this.request("PUT", path, headers, body);
+    if (response.status === 409 || response.status === 412)
+      return false;
+    assertOk2(response, path);
+    return true;
+  }
+  async delete(path) {
+    const response = await this.request("DELETE", path);
+    assertOk2(response, path);
+  }
+  async *list(prefix, options) {
+    let continuationToken;
+    let emitted = 0;
+    do {
+      const query = new URLSearchParams({ "list-type": "2", prefix });
+      if (options?.limit !== void 0)
+        query.set("max-keys", String(options.limit - emitted));
+      if (options?.delimiter !== void 0)
+        query.set("delimiter", options.delimiter);
+      if (continuationToken !== void 0)
+        query.set("continuation-token", continuationToken);
+      const response = await this.request("GET", "", {}, void 0, query);
+      assertOk2(response, prefix);
+      const result = parseListObjectsV2(await response.text());
+      for (const object of result.objects) {
+        if (options?.limit !== void 0 && emitted >= options.limit)
+          return;
+        yield object;
+        emitted += 1;
+      }
+      continuationToken = result.nextContinuationToken;
+    } while (continuationToken !== void 0 && (options?.limit === void 0 || emitted < options.limit));
+  }
+  async head(path) {
+    const response = await this.request("HEAD", path);
+    if (response.status === 404)
+      return null;
+    assertOk2(response, path);
+    const contentLength = response.headers.get("content-length");
+    if (contentLength === null) {
+      throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `Missing S3 content-length for ${path}`, {
+        path
+      });
+    }
+    const head = { size: Number(contentLength) };
+    const etag = response.headers.get("etag");
+    const contentType = response.headers.get("content-type");
+    const lastModified = response.headers.get("last-modified");
+    if (etag !== null)
+      head.etag = etag;
+    if (contentType !== null)
+      head.contentType = contentType;
+    if (lastModified !== null)
+      head.lastModified = new Date(lastModified);
+    return head;
+  }
+  async request(method, path, headers = {}, body, query = new URLSearchParams()) {
+    const url = new URL(`${encodeURIComponent(this.options.bucket)}/${encodeObjectPath2(path)}`, ensureSlash(this.options.endpoint));
+    url.search = query.toString();
+    const signRequest = {
+      method,
+      url,
+      headers,
+      region: this.options.region,
+      accessKeyId: this.options.accessKeyId,
+      secretAccessKey: this.options.secretAccessKey,
+      now: this.now()
+    };
+    if (this.options.sessionToken !== void 0)
+      signRequest.sessionToken = this.options.sessionToken;
+    const requestBody = body === void 0 ? void 0 : bodyInit2(body);
+    const signed = await signS3Request(signRequest, this.aws, requestBody);
+    const init = { method, headers: signed };
+    if (requestBody !== void 0)
+      init.body = requestBody;
+    return this.fetchImpl(url, init);
+  }
+};
+async function signS3Request(request, client = s3SignerClient(request), body) {
+  const headers = new Headers(request.headers);
+  if (!headers.has("x-amz-content-sha256")) {
+    headers.set("x-amz-content-sha256", "UNSIGNED-PAYLOAD");
+  }
+  const init = {
+    method: request.method,
+    headers,
+    aws: {
+      datetime: timestamp(request.now)
+    }
+  };
+  if (body !== void 0)
+    init.body = body;
+  const signed = await client.sign(request.url, init);
+  return signed.headers;
+}
+function s3SignerClient(request) {
+  const options = {
+    accessKeyId: request.accessKeyId,
+    secretAccessKey: request.secretAccessKey,
+    region: request.region,
+    service: "s3",
+    retries: 0
+  };
+  if (request.sessionToken !== void 0)
+    options.sessionToken = request.sessionToken;
+  return new AwsClient(options);
+}
+var listObjectsParser = new XMLParser({
+  ignoreAttributes: true,
+  parseTagValue: false,
+  trimValues: true
+});
+function parseListObjectsV2(xml) {
+  const parsed = listObjectsParser.parse(xml);
+  const result = parsed.ListBucketResult ?? {};
+  const objects = [];
+  for (const content of arrayOf(result.Contents)) {
+    const key = stringValue(content.Key);
+    const size = Number(stringValue(content.Size));
+    if (!key || !Number.isFinite(size))
+      continue;
+    const info = { path: key, size };
+    const etag = stringValue(content.ETag);
+    const lastModified = stringValue(content.LastModified);
+    if (etag)
+      info.etag = etag;
+    if (lastModified)
+      info.lastModified = new Date(lastModified);
+    objects.push(info);
+  }
+  const nextContinuationToken = isTrue(result.IsTruncated) ? stringValue(result.NextContinuationToken) : "";
+  return {
+    objects,
+    ...nextContinuationToken ? { nextContinuationToken } : {}
+  };
+}
+function arrayOf(value) {
+  if (value === void 0 || value === null)
+    return [];
+  return Array.isArray(value) ? value : [value];
+}
+function stringValue(value) {
+  if (value === void 0 || value === null)
+    return "";
+  return String(value);
+}
+function isTrue(value) {
+  return value === true || String(value).toLowerCase() === "true";
+}
+function ensureSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function encodeObjectPath2(path) {
+  if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//iu.test(path) || path.startsWith("/")) {
+    throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path must be relative: ${path}`, {
+      path
+    });
+  }
+  if (path === "")
+    return "";
+  return path.split("/").map((segment) => {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path has invalid encoding: ${path}`, {
+        path
+      });
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new LaQLError("LAQL_VALIDATION_ERROR", `Object path contains traversal: ${path}`, {
+        path
+      });
+    }
+    return encodeURIComponent(segment);
+  }).join("/");
+}
+function assertOk2(response, path) {
+  if (response.ok || response.status === 206)
+    return;
+  if (response.status === 404) {
+    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `No object at ${path}`, { path });
+  }
+  throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `S3 request failed for ${path}`, {
+    path,
+    status: response.status
+  });
+}
+function timestamp(date) {
+  return date.toISOString().replace(/[:-]|\.\d{3}/gu, "");
+}
+function bodyInit2(body) {
+  if (body instanceof Uint8Array)
+    return arrayBuffer(body);
+  return body;
+}
+function arrayBuffer(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+
+export { httpStore, s3Store };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "lakeql",
+  "version": "0.1.0",
+  "description": "LaQL: lightweight TypeScript query engine for Iceberg + Parquet on object storage",
+  "keywords": [
+    "lakehouse",
+    "parquet",
+    "iceberg",
+    "query-engine",
+    "object-storage"
+  ],
+  "author": "Erik Aronesty",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./cloudflare": {
+      "types": "./dist/cloudflare.d.ts",
+      "default": "./dist/cloudflare.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepack": "pnpm -w build && pnpm --filter lakeql build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/earonesty/laql.git",
+    "directory": "packages/laql"
+  },
+  "homepage": "https://laql.dev",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@turf/boolean-contains": "^7.2.0",
+    "@turf/boolean-intersects": "^7.2.0",
+    "avsc": "^5.7.9",
+    "aws4fetch": "^1.0.20",
+    "fast-xml-parser": "^5.9.0",
+    "h3-js": "^4.4.0",
+    "hyparquet": "^1.26.0",
+    "hyparquet-writer": "^0.15.6"
+  },
+  "devDependencies": {
+    "@laql/core": "workspace:*",
+    "@laql/fixtures": "workspace:*",
+    "@laql/http": "workspace:*",
+    "@laql/iceberg": "workspace:*",
+    "@laql/parquet": "workspace:*",
+    "@laql/r2": "workspace:*",
+    "@laql/s3": "workspace:*",
+    "tsup": "^8.5.0"
+  }
+}