@gscdump/lakehouse 0.40.2 → 1.0.0

package/README.md

@@ -0,0 +1,49 @@
+# @gscdump/lakehouse
+
+Dataset-agnostic Iceberg catalog, schema, and dataset-registry primitives for
+R2 Data Catalog producers.
+
+## Install
+
+```bash
+npm install @gscdump/lakehouse
+```
+
+Node.js 22 or newer is required.
+
+## Public surfaces
+
+- `@gscdump/lakehouse` — connect to a catalog, define datasets, derive table
+  specifications, resolve data files, and use bigint-safe serialization.
+- `@gscdump/lakehouse/maintenance` — stable commit classification and orphan
+  cleanup workflows.
+- `@gscdump/lakehouse/provisioning` — adopt, allocate, or provision R2 Data
+  Catalog resources.
+- `@gscdump/lakehouse/unsafe-raw` — explicit escape hatch for package adapters
+  and raw-metadata diagnostics. Application maintenance belongs on the stable
+  maintenance subpath.
+
+```ts
+import { connectIcebergCatalog, listIcebergTables } from '@gscdump/lakehouse'
+import { isCommitRateLimited } from '@gscdump/lakehouse/maintenance'
+
+const connection = await connectIcebergCatalog(config)
+const tables = await listIcebergTables(connection)
+
+try {
+  // Commit through a dataset or package adapter.
+}
+catch (error) {
+  if (isCommitRateLimited(error)) {
+    // Retry using the caller's bounded backoff policy.
+  }
+}
+```
+
+The dataset registry is the normal authoring boundary. Raw Icebird table
+creation and append primitives are intentionally excluded from the package
+root so producers cannot silently bypass registered dataset definitions.
+
+## License
+
+[MIT](../../LICENSE)

package/dist/_chunks/libs/hyparquet-compressors.mjs

@@ -1,16 +1,5 @@
-import { snappyUncompress as snappyUncompress$1 } from "./hyparquet.mjs";
+import "./hyparquet.mjs";
 import "./fzstd.mjs";
-function decode(input, outputLength) {
-	const output = new Uint8Array(outputLength);
-	snappyUncompress$1(input, output);
-	return output;
-}
-function snappyUncompressor() {
-	return decode;
-}
-function snappyUncompress(input, outputLength) {
-	return decode(input, outputLength);
-}
 const BROTLI_READ_SIZE = 4096;
 const BROTLI_IBUF_SIZE = 8224;
 const BROTLI_IBUF_MASK = 2 * BROTLI_READ_SIZE - 1;
@@ -2793,4 +2782,4 @@ new Uint8Array([
 	5,
 	5
 ]);
-export { gunzip, snappyUncompress, snappyUncompressor };
+export { gunzip };

package/dist/maintenance.d.mts

@@ -0,0 +1,94 @@
+import { IcebergConnection, isCommitRateLimited } from "./_chunks/catalog.mjs";
+/** One listed object under a data prefix. */
+interface SweepListedObject {
+  key: string;
+  uploaded: Date;
+}
+/** One page of a prefix listing. */
+interface SweepListPage {
+  objects: readonly SweepListedObject[];
+  truncated: boolean;
+  cursor?: string;
+}
+/**
+ * Minimal storage client `sweepUncommittedOrphans` needs: list-by-prefix +
+ * batch delete against the warehouse bucket. Deliberately NOT an S3 SDK
+ * client shape — this interface is structurally satisfied by Cloudflare's
+ * native `R2Bucket` Workers binding (`env.R2_ANALYTICS.list({ prefix })` /
+ * `env.R2_ANALYTICS.delete(keys)`), so a caller running inside a Worker can
+ * pass the binding straight through with no adapter. Any other
+ * S3-compatible client can be wrapped to this shape.
+ */
+interface SweepStorageClient {
+  list: (options: {
+    prefix: string;
+    cursor?: string;
+  }) => Promise<SweepListPage>;
+  delete: (keys: string[]) => Promise<void>;
+}
+interface SweepUncommittedOrphansOptions {
+  conn: IcebergConnection;
+  s3: SweepStorageClient;
+  /**
+   * Bare R2 bucket name backing `conn`'s warehouse. Every scanned table's
+   * `location` must resolve into this exact bucket; a table whose location
+   * points elsewhere is SKIPPED — never guessed at, never touched.
+   */
+  bucket: string;
+  /**
+   * Restrict the sweep to these tables; defaults to every table currently
+   * in `conn.namespace` (`conn` already carries the namespace scope, so
+   * there's no separate `namespace` field here).
+   */
+  tables?: readonly string[];
+  /** Only delete objects older than this many hours. Default 48. */
+  graceHours?: number;
+  /** Hard cap on deletions in one run. Default 500. */
+  maxDeletes?: number;
+  /** Compute the delete set but never call `s3.delete`. Default false. */
+  dryRun?: boolean;
+  /** Injectable clock (ms epoch). Defaults to `Date.now`. */
+  now?: () => number;
+  /** Maximum catalog/object-store reads held in flight. Default 4, max 32. */
+  ioConcurrency?: number;
+}
+interface SweepUncommittedOrphansResult {
+  /** Tables whose retained snapshots were successfully walked. */
+  scannedTables: string[];
+  /** Tables skipped because their `location` didn't resolve into `bucket` — never scanned, never touched. */
+  skippedTables: string[];
+  /** Count of live (referenced-by-some-retained-snapshot) files found across `scannedTables`. */
+  liveFileCount: number;
+  /** Objects under a scanned table's data prefix with no snapshot reference anywhere, past `graceHours`. */
+  candidateCount: number;
+  /** Keys deleted (or, under `dryRun`, that WOULD be deleted). */
+  deleted: string[];
+  dryRun: boolean;
+  /** True when `candidateCount` exceeded `maxDeletes` — remaining orphans are left for the next run. */
+  cappedAtLimit: boolean;
+  /** Set when the sweep did nothing because the table scope listed zero tables (fail-closed — see class docs). */
+  reason?: 'zero-tables';
+}
+/**
+ * Sweep data files written under a table's `data/` prefix that were NEVER
+ * referenced by any snapshot the catalog still retains — a crashed/partial
+ * writer's leftovers. This is the one orphan class Cloudflare's own R2 Data
+ * Catalog snapshot-expiration GC does not cover.
+ *
+ * HARD SAFETY:
+ * - A listing failure (table load / manifest walk throwing) PROPAGATES.
+ *   It is never caught and treated as "no live files" — that would make
+ *   every real data file look orphaned. Callers must let this reject and
+ *   must not proceed to delete on catch.
+ * - Zero tables in scope is treated as "couldn't determine what's live",
+ *   not "nothing to protect" — the sweep no-ops with `reason: 'zero-tables'`
+ *   rather than listing/deleting anything.
+ * - Deletions are capped at `maxDeletes` per run (default 500).
+ * - `dryRun` computes the exact candidate set without ever calling `s3.delete`.
+ * - Only ever lists/deletes keys under a scanned table's own
+ *   `<table.location>/data/` prefix, and every candidate is re-checked to
+ *   actually start with that prefix before being considered for deletion —
+ *   never a bare bucket-root listing, never a key outside a data prefix.
+ */
+declare function sweepUncommittedOrphans(opts: SweepUncommittedOrphansOptions): Promise<SweepUncommittedOrphansResult>;
+export { type SweepListPage, type SweepListedObject, type SweepStorageClient, type SweepUncommittedOrphansOptions, type SweepUncommittedOrphansResult, isCommitRateLimited, sweepUncommittedOrphans };

package/dist/maintenance.mjs

@@ -0,0 +1,140 @@
+import { isCommitRateLimited } from "./_chunks/catalog.mjs";
+import { icebergManifests, restCatalogListTables, restCatalogLoadTable } from "./_chunks/libs/icebird.mjs";
+const DEFAULT_GRACE_HOURS = 48;
+const DEFAULT_MAX_DELETES = 500;
+const DEFAULT_IO_CONCURRENCY = 4;
+const MAX_IO_CONCURRENCY = 32;
+const HOUR_MS = 3600 * 1e3;
+function createIoLimiter(requested) {
+	const concurrency = typeof requested === "number" && Number.isFinite(requested) ? Math.max(1, Math.min(MAX_IO_CONCURRENCY, Math.floor(requested))) : DEFAULT_IO_CONCURRENCY;
+	let active = 0;
+	const waiters = [];
+	return async (operation) => {
+		if (active >= concurrency) await new Promise((resolve) => waiters.push(resolve));
+		active++;
+		try {
+			return await operation();
+		} finally {
+			active--;
+			waiters.shift()?.();
+		}
+	};
+}
+async function settleOrThrow(promises) {
+	const settled = await Promise.allSettled(promises);
+	const failure = settled.find((result) => result.status === "rejected");
+	if (failure) throw failure.reason;
+	return settled.map((result) => result.value);
+}
+function splitBucketKey(filePath) {
+	if (!filePath.startsWith("s3://")) return null;
+	const rest = filePath.slice(5);
+	const slash = rest.indexOf("/");
+	if (slash < 0) return null;
+	return {
+		bucket: rest.slice(0, slash),
+		key: rest.slice(slash + 1)
+	};
+}
+async function scanTable(conn, table, bucket, io) {
+	const { metadata } = await io(() => restCatalogLoadTable(conn.catalog, {
+		namespace: conn.namespace,
+		table
+	}));
+	const location = splitBucketKey(String(metadata.location ?? ""));
+	if (!location || location.bucket !== bucket) return {
+		dataPrefix: null,
+		liveKeys: /* @__PURE__ */ new Set()
+	};
+	const dataPrefix = `${location.key.replace(/\/+$/, "")}/data/`;
+	const liveKeys = /* @__PURE__ */ new Set();
+	const manifestsBySnapshot = await settleOrThrow((metadata.snapshots ?? []).map((snapshot) => io(() => icebergManifests({
+		metadata,
+		resolver: conn.resolver,
+		snapshotId: snapshot["snapshot-id"]
+	}))));
+	for (const manifests of manifestsBySnapshot) for (const manifest of manifests) for (const entry of manifest.entries) {
+		if (entry.status === 2) continue;
+		const filePath = entry.data_file?.file_path;
+		if (!filePath) continue;
+		const parsed = splitBucketKey(filePath);
+		if (parsed && parsed.bucket === bucket) liveKeys.add(parsed.key);
+	}
+	return {
+		dataPrefix,
+		liveKeys
+	};
+}
+async function listAllUnderPrefix(s3, prefix, io) {
+	const out = [];
+	let cursor;
+	do {
+		const page = await io(() => s3.list({
+			prefix,
+			cursor
+		}));
+		out.push(...page.objects);
+		cursor = page.truncated ? page.cursor : void 0;
+	} while (cursor);
+	return out;
+}
+async function sweepUncommittedOrphans(opts) {
+	const { conn, s3, bucket } = opts;
+	const graceHours = opts.graceHours ?? DEFAULT_GRACE_HOURS;
+	const maxDeletes = opts.maxDeletes ?? DEFAULT_MAX_DELETES;
+	const dryRun = opts.dryRun ?? false;
+	const graceCutoff = (opts.now ?? Date.now)() - graceHours * HOUR_MS;
+	const io = createIoLimiter(opts.ioConcurrency);
+	const tables = opts.tables ?? (await io(() => restCatalogListTables(conn.catalog, { namespace: conn.namespace }))).map((t) => t.name);
+	if (tables.length === 0) return {
+		scannedTables: [],
+		skippedTables: [],
+		liveFileCount: 0,
+		candidateCount: 0,
+		deleted: [],
+		dryRun,
+		cappedAtLimit: false,
+		reason: "zero-tables"
+	};
+	const tableResults = await settleOrThrow(tables.map(async (table) => {
+		const { dataPrefix, liveKeys } = await scanTable(conn, table, bucket, io);
+		if (!dataPrefix) return {
+			table,
+			skipped: true,
+			liveFileCount: 0,
+			candidates: []
+		};
+		const listed = await listAllUnderPrefix(s3, dataPrefix, io);
+		const tableCandidates = [];
+		for (const obj of listed) {
+			if (!obj.key.startsWith(dataPrefix)) continue;
+			if (liveKeys.has(obj.key)) continue;
+			if (obj.uploaded.getTime() > graceCutoff) continue;
+			tableCandidates.push(obj);
+		}
+		return {
+			table,
+			skipped: false,
+			liveFileCount: liveKeys.size,
+			candidates: tableCandidates
+		};
+	}));
+	const scannedTables = tableResults.filter((result) => !result.skipped).map((result) => result.table);
+	const skippedTables = tableResults.filter((result) => result.skipped).map((result) => result.table);
+	const liveFileCount = tableResults.reduce((sum, result) => sum + result.liveFileCount, 0);
+	const candidates = tableResults.flatMap((result) => result.candidates);
+	const candidateCount = candidates.length;
+	const toDelete = candidates.slice(0, maxDeletes);
+	const cappedAtLimit = candidateCount > maxDeletes;
+	if (!dryRun && toDelete.length > 0) await s3.delete(toDelete.map((o) => o.key));
+	return {
+		scannedTables,
+		skippedTables,
+		liveFileCount,
+		candidateCount,
+		deleted: toDelete.map((o) => o.key),
+		dryRun,
+		cappedAtLimit
+	};
+}
+export { isCommitRateLimited, sweepUncommittedOrphans };

package/dist/unsafe-raw.d.mts

@@ -1,95 +1,3 @@
-import { IcebergConnection, icebergAppendRetrying, isCommitRateLimited } from "./_chunks/catalog.mjs";
+import { icebergAppendRetrying } from "./_chunks/catalog.mjs";
 import { icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver } from "./_chunks/libs/icebird.mjs";
-/** One listed object under a data prefix. */
-interface SweepListedObject {
-  key: string;
-  uploaded: Date;
-}
-/** One page of a prefix listing. */
-interface SweepListPage {
-  objects: readonly SweepListedObject[];
-  truncated: boolean;
-  cursor?: string;
-}
-/**
- * Minimal storage client `sweepUncommittedOrphans` needs: list-by-prefix +
- * batch delete against the warehouse bucket. Deliberately NOT an S3 SDK
- * client shape — this interface is structurally satisfied by Cloudflare's
- * native `R2Bucket` Workers binding (`env.R2_ANALYTICS.list({ prefix })` /
- * `env.R2_ANALYTICS.delete(keys)`), so a caller running inside a Worker can
- * pass the binding straight through with no adapter. Any other
- * S3-compatible client can be wrapped to this shape.
- */
-interface SweepStorageClient {
-  list: (options: {
-    prefix: string;
-    cursor?: string;
-  }) => Promise<SweepListPage>;
-  delete: (keys: string[]) => Promise<void>;
-}
-interface SweepUncommittedOrphansOptions {
-  conn: IcebergConnection;
-  s3: SweepStorageClient;
-  /**
-   * Bare R2 bucket name backing `conn`'s warehouse. Every scanned table's
-   * `location` must resolve into this exact bucket; a table whose location
-   * points elsewhere is SKIPPED — never guessed at, never touched.
-   */
-  bucket: string;
-  /**
-   * Restrict the sweep to these tables; defaults to every table currently
-   * in `conn.namespace` (`conn` already carries the namespace scope, so
-   * there's no separate `namespace` field here).
-   */
-  tables?: readonly string[];
-  /** Only delete objects older than this many hours. Default 48. */
-  graceHours?: number;
-  /** Hard cap on deletions in one run. Default 500. */
-  maxDeletes?: number;
-  /** Compute the delete set but never call `s3.delete`. Default false. */
-  dryRun?: boolean;
-  /** Injectable clock (ms epoch). Defaults to `Date.now`. */
-  now?: () => number;
-  /** Maximum catalog/object-store reads held in flight. Default 4, max 32. */
-  ioConcurrency?: number;
-}
-interface SweepUncommittedOrphansResult {
-  /** Tables whose retained snapshots were successfully walked. */
-  scannedTables: string[];
-  /** Tables skipped because their `location` didn't resolve into `bucket` — never scanned, never touched. */
-  skippedTables: string[];
-  /** Count of live (referenced-by-some-retained-snapshot) files found across `scannedTables`. */
-  liveFileCount: number;
-  /** Objects under a scanned table's data prefix with no snapshot reference anywhere, past `graceHours`. */
-  candidateCount: number;
-  /** Keys deleted (or, under `dryRun`, that WOULD be deleted). */
-  deleted: string[];
-  dryRun: boolean;
-  /** True when `candidateCount` exceeded `maxDeletes` — remaining orphans are left for the next run. */
-  cappedAtLimit: boolean;
-  /** Set when the sweep did nothing because the table scope listed zero tables (fail-closed — see class docs). */
-  reason?: 'zero-tables';
-}
-/**
- * Sweep data files written under a table's `data/` prefix that were NEVER
- * referenced by any snapshot the catalog still retains — a crashed/partial
- * writer's leftovers. This is the one orphan class Cloudflare's own R2 Data
- * Catalog snapshot-expiration GC does not cover.
- *
- * HARD SAFETY:
- * - A listing failure (table load / manifest walk throwing) PROPAGATES.
- *   It is never caught and treated as "no live files" — that would make
- *   every real data file look orphaned. Callers must let this reject and
- *   must not proceed to delete on catch.
- * - Zero tables in scope is treated as "couldn't determine what's live",
- *   not "nothing to protect" — the sweep no-ops with `reason: 'zero-tables'`
- *   rather than listing/deleting anything.
- * - Deletions are capped at `maxDeletes` per run (default 500).
- * - `dryRun` computes the exact candidate set without ever calling `s3.delete`.
- * - Only ever lists/deletes keys under a scanned table's own
- *   `<table.location>/data/` prefix, and every candidate is re-checked to
- *   actually start with that prefix before being considered for deletion —
- *   never a bare bucket-root listing, never a key outside a data prefix.
- */
-declare function sweepUncommittedOrphans(opts: SweepUncommittedOrphansOptions): Promise<SweepUncommittedOrphansResult>;
-export { type SweepListPage, type SweepListedObject, type SweepStorageClient, type SweepUncommittedOrphansOptions, type SweepUncommittedOrphansResult, icebergAppend, icebergAppendRetrying, icebergCreateTable, icebergDropTable, icebergManifests, isCommitRateLimited, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver, sweepUncommittedOrphans };
+export { icebergAppend, icebergAppendRetrying, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };

package/dist/unsafe-raw.mjs

@@ -1,140 +1,3 @@
-import { icebergAppendRetrying, isCommitRateLimited } from "./_chunks/catalog.mjs";
+import { icebergAppendRetrying } from "./_chunks/catalog.mjs";
 import { icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver } from "./_chunks/libs/icebird.mjs";
-const DEFAULT_GRACE_HOURS = 48;
-const DEFAULT_MAX_DELETES = 500;
-const DEFAULT_IO_CONCURRENCY = 4;
-const MAX_IO_CONCURRENCY = 32;
-const HOUR_MS = 3600 * 1e3;
-function createIoLimiter(requested) {
-	const concurrency = typeof requested === "number" && Number.isFinite(requested) ? Math.max(1, Math.min(MAX_IO_CONCURRENCY, Math.floor(requested))) : DEFAULT_IO_CONCURRENCY;
-	let active = 0;
-	const waiters = [];
-	return async (operation) => {
-		if (active >= concurrency) await new Promise((resolve) => waiters.push(resolve));
-		active++;
-		try {
-			return await operation();
-		} finally {
-			active--;
-			waiters.shift()?.();
-		}
-	};
-}
-async function settleOrThrow(promises) {
-	const settled = await Promise.allSettled(promises);
-	const failure = settled.find((result) => result.status === "rejected");
-	if (failure) throw failure.reason;
-	return settled.map((result) => result.value);
-}
-function splitBucketKey(filePath) {
-	if (!filePath.startsWith("s3://")) return null;
-	const rest = filePath.slice(5);
-	const slash = rest.indexOf("/");
-	if (slash < 0) return null;
-	return {
-		bucket: rest.slice(0, slash),
-		key: rest.slice(slash + 1)
-	};
-}
-async function scanTable(conn, table, bucket, io) {
-	const { metadata } = await io(() => restCatalogLoadTable(conn.catalog, {
-		namespace: conn.namespace,
-		table
-	}));
-	const location = splitBucketKey(String(metadata.location ?? ""));
-	if (!location || location.bucket !== bucket) return {
-		dataPrefix: null,
-		liveKeys: /* @__PURE__ */ new Set()
-	};
-	const dataPrefix = `${location.key.replace(/\/+$/, "")}/data/`;
-	const liveKeys = /* @__PURE__ */ new Set();
-	const manifestsBySnapshot = await settleOrThrow((metadata.snapshots ?? []).map((snapshot) => io(() => icebergManifests({
-		metadata,
-		resolver: conn.resolver,
-		snapshotId: snapshot["snapshot-id"]
-	}))));
-	for (const manifests of manifestsBySnapshot) for (const manifest of manifests) for (const entry of manifest.entries) {
-		if (entry.status === 2) continue;
-		const filePath = entry.data_file?.file_path;
-		if (!filePath) continue;
-		const parsed = splitBucketKey(filePath);
-		if (parsed && parsed.bucket === bucket) liveKeys.add(parsed.key);
-	}
-	return {
-		dataPrefix,
-		liveKeys
-	};
-}
-async function listAllUnderPrefix(s3, prefix, io) {
-	const out = [];
-	let cursor;
-	do {
-		const page = await io(() => s3.list({
-			prefix,
-			cursor
-		}));
-		out.push(...page.objects);
-		cursor = page.truncated ? page.cursor : void 0;
-	} while (cursor);
-	return out;
-}
-async function sweepUncommittedOrphans(opts) {
-	const { conn, s3, bucket } = opts;
-	const graceHours = opts.graceHours ?? DEFAULT_GRACE_HOURS;
-	const maxDeletes = opts.maxDeletes ?? DEFAULT_MAX_DELETES;
-	const dryRun = opts.dryRun ?? false;
-	const graceCutoff = (opts.now ?? Date.now)() - graceHours * HOUR_MS;
-	const io = createIoLimiter(opts.ioConcurrency);
-	const tables = opts.tables ?? (await io(() => restCatalogListTables(conn.catalog, { namespace: conn.namespace }))).map((t) => t.name);
-	if (tables.length === 0) return {
-		scannedTables: [],
-		skippedTables: [],
-		liveFileCount: 0,
-		candidateCount: 0,
-		deleted: [],
-		dryRun,
-		cappedAtLimit: false,
-		reason: "zero-tables"
-	};
-	const tableResults = await settleOrThrow(tables.map(async (table) => {
-		const { dataPrefix, liveKeys } = await scanTable(conn, table, bucket, io);
-		if (!dataPrefix) return {
-			table,
-			skipped: true,
-			liveFileCount: 0,
-			candidates: []
-		};
-		const listed = await listAllUnderPrefix(s3, dataPrefix, io);
-		const tableCandidates = [];
-		for (const obj of listed) {
-			if (!obj.key.startsWith(dataPrefix)) continue;
-			if (liveKeys.has(obj.key)) continue;
-			if (obj.uploaded.getTime() > graceCutoff) continue;
-			tableCandidates.push(obj);
-		}
-		return {
-			table,
-			skipped: false,
-			liveFileCount: liveKeys.size,
-			candidates: tableCandidates
-		};
-	}));
-	const scannedTables = tableResults.filter((result) => !result.skipped).map((result) => result.table);
-	const skippedTables = tableResults.filter((result) => result.skipped).map((result) => result.table);
-	const liveFileCount = tableResults.reduce((sum, result) => sum + result.liveFileCount, 0);
-	const candidates = tableResults.flatMap((result) => result.candidates);
-	const candidateCount = candidates.length;
-	const toDelete = candidates.slice(0, maxDeletes);
-	const cappedAtLimit = candidateCount > maxDeletes;
-	if (!dryRun && toDelete.length > 0) await s3.delete(toDelete.map((o) => o.key));
-	return {
-		scannedTables,
-		skippedTables,
-		liveFileCount,
-		candidateCount,
-		deleted: toDelete.map((o) => o.key),
-		dryRun,
-		cappedAtLimit
-	};
-}
-export { icebergAppend, icebergAppendRetrying, icebergCreateTable, icebergDropTable, icebergManifests, isCommitRateLimited, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver, sweepUncommittedOrphans };
+export { icebergAppend, icebergAppendRetrying, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/lakehouse",
   "type": "module",
-  "version": "0.40.2",
+  "version": "1.0.0",
   "description": "Dataset-agnostic Iceberg lakehouse layer + dataset registry for R2 Data Catalog producers (ADR-0021).",
   "author": {
     "name": "Harlan Wilton",
@@ -26,6 +26,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./maintenance": {
+      "types": "./dist/maintenance.d.mts",
+      "import": "./dist/maintenance.mjs",
+      "default": "./dist/maintenance.mjs"
+    },
     "./unsafe-raw": {
       "types": "./dist/unsafe-raw.d.mts",
       "import": "./dist/unsafe-raw.mjs",
@@ -43,7 +48,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",

package/dist/vendor/hysnappy-purejs.d.mts

@@ -1,29 +0,0 @@
-/**
- * Pure-JS drop-in replacement for `hysnappy`.
- *
- * `hysnappy`'s `snappyUncompressor()` eagerly compiles a WASM module
- * (`new WebAssembly.Module(byteArray)`) — and `hyparquet-compressors`
- * instantiates it at module top level (`SNAPPY: snappyUncompressor()`).
- * Cloudflare's `workerd` forbids compiling WebAssembly from a runtime buffer
- * (WASM must be a bundled module import), so any Worker bundle that imports
- * `icebird` (→ `hyparquet-compressors`) fails to start with
- * `CompileError: Wasm code generation disallowed by embedder`.
- *
- * `icebird`'s append path never actually decompresses a snappy data file — it
- * only reads gzipped `metadata.json` and Avro manifests — so the snappy
- * decompressor is instantiated but never invoked. This shim swaps the WASM
- * codec for `hyparquet`'s pure-JS snappy decompressor (a vendored snappyjs),
- * keeping the exact `hysnappy` API surface so `hyparquet-compressors` is
- * unaware of the swap. Wired in via a build-time `hysnappy` alias.
- *
- * See `docs/plans/2026-05-22-icebird-ingest-writer-spike.md` (section e).
- */
-/**
- * Pure-JS stand-in for `hysnappy`'s `snappyUncompressor()`. Returns the
- * decompressor immediately — no WASM compilation, so it is safe to call at
- * module top level inside `workerd`.
- */
-declare function snappyUncompressor(): (input: Uint8Array, outputLength: number) => Uint8Array;
-/** Pure-JS stand-in for `hysnappy`'s `snappyUncompress(input, outputLength)`. */
-declare function snappyUncompress(input: Uint8Array, outputLength: number): Uint8Array;
-export { snappyUncompress, snappyUncompressor };

package/dist/vendor/hysnappy-purejs.mjs

@@ -1,2 +0,0 @@
-import { snappyUncompress, snappyUncompressor } from "../_chunks/libs/hyparquet-compressors.mjs";
-export { snappyUncompress, snappyUncompressor };