@sixb/core 0.0.1

package/dist/chunk-2s6sydsh.js

@@ -0,0 +1,368 @@
+// @bun
+import {
+  getDatasetRowValidationError
+} from "./chunk-r65yscvk.js";
+
+// src/lake-storage/errors.ts
+class LakeStorageError extends Error {
+  name = "LakeStorageError";
+}
+
+// src/lake-storage/definition-updates.ts
+var SCHEMA_UPDATE_V1_POLICY = "Dataset definition updates V1 support only adding nullable columns.";
+function planDatasetDefinitionUpdate(existing, requested) {
+  assertSameDataset(existing, requested);
+  const addedColumns = getAddedColumnsAfterValidatingExistingColumns(existing, requested);
+  assertAddedColumnsAreNullable(requested.id, addedColumns);
+  const schema = toSchemaUpdatePlan(addedColumns);
+  const definition = mergeDatasetDefinition(existing, requested, addedColumns);
+  const metadata = {
+    descriptionChanged: existing.description !== definition.description,
+    partitionByChanged: !areStringArraysEqual(existing.partitionBy, definition.partitionBy)
+  };
+  return {
+    existing: structuredClone(existing),
+    requested: structuredClone(requested),
+    definition,
+    schema,
+    metadata,
+    changed: schema.kind !== "none" || metadata.descriptionChanged || metadata.partitionByChanged
+  };
+}
+function mergeStrictDatasetDefinition(options) {
+  if (!options.existing) {
+    return structuredClone(options.next);
+  }
+  const plan = planDatasetDefinitionUpdate(options.existing, options.next);
+  if (plan.schema.kind !== "none") {
+    throw new LakeStorageError(`[SixbLake] Dataset '${options.next.id}' cannot be redefined with an incompatible schema.`);
+  }
+  return structuredClone(plan.definition);
+}
+async function assertLakeDatasetDefinitionsCompatible(options) {
+  await options.lakeStorage.assertDatasetDefinitionsCompatible(options.definitions);
+}
+function assertSameDataset(existing, requested) {
+  if (existing.id !== requested.id) {
+    throw new LakeStorageError(`[SixbLake] Cannot update dataset '${existing.id}' with definition for '${requested.id}'.`);
+  }
+}
+function getAddedColumnsAfterValidatingExistingColumns(existing, requested) {
+  const existingColumns = existing.schema.columns;
+  const requestedColumnsByName = new Map(requested.schema.columns.map((column) => [column.name, column]));
+  for (const existingColumn of existingColumns) {
+    const requestedColumn = requestedColumnsByName.get(existingColumn.name);
+    if (requestedColumn === undefined) {
+      throwUnsupportedSchemaUpdate(requested.id, `dropping column '${existingColumn.name}' is not supported`);
+    }
+    assertExistingColumnUnchanged(requested.id, existingColumn, requestedColumn);
+  }
+  const existingColumnNames = new Set(existingColumns.map((column) => column.name));
+  return requested.schema.columns.filter((column) => !existingColumnNames.has(column.name));
+}
+function assertAddedColumnsAreNullable(datasetId, addedColumns) {
+  for (const column of addedColumns) {
+    if (!isNullable(column)) {
+      throwUnsupportedSchemaUpdate(datasetId, `adding required column '${column.name}' is not supported`);
+    }
+  }
+}
+function assertExistingColumnUnchanged(datasetId, existing, requested) {
+  if (existing.type !== requested.type) {
+    throwUnsupportedSchemaUpdate(datasetId, `changing column '${existing.name}' type from '${existing.type}' to '${requested.type}' is not supported`);
+  }
+  if (isNullable(existing) !== isNullable(requested)) {
+    throwUnsupportedSchemaUpdate(datasetId, `changing column '${existing.name}' nullability is not supported`);
+  }
+}
+function toSchemaUpdatePlan(addedColumns) {
+  if (addedColumns.length === 0) {
+    return { kind: "none" };
+  }
+  return {
+    kind: "addNullableColumns",
+    columns: cloneColumns(addedColumns)
+  };
+}
+function mergeDatasetDefinition(existing, requested, addedColumns) {
+  assertCompatibleMetadataField(requested.id, "description", existing.description, requested.description);
+  assertCompatibleMetadataField(requested.id, "partitionBy", existing.partitionBy, requested.partitionBy);
+  const columns = [...cloneColumns(existing.schema.columns), ...cloneColumns(addedColumns)];
+  const partitionBy = requested.partitionBy ?? existing.partitionBy;
+  const description = requested.description ?? existing.description;
+  return {
+    kind: "dataset",
+    id: requested.id,
+    schema: { columns },
+    ...partitionBy !== undefined ? { partitionBy: [...partitionBy] } : {},
+    ...description !== undefined ? { description } : {}
+  };
+}
+function assertCompatibleMetadataField(datasetId, field, existing, requested) {
+  if (existing === undefined || requested === undefined || areDefinitionValuesEqual(existing, requested)) {
+    return;
+  }
+  throw new LakeStorageError(`[SixbLake] Dataset '${datasetId}' cannot be redefined with an incompatible ${field}.`);
+}
+function areStringArraysEqual(left, right) {
+  if (left === undefined || right === undefined) {
+    return left === right;
+  }
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function areDefinitionValuesEqual(left, right) {
+  if (typeof left === "string" || typeof right === "string") {
+    return left === right;
+  }
+  return areStringArraysEqual(left, right);
+}
+function isNullable(column) {
+  return column.nullable === true;
+}
+function cloneColumns(columns) {
+  return columns.map((column) => ({ ...column }));
+}
+function throwUnsupportedSchemaUpdate(datasetId, detail) {
+  throw new LakeStorageError(`[SixbLake] Dataset '${datasetId}' cannot apply schema update because ${detail}. ${SCHEMA_UPDATE_V1_POLICY}`);
+}
+// src/lake-storage/in-memory.ts
+import { randomUUID } from "crypto";
+function cloneDatasetDefinition(definition) {
+  return structuredClone(definition);
+}
+function cloneDatasetVersion(version) {
+  return {
+    ...structuredClone(version),
+    createdAt: new Date(version.createdAt)
+  };
+}
+function cloneRow(row) {
+  return structuredClone(row);
+}
+function selectColumns(row, columns) {
+  if (!columns || columns.length === 0) {
+    return cloneRow(row);
+  }
+  const selected = {};
+  for (const column of columns) {
+    selected[column] = row[column];
+  }
+  return selected;
+}
+function rowContentKey(row, schema) {
+  return JSON.stringify(schema.columns.map((column) => row[column.name] ?? null));
+}
+function sameRowContent(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  const sortedLeft = [...left].sort();
+  const sortedRight = [...right].sort();
+  return sortedLeft.every((key, index) => key === sortedRight[index]);
+}
+function assertDatasetId(datasetId) {
+  if (datasetId.trim().length === 0) {
+    throw new LakeStorageError("[LakeStorage] Dataset id must not be empty");
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+class InMemoryLakeWriteSession {
+  storage;
+  input;
+  rows = [];
+  closed = false;
+  constructor(storage, input) {
+    this.storage = storage;
+    this.input = input;
+  }
+  async writeRows(rows) {
+    this.assertOpen();
+    for await (const row of rows) {
+      const validationError = getDatasetRowValidationError(row, this.input.dataset);
+      if (validationError) {
+        throw new LakeStorageError(`[LakeStorage] ${validationError}`);
+      }
+      this.rows.push(cloneRow(row));
+    }
+  }
+  async commit(input) {
+    this.assertOpen();
+    this.closed = true;
+    return this.storage.commitWrite({
+      write: this.input,
+      rows: this.rows,
+      commit: input
+    });
+  }
+  async abort() {
+    this.closed = true;
+    this.rows.length = 0;
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new LakeStorageError("[LakeStorage] Write session is already closed");
+    }
+  }
+}
+
+class InMemoryLakeStorage {
+  datasets = new Map;
+  versionsByDataset = new Map;
+  rowsByVersionId = new Map;
+  latestVersionIdByDataset = new Map;
+  async createDataset(definition) {
+    assertDatasetId(definition.id);
+    const existing = this.datasets.get(definition.id);
+    const stored = mergeStrictDatasetDefinition({
+      existing,
+      next: definition
+    });
+    this.datasets.set(definition.id, stored);
+    return cloneDatasetDefinition(stored);
+  }
+  async assertDatasetDefinitionsCompatible(definitions) {
+    const failures = [];
+    for (const definition of definitions) {
+      try {
+        assertDatasetId(definition.id);
+        const existing = this.datasets.get(definition.id);
+        if (!existing) {
+          continue;
+        }
+        mergeStrictDatasetDefinition({
+          existing,
+          next: definition
+        });
+      } catch (error) {
+        failures.push(`- ${definition.id}: ${errorMessage(error)}`);
+      }
+    }
+    if (failures.length > 0) {
+      const details = failures.join(`
+`);
+      throw new LakeStorageError(`[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).
+${details}`);
+    }
+  }
+  async getDataset(datasetId) {
+    const definition = this.datasets.get(datasetId);
+    return definition ? cloneDatasetDefinition(definition) : null;
+  }
+  async listDatasets() {
+    return [...this.datasets.values()].map((definition) => cloneDatasetDefinition(definition));
+  }
+  async listDatasetCatalogState(datasetIds) {
+    return Promise.all(datasetIds.map(async (datasetId) => {
+      if (!this.datasets.has(datasetId)) {
+        return { datasetId, materialized: false, latestVersion: null };
+      }
+      const latest = await this.getLatestVersion(datasetId);
+      return {
+        datasetId,
+        materialized: true,
+        latestVersion: latest ? {
+          datasetId: latest.datasetId,
+          versionId: latest.versionId,
+          mode: latest.mode,
+          createdAt: latest.createdAt,
+          ...latest.rowCount !== undefined ? { rowCount: latest.rowCount } : {}
+        } : null
+      };
+    }));
+  }
+  async listVersions(datasetId, limit) {
+    const versions = [...this.versionsByDataset.get(datasetId) ?? []].sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime()).map((version) => cloneDatasetVersion(version));
+    return limit === undefined ? versions : versions.slice(0, Math.max(0, limit));
+  }
+  async beginWrite(input) {
+    const definition = await this.getDataset(input.dataset.id);
+    if (!definition) {
+      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.dataset.id}'`);
+    }
+    return new InMemoryLakeWriteSession(this, {
+      ...input,
+      dataset: definition,
+      mode: input.mode ?? "snapshot"
+    });
+  }
+  async getLatestVersion(datasetId) {
+    const latestVersionId = this.latestVersionIdByDataset.get(datasetId);
+    if (!latestVersionId) {
+      return null;
+    }
+    return this.getVersion(datasetId, latestVersionId);
+  }
+  async getVersion(datasetId, versionId) {
+    const versions = this.versionsByDataset.get(datasetId) ?? [];
+    const version = versions.find((candidate) => candidate.versionId === versionId);
+    return version ? cloneDatasetVersion(version) : null;
+  }
+  async* readRows(input) {
+    const definition = this.datasets.get(input.datasetId);
+    if (!definition) {
+      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.datasetId}'`);
+    }
+    const version = input.versionId === undefined ? await this.getLatestVersion(input.datasetId) : await this.getVersion(input.datasetId, input.versionId);
+    if (!version) {
+      throw new LakeStorageError(`[LakeStorage] No committed version found for dataset '${input.datasetId}'`);
+    }
+    const offset = Math.max(0, input.offset ?? 0);
+    const limit = input.limit === undefined ? undefined : Math.max(0, input.limit);
+    const rows = this.rowsByVersionId.get(version.versionId)?.slice(offset, limit === undefined ? undefined : offset + limit);
+    for (const row of rows ?? []) {
+      yield selectColumns(row, input.columns);
+    }
+  }
+  async commitWrite(options) {
+    const definition = this.datasets.get(options.write.dataset.id);
+    if (!definition) {
+      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${options.write.dataset.id}'`);
+    }
+    const mode = options.write.mode ?? "snapshot";
+    const latestVersion = await this.getLatestVersion(options.write.dataset.id);
+    if (options.commit?.expectedLatestVersionId !== undefined) {
+      const actual = latestVersion?.versionId;
+      if (actual !== options.commit.expectedLatestVersionId) {
+        throw new LakeStorageError(`[LakeStorage] Optimistic commit failed for dataset '${options.write.dataset.id}': expected latest version '${options.commit.expectedLatestVersionId}', found '${actual ?? "none"}'`);
+      }
+    }
+    if (latestVersion && this.isUnchangedWrite(mode, latestVersion, options.rows, definition.schema)) {
+      return { ...latestVersion, outcome: "unchanged" };
+    }
+    const versionId = `ver_${randomUUID()}`;
+    const visibleRows = mode === "append" ? [...this.rowsByVersionId.get(latestVersion?.versionId ?? "") ?? [], ...options.rows] : [...options.rows];
+    const sizeBytes = new TextEncoder().encode(visibleRows.map((row) => JSON.stringify(row)).join(`
+`)).byteLength;
+    const version = {
+      datasetId: options.write.dataset.id,
+      versionId,
+      parentVersionId: mode === "append" ? latestVersion?.versionId : undefined,
+      mode,
+      createdAt: new Date,
+      schema: definition.schema,
+      producer: options.write.producer ? structuredClone(options.write.producer) : undefined,
+      inputs: options.write.inputs ? structuredClone(options.write.inputs) : undefined,
+      rowCount: visibleRows.length,
+      sizeBytes
+    };
+    const versions = this.versionsByDataset.get(options.write.dataset.id) ?? [];
+    versions.push(version);
+    this.versionsByDataset.set(options.write.dataset.id, versions);
+    this.rowsByVersionId.set(versionId, visibleRows.map((row) => cloneRow(row)));
+    this.latestVersionIdByDataset.set(options.write.dataset.id, versionId);
+    return { ...cloneDatasetVersion(version), outcome: "created" };
+  }
+  isUnchangedWrite(mode, latestVersion, rows, schema) {
+    if (mode === "append") {
+      return rows.length === 0;
+    }
+    const previousRows = this.rowsByVersionId.get(latestVersion.versionId) ?? [];
+    return sameRowContent(rows.map((row) => rowContentKey(row, schema)), previousRows.map((row) => rowContentKey(row, schema)));
+  }
+}
+export { LakeStorageError, planDatasetDefinitionUpdate, mergeStrictDatasetDefinition, assertLakeDatasetDefinitionsCompatible, InMemoryLakeStorage };
+
+//# debugId=ABB8A17B04F411C364756E2164756E21

package/dist/chunk-2s6sydsh.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/lake-storage/errors.ts", "../src/lake-storage/definition-updates.ts", "../src/lake-storage/in-memory.ts"],
+  "sourcesContent": [
+    "/**\n * Error for lake-storage invariants and invalid lake operations.\n */\nexport class LakeStorageError extends Error {\n  readonly name = \"LakeStorageError\"\n}\n",
+    "import type { DatasetColumnDefinition, DatasetDefinition } from \"../datasets\"\nimport { LakeStorageError } from \"./errors\"\nimport type { LakeStorage } from \"./types\"\n\nexport type DatasetSchemaUpdatePlan =\n  | { readonly kind: \"none\" }\n  | {\n      readonly kind: \"addNullableColumns\"\n      readonly columns: readonly DatasetColumnDefinition[]\n    }\n\nexport interface DatasetMetadataUpdatePlan {\n  readonly descriptionChanged: boolean\n  readonly partitionByChanged: boolean\n}\n\nexport interface DatasetDefinitionUpdatePlan {\n  readonly existing: DatasetDefinition\n  readonly requested: DatasetDefinition\n  readonly definition: DatasetDefinition\n  readonly schema: DatasetSchemaUpdatePlan\n  readonly metadata: DatasetMetadataUpdatePlan\n  readonly changed: boolean\n}\n\nconst SCHEMA_UPDATE_V1_POLICY =\n  \"Dataset definition updates V1 support only adding nullable columns.\"\n\n/**\n * Build a provider-neutral update plan for two versions of the same dataset\n * definition. Core owns the definition diff; storage providers own how much of\n * the plan they can apply.\n */\nexport function planDatasetDefinitionUpdate(\n  existing: DatasetDefinition,\n  requested: DatasetDefinition\n): DatasetDefinitionUpdatePlan {\n  assertSameDataset(existing, requested)\n\n  const addedColumns = getAddedColumnsAfterValidatingExistingColumns(existing, requested)\n  assertAddedColumnsAreNullable(requested.id, addedColumns)\n\n  const schema = toSchemaUpdatePlan(addedColumns)\n  const definition = mergeDatasetDefinition(existing, requested, addedColumns)\n  const metadata: DatasetMetadataUpdatePlan = {\n    descriptionChanged: existing.description !== definition.description,\n    partitionByChanged: !areStringArraysEqual(existing.partitionBy, definition.partitionBy),\n  }\n\n  return {\n    existing: structuredClone(existing),\n    requested: structuredClone(requested),\n    definition,\n    schema,\n    metadata,\n    changed: schema.kind !== \"none\" || metadata.descriptionChanged || metadata.partitionByChanged,\n  }\n}\n\n/**\n * Strict providers can use this helper when they do not support schema\n * evolution. Metadata-only compatible additions are still merged.\n */\nexport function mergeStrictDatasetDefinition(options: {\n  readonly existing?: DatasetDefinition | null\n  readonly next: DatasetDefinition\n}): DatasetDefinition {\n  if (!options.existing) {\n    return structuredClone(options.next)\n  }\n\n  const plan = planDatasetDefinitionUpdate(options.existing, options.next)\n  if (plan.schema.kind !== \"none\") {\n    throw new LakeStorageError(\n      `[SixbLake] Dataset '${options.next.id}' cannot be redefined with an incompatible schema.`\n    )\n  }\n\n  return structuredClone(plan.definition)\n}\n\nexport interface AssertLakeDatasetDefinitionsCompatibleOptions {\n  readonly lakeStorage: LakeStorage\n  readonly definitions: readonly DatasetDefinition[]\n}\n\nexport async function assertLakeDatasetDefinitionsCompatible(\n  options: AssertLakeDatasetDefinitionsCompatibleOptions\n): Promise<void> {\n  await options.lakeStorage.assertDatasetDefinitionsCompatible(options.definitions)\n}\n\nfunction assertSameDataset(existing: DatasetDefinition, requested: DatasetDefinition): void {\n  if (existing.id !== requested.id) {\n    throw new LakeStorageError(\n      `[SixbLake] Cannot update dataset '${existing.id}' with definition for '${requested.id}'.`\n    )\n  }\n}\n\nfunction getAddedColumnsAfterValidatingExistingColumns(\n  existing: DatasetDefinition,\n  requested: DatasetDefinition\n): readonly DatasetColumnDefinition[] {\n  const existingColumns = existing.schema.columns\n  const requestedColumnsByName = new Map(\n    requested.schema.columns.map((column) => [column.name, column])\n  )\n\n  // Existing columns are matched by name, not position. Developers can reorder\n  // declarations for readability without implying a storage-level schema change.\n  for (const existingColumn of existingColumns) {\n    const requestedColumn = requestedColumnsByName.get(existingColumn.name)\n    if (requestedColumn === undefined) {\n      throwUnsupportedSchemaUpdate(\n        requested.id,\n        `dropping column '${existingColumn.name}' is not supported`\n      )\n    }\n\n    assertExistingColumnUnchanged(requested.id, existingColumn, requestedColumn)\n  }\n\n  const existingColumnNames = new Set(existingColumns.map((column) => column.name))\n  return requested.schema.columns.filter((column) => !existingColumnNames.has(column.name))\n}\n\nfunction assertAddedColumnsAreNullable(\n  datasetId: string,\n  addedColumns: readonly DatasetColumnDefinition[]\n): void {\n  for (const column of addedColumns) {\n    // Existing rows have no value for a new column. Until DatasetDefinition\n    // supports defaults or backfills, only nullable columns are safe to add.\n    if (!isNullable(column)) {\n      throwUnsupportedSchemaUpdate(\n        datasetId,\n        `adding required column '${column.name}' is not supported`\n      )\n    }\n  }\n}\n\nfunction assertExistingColumnUnchanged(\n  datasetId: string,\n  existing: DatasetColumnDefinition,\n  requested: DatasetColumnDefinition\n): void {\n  if (existing.type !== requested.type) {\n    throwUnsupportedSchemaUpdate(\n      datasetId,\n      `changing column '${existing.name}' type from '${existing.type}' to '${requested.type}' is not supported`\n    )\n  }\n\n  if (isNullable(existing) !== isNullable(requested)) {\n    throwUnsupportedSchemaUpdate(\n      datasetId,\n      `changing column '${existing.name}' nullability is not supported`\n    )\n  }\n}\n\nfunction toSchemaUpdatePlan(\n  addedColumns: readonly DatasetColumnDefinition[]\n): DatasetSchemaUpdatePlan {\n  if (addedColumns.length === 0) {\n    return { kind: \"none\" }\n  }\n\n  return {\n    kind: \"addNullableColumns\",\n    columns: cloneColumns(addedColumns),\n  }\n}\n\nfunction mergeDatasetDefinition(\n  existing: DatasetDefinition,\n  requested: DatasetDefinition,\n  addedColumns: readonly DatasetColumnDefinition[]\n): DatasetDefinition {\n  assertCompatibleMetadataField(\n    requested.id,\n    \"description\",\n    existing.description,\n    requested.description\n  )\n  assertCompatibleMetadataField(\n    requested.id,\n    \"partitionBy\",\n    existing.partitionBy,\n    requested.partitionBy\n  )\n\n  const columns = [...cloneColumns(existing.schema.columns), ...cloneColumns(addedColumns)]\n  const partitionBy = requested.partitionBy ?? existing.partitionBy\n  const description = requested.description ?? existing.description\n\n  return {\n    kind: \"dataset\",\n    id: requested.id,\n    schema: { columns },\n    ...(partitionBy !== undefined ? { partitionBy: [...partitionBy] } : {}),\n    ...(description !== undefined ? { description } : {}),\n  }\n}\n\nfunction assertCompatibleMetadataField(\n  datasetId: string,\n  field: \"description\" | \"partitionBy\",\n  existing: string | readonly string[] | undefined,\n  requested: string | readonly string[] | undefined\n): void {\n  if (\n    existing === undefined ||\n    requested === undefined ||\n    areDefinitionValuesEqual(existing, requested)\n  ) {\n    return\n  }\n\n  throw new LakeStorageError(\n    `[SixbLake] Dataset '${datasetId}' cannot be redefined with an incompatible ${field}.`\n  )\n}\n\nfunction areStringArraysEqual(\n  left: readonly string[] | undefined,\n  right: readonly string[] | undefined\n): boolean {\n  if (left === undefined || right === undefined) {\n    return left === right\n  }\n\n  return left.length === right.length && left.every((value, index) => value === right[index])\n}\n\nfunction areDefinitionValuesEqual(\n  left: string | readonly string[],\n  right: string | readonly string[]\n): boolean {\n  if (typeof left === \"string\" || typeof right === \"string\") {\n    return left === right\n  }\n\n  return areStringArraysEqual(left, right)\n}\n\nfunction isNullable(column: DatasetColumnDefinition): boolean {\n  return column.nullable === true\n}\n\nfunction cloneColumns(\n  columns: readonly DatasetColumnDefinition[]\n): readonly DatasetColumnDefinition[] {\n  return columns.map((column) => ({ ...column }))\n}\n\nfunction throwUnsupportedSchemaUpdate(datasetId: string, detail: string): never {\n  throw new LakeStorageError(\n    `[SixbLake] Dataset '${datasetId}' cannot apply schema update because ${detail}. ${SCHEMA_UPDATE_V1_POLICY}`\n  )\n}\n",
+    "import { randomUUID } from \"node:crypto\"\nimport type { DatasetDefinition, DatasetSchema } from \"../datasets\"\nimport { getDatasetRowValidationError } from \"../datasets/validation\"\nimport { mergeStrictDatasetDefinition } from \"./definition-updates\"\nimport { LakeStorageError } from \"./errors\"\nimport type {\n  BeginDatasetWriteInput,\n  CommitDatasetWriteInput,\n  DatasetCatalogState,\n  DatasetRow,\n  DatasetVersion,\n  DatasetWriteCommitResult,\n  DatasetWriteMode,\n  LakeStorage,\n  LakeWriteSession,\n  ReadDatasetRowsInput,\n} from \"./types\"\n\nfunction cloneDatasetDefinition(definition: DatasetDefinition): DatasetDefinition {\n  return structuredClone(definition)\n}\n\nfunction cloneDatasetVersion(version: DatasetVersion): DatasetVersion {\n  return {\n    ...structuredClone(version),\n    createdAt: new Date(version.createdAt),\n  }\n}\n\nfunction cloneRow(row: DatasetRow): DatasetRow {\n  return structuredClone(row)\n}\n\nfunction selectColumns(row: DatasetRow, columns?: readonly string[]): DatasetRow {\n  if (!columns || columns.length === 0) {\n    return cloneRow(row)\n  }\n\n  const selected: Record<string, unknown> = {}\n  for (const column of columns) {\n    selected[column] = row[column]\n  }\n  return selected\n}\n\n// Canonical content key for unchanged-write detection. JSON.stringify\n// serializes Date values via toJSON, matching how rows persist as JSON;\n// missing and undefined nullable values normalize to null. The unchanged-write\n// semantics are pinned by the shared lake-storage contract suite.\nfunction rowContentKey(row: DatasetRow, schema: DatasetSchema): string {\n  return JSON.stringify(schema.columns.map((column) => row[column.name] ?? null))\n}\n\n// Order-insensitive multiset equality over canonical row keys.\nfunction sameRowContent(left: readonly string[], right: readonly string[]): boolean {\n  if (left.length !== right.length) {\n    return false\n  }\n\n  const sortedLeft = [...left].sort()\n  const sortedRight = [...right].sort()\n  return sortedLeft.every((key, index) => key === sortedRight[index])\n}\n\nfunction assertDatasetId(datasetId: string): void {\n  if (datasetId.trim().length === 0) {\n    throw new LakeStorageError(\"[LakeStorage] Dataset id must not be empty\")\n  }\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error)\n}\n\nclass InMemoryLakeWriteSession implements LakeWriteSession {\n  private readonly rows: DatasetRow[] = []\n  private closed = false\n\n  constructor(\n    private readonly storage: InMemoryLakeStorage,\n    private readonly input: BeginDatasetWriteInput\n  ) {}\n\n  async writeRows(rows: Iterable<DatasetRow> | AsyncIterable<DatasetRow>): Promise<void> {\n    this.assertOpen()\n\n    for await (const row of rows) {\n      const validationError = getDatasetRowValidationError(row, this.input.dataset)\n      if (validationError) {\n        throw new LakeStorageError(`[LakeStorage] ${validationError}`)\n      }\n\n      this.rows.push(cloneRow(row))\n    }\n  }\n\n  async commit(input?: CommitDatasetWriteInput): Promise<DatasetWriteCommitResult> {\n    this.assertOpen()\n    this.closed = true\n    return this.storage.commitWrite({\n      write: this.input,\n      rows: this.rows,\n      commit: input,\n    })\n  }\n\n  async abort(): Promise<void> {\n    this.closed = true\n    this.rows.length = 0\n  }\n\n  private assertOpen(): void {\n    if (this.closed) {\n      throw new LakeStorageError(\"[LakeStorage] Write session is already closed\")\n    }\n  }\n}\n\nexport class InMemoryLakeStorage implements LakeStorage {\n  private readonly datasets = new Map<string, DatasetDefinition>()\n  private readonly versionsByDataset = new Map<string, DatasetVersion[]>()\n  private readonly rowsByVersionId = new Map<string, readonly DatasetRow[]>()\n  private readonly latestVersionIdByDataset = new Map<string, string>()\n\n  async createDataset(definition: DatasetDefinition): Promise<DatasetDefinition> {\n    assertDatasetId(definition.id)\n    const existing = this.datasets.get(definition.id)\n    const stored = mergeStrictDatasetDefinition({\n      existing,\n      next: definition,\n    })\n    this.datasets.set(definition.id, stored)\n    return cloneDatasetDefinition(stored)\n  }\n\n  async assertDatasetDefinitionsCompatible(\n    definitions: readonly DatasetDefinition[]\n  ): Promise<void> {\n    const failures: string[] = []\n\n    for (const definition of definitions) {\n      try {\n        assertDatasetId(definition.id)\n        const existing = this.datasets.get(definition.id)\n        if (!existing) {\n          continue\n        }\n\n        mergeStrictDatasetDefinition({\n          existing,\n          next: definition,\n        })\n      } catch (error) {\n        failures.push(`- ${definition.id}: ${errorMessage(error)}`)\n      }\n    }\n\n    if (failures.length > 0) {\n      const details = failures.join(\"\\n\")\n      throw new LakeStorageError(\n        `[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).\\n${details}`\n      )\n    }\n  }\n\n  async getDataset(datasetId: string): Promise<DatasetDefinition | null> {\n    const definition = this.datasets.get(datasetId)\n    return definition ? cloneDatasetDefinition(definition) : null\n  }\n\n  async listDatasets(): Promise<readonly DatasetDefinition[]> {\n    return [...this.datasets.values()].map((definition) => cloneDatasetDefinition(definition))\n  }\n\n  async listDatasetCatalogState(\n    datasetIds: readonly string[]\n  ): Promise<readonly DatasetCatalogState[]> {\n    return Promise.all(\n      datasetIds.map(async (datasetId) => {\n        if (!this.datasets.has(datasetId)) {\n          return { datasetId, materialized: false, latestVersion: null }\n        }\n\n        const latest = await this.getLatestVersion(datasetId)\n        return {\n          datasetId,\n          materialized: true,\n          latestVersion: latest\n            ? {\n                datasetId: latest.datasetId,\n                versionId: latest.versionId,\n                mode: latest.mode,\n                createdAt: latest.createdAt,\n                ...(latest.rowCount !== undefined ? { rowCount: latest.rowCount } : {}),\n              }\n            : null,\n        }\n      })\n    )\n  }\n\n  async listVersions(datasetId: string, limit?: number): Promise<readonly DatasetVersion[]> {\n    const versions = [...(this.versionsByDataset.get(datasetId) ?? [])]\n      .sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime())\n      .map((version) => cloneDatasetVersion(version))\n\n    return limit === undefined ? versions : versions.slice(0, Math.max(0, limit))\n  }\n\n  async beginWrite(input: BeginDatasetWriteInput): Promise<LakeWriteSession> {\n    const definition = await this.getDataset(input.dataset.id)\n    if (!definition) {\n      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.dataset.id}'`)\n    }\n\n    return new InMemoryLakeWriteSession(this, {\n      ...input,\n      dataset: definition,\n      mode: input.mode ?? \"snapshot\",\n    })\n  }\n\n  async getLatestVersion(datasetId: string): Promise<DatasetVersion | null> {\n    const latestVersionId = this.latestVersionIdByDataset.get(datasetId)\n    if (!latestVersionId) {\n      return null\n    }\n\n    return this.getVersion(datasetId, latestVersionId)\n  }\n\n  async getVersion(datasetId: string, versionId: string): Promise<DatasetVersion | null> {\n    const versions = this.versionsByDataset.get(datasetId) ?? []\n    const version = versions.find((candidate) => candidate.versionId === versionId)\n    return version ? cloneDatasetVersion(version) : null\n  }\n\n  async *readRows(input: ReadDatasetRowsInput): AsyncIterable<DatasetRow> {\n    const definition = this.datasets.get(input.datasetId)\n    if (!definition) {\n      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.datasetId}'`)\n    }\n\n    const version =\n      input.versionId === undefined\n        ? await this.getLatestVersion(input.datasetId)\n        : await this.getVersion(input.datasetId, input.versionId)\n\n    if (!version) {\n      throw new LakeStorageError(\n        `[LakeStorage] No committed version found for dataset '${input.datasetId}'`\n      )\n    }\n\n    const offset = Math.max(0, input.offset ?? 0)\n    const limit = input.limit === undefined ? undefined : Math.max(0, input.limit)\n    const rows = this.rowsByVersionId\n      .get(version.versionId)\n      ?.slice(offset, limit === undefined ? undefined : offset + limit)\n\n    for (const row of rows ?? []) {\n      yield selectColumns(row, input.columns)\n    }\n  }\n\n  async commitWrite(options: {\n    write: BeginDatasetWriteInput\n    rows: readonly DatasetRow[]\n    commit?: CommitDatasetWriteInput\n  }): Promise<DatasetWriteCommitResult> {\n    const definition = this.datasets.get(options.write.dataset.id)\n    if (!definition) {\n      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${options.write.dataset.id}'`)\n    }\n\n    const mode = options.write.mode ?? \"snapshot\"\n    const latestVersion = await this.getLatestVersion(options.write.dataset.id)\n\n    if (options.commit?.expectedLatestVersionId !== undefined) {\n      const actual = latestVersion?.versionId\n      if (actual !== options.commit.expectedLatestVersionId) {\n        throw new LakeStorageError(\n          `[LakeStorage] Optimistic commit failed for dataset '${options.write.dataset.id}': expected latest version '${options.commit.expectedLatestVersionId}', found '${actual ?? \"none\"}'`\n        )\n      }\n    }\n\n    // Content-identical snapshots and empty appends reuse the latest version\n    // instead of creating a new one.\n    if (\n      latestVersion &&\n      this.isUnchangedWrite(mode, latestVersion, options.rows, definition.schema)\n    ) {\n      return { ...latestVersion, outcome: \"unchanged\" }\n    }\n\n    const versionId = `ver_${randomUUID()}`\n    const visibleRows =\n      mode === \"append\"\n        ? [...(this.rowsByVersionId.get(latestVersion?.versionId ?? \"\") ?? []), ...options.rows]\n        : [...options.rows]\n\n    const sizeBytes = new TextEncoder().encode(\n      visibleRows.map((row) => JSON.stringify(row)).join(\"\\n\")\n    ).byteLength\n\n    const version: DatasetVersion = {\n      datasetId: options.write.dataset.id,\n      versionId,\n      parentVersionId: mode === \"append\" ? latestVersion?.versionId : undefined,\n      mode,\n      createdAt: new Date(),\n      schema: definition.schema,\n      producer: options.write.producer ? structuredClone(options.write.producer) : undefined,\n      inputs: options.write.inputs ? structuredClone(options.write.inputs) : undefined,\n      rowCount: visibleRows.length,\n      sizeBytes,\n    }\n\n    const versions = this.versionsByDataset.get(options.write.dataset.id) ?? []\n    versions.push(version)\n    this.versionsByDataset.set(options.write.dataset.id, versions)\n    this.rowsByVersionId.set(\n      versionId,\n      visibleRows.map((row) => cloneRow(row))\n    )\n    this.latestVersionIdByDataset.set(options.write.dataset.id, versionId)\n\n    return { ...cloneDatasetVersion(version), outcome: \"created\" }\n  }\n\n  private isUnchangedWrite(\n    mode: DatasetWriteMode,\n    latestVersion: DatasetVersion,\n    rows: readonly DatasetRow[],\n    schema: DatasetSchema\n  ): boolean {\n    if (mode === \"append\") {\n      return rows.length === 0\n    }\n\n    const previousRows = this.rowsByVersionId.get(latestVersion.versionId) ?? []\n    return sameRowContent(\n      rows.map((row) => rowContentKey(row, schema)),\n      previousRows.map((row) => rowContentKey(row, schema))\n    )\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "ABB8A17B04F411C364756E2164756E21",
+  "names": []
+}

package/dist/chunk-45tw90k7.js

@@ -0,0 +1,72 @@
+// @bun
+import {
+  isRecord,
+  validateSchemaValue
+} from "./chunk-tsk2bxs3.js";
+import {
+  OntologyValidationError
+} from "./chunk-dktq02ne.js";
+
+// src/ontology/refs.ts
+function ref(objectType) {
+  return {
+    type: "objectRef",
+    objectTypeId: objectType.id
+  };
+}
+function isObjectRefSchema(schema) {
+  return typeof schema === "object" && schema !== null && schema.type === "objectRef";
+}
+function validateSchemaOrRefValue(schema, value, path, valueTypesById) {
+  if (isObjectRefSchema(schema)) {
+    validateObjectRefValue(schema, value, path);
+    return;
+  }
+  validateSchemaValue(schema, value, path, valueTypesById);
+}
+function validateObjectRefValue(schema, value, path) {
+  if (!isRecord(value)) {
+    throw new OntologyValidationError(`[Sixb] Property ${path} must be an objectRef`);
+  }
+  const allowedFields = new Set(["objectTypeId", "primaryId"]);
+  for (const fieldId of Object.keys(value)) {
+    if (!allowedFields.has(fieldId)) {
+      throw new OntologyValidationError(`[Sixb] Unknown field '${path}.${fieldId}'`);
+    }
+  }
+  if (value.objectTypeId !== schema.objectTypeId) {
+    throw new OntologyValidationError(`[Sixb] Property ${path}.objectTypeId must be "${schema.objectTypeId}"`);
+  }
+  if (typeof value.primaryId !== "string") {
+    throw new OntologyValidationError(`[Sixb] Property ${path}.primaryId must be a string`);
+  }
+}
+
+// src/ontology/tokens.ts
+function createPropertyTokenMap(objectType) {
+  const tokenEntries = objectType.properties.map((property) => {
+    const token = {
+      objectTypeId: objectType.id,
+      id: property.id,
+      property
+    };
+    return [property.id, token];
+  });
+  return Object.fromEntries(tokenEntries);
+}
+function createLinkTokenMap(objectType) {
+  const tokenEntries = objectType.links.map((link) => {
+    const token = {
+      objectTypeId: objectType.id,
+      id: link.id,
+      targetObjectTypeId: link.targetObjectTypeId,
+      link
+    };
+    return [link.id, token];
+  });
+  return Object.fromEntries(tokenEntries);
+}
+
+export { ref, isObjectRefSchema, validateSchemaOrRefValue, createPropertyTokenMap, createLinkTokenMap };
+
+//# debugId=912178D6A694401B64756E2164756E21

package/dist/chunk-45tw90k7.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/ontology/refs.ts", "../src/ontology/tokens.ts"],
+  "sourcesContent": [
+    "import { OntologyValidationError } from \"./errors\"\nimport type { InferSchema } from \"./inference\"\nimport type { ObjectType, Schema, ValueType } from \"./types\"\nimport { isRecord, validateSchemaValue } from \"./validation\"\n\nexport type ObjectRef<TObjectTypeId extends string = string> = {\n  objectTypeId: TObjectTypeId\n  primaryId: string\n}\n\nexport interface ObjectRefSchema<TObjectTypeId extends string = string> {\n  readonly type: \"objectRef\"\n  readonly objectTypeId: TObjectTypeId\n}\n\nexport type SchemaOrRef = Schema | ObjectRefSchema\n\nexport type InferSchemaOrRef<\n  TSchema extends SchemaOrRef,\n  TValueTypes extends readonly ValueType[] = [],\n> =\n  TSchema extends ObjectRefSchema<infer TObjectTypeId>\n    ? ObjectRef<TObjectTypeId>\n    : TSchema extends Schema\n      ? InferSchema<TSchema, TValueTypes>\n      : never\n\nexport function ref<const TObjectType extends ObjectType>(\n  objectType: TObjectType\n): ObjectRefSchema<TObjectType[\"id\"]> {\n  return {\n    type: \"objectRef\",\n    objectTypeId: objectType.id,\n  }\n}\n\nexport function isObjectRefSchema(schema: SchemaOrRef): schema is ObjectRefSchema {\n  return (\n    typeof schema === \"object\" &&\n    schema !== null &&\n    (schema as { type?: unknown }).type === \"objectRef\"\n  )\n}\n\nexport function validateSchemaOrRefValue(\n  schema: SchemaOrRef,\n  value: unknown,\n  path: string,\n  valueTypesById: ReadonlyMap<string, ValueType>\n): void {\n  if (isObjectRefSchema(schema)) {\n    validateObjectRefValue(schema, value, path)\n    return\n  }\n\n  validateSchemaValue(schema, value, path, valueTypesById)\n}\n\nfunction validateObjectRefValue(schema: ObjectRefSchema, value: unknown, path: string): void {\n  if (!isRecord(value)) {\n    throw new OntologyValidationError(`[Sixb] Property ${path} must be an objectRef`)\n  }\n\n  const allowedFields = new Set([\"objectTypeId\", \"primaryId\"])\n  for (const fieldId of Object.keys(value)) {\n    if (!allowedFields.has(fieldId)) {\n      throw new OntologyValidationError(`[Sixb] Unknown field '${path}.${fieldId}'`)\n    }\n  }\n\n  if (value.objectTypeId !== schema.objectTypeId) {\n    throw new OntologyValidationError(\n      `[Sixb] Property ${path}.objectTypeId must be \"${schema.objectTypeId}\"`\n    )\n  }\n\n  if (typeof value.primaryId !== \"string\") {\n    throw new OntologyValidationError(`[Sixb] Property ${path}.primaryId must be a string`)\n  }\n}\n",
+    "import type { ObjectLink, ObjectType, Property } from \"./types\"\n\ndeclare const propertyTokenBrand: unique symbol\ndeclare const linkTokenBrand: unique symbol\n\n/**\n * Strongly-typed handle to a property on a specific object type.\n *\n * Tokens let runtime APIs accept object properties without using string ids.\n */\nexport type PropertyToken<\n  TObjectTypeId extends string = string,\n  TPropertyId extends string = string,\n  TProperty extends Property = Property,\n> = {\n  readonly [propertyTokenBrand]?: never\n  readonly objectTypeId: TObjectTypeId\n  readonly id: TPropertyId\n  readonly property: TProperty\n}\n\nexport type PropertyTokenMap<TObjectType extends ObjectType> = {\n  readonly [P in TObjectType[\"properties\"][number] as P[\"id\"]]: PropertyToken<\n    TObjectType[\"id\"],\n    P[\"id\"],\n    P\n  >\n}\n\nexport type LinkToken<\n  TObjectTypeId extends string = string,\n  TLinkId extends string = string,\n  TTargetObjectTypeId extends string | readonly string[] = string | readonly string[],\n  TLink extends ObjectLink = ObjectLink,\n> = {\n  readonly [linkTokenBrand]?: never\n  readonly objectTypeId: TObjectTypeId\n  readonly id: TLinkId\n  readonly targetObjectTypeId: TTargetObjectTypeId\n  readonly link: TLink\n}\n\nexport type LinkTokenMap<TObjectType extends ObjectType> = {\n  readonly [L in TObjectType[\"links\"][number] as L[\"id\"]]: LinkToken<\n    TObjectType[\"id\"],\n    L[\"id\"],\n    L[\"targetObjectTypeId\"],\n    L\n  >\n}\n\n/**\n * Object type with property tokens (`p.*`).\n *\n * The original ontology shape is preserved; this only adds typed handles.\n */\nexport type ObjectTypeWithPropertyTokens<TObjectType extends ObjectType = ObjectType> =\n  TObjectType & {\n    readonly p: PropertyTokenMap<TObjectType>\n  }\n\n/**\n * Object type with property tokens (`p.*`) and link tokens (`l.*`).\n *\n * `links` is a plain array for iteration.\n * `l` provides keyed token access (`Room.l.hasThermostat`).\n */\nexport type ObjectTypeWithTokens<TObjectType extends ObjectType = ObjectType> =\n  ObjectTypeWithPropertyTokens<TObjectType> & {\n    readonly l: LinkTokenMap<TObjectType>\n  }\n\n/**\n * Build the `objectType.p.*` token map once when the object type is defined.\n */\nexport function createPropertyTokenMap<TObjectType extends ObjectType>(\n  objectType: TObjectType\n): PropertyTokenMap<TObjectType> {\n  const tokenEntries = objectType.properties.map((property) => {\n    const token: PropertyToken<TObjectType[\"id\"], typeof property.id, typeof property> = {\n      objectTypeId: objectType.id,\n      id: property.id,\n      property,\n    }\n    return [property.id, token] as const\n  })\n\n  return Object.fromEntries(tokenEntries) as PropertyTokenMap<TObjectType>\n}\n\n/**\n * Build the `objectType.l.*` link token map once when the object type is defined.\n */\nexport function createLinkTokenMap<TObjectType extends ObjectType>(\n  objectType: TObjectType\n): LinkTokenMap<TObjectType> {\n  const tokenEntries = objectType.links.map((link) => {\n    const token: LinkToken<\n      TObjectType[\"id\"],\n      typeof link.id,\n      typeof link.targetObjectTypeId,\n      typeof link\n    > = {\n      objectTypeId: objectType.id,\n      id: link.id,\n      targetObjectTypeId: link.targetObjectTypeId,\n      link,\n    }\n    return [link.id, token] as const\n  })\n\n  return Object.fromEntries(tokenEntries) as LinkTokenMap<TObjectType>\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;AA2BO,SAAS,GAAyC,CACvD,YACoC;AAAA,EACpC,OAAO;AAAA,IACL,MAAM;AAAA,IACN,cAAc,WAAW;AAAA,EAC3B;AAAA;AAGK,SAAS,iBAAiB,CAAC,QAAgD;AAAA,EAChF,OACE,OAAO,WAAW,YAClB,WAAW,QACV,OAA8B,SAAS;AAAA;AAIrC,SAAS,wBAAwB,CACtC,QACA,OACA,MACA,gBACM;AAAA,EACN,IAAI,kBAAkB,MAAM,GAAG;AAAA,IAC7B,uBAAuB,QAAQ,OAAO,IAAI;AAAA,IAC1C;AAAA,EACF;AAAA,EAEA,oBAAoB,QAAQ,OAAO,MAAM,cAAc;AAAA;AAGzD,SAAS,sBAAsB,CAAC,QAAyB,OAAgB,MAAoB;AAAA,EAC3F,IAAI,CAAC,SAAS,KAAK,GAAG;AAAA,IACpB,MAAM,IAAI,wBAAwB,mBAAmB,2BAA2B;AAAA,EAClF;AAAA,EAEA,MAAM,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,WAAW,CAAC;AAAA,EAC3D,WAAW,WAAW,OAAO,KAAK,KAAK,GAAG;AAAA,IACxC,IAAI,CAAC,cAAc,IAAI,OAAO,GAAG;AAAA,MAC/B,MAAM,IAAI,wBAAwB,yBAAyB,QAAQ,UAAU;AAAA,IAC/E;AAAA,EACF;AAAA,EAEA,IAAI,MAAM,iBAAiB,OAAO,cAAc;AAAA,IAC9C,MAAM,IAAI,wBACR,mBAAmB,8BAA8B,OAAO,eAC1D;AAAA,EACF;AAAA,EAEA,IAAI,OAAO,MAAM,cAAc,UAAU;AAAA,IACvC,MAAM,IAAI,wBAAwB,mBAAmB,iCAAiC;AAAA,EACxF;AAAA;;;ACHK,SAAS,sBAAsD,CACpE,YAC+B;AAAA,EAC/B,MAAM,eAAe,WAAW,WAAW,IAAI,CAAC,aAAa;AAAA,IAC3D,MAAM,QAA+E;AAAA,MACnF,cAAc,WAAW;AAAA,MACzB,IAAI,SAAS;AAAA,MACb;AAAA,IACF;AAAA,IACA,OAAO,CAAC,SAAS,IAAI,KAAK;AAAA,GAC3B;AAAA,EAED,OAAO,OAAO,YAAY,YAAY;AAAA;AAMjC,SAAS,kBAAkD,CAChE,YAC2B;AAAA,EAC3B,MAAM,eAAe,WAAW,MAAM,IAAI,CAAC,SAAS;AAAA,IAClD,MAAM,QAKF;AAAA,MACF,cAAc,WAAW;AAAA,MACzB,IAAI,KAAK;AAAA,MACT,oBAAoB,KAAK;AAAA,MACzB;AAAA,IACF;AAAA,IACA,OAAO,CAAC,KAAK,IAAI,KAAK;AAAA,GACvB;AAAA,EAED,OAAO,OAAO,YAAY,YAAY;AAAA;",
+  "debugId": "912178D6A694401B64756E2164756E21",
+  "names": []
+}

package/dist/chunk-4pycxcj3.js

@@ -0,0 +1,35 @@
+// @bun
+// src/blob-storage/derive.ts
+function blobDigestHex(digest) {
+  return digest.slice("sha256:".length);
+}
+function blobIdFromDigest(digest) {
+  return `blob_${blobDigestHex(digest)}`;
+}
+
+// src/blob-storage/validation.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isBlobDigest(value) {
+  return typeof value === "string" && value.startsWith("sha256:") && value.length > "sha256:".length;
+}
+function isFileRef(value) {
+  return isPlainObject(value) && typeof value.blobId === "string" && value.blobId.trim().length > 0 && isBlobDigest(value.digest) && value.blobId === blobIdFromDigest(value.digest) && typeof value.sizeBytes === "number" && Number.isInteger(value.sizeBytes) && value.sizeBytes >= 0 && (value.fileName === undefined || typeof value.fileName === "string") && (value.mediaType === undefined || typeof value.mediaType === "string") && (value.logicalPath === undefined || typeof value.logicalPath === "string");
+}
+function supportsDirectUpload(storage) {
+  const candidate = storage;
+  return typeof candidate.createUpload === "function" && typeof candidate.signUploadPart === "function" && typeof candidate.completeUpload === "function" && typeof candidate.abortUpload === "function";
+}
+function supportsRangeRead(storage) {
+  const candidate = storage;
+  return typeof candidate.openRange === "function";
+}
+
+export { blobDigestHex, blobIdFromDigest, isBlobDigest, isFileRef, supportsDirectUpload, supportsRangeRead };
+
+//# debugId=67B4834FB7B6EE4A64756E2164756E21

package/dist/chunk-4pycxcj3.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/blob-storage/derive.ts", "../src/blob-storage/validation.ts"],
+  "sourcesContent": [
+    "import type { BlobDigest } from \"./types\"\n\n// Pure, crypto-free derivations of blob identity from a digest. Kept out of\n// `utils.ts` (which imports `node:crypto`) so the browser-safe `./browser`\n// barrel can reuse them without dragging Node crypto into the client bundle.\n\nexport function blobDigestHex(digest: BlobDigest): string {\n  return digest.slice(\"sha256:\".length)\n}\n\nexport function blobIdFromDigest(digest: BlobDigest): string {\n  return `blob_${blobDigestHex(digest)}`\n}\n",
+    "import { blobIdFromDigest } from \"./derive\"\nimport type {\n  BlobDigest,\n  BlobStorage,\n  DirectUploadBlobStorage,\n  FileRef,\n  RangeReadableBlobStorage,\n} from \"./types\"\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    return false\n  }\n\n  const prototype = Object.getPrototypeOf(value)\n  return prototype === Object.prototype || prototype === null\n}\n\nexport function isBlobDigest(value: unknown): value is BlobDigest {\n  return typeof value === \"string\" && value.startsWith(\"sha256:\") && value.length > \"sha256:\".length\n}\n\nexport function isFileRef(value: unknown): value is FileRef {\n  return (\n    isPlainObject(value) &&\n    typeof value.blobId === \"string\" &&\n    value.blobId.trim().length > 0 &&\n    isBlobDigest(value.digest) &&\n    // Blob identity is content-addressed: the id must be derivable from the digest.\n    // Rejecting a mismatch guards against tampered or malformed references.\n    value.blobId === blobIdFromDigest(value.digest) &&\n    typeof value.sizeBytes === \"number\" &&\n    Number.isInteger(value.sizeBytes) &&\n    value.sizeBytes >= 0 &&\n    (value.fileName === undefined || typeof value.fileName === \"string\") &&\n    (value.mediaType === undefined || typeof value.mediaType === \"string\") &&\n    (value.logicalPath === undefined || typeof value.logicalPath === \"string\")\n  )\n}\n\nexport function supportsDirectUpload(\n  storage: BlobStorage\n): storage is BlobStorage & DirectUploadBlobStorage {\n  const candidate = storage as Partial<DirectUploadBlobStorage>\n  return (\n    typeof candidate.createUpload === \"function\" &&\n    typeof candidate.signUploadPart === \"function\" &&\n    typeof candidate.completeUpload === \"function\" &&\n    typeof candidate.abortUpload === \"function\"\n  )\n}\n\nexport function supportsRangeRead(\n  storage: BlobStorage\n): storage is BlobStorage & RangeReadableBlobStorage {\n  const candidate = storage as Partial<RangeReadableBlobStorage>\n  return typeof candidate.openRange === \"function\"\n}\n"
+  ],
+  "mappings": ";;AAMO,SAAS,aAAa,CAAC,QAA4B;AAAA,EACxD,OAAO,OAAO,MAAM,UAAU,MAAM;AAAA;AAG/B,SAAS,gBAAgB,CAAC,QAA4B;AAAA,EAC3D,OAAO,QAAQ,cAAc,MAAM;AAAA;;;ACFrC,SAAS,aAAa,CAAC,OAAkD;AAAA,EACvE,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GAAG;AAAA,IACvE,OAAO;AAAA,EACT;AAAA,EAEA,MAAM,YAAY,OAAO,eAAe,KAAK;AAAA,EAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AAAA;AAGlD,SAAS,YAAY,CAAC,OAAqC;AAAA,EAChE,OAAO,OAAO,UAAU,YAAY,MAAM,WAAW,SAAS,KAAK,MAAM,SAAS,UAAU;AAAA;AAGvF,SAAS,SAAS,CAAC,OAAkC;AAAA,EAC1D,OACE,cAAc,KAAK,KACnB,OAAO,MAAM,WAAW,YACxB,MAAM,OAAO,KAAK,EAAE,SAAS,KAC7B,aAAa,MAAM,MAAM,KAGzB,MAAM,WAAW,iBAAiB,MAAM,MAAM,KAC9C,OAAO,MAAM,cAAc,YAC3B,OAAO,UAAU,MAAM,SAAS,KAChC,MAAM,aAAa,MAClB,MAAM,aAAa,aAAa,OAAO,MAAM,aAAa,cAC1D,MAAM,cAAc,aAAa,OAAO,MAAM,cAAc,cAC5D,MAAM,gBAAgB,aAAa,OAAO,MAAM,gBAAgB;AAAA;AAI9D,SAAS,oBAAoB,CAClC,SACkD;AAAA,EAClD,MAAM,YAAY;AAAA,EAClB,OACE,OAAO,UAAU,iBAAiB,cAClC,OAAO,UAAU,mBAAmB,cACpC,OAAO,UAAU,mBAAmB,cACpC,OAAO,UAAU,gBAAgB;AAAA;AAI9B,SAAS,iBAAiB,CAC/B,SACmD;AAAA,EACnD,MAAM,YAAY;AAAA,EAClB,OAAO,OAAO,UAAU,cAAc;AAAA;",
+  "debugId": "67B4834FB7B6EE4A64756E2164756E21",
+  "names": []
+}