pikelet-wasm 0.7.0 → 0.8.1

package/{pancake-artifact-common.js → src/artifact/pikelet-artifact-common.js}

@@ -1,13 +1,13 @@
 'use strict';
 // Shared by the range and sketch artifact readers/builders: read budgets and
 // range validation, range sources, the result heap, snapshot parsing, and
-// SHA-256 helpers. Not a public entry; pancake-artifact.js re-exports what is public.
-// Split out of pancake-artifact.js (the public entry, which re-exports the
+// SHA-256 helpers. Not a public entry; pikelet-artifact.js re-exports what is public.
+// Split out of pikelet-artifact.js (the public entry, which re-exports the
 // three parts); see that file for the module map.
 
-const { pancakeError, PANCAKE_ERROR_CODES } = require('./pancake-errors.js');
+const { pikeletError, PIKELET_ERROR_CODES } = require('../errors/pikelet-errors.js');
 
-const PANCAKE_MAGIC = 0x504E434B;
+const PIKELET_MAGIC = 0x504E434B;
 const V1_ENVELOPE_HEADER_SIZE = 24;
 const V2_ENVELOPE_HEADER_SIZE = 20;
 const V3_ENVELOPE_HEADER_SIZE = 32;
@@ -54,16 +54,16 @@ async function mapLimit(items, limit, fn) {
 function checkArtifactRange(source, offset, length, label, limit = MAX_ARTIFACT_READ_BYTES) {
     if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length)
         || offset < 0 || length < 0 || !Number.isSafeInteger(offset + length)) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
             `Artifact ${label} range is out of bounds`, { offset, length });
     }
     const max = Math.min(limit, MAX_ARTIFACT_READ_BYTES);
     if (length > max) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
             `Artifact ${label} range exceeds the maximum read size`, { length, max });
     }
     if (source && Number.isSafeInteger(source.size) && offset + length > source.size) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
             `Artifact ${label} range extends past the source size`, { offset, length, size: source.size });
     }
     return length;
@@ -84,7 +84,7 @@ function resolveMaxReadBytes(value) {
     if (value === undefined) return DEFAULT_OPEN_READ_BYTES;
     if (value === Infinity) return MAX_ARTIFACT_READ_BYTES;
     if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT,
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT,
             'maxReadBytes must be a positive number or Infinity', { maxReadBytes: value });
     }
     return value;
@@ -95,7 +95,7 @@ function asUint8Array(bytes) {
     if (ArrayBuffer.isView(bytes)) {
         return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
-    throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, 'Range source returned a non-binary value');
+    throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, 'Range source returned a non-binary value');
 }
 
 // Both readers accept a maxCacheBytes option: undefined keeps the default,
@@ -106,7 +106,7 @@ function resolveMaxCacheBytes(value, floorBytes, defaultBytes) {
     if (value === undefined) return defaultBytes;
     if (value === Infinity) return Infinity;
     if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, 'maxCacheBytes must be a positive number or Infinity', { maxCacheBytes: value });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, 'maxCacheBytes must be a positive number or Infinity', { maxCacheBytes: value });
     }
     return Math.max(value, floorBytes);
 }
@@ -213,7 +213,7 @@ class NodeFileRangeSource {
 
     async read(offset, length) {
         if (this.fd === null) {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, 'NodeFileRangeSource is closed', { filePath: this.filePath });
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, 'NodeFileRangeSource is closed', { filePath: this.filePath });
         }
         // Defense in depth: the callers validate artifact-derived ranges, but
         // a future caller must not be able to drive a giant Buffer.alloc or a
@@ -221,7 +221,7 @@ class NodeFileRangeSource {
         if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length)
             || offset < 0 || length < 0 || length > MAX_ARTIFACT_READ_BYTES
             || offset + length > this.size) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
                 'NodeFileRangeSource.read() range is out of bounds', { offset, length, size: this.size });
         }
         const buffer = Buffer.alloc(length);
@@ -245,7 +245,7 @@ class NodeFileRangeSource {
 }
 
 // The artifact readers apply the same query-vector contract as the core
-// engine (pancake-core.js assertNumericVector / validateVectorValues): a
+// engine (pikelet-core.js assertNumericVector / validateVectorValues): a
 // plain array must hold real numbers (Float32Array.from would coerce '1',
 // '', true silently), every component must be finite for every metric (an
 // L2 search over NaN would otherwise return distance: NaN results), and a
@@ -253,31 +253,31 @@ class NodeFileRangeSource {
 function normalizeQuery(query, dim, metric = 0) {
     if (!(query instanceof Float32Array)) {
         if (!Array.isArray(query)) {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_VECTOR, 'search() query must be a Float32Array or number[]');
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_VECTOR, 'search() query must be a Float32Array or number[]');
         }
         for (let i = 0; i < query.length; i++) {
             if (typeof query[i] !== 'number') {
-                throw pancakeError(PANCAKE_ERROR_CODES.INVALID_VECTOR,
+                throw pikeletError(PIKELET_ERROR_CODES.INVALID_VECTOR,
                     `search() query must contain only numbers; found ${typeof query[i]} at index ${i}`, { index: i, actualType: typeof query[i] });
             }
         }
         query = Float32Array.from(query);
     }
     if (query.length !== dim) {
-        throw pancakeError(PANCAKE_ERROR_CODES.DIMENSION_MISMATCH, `search() query dimension ${query.length} does not match artifact dimension ${dim}`, { queryDim: query.length, dim });
+        throw pikeletError(PIKELET_ERROR_CODES.DIMENSION_MISMATCH, `search() query dimension ${query.length} does not match artifact dimension ${dim}`, { queryDim: query.length, dim });
     }
     let norm = 0;
     for (let i = 0; i < query.length; i++) {
         const value = query[i];
         if (!Number.isFinite(value)) {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_VECTOR, 'search() query contains non-finite value (NaN or Infinity)', { index: i, reason: 'non_finite' });
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_VECTOR, 'search() query contains non-finite value (NaN or Infinity)', { index: i, reason: 'non_finite' });
         }
         norm += value * value;
     }
     if (metric === 1) {
         norm = Math.sqrt(norm);
         if (!Number.isFinite(norm) || norm <= 1e-30) {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_VECTOR, 'search() query has invalid cosine norm', { reason: 'invalid_cosine_norm' });
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_VECTOR, 'search() query has invalid cosine norm', { reason: 'invalid_cosine_norm' });
         }
         const normalized = new Float32Array(query.length);
         for (let i = 0; i < query.length; i++) normalized[i] = query[i] / norm;
@@ -292,7 +292,7 @@ function normalizeQuery(query, dim, metric = 0) {
 // count results, so a k of 1e9 over 300 rows must not allocate 1e9 slots.
 function resolveSearchK(k, count) {
     if (!Number.isSafeInteger(k) || k < 1) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, 'search() k must be a positive integer', { k });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, 'search() k must be a positive integer', { k });
     }
     return Math.min(k, count);
 }
@@ -302,41 +302,41 @@ function resolveSearchK(k, count) {
 function resolveOptionalPositiveInt(value, name, fallback) {
     if (value === undefined || value === null || value === 0) return fallback;
     if (!Number.isSafeInteger(value) || value < 1) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `search() ${name} must be a positive integer (0 or undefined selects the default)`, { [name]: value });
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `search() ${name} must be a positive integer (0 or undefined selects the default)`, { [name]: value });
     }
     return value;
 }
 
 function unwrapSnapshot(bytes) {
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    if (bytes.byteLength < 4 || view.getUint32(0, true) !== PANCAKE_MAGIC) return bytes;
+    if (bytes.byteLength < 4 || view.getUint32(0, true) !== PIKELET_MAGIC) return bytes;
     // Envelope fields are untrusted: every size read from them must be
     // checked against the actual buffer before slicing, so a corrupt
     // envelope fails closed with a coded error instead of a raw RangeError.
     if (bytes.byteLength < 8) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Pancake envelope is truncated', { byteLength: bytes.byteLength });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Pikelet envelope is truncated', { byteLength: bytes.byteLength });
     }
     const version = view.getUint32(4, true);
     if (version === 1 || version === 2) {
         const headerSize = version === 1 ? V1_ENVELOPE_HEADER_SIZE : V2_ENVELOPE_HEADER_SIZE;
         if (bytes.byteLength < headerSize) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Pancake envelope is truncated', { version, byteLength: bytes.byteLength });
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Pikelet envelope is truncated', { version, byteLength: bytes.byteLength });
         }
         return bytes.subarray(headerSize);
     }
     if (version === 3) {
         if (bytes.byteLength < V3_ENVELOPE_HEADER_SIZE) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Pancake envelope is truncated', { version, byteLength: bytes.byteLength });
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Pikelet envelope is truncated', { version, byteLength: bytes.byteLength });
         }
         const mappingCount = view.getUint32(24, true);
         const rawSize = view.getUint32(28, true);
         const rawOffset = V3_ENVELOPE_HEADER_SIZE + mappingCount * MAPPING_ENTRY_SIZE;
         if (rawOffset + rawSize > bytes.byteLength) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Pancake envelope declares more data than the snapshot contains', { mappingCount, rawSize, byteLength: bytes.byteLength });
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Pikelet envelope declares more data than the snapshot contains', { mappingCount, rawSize, byteLength: bytes.byteLength });
         }
         return bytes.subarray(rawOffset, rawOffset + rawSize);
     }
-    throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `Unsupported Pancake envelope version ${version}`, { version });
+    throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `Unsupported Pikelet envelope version ${version}`, { version });
 }
 
 function parseUint8Snapshot(bytes) {
@@ -346,7 +346,7 @@ function parseUint8Snapshot(bytes) {
     // Snapshot bytes are untrusted: sizes read from the header drive every
     // subsequent read, so each read checks the remaining buffer and fails
     // closed with a coded error instead of a raw RangeError.
-    const truncated = () => pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot is truncated', { offset, byteLength: raw.byteLength });
+    const truncated = () => pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot is truncated', { offset, byteLength: raw.byteLength });
     const u32 = () => {
         if (raw.byteLength - offset < 4) throw truncated();
         const value = view.getUint32(offset, true);
@@ -371,22 +371,22 @@ function parseUint8Snapshot(bytes) {
     const metric = u32();
     const efConstruction = u32();
     if (magic !== UINT8_HNSW_MAGIC_V1) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Search Artifact export currently supports uint8 Pancake snapshots only');
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Search Artifact export currently supports uint8 Pikelet snapshots only');
     }
     // Contract §6: reject unknown future versions instead of parsing them
     // as v2 — a changed layout must fail closed, not misparse.
     if (version > 2) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported uint8 snapshot format version', { version });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported uint8 snapshot format version', { version });
     }
     if (metric !== 0 && metric !== 1) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported uint8 snapshot metric', { metric });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported uint8 snapshot metric', { metric });
     }
     // Same structural sanity the engine's own deserialize enforces; the
     // level cap mirrors MAX_DESERIALIZE_LEVEL in src/uint8_float_hnsw.hpp.
     if (dim < 1 || count < 1 || entryPoint >= count || maxLevel > 64
         || !Number.isSafeInteger(count * dim)
         || raw.byteLength - offset < count * 8 + count * dim) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot header is inconsistent', { dim, count, entryPoint, maxLevel, byteLength: raw.byteLength });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot header is inconsistent', { dim, count, entryPoint, maxLevel, byteLength: raw.byteLength });
     }
 
     const scales = new Float32Array(count);
@@ -405,7 +405,7 @@ function parseUint8Snapshot(bytes) {
     // Same envelope as the engine: create() accepts M in [2, 128] and fixes
     // M0 = 2*M, and its own import rejects M outside that range.
     if (!(M >= 2 && M <= 128) || !(M0 >= M && M0 <= 256)) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot graph parameters are implausible', { M, M0 });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot graph parameters are implausible', { M, M0 });
     }
     // Edge layout follows the engine's deserializer (uint8_float_hnsw.hpp):
     // version >= 2 stores {u32 id, f32 distance} per edge, version 1 stores
@@ -418,21 +418,21 @@ function parseUint8Snapshot(bytes) {
     for (let id = 0; id < count; id++) {
         const level = u32();
         if (level > maxLevel) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot node level exceeds header maxLevel', { id, level, maxLevel });
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot node level exceeds header maxLevel', { id, level, maxLevel });
         }
         levels[id] = level;
         for (let l = 0; l <= level; l++) {
             const size = u32();
             const cap = l === 0 ? M0 : M;
             if (size > cap) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot adjacency exceeds the graph parameter bound', { id, level: l, size, cap });
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot adjacency exceeds the graph parameter bound', { id, level: l, size, cap });
             }
             if (raw.byteLength - offset < size * edgeBytes) throw truncated();
             const edges = new Uint32Array(size);
             for (let e = 0; e < size; e++) {
                 const neighbor = u32();
                 if (neighbor >= count) {
-                    throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot neighbor id is out of range', { id, level: l, neighbor, count });
+                    throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'uint8 snapshot neighbor id is out of range', { id, level: l, neighbor, count });
                 }
                 edges[e] = neighbor;
                 if (version >= 2) offset += 4; // the serialized float edge distance, unused here
@@ -468,12 +468,12 @@ async function sha256BytesAsync(bytes) {
 async function verifySha256(bytes, expected, label) {
     const digest = await sha256BytesAsync(bytes);
     if (!digest) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
             'Artifact verification requested but no crypto backend is available; pass verify:false to skip');
     }
     for (let b = 0; b < 32; b++) {
         if (digest[b] !== expected[b]) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `${label} failed hash verification`);
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `${label} failed hash verification`);
         }
     }
 }
@@ -498,7 +498,7 @@ async function verifySegmentSha256(source, offset, totalBytes, expected, label,
             const len = Math.min(chunkBytes, totalBytes - done);
             const bytes = await readChecked(source, offset + done, len, label);
             if (bytes.byteLength !== len) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
                     `Artifact ${label} is truncated`, { offset: offset + done, expected: len, actual: bytes.byteLength });
             }
             hash.update(bytes);
@@ -507,20 +507,20 @@ async function verifySegmentSha256(source, offset, totalBytes, expected, label,
         const digest = new Uint8Array(hash.digest());
         for (let b = 0; b < 32; b++) {
             if (digest[b] !== expected[b]) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `${label} failed hash verification`);
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `${label} failed hash verification`);
             }
         }
         return;
     }
     const oneShotLimit = options.oneShotLimit || DEFAULT_OPEN_READ_BYTES;
     if (totalBytes > oneShotLimit) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
             `Artifact ${label} is too large to verify without a streaming crypto backend`,
             { totalBytes, oneShotLimit });
     }
     const bytes = await readChecked(source, offset, totalBytes, label, oneShotLimit);
     if (bytes.byteLength !== totalBytes) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
             `Artifact ${label} is truncated`, { offset, expected: totalBytes, actual: bytes.byteLength });
     }
     await verifySha256(bytes, expected, label);
@@ -529,7 +529,7 @@ async function verifySegmentSha256(source, offset, totalBytes, expected, label,
 module.exports = {
     resolveSearchK,
     resolveOptionalPositiveInt,
-    PANCAKE_MAGIC,
+    PIKELET_MAGIC,
     V1_ENVELOPE_HEADER_SIZE,
     V2_ENVELOPE_HEADER_SIZE,
     V3_ENVELOPE_HEADER_SIZE,

package/{pancake-artifact-range.js → src/artifact/pikelet-artifact-range.js}

@@ -1,10 +1,10 @@
 'use strict';
-// Range artifact profile (.pancake-range) — spec/SEARCH_ARTIFACT_CONTRACT.md 9.2:
-// PancakeRangeArtifact reader and the range-artifact builder.
-// Split out of pancake-artifact.js (the public entry, which re-exports the
+// Range artifact profile (.pikelet-range) — spec/SEARCH_ARTIFACT_CONTRACT.md 9.2:
+// PikeletRangeArtifact reader and the range-artifact builder.
+// Split out of pikelet-artifact.js (the public entry, which re-exports the
 // three parts); see that file for the module map.
 
-const { pancakeError, PANCAKE_ERROR_CODES } = require('./pancake-errors.js');
+const { pikeletError, PIKELET_ERROR_CODES } = require('../errors/pikelet-errors.js');
 const {
     MAX_COALESCED_RANGE_BYTES,
     readChecked,
@@ -22,7 +22,7 @@ const {
     verifySegmentSha256,
     resolveSearchK,
     resolveOptionalPositiveInt,
-} = require('./pancake-artifact-common.js');
+} = require('./pikelet-artifact-common.js');
 
 const RANGE_MAGIC = 0x31415250; // PRA1
 const HEADER_BYTES = 128;
@@ -35,7 +35,7 @@ const RANGE_DIGESTS_OFFSET = 128;
 const RANGE_DIGEST_BYTES = 32;
 const ROUTER_LOCATION_MASK = 0x80000000;
 const LOCATION_ORDINAL_MASK = 0x7fffffff;
-class PancakeRangeArtifact {
+class PikeletRangeArtifact {
     constructor(source, header, idMap, options = {}) {
         this.source = source;
         this.version = header.version;
@@ -77,11 +77,11 @@ class PancakeRangeArtifact {
 
     static async open(source, options = {}) {
         if (!source || typeof source.read !== 'function') {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, 'PancakeRangeArtifact.open() requires a range source with read(offset, length)');
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, 'PikeletRangeArtifact.open() requires a range source with read(offset, length)');
         }
         const headerBytes = await readChecked(source, 0, HEADER_BYTES, 'header');
         if (headerBytes.byteLength < HEADER_BYTES) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact header is truncated');
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact header is truncated');
         }
         const header = parseHeader(headerBytes);
         // Resolved before construction: the id-map read below is driven by an
@@ -91,7 +91,7 @@ class PancakeRangeArtifact {
         if (header.version >= 3) {
             const digestBytes = await readChecked(source, RANGE_DIGESTS_OFFSET, RANGE_DIGEST_BYTES * 3, 'header digests');
             if (digestBytes.byteLength !== RANGE_DIGEST_BYTES * 3) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact header digests are truncated');
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact header digests are truncated');
             }
             digests = {
                 idMap: new Uint8Array(digestBytes.subarray(0, RANGE_DIGEST_BYTES)),
@@ -101,12 +101,12 @@ class PancakeRangeArtifact {
         }
         const idMapBytes = await readChecked(source, header.idMapOffset, header.count * 4, 'id map', maxReadBytes);
         if (idMapBytes.byteLength !== header.count * 4) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact id map is truncated');
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact id map is truncated');
         }
         const copied = new Uint8Array(idMapBytes.byteLength);
         copied.set(idMapBytes);
         const idMap = new Uint32Array(copied.buffer);
-        const artifact = new PancakeRangeArtifact(source, header, idMap, options);
+        const artifact = new PikeletRangeArtifact(source, header, idMap, options);
         artifact.digests = digests;
         if (digests && artifact.verify) {
             await verifySha256(copied, digests.idMap, 'Range artifact id map');
@@ -124,7 +124,7 @@ class PancakeRangeArtifact {
         // open must release it, or every corrupt artifact leaks an fd.
         const source = new NodeFileRangeSource(filePath);
         try {
-            return await PancakeRangeArtifact.open(source, options);
+            return await PikeletRangeArtifact.open(source, options);
         } catch (err) {
             await source.close().catch(() => {});
             throw err;
@@ -179,7 +179,7 @@ class PancakeRangeArtifact {
     // complete-profile manifest.
     async verifyBaseSegment(options = {}) {
         if (!this.digests) {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT,
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT,
                 'Range artifact predates segment digests (format v3); nothing to verify against', { version: this.version });
         }
         const bytes = this.baseCount * this.recordBytes;
@@ -199,19 +199,19 @@ class PancakeRangeArtifact {
 
     recordAddressForId(id) {
         if (!Number.isInteger(id) || id < 0 || id >= this.count) {
-            throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `Node id ${id} is outside artifact bounds`, { id, count: this.count });
+            throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `Node id ${id} is outside artifact bounds`, { id, count: this.count });
         }
         const location = this.originalToLocation[id];
         if (this.version >= 2) {
             const ordinal = location & LOCATION_ORDINAL_MASK;
             if ((location & ROUTER_LOCATION_MASK) !== 0) {
-                if (ordinal >= this.routerCount) throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `Router ordinal ${ordinal} is outside artifact`);
+                if (ordinal >= this.routerCount) throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `Router ordinal ${ordinal} is outside artifact`);
                 return this.routerRecordsOffset + ordinal * this.recordBytes;
             }
-            if (ordinal >= this.baseCount) throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `Base ordinal ${ordinal} is outside artifact`);
+            if (ordinal >= this.baseCount) throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `Base ordinal ${ordinal} is outside artifact`);
             return this.baseRecordsOffset + ordinal * this.recordBytes;
         }
-        if (location >= this.count) throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `Node id ${id} is not addressable in artifact`);
+        if (location >= this.count) throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `Node id ${id} is not addressable in artifact`);
         return this.recordsOffset + location * this.recordBytes;
     }
 
@@ -245,7 +245,7 @@ class PancakeRangeArtifact {
         await this.prefetch([id]);
         const node = this.cachedNode(id);
         if (node === undefined) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
                 'Range artifact record for id was not resolved by its address', { id });
         }
         return node;
@@ -281,7 +281,7 @@ class PancakeRangeArtifact {
             const bytes = end - start;
             const buffer = await readChecked(this.source, start, bytes, 'record');
             if (buffer.byteLength !== bytes) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record read returned a truncated range', { offset: start, bytes, actual: buffer.byteLength });
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record read returned a truncated range', { offset: start, bytes, actual: buffer.byteLength });
             }
             return { start, end, bytes, buffer };
         };
@@ -297,7 +297,7 @@ class PancakeRangeArtifact {
                 // poison the cache under an attacker-chosen key and searches
                 // for the real id would die uncoded.
                 if (originalId >= this.count || this.recordAddressForId(originalId) !== start + off) {
-                    throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+                    throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
                         'Range artifact record id does not match its address',
                         { originalId, address: start + off });
                 }
@@ -331,7 +331,7 @@ class PancakeRangeArtifact {
         const bytes = this.routerCount * this.recordBytes;
         const buffer = await readChecked(this.source, this.routerRecordsOffset, bytes, 'router segment', this.maxReadBytes);
         if (buffer.byteLength !== bytes) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact router segment is truncated');
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact router segment is truncated');
         }
         if (this.digests && this.verify) {
             await verifySha256(buffer, this.digests.router, 'Range artifact router segment');
@@ -344,7 +344,7 @@ class PancakeRangeArtifact {
             // Same untrusted-id check as decodeRange: the embedded id must map
             // back to this router slot's address.
             if (originalId >= this.count || this.recordAddressForId(originalId) !== address) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID,
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID,
                     'Range artifact router record id does not match its address',
                     { originalId, address });
             }
@@ -362,13 +362,13 @@ class PancakeRangeArtifact {
         // Records are untrusted bytes. Counts beyond the header geometry would
         // read filler (or zeros) as edges; fail closed instead.
         if (level > this.maxLevel || baseCount > this.M0) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record structure is inconsistent', { id, level, baseCount });
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record structure is inconsistent', { id, level, baseCount });
         }
         const upperCounts = new Uint16Array(this.maxLevel);
         for (let i = 0; i < this.maxLevel; i++) {
             upperCounts[i] = readU16(view, state);
             if (upperCounts[i] > this.M) {
-                throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record structure is inconsistent', { id, level: i + 1, edges: upperCounts[i] });
+                throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record structure is inconsistent', { id, level: i + 1, edges: upperCounts[i] });
             }
         }
         const qdata = new Uint8Array(this.dim);
@@ -376,12 +376,19 @@ class PancakeRangeArtifact {
         state.offset += this.dim;
         const scale = readF32(view, state);
         const offset = readF32(view, state);
+        // A NaN/Infinity affine pair makes every distance to this node
+        // non-finite; NaN compares false everywhere, so the node can sit in
+        // the result heap without ever being displaced. Digests do not catch
+        // this (the producer signs whatever bytes it wrote), so decode does.
+        if (!Number.isFinite(scale) || !Number.isFinite(offset)) {
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record has a non-finite scale or offset', { id, scale, offset });
+        }
         const base = new Uint32Array(baseCount);
         for (let i = 0; i < this.M0; i++) {
             const neighbor = readU32(view, state);
             if (i < baseCount) {
                 if (neighbor >= this.count) {
-                    throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record has an out-of-bounds neighbor', { id, neighbor, count: this.count });
+                    throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record has an out-of-bounds neighbor', { id, neighbor, count: this.count });
                 }
                 base[i] = neighbor;
             }
@@ -393,7 +400,7 @@ class PancakeRangeArtifact {
                 const neighbor = readU32(view, state);
                 if (i < edges.length) {
                     if (neighbor >= this.count) {
-                        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record has an out-of-bounds neighbor', { id, neighbor, count: this.count });
+                        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact record has an out-of-bounds neighbor', { id, neighbor, count: this.count });
                     }
                     edges[i] = neighbor;
                 }
@@ -511,7 +518,7 @@ class PancakeRangeArtifact {
 
         const top = results.items.sort(compareDistancesAsc).slice(0, k);
         // Traversal orders by squared L2; the API contract (README "Distance
-        // values") reports Euclidean, matching PancakeIndex.search.
+        // values") reports Euclidean, matching PikeletIndex.search.
         if (this.metric !== 1) {
             for (const hit of top) hit.distance = Math.sqrt(hit.distance);
         }
@@ -528,12 +535,12 @@ function parseHeader(headerBytes) {
     const state = { offset: 0 };
     const magic = readU32(view, state);
     if (magic !== RANGE_MAGIC) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Not a Pancake range artifact', { magic });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Not a Pikelet range artifact', { magic });
     }
     const version = readU32(view, state);
     const kind = readU32(view, state);
     if (kind !== RANGE_KIND_U8) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported Pancake range artifact kind', { kind });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported Pikelet range artifact kind', { kind });
     }
     const header = {
         version,
@@ -556,7 +563,7 @@ function parseHeader(headerBytes) {
     };
     if (header.metric !== 0) {
         if (header.metric !== 1) {
-            throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported Pancake range artifact metric', { metric: header.metric });
+            throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported Pikelet range artifact metric', { metric: header.metric });
         }
     }
     if (version >= 2) {
@@ -569,7 +576,7 @@ function parseHeader(headerBytes) {
         header.baseRecordsOffset = header.recordsOffset;
     }
     if (version < 1 || version > RANGE_VERSION) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported Pancake range artifact version', { version });
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Unsupported Pikelet range artifact version', { version });
     }
     // recordBytes must agree with the layout the geometry implies, or
     // decodeNode would read past record boundaries on a corrupt header.
@@ -580,7 +587,7 @@ function parseHeader(headerBytes) {
         || header.entryPoint >= header.count
         || header.recordBytes !== expectedRecordBytes
         || (version >= 2 && header.routerCount + header.baseCount !== header.count)) {
-        throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact header geometry is inconsistent', {
+        throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, 'Range artifact header geometry is inconsistent', {
             dim: header.dim, count: header.count, maxLevel: header.maxLevel,
             M: header.M, M0: header.M0, recordBytes: header.recordBytes, expectedRecordBytes,
         });
@@ -662,7 +669,7 @@ function identityPermutation(count) {
 function buildOrdinalToOriginal(index, layout) {
     if (layout === 'identity') return identityPermutation(index.count);
     if (layout === 'rcm') return reverseCuthillMckeePermutation(index);
-    throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `Unsupported Search Artifact layout '${layout}'`, { layout });
+    throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `Unsupported Search Artifact layout '${layout}'`, { layout });
 }
 
 function exportSplitArtifact(index, outPath, options = {}) {
@@ -742,7 +749,7 @@ function exportSplitArtifact(index, outPath, options = {}) {
         fs.closeSync(fd);
     }
     return {
-        format: 'pancake-range-artifact',
+        format: 'pikelet-range-artifact',
         formatVersion: RANGE_VERSION,
         integrity: {
             idMapSha256: idMapDigest.toString('hex'),
@@ -778,7 +785,7 @@ function exportSplitArtifact(index, outPath, options = {}) {
 
 function buildRangeArtifact(snapshotBytes, outPath, options = {}) {
     if (typeof outPath !== 'string' || outPath.length === 0) {
-        throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, 'buildRangeArtifact() requires an output path');
+        throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, 'buildRangeArtifact() requires an output path');
     }
     const index = parseUint8Snapshot(snapshotBytes);
     return exportSplitArtifact(index, outPath, options);
@@ -791,7 +798,7 @@ function buildRangeArtifactFile(snapshotPath, outPath, options = {}) {
 }
 
 module.exports = {
-    PancakeRangeArtifact,
+    PikeletRangeArtifact,
     buildRangeArtifact,
     buildRangeArtifactFile,
     exportSplitArtifact,