pikelet-wasm 0.7.0 → 0.8.0

package/{pancake-errors.js → pikelet-errors.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const PANCAKE_ERROR_CODES = Object.freeze({
+const PIKELET_ERROR_CODES = Object.freeze({
     INVALID_ARGUMENT: 'INVALID_ARGUMENT',
     DIMENSION_MISMATCH: 'DIMENSION_MISMATCH',
     INVALID_VECTOR: 'INVALID_VECTOR',
@@ -17,24 +17,25 @@ const PANCAKE_ERROR_CODES = Object.freeze({
     INTERNAL_INVARIANT: 'INTERNAL_INVARIANT',
     // Reserved for the deferred shared-runtime API.
     INDEX_LIMIT: 'INDEX_LIMIT',
+    ARTIFACT_CHANGED: 'ARTIFACT_CHANGED',
 });
 
-class PancakeError extends Error {
+class PikeletError extends Error {
     constructor(code, message, details, cause) {
         super(message);
-        this.name = 'PancakeError';
+        this.name = 'PikeletError';
         this.code = code;
         if (details !== undefined) this.details = details;
         if (cause !== undefined) this.cause = cause;
     }
 }
 
-function pancakeError(code, message, details, cause) {
-    return new PancakeError(code, message, details, cause);
+function pikeletError(code, message, details, cause) {
+    return new PikeletError(code, message, details, cause);
 }
 
 module.exports = {
-    PancakeError,
-    PANCAKE_ERROR_CODES,
-    pancakeError,
+    PikeletError,
+    PIKELET_ERROR_CODES,
+    pikeletError,
 };

package/{pancake.d.ts → pikelet.d.ts}

@@ -1,6 +1,6 @@
 export type Metric = 'cosine' | 'l2';
 
-export const PANCAKE_ERROR_CODES: Readonly<{
+export const PIKELET_ERROR_CODES: Readonly<{
   INVALID_ARGUMENT: 'INVALID_ARGUMENT';
   DIMENSION_MISMATCH: 'DIMENSION_MISMATCH';
   INVALID_VECTOR: 'INVALID_VECTOR';
@@ -18,13 +18,13 @@ export const PANCAKE_ERROR_CODES: Readonly<{
   INDEX_LIMIT: 'INDEX_LIMIT';
 }>;
 
-export type PancakeErrorCode = typeof PANCAKE_ERROR_CODES[keyof typeof PANCAKE_ERROR_CODES];
+export type PikeletErrorCode = typeof PIKELET_ERROR_CODES[keyof typeof PIKELET_ERROR_CODES];
 
-export class PancakeError extends Error {
-  readonly code: PancakeErrorCode;
+export class PikeletError extends Error {
+  readonly code: PikeletErrorCode;
   readonly details?: Readonly<Record<string, unknown>>;
   readonly cause?: unknown;
-  constructor(code: PancakeErrorCode, message: string, details?: Readonly<Record<string, unknown>>, cause?: unknown);
+  constructor(code: PikeletErrorCode, message: string, details?: Readonly<Record<string, unknown>>, cause?: unknown);
 }
 
 export type VectorInput = Float32Array | readonly number[];
@@ -68,10 +68,10 @@ export interface SearchOptions {
 
 export interface FromVectorsResult<Id = unknown> {
   /** Created and populated index. Caller owns dispose(). */
-  index: PancakeIndex;
-  /** Stable Pancake IDs returned in insertion order. */
+  index: PikeletIndex;
+  /** Stable Pikelet IDs returned in insertion order. */
   ids: number[];
-  /** Mapping from Pancake IDs back to caller-provided source IDs. */
+  /** Mapping from Pikelet IDs back to caller-provided source IDs. */
   idMap: Map<number, Id>;
 }
 
@@ -90,7 +90,7 @@ export interface JsonFileOptions extends Omit<CreateOptions, 'dim'> {
 
 export interface RestoreOptions extends Partial<CreateOptions> {}
 
-export type SnapshotFormat = 'pancake' | 'raw';
+export type SnapshotFormat = 'pikelet' | 'raw';
 
 export interface SnapshotInspection {
   readonly format: SnapshotFormat;
@@ -141,7 +141,7 @@ export interface RangeArtifactSearchOptions {
   maxRangeBytes?: number;
 }
 
-/** A decoded graph record, as returned by {@link PancakeRangeArtifact.readNode}. */
+/** A decoded graph record, as returned by {@link PikeletRangeArtifact.readNode}. */
 export interface RangeArtifactNode {
   readonly id: number;
   readonly level: number;
@@ -220,7 +220,7 @@ export interface RangeArtifactBuildOptions {
 }
 
 export interface RangeArtifactBuildManifest {
-  readonly format: 'pancake-range-artifact';
+  readonly format: 'pikelet-range-artifact';
   readonly formatVersion: number;
   /** Hex SHA-256 whole-segment digests stamped into the v3 header. */
   readonly integrity: Readonly<{
@@ -240,7 +240,7 @@ export interface RangeArtifactBuildManifest {
 /**
  * Node-only file-backed range source. This is NOT a named runtime export of
  * any entrypoint: reach the constructor via the Node API object
- * (`Pancake.NodeFileRangeSource`) or the `pikelet-wasm/artifact` subpath.
+ * (`Pikelet.NodeFileRangeSource`) or the `pikelet-wasm/artifact` subpath.
  */
 export interface NodeFileRangeSource extends RangeReadSource {
   readonly filePath: string;
@@ -256,10 +256,10 @@ export interface NodeFileRangeSourceConstructor {
 
 /**
  * A range-readable Search Artifact reader. The class is NOT a named runtime
- * export of any entrypoint: reach it via `Pancake.RangeArtifact` or the
+ * export of any entrypoint: reach it via `Pikelet.RangeArtifact` or the
  * `pikelet-wasm/artifact` subpath.
  */
-export interface PancakeRangeArtifact {
+export interface PikeletRangeArtifact {
   readonly version: number;
   readonly kind: number;
   readonly dim: number;
@@ -299,11 +299,11 @@ export interface PancakeRangeArtifact {
   close(): Promise<void>;
 }
 
-export interface PancakeRangeArtifactConstructor {
-  open(source: RangeReadSource, options?: RangeArtifactOpenOptions): Promise<PancakeRangeArtifact>;
+export interface PikeletRangeArtifactConstructor {
+  open(source: RangeReadSource, options?: RangeArtifactOpenOptions): Promise<PikeletRangeArtifact>;
   /** Node entrypoints only. */
-  openFile(filePath: string, options?: RangeArtifactOpenOptions): Promise<PancakeRangeArtifact>;
-  readonly prototype: PancakeRangeArtifact;
+  openFile(filePath: string, options?: RangeArtifactOpenOptions): Promise<PikeletRangeArtifact>;
+  readonly prototype: PikeletRangeArtifact;
 }
 
 /** Resident sketch tier: the coarse staged-boot tier or the full tier. */
@@ -335,7 +335,7 @@ export interface SketchArtifactOpenOptions {
   /**
    * Staged boot: when the artifact carries a micro tier, become searchable
    * after loading only the stage-1 prefix and swap to the full tier in the
-   * background (see {@link PancakeSketchArtifact.fullyResident}). Ignored for
+   * background (see {@link PikeletSketchArtifact.fullyResident}). Ignored for
    * artifacts without a micro tier. Default: false.
    */
   staged?: boolean;
@@ -468,7 +468,7 @@ export interface SketchArtifactBuildOptions {
 }
 
 export interface SketchArtifactBuildManifest {
-  readonly format: 'pancake-sketch-artifact';
+  readonly format: 'pikelet-sketch-artifact';
   readonly formatVersion: number;
   /** Output path; absent on the bytes-in/bytes-out builder. */
   readonly file?: string;
@@ -489,10 +489,10 @@ export interface SketchArtifactBuildManifest {
 
 /**
  * A sketch Search Artifact reader. The class is NOT a named runtime export of
- * any entrypoint: reach it via `Pancake.SketchArtifact` or the
+ * any entrypoint: reach it via `Pikelet.SketchArtifact` or the
  * `pikelet-wasm/artifact` subpath.
  */
-export interface PancakeSketchArtifact {
+export interface PikeletSketchArtifact {
   readonly metric: number;
   readonly dim: number;
   readonly count: number;
@@ -509,7 +509,7 @@ export interface PancakeSketchArtifact {
    * Already resolved for non-staged opens; rejects if the background stage-2
    * load fails.
    */
-  readonly fullyResident: Promise<PancakeSketchArtifact>;
+  readonly fullyResident: Promise<PikeletSketchArtifact>;
   readonly recommendedRerank: number;
   readonly residentBytes: number;
   readonly residentVerified: boolean;
@@ -531,11 +531,11 @@ export interface PancakeSketchArtifact {
   close(): Promise<void>;
 }
 
-export interface PancakeSketchArtifactConstructor {
-  open(source: RangeReadSource, options?: SketchArtifactOpenOptions): Promise<PancakeSketchArtifact>;
+export interface PikeletSketchArtifactConstructor {
+  open(source: RangeReadSource, options?: SketchArtifactOpenOptions): Promise<PikeletSketchArtifact>;
   /** Node entrypoints only. */
-  openFile(filePath: string, options?: SketchArtifactOpenOptions): Promise<PancakeSketchArtifact>;
-  readonly prototype: PancakeSketchArtifact;
+  openFile(filePath: string, options?: SketchArtifactOpenOptions): Promise<PikeletSketchArtifact>;
+  readonly prototype: PikeletSketchArtifact;
 }
 
 export interface MemoryUsage {
@@ -558,7 +558,7 @@ export interface ResolvedConfig {
   readonly seed: number;
 }
 
-export interface PancakeIndex {
+export interface PikeletIndex {
   /** Insert a single vector. Returns its stable external ID. */
   add(vector: VectorInput): number;
   /** Insert multiple vectors. Returns stable external IDs in insertion order. */
@@ -617,23 +617,23 @@ export interface PancakeIndex {
 /**
  * The portable API exposed by every entrypoint (Node, browser, Workers).
  * The browser/Workers entrypoints expose exactly this surface; the Node
- * entrypoints add file helpers (see {@link NodePancakeApi}).
+ * entrypoints add file helpers (see {@link NodePikeletApi}).
  */
-export interface PancakeApi {
-  readonly PancakeError: typeof PancakeError;
-  readonly PANCAKE_ERROR_CODES: typeof PANCAKE_ERROR_CODES;
-  readonly RangeArtifact: PancakeRangeArtifactConstructor;
-  readonly SketchArtifact: PancakeSketchArtifactConstructor;
+export interface PikeletApi {
+  readonly PikeletError: typeof PikeletError;
+  readonly PIKELET_ERROR_CODES: typeof PIKELET_ERROR_CODES;
+  readonly RangeArtifact: PikeletRangeArtifactConstructor;
+  readonly SketchArtifact: PikeletSketchArtifactConstructor;
   /** Build a WASM-backed SIMD scanner for a sketch artifact's resident tier. */
-  createSketchScanner(artifact: PancakeSketchArtifact, options?: SketchScannerOptions): Promise<SketchScanner>;
-  /** Create a new Pancake index using the runtime-specific packaged entrypoint. */
-  create(opts: CreateOptions): Promise<PancakeIndex>;
+  createSketchScanner(artifact: PikeletSketchArtifact, options?: SketchScannerOptions): Promise<SketchScanner>;
+  /** Create a new Pikelet index using the runtime-specific packaged entrypoint. */
+  create(opts: CreateOptions): Promise<PikeletIndex>;
   /** Restore an envelope snapshot, inferring its construction config. */
-  restore(snapshot: Uint8Array | ArrayBufferLike, overrides?: RestoreOptions): Promise<PancakeIndex>;
+  restore(snapshot: Uint8Array | ArrayBufferLike, overrides?: RestoreOptions): Promise<PikeletIndex>;
   /** Validate and inspect snapshot headers without creating a WASM index. */
   inspectSnapshot(snapshot: Uint8Array | ArrayBufferLike): SnapshotInspection;
   /** Create an index, run a callback, and always dispose the index afterward. */
-  withIndex<T>(opts: CreateOptions, fn: (index: PancakeIndex) => T | Promise<T>): Promise<T>;
+  withIndex<T>(opts: CreateOptions, fn: (index: PikeletIndex) => T | Promise<T>): Promise<T>;
   /** Create and populate an index from raw vectors. Infers dim and maxElements by default. */
   fromVectors(vectors: readonly VectorInput[], opts?: Omit<CreateOptions, 'dim'> & Partial<Pick<CreateOptions, 'dim'>>): Promise<FromVectorsResult<never>>;
   /** Create and populate an index from { id, vector } records. */
@@ -644,29 +644,29 @@ export interface PancakeApi {
  * The Node.js API: the portable surface plus filesystem helpers. These helpers
  * exist only on the Node entrypoints (`pikelet-wasm`, `pikelet-wasm/node`); the
  * browser/Workers entrypoints do not expose them, and importing those returns
- * the narrower {@link PancakeApi}.
+ * the narrower {@link PikeletApi}.
  */
-export interface NodePancakeApi extends PancakeApi {
+export interface NodePikeletApi extends PikeletApi {
   readonly NodeFileRangeSource: NodeFileRangeSourceConstructor;
   /**
-   * Build a range-readable Search Artifact from a uint8 Pancake snapshot.
-   * @deprecated The `.pancake-range` profile is deprecated
-   * (spec/SEARCH_ARTIFACT_CONTRACT.md 9.2); build a `.pancake-sketch`
+   * Build a range-readable Search Artifact from a uint8 Pikelet snapshot.
+   * @deprecated The `.pikelet-range` profile is deprecated
+   * (spec/SEARCH_ARTIFACT_CONTRACT.md 9.2); build a `.pikelet-sketch`
    * artifact instead. Readers stay supported for existing artifacts.
    */
   buildRangeArtifact(snapshot: Uint8Array | ArrayBufferLike, outPath: string, opts?: RangeArtifactBuildOptions): RangeArtifactBuildManifest;
   /**
-   * Build a range-readable Search Artifact from a uint8 Pancake snapshot file.
-   * @deprecated The `.pancake-range` profile is deprecated
-   * (spec/SEARCH_ARTIFACT_CONTRACT.md 9.2); build a `.pancake-sketch`
+   * Build a range-readable Search Artifact from a uint8 Pikelet snapshot file.
+   * @deprecated The `.pikelet-range` profile is deprecated
+   * (spec/SEARCH_ARTIFACT_CONTRACT.md 9.2); build a `.pikelet-sketch`
    * artifact instead. Readers stay supported for existing artifacts.
    */
   buildRangeArtifactFile(snapshotPath: string, outPath: string, opts?: RangeArtifactBuildOptions): RangeArtifactBuildManifest;
   /** Open a range-readable Search Artifact from a local file. */
-  openRangeArtifactFile(filePath: string, opts?: RangeArtifactOpenOptions): Promise<PancakeRangeArtifact>;
-  /** Build a sketch Search Artifact from a uint8 Pancake snapshot. */
+  openRangeArtifactFile(filePath: string, opts?: RangeArtifactOpenOptions): Promise<PikeletRangeArtifact>;
+  /** Build a sketch Search Artifact from a uint8 Pikelet snapshot. */
   buildSketchArtifact(snapshot: Uint8Array | ArrayBufferLike, outPath: string, opts?: SketchArtifactBuildOptions): SketchArtifactBuildManifest;
-  /** Build a sketch Search Artifact from a uint8 Pancake snapshot file. */
+  /** Build a sketch Search Artifact from a uint8 Pikelet snapshot file. */
   buildSketchArtifactFile(snapshotPath: string, outPath: string, opts?: SketchArtifactBuildOptions): SketchArtifactBuildManifest;
   /**
    * Bytes-in/bytes-out sketch build for producers assembling segments in
@@ -675,17 +675,17 @@ export interface NodePancakeApi extends PancakeApi {
    */
   buildSketchArtifactBytes(snapshot: Uint8Array | ArrayBufferLike, opts?: SketchArtifactBuildOptions): { bytes: Uint8Array; manifest: SketchArtifactBuildManifest };
   /** Open a sketch Search Artifact from a local file. */
-  openSketchArtifactFile(filePath: string, opts?: SketchArtifactOpenOptions): Promise<PancakeSketchArtifact>;
+  openSketchArtifactFile(filePath: string, opts?: SketchArtifactOpenOptions): Promise<PikeletSketchArtifact>;
   /** Load vectors from a JSON/JSONL file and build an index. */
   loadJsonFile<Id = unknown>(filePath: string, opts?: JsonFileOptions): Promise<FromVectorsResult<Id>>;
   /**
-   * Load a previously exported Pancake snapshot from disk. Envelope snapshots
+   * Load a previously exported Pikelet snapshot from disk. Envelope snapshots
    * carry their own config, so `opts` is only required for raw engine
    * snapshots (which need the full create config).
    */
-  loadSnapshotFile(filePath: string, opts?: SnapshotFileOptions): Promise<PancakeIndex>;
+  loadSnapshotFile(filePath: string, opts?: SnapshotFileOptions): Promise<PikeletIndex>;
 }
 
-declare const Pancake: NodePancakeApi;
+declare const Pikelet: NodePikeletApi;
 
-export default Pancake;
+export default Pikelet;

package/{pancake.js → pikelet.js}

@@ -2,10 +2,10 @@
 
 const loadEngine = require('./dist/engine.js');
 const loadScalarEngine = require('./dist/engine.scalar.js');
-const createPancakeApi = require('./pancake-core.js');
-const { PancakeError, PANCAKE_ERROR_CODES, pancakeError } = require('./pancake-errors.js');
-const { PancakeRangeArtifact, PancakeSketchArtifact, createSketchScanner, NodeFileRangeSource, buildRangeArtifact, buildRangeArtifactFile, buildSketchArtifact, buildSketchArtifactBytes, buildSketchArtifactFile } = require('./pancake-artifact.js');
-const { createCachedModuleLoader } = require('./pancake-loader.js');
+const createPikeletApi = require('./pikelet-core.js');
+const { PikeletError, PIKELET_ERROR_CODES, pikeletError } = require('./pikelet-errors.js');
+const { PikeletRangeArtifact, PikeletSketchArtifact, createSketchScanner, NodeFileRangeSource, buildRangeArtifact, buildRangeArtifactFile, buildSketchArtifact, buildSketchArtifactBytes, buildSketchArtifactFile } = require('./pikelet-artifact.js');
+const { createCachedModuleLoader } = require('./pikelet-loader.js');
 const _path = require('path');
 const _fs = require('fs');
 let _engineVariantPromise = null;
@@ -29,13 +29,13 @@ function readWasmBinary(fileName) {
         );
     } catch (error) {
         const message = error && error.message ? error.message : String(error);
-        throw pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED, `Failed to load Pancake WASM binary (${fileName}): ${message}`, { fileName }, error);
+        throw pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED, `Failed to load Pikelet WASM binary (${fileName}): ${message}`, { fileName }, error);
     }
 }
 
 function makeLoadError(message, error) {
     const detail = error && error.message ? error.message : String(error);
-    return pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
+    return pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
 }
 
 const _moduleLoader = createCachedModuleLoader((variant) =>
@@ -58,7 +58,7 @@ function parseJsonLines(text, filePath) {
             rows.push(JSON.parse(line));
         } catch (error) {
             const message = error && error.message ? error.message : String(error);
-            throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `Failed to parse JSONL in ${filePath} at line ${i + 1}: ${message}`, { filePath, line: i + 1 }, error);
+            throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `Failed to parse JSONL in ${filePath} at line ${i + 1}: ${message}`, { filePath, line: i + 1 }, error);
         }
     }
     return rows;
@@ -67,22 +67,22 @@ function parseJsonLines(text, filePath) {
 function inferJsonFormat(filePath) {
     if (/\.json$/i.test(filePath)) return 'json';
     if (/\.(jsonl|ndjson)$/i.test(filePath)) return 'jsonl';
-    throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `loadJsonFile() could not infer format from '${filePath}'. Use a .json/.jsonl/.ndjson extension or pass opts.format.`, { filePath });
+    throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `loadJsonFile() could not infer format from '${filePath}'. Use a .json/.jsonl/.ndjson extension or pass opts.format.`, { filePath });
 }
 
 function remapJsonRows(rows, vectorKey, idKey) {
     if (!Array.isArray(rows)) {
-        throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, 'loadJsonFile() expects a JSON array or JSONL sequence of vectors/records');
+        throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, 'loadJsonFile() expects a JSON array or JSONL sequence of vectors/records');
     }
     return rows.map((row, i) => {
         if (row instanceof Float32Array || Array.isArray(row)) {
             return row;
         }
         if (!row || typeof row !== 'object') {
-            throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `loadJsonFile() expected an object or vector at index ${i}`, { index: i });
+            throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `loadJsonFile() expected an object or vector at index ${i}`, { index: i });
         }
         if (!(vectorKey in row)) {
-            throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `loadJsonFile() missing vectorKey '${vectorKey}' at index ${i}`, { index: i, vectorKey });
+            throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `loadJsonFile() missing vectorKey '${vectorKey}' at index ${i}`, { index: i, vectorKey });
         }
         const mapped = { vector: row[vectorKey] };
         if (Object.prototype.hasOwnProperty.call(row, idKey)) {
@@ -94,13 +94,13 @@ function remapJsonRows(rows, vectorKey, idKey) {
 
 function validateFilePath(filePath, helperName) {
     if (typeof filePath !== 'string' || filePath.length === 0) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() requires a non-empty file path`);
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() requires a non-empty file path`);
     }
 }
 
 function validateMaxFileBytes(maxFileBytes, helperName) {
     if (!Number.isInteger(maxFileBytes) || maxFileBytes <= 0) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() maxFileBytes must be a positive integer`, { maxFileBytes });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() maxFileBytes must be a positive integer`, { maxFileBytes });
     }
 }
 
@@ -110,17 +110,17 @@ function statRegularFile(filePath, helperName) {
         stat = _fs.statSync(filePath);
     } catch (error) {
         const message = error && error.message ? error.message : String(error);
-        throw pancakeError(PANCAKE_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not stat ${filePath}: ${message}`, { filePath }, error);
+        throw pikeletError(PIKELET_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not stat ${filePath}: ${message}`, { filePath }, error);
     }
     if (!stat.isFile()) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() expected a regular file: ${filePath}`, { filePath });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() expected a regular file: ${filePath}`, { filePath });
     }
     return stat;
 }
 
 function enforceFileSize(stat, maxFileBytes, helperName, filePath) {
     if (stat.size > maxFileBytes) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() file exceeds maxFileBytes (${stat.size} > ${maxFileBytes}): ${filePath}`, { filePath, fileBytes: stat.size, maxFileBytes });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() file exceeds maxFileBytes (${stat.size} > ${maxFileBytes}): ${filePath}`, { filePath, fileBytes: stat.size, maxFileBytes });
     }
 }
 
@@ -133,7 +133,7 @@ function readUtf8FileWithLimit(filePath, helperName, maxFileBytes) {
         return _fs.readFileSync(filePath, 'utf8');
     } catch (error) {
         const message = error && error.message ? error.message : String(error);
-        throw pancakeError(PANCAKE_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
+        throw pikeletError(PIKELET_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
     }
 }
 
@@ -146,18 +146,18 @@ function readBinaryFileWithLimit(filePath, helperName, maxFileBytes) {
         return _fs.readFileSync(filePath);
     } catch (error) {
         const message = error && error.message ? error.message : String(error);
-        throw pancakeError(PANCAKE_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
+        throw pikeletError(PIKELET_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
     }
 }
 
 function validateSnapshotBytes(snapshot, filePath) {
     if (!snapshot || snapshot.byteLength < 4) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() snapshot is too small to be valid: ${filePath}`, { filePath });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() snapshot is too small to be valid: ${filePath}`, { filePath });
     }
     const view = new DataView(snapshot.buffer, snapshot.byteOffset, snapshot.byteLength);
     const magic = view.getUint32(0, true);
     if (!SUPPORTED_SNAPSHOT_MAGICS.has(magic)) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() unsupported snapshot file type: ${filePath}`, { filePath, magic });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() unsupported snapshot file type: ${filePath}`, { filePath, magic });
     }
 }
 
@@ -168,7 +168,7 @@ async function loadNodeEngine() {
         try {
             return await _moduleLoader.instantiate(loadScalarEngine, 'scalar');
         } catch (error) {
-            throw makeLoadError('Pancake failed to load the scalar WASM engine', error);
+            throw makeLoadError('Pikelet failed to load the scalar WASM engine', error);
         }
     }
 
@@ -181,37 +181,37 @@ async function loadNodeEngine() {
             return engine;
         } catch (scalarError) {
             throw makeLoadError(
-                `Pancake failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
+                `Pikelet failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
                 scalarError
             );
         }
     }
 }
 
-const Pancake = createPancakeApi(loadNodeEngine);
+const Pikelet = createPikeletApi(loadNodeEngine);
 
-Pancake.RangeArtifact = PancakeRangeArtifact;
-Pancake.NodeFileRangeSource = NodeFileRangeSource;
-Pancake.buildRangeArtifact = buildRangeArtifact;
-Pancake.buildRangeArtifactFile = buildRangeArtifactFile;
+Pikelet.RangeArtifact = PikeletRangeArtifact;
+Pikelet.NodeFileRangeSource = NodeFileRangeSource;
+Pikelet.buildRangeArtifact = buildRangeArtifact;
+Pikelet.buildRangeArtifactFile = buildRangeArtifactFile;
 
-Pancake.openRangeArtifactFile = async function openRangeArtifactFile(filePath, opts) {
+Pikelet.openRangeArtifactFile = async function openRangeArtifactFile(filePath, opts) {
     validateFilePath(filePath, 'openRangeArtifactFile');
-    return PancakeRangeArtifact.openFile(filePath, opts);
+    return PikeletRangeArtifact.openFile(filePath, opts);
 };
 
-Pancake.SketchArtifact = PancakeSketchArtifact;
-Pancake.createSketchScanner = (artifact, options) => createSketchScanner(loadNodeEngine, artifact, options);
-Pancake.buildSketchArtifact = buildSketchArtifact;
-Pancake.buildSketchArtifactBytes = buildSketchArtifactBytes;
-Pancake.buildSketchArtifactFile = buildSketchArtifactFile;
+Pikelet.SketchArtifact = PikeletSketchArtifact;
+Pikelet.createSketchScanner = (artifact, options) => createSketchScanner(loadNodeEngine, artifact, options);
+Pikelet.buildSketchArtifact = buildSketchArtifact;
+Pikelet.buildSketchArtifactBytes = buildSketchArtifactBytes;
+Pikelet.buildSketchArtifactFile = buildSketchArtifactFile;
 
-Pancake.openSketchArtifactFile = async function openSketchArtifactFile(filePath, opts) {
+Pikelet.openSketchArtifactFile = async function openSketchArtifactFile(filePath, opts) {
     validateFilePath(filePath, 'openSketchArtifactFile');
-    return PancakeSketchArtifact.openFile(filePath, opts);
+    return PikeletSketchArtifact.openFile(filePath, opts);
 };
 
-Pancake.loadSnapshotFile = async function loadSnapshotFile(filePath, opts) {
+Pikelet.loadSnapshotFile = async function loadSnapshotFile(filePath, opts) {
     const {
         maxFileBytes = DEFAULT_SNAPSHOT_FILE_BYTES,
         ...createOpts
@@ -219,10 +219,10 @@ Pancake.loadSnapshotFile = async function loadSnapshotFile(filePath, opts) {
 
     const snapshot = readBinaryFileWithLimit(filePath, 'loadSnapshotFile', maxFileBytes);
     validateSnapshotBytes(snapshot, filePath);
-    return Pancake.restore(snapshot, createOpts);
+    return Pikelet.restore(snapshot, createOpts);
 };
 
-Pancake.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
+Pikelet.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
     const {
         format = inferJsonFormat(filePath),
         vectorKey = 'vector',
@@ -232,7 +232,7 @@ Pancake.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
     } = opts;
 
     if (format !== 'json' && format !== 'jsonl') {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `loadJsonFile() format must be 'json' or 'jsonl', got '${format}'`, { format });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `loadJsonFile() format must be 'json' or 'jsonl', got '${format}'`, { format });
     }
 
     const text = readUtf8FileWithLimit(filePath, 'loadJsonFile', maxFileBytes);
@@ -244,11 +244,11 @@ Pancake.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
             rows = JSON.parse(text);
         } catch (error) {
             const message = error && error.message ? error.message : String(error);
-            throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `Failed to parse JSON in ${filePath}: ${message}`, { filePath }, error);
+            throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `Failed to parse JSON in ${filePath}: ${message}`, { filePath }, error);
         }
     }
-    return Pancake.fromVectors(remapJsonRows(rows, vectorKey, idKey), createOpts);
+    return Pikelet.fromVectors(remapJsonRows(rows, vectorKey, idKey), createOpts);
 };
 
-module.exports = Pancake;
-module.exports.default = Pancake;
+module.exports = Pikelet;
+module.exports.default = Pikelet;