pikelet-wasm 0.7.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (32) hide show
  1. package/CHANGELOG.md +19 -3
  2. package/NOTICE +5 -0
  3. package/README.md +397 -454
  4. package/complete/builder.d.ts +4 -4
  5. package/complete/builder.mjs +8 -8
  6. package/complete/encoder-kernels/encoder.node.wasm +0 -0
  7. package/complete/encoder-kernels/encoder.wasm +0 -0
  8. package/complete/index.d.ts +11 -7
  9. package/complete/index.mjs +161 -112
  10. package/complete/inline-transformer.mjs +22 -9
  11. package/complete/lexical.mjs +11 -11
  12. package/complete/retrieval-abstention.mjs +18 -6
  13. package/complete/sources.mjs +22 -1
  14. package/dist/engine.js +1 -1
  15. package/dist/engine.scalar.js +1 -1
  16. package/dist/engine.scalar.wasm +0 -0
  17. package/dist/engine.wasm +0 -0
  18. package/package.json +58 -51
  19. package/{pancake-artifact-common.js → pikelet-artifact-common.js} +42 -42
  20. package/{pancake-artifact-range.js → pikelet-artifact-range.js} +36 -36
  21. package/{pancake-artifact-sketch.js → pikelet-artifact-sketch.js} +76 -66
  22. package/{pancake-artifact.d.ts → pikelet-artifact.d.ts} +11 -11
  23. package/{pancake-artifact.js → pikelet-artifact.js} +10 -10
  24. package/{pancake-core.js → pikelet-core.js} +136 -136
  25. package/{pancake-errors.js → pikelet-errors.js} +9 -8
  26. package/{pancake.d.ts → pikelet.d.ts} +55 -55
  27. package/{pancake.js → pikelet.js} +44 -44
  28. package/{pancake.node.mjs → pikelet.node.mjs} +46 -46
  29. package/{pancake.web.d.ts → pikelet.web.d.ts} +13 -13
  30. package/{pancake.web.mjs → pikelet.web.mjs} +20 -20
  31. package/{pancake.workerd.mjs → pikelet.workerd.mjs} +18 -18
  32. /package/{pancake-loader.js → pikelet-loader.js} +0 -0
@@ -3,13 +3,13 @@ import path from 'node:path';
3
3
  import { fileURLToPath } from 'node:url';
4
4
  import loadEngine from './dist/engine.js';
5
5
  import loadScalarEngine from './dist/engine.scalar.js';
6
- import createPancakeApi from './pancake-core.js';
7
- import errorContract from './pancake-errors.js';
8
- import loaderContract from './pancake-loader.js';
9
- import artifactContract from './pancake-artifact.js';
10
- const { PancakeError, PANCAKE_ERROR_CODES, pancakeError } = errorContract;
6
+ import createPikeletApi from './pikelet-core.js';
7
+ import errorContract from './pikelet-errors.js';
8
+ import loaderContract from './pikelet-loader.js';
9
+ import artifactContract from './pikelet-artifact.js';
10
+ const { PikeletError, PIKELET_ERROR_CODES, pikeletError } = errorContract;
11
11
  const { createCachedModuleLoader } = loaderContract;
12
- const { PancakeRangeArtifact, PancakeSketchArtifact, createSketchScanner, NodeFileRangeSource, buildRangeArtifact, buildRangeArtifactFile, buildSketchArtifact, buildSketchArtifactBytes, buildSketchArtifactFile } = artifactContract;
12
+ const { PikeletRangeArtifact, PikeletSketchArtifact, createSketchScanner, NodeFileRangeSource, buildRangeArtifact, buildRangeArtifactFile, buildSketchArtifact, buildSketchArtifactBytes, buildSketchArtifactFile } = artifactContract;
13
13
 
14
14
  const __filename = fileURLToPath(import.meta.url);
15
15
  const __dirname = path.dirname(__filename);
@@ -34,13 +34,13 @@ function readWasmBinary(fileName) {
34
34
  );
35
35
  } catch (error) {
36
36
  const message = error && error.message ? error.message : String(error);
37
- throw pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED, `Failed to load Pancake WASM binary (${fileName}): ${message}`, { fileName }, error);
37
+ throw pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED, `Failed to load Pikelet WASM binary (${fileName}): ${message}`, { fileName }, error);
38
38
  }
39
39
  }
40
40
 
41
41
  function makeLoadError(message, error) {
42
42
  const detail = error && error.message ? error.message : String(error);
43
- return pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
43
+ return pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
44
44
  }
45
45
 
46
46
  const moduleLoader = createCachedModuleLoader((variant) =>
@@ -63,7 +63,7 @@ function parseJsonLines(text, filePath) {
63
63
  rows.push(JSON.parse(line));
64
64
  } catch (error) {
65
65
  const message = error && error.message ? error.message : String(error);
66
- throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `Failed to parse JSONL in ${filePath} at line ${i + 1}: ${message}`, { filePath, line: i + 1 }, error);
66
+ throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `Failed to parse JSONL in ${filePath} at line ${i + 1}: ${message}`, { filePath, line: i + 1 }, error);
67
67
  }
68
68
  }
69
69
  return rows;
@@ -72,22 +72,22 @@ function parseJsonLines(text, filePath) {
72
72
  function inferJsonFormat(filePath) {
73
73
  if (/\.json$/i.test(filePath)) return 'json';
74
74
  if (/\.(jsonl|ndjson)$/i.test(filePath)) return 'jsonl';
75
- 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 });
75
+ 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 });
76
76
  }
77
77
 
78
78
  function remapJsonRows(rows, vectorKey, idKey) {
79
79
  if (!Array.isArray(rows)) {
80
- throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, 'loadJsonFile() expects a JSON array or JSONL sequence of vectors/records');
80
+ throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, 'loadJsonFile() expects a JSON array or JSONL sequence of vectors/records');
81
81
  }
82
82
  return rows.map((row, i) => {
83
83
  if (row instanceof Float32Array || Array.isArray(row)) {
84
84
  return row;
85
85
  }
86
86
  if (!row || typeof row !== 'object') {
87
- throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `loadJsonFile() expected an object or vector at index ${i}`, { index: i });
87
+ throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `loadJsonFile() expected an object or vector at index ${i}`, { index: i });
88
88
  }
89
89
  if (!(vectorKey in row)) {
90
- throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `loadJsonFile() missing vectorKey '${vectorKey}' at index ${i}`, { index: i, vectorKey });
90
+ throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `loadJsonFile() missing vectorKey '${vectorKey}' at index ${i}`, { index: i, vectorKey });
91
91
  }
92
92
  const mapped = { vector: row[vectorKey] };
93
93
  if (Object.prototype.hasOwnProperty.call(row, idKey)) {
@@ -99,13 +99,13 @@ function remapJsonRows(rows, vectorKey, idKey) {
99
99
 
100
100
  function validateFilePath(filePath, helperName) {
101
101
  if (typeof filePath !== 'string' || filePath.length === 0) {
102
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() requires a non-empty file path`);
102
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() requires a non-empty file path`);
103
103
  }
104
104
  }
105
105
 
106
106
  function validateMaxFileBytes(maxFileBytes, helperName) {
107
107
  if (!Number.isInteger(maxFileBytes) || maxFileBytes <= 0) {
108
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() maxFileBytes must be a positive integer`, { maxFileBytes });
108
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() maxFileBytes must be a positive integer`, { maxFileBytes });
109
109
  }
110
110
  }
111
111
 
@@ -115,17 +115,17 @@ function statRegularFile(filePath, helperName) {
115
115
  stat = statSync(filePath);
116
116
  } catch (error) {
117
117
  const message = error && error.message ? error.message : String(error);
118
- throw pancakeError(PANCAKE_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not stat ${filePath}: ${message}`, { filePath }, error);
118
+ throw pikeletError(PIKELET_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not stat ${filePath}: ${message}`, { filePath }, error);
119
119
  }
120
120
  if (!stat.isFile()) {
121
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() expected a regular file: ${filePath}`, { filePath });
121
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() expected a regular file: ${filePath}`, { filePath });
122
122
  }
123
123
  return stat;
124
124
  }
125
125
 
126
126
  function enforceFileSize(stat, maxFileBytes, helperName, filePath) {
127
127
  if (stat.size > maxFileBytes) {
128
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() file exceeds maxFileBytes (${stat.size} > ${maxFileBytes}): ${filePath}`, { filePath, fileBytes: stat.size, maxFileBytes });
128
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${helperName}() file exceeds maxFileBytes (${stat.size} > ${maxFileBytes}): ${filePath}`, { filePath, fileBytes: stat.size, maxFileBytes });
129
129
  }
130
130
  }
131
131
 
@@ -138,7 +138,7 @@ function readUtf8FileWithLimit(filePath, helperName, maxFileBytes) {
138
138
  return readFileSync(filePath, 'utf8');
139
139
  } catch (error) {
140
140
  const message = error && error.message ? error.message : String(error);
141
- throw pancakeError(PANCAKE_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
141
+ throw pikeletError(PIKELET_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
142
142
  }
143
143
  }
144
144
 
@@ -151,18 +151,18 @@ function readBinaryFileWithLimit(filePath, helperName, maxFileBytes) {
151
151
  return readFileSync(filePath);
152
152
  } catch (error) {
153
153
  const message = error && error.message ? error.message : String(error);
154
- throw pancakeError(PANCAKE_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
154
+ throw pikeletError(PIKELET_ERROR_CODES.FILE_IO_FAILED, `${helperName}() could not read ${filePath}: ${message}`, { filePath }, error);
155
155
  }
156
156
  }
157
157
 
158
158
  function validateSnapshotBytes(snapshot, filePath) {
159
159
  if (!snapshot || snapshot.byteLength < 4) {
160
- throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() snapshot is too small to be valid: ${filePath}`, { filePath });
160
+ throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() snapshot is too small to be valid: ${filePath}`, { filePath });
161
161
  }
162
162
  const view = new DataView(snapshot.buffer, snapshot.byteOffset, snapshot.byteLength);
163
163
  const magic = view.getUint32(0, true);
164
164
  if (!SUPPORTED_SNAPSHOT_MAGICS.has(magic)) {
165
- throw pancakeError(PANCAKE_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() unsupported snapshot file type: ${filePath}`, { filePath, magic });
165
+ throw pikeletError(PIKELET_ERROR_CODES.SNAPSHOT_INVALID, `loadSnapshotFile() unsupported snapshot file type: ${filePath}`, { filePath, magic });
166
166
  }
167
167
  }
168
168
 
@@ -173,7 +173,7 @@ async function loadNodeEngine() {
173
173
  try {
174
174
  return await moduleLoader.instantiate(loadScalarEngine, 'scalar');
175
175
  } catch (error) {
176
- throw makeLoadError('Pancake failed to load the scalar WASM engine', error);
176
+ throw makeLoadError('Pikelet failed to load the scalar WASM engine', error);
177
177
  }
178
178
  }
179
179
 
@@ -186,38 +186,38 @@ async function loadNodeEngine() {
186
186
  return engine;
187
187
  } catch (scalarError) {
188
188
  throw makeLoadError(
189
- `Pancake failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
189
+ `Pikelet failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
190
190
  scalarError
191
191
  );
192
192
  }
193
193
  }
194
194
  }
195
195
 
196
- const Pancake = createPancakeApi(loadNodeEngine);
197
- export { PancakeError, PANCAKE_ERROR_CODES };
196
+ const Pikelet = createPikeletApi(loadNodeEngine);
197
+ export { PikeletError, PIKELET_ERROR_CODES };
198
198
 
199
- Pancake.RangeArtifact = PancakeRangeArtifact;
200
- Pancake.NodeFileRangeSource = NodeFileRangeSource;
201
- Pancake.buildRangeArtifact = buildRangeArtifact;
202
- Pancake.buildRangeArtifactFile = buildRangeArtifactFile;
199
+ Pikelet.RangeArtifact = PikeletRangeArtifact;
200
+ Pikelet.NodeFileRangeSource = NodeFileRangeSource;
201
+ Pikelet.buildRangeArtifact = buildRangeArtifact;
202
+ Pikelet.buildRangeArtifactFile = buildRangeArtifactFile;
203
203
 
204
- Pancake.openRangeArtifactFile = async function openRangeArtifactFile(filePath, opts) {
204
+ Pikelet.openRangeArtifactFile = async function openRangeArtifactFile(filePath, opts) {
205
205
  validateFilePath(filePath, 'openRangeArtifactFile');
206
- return PancakeRangeArtifact.openFile(filePath, opts);
206
+ return PikeletRangeArtifact.openFile(filePath, opts);
207
207
  };
208
208
 
209
- Pancake.SketchArtifact = PancakeSketchArtifact;
210
- Pancake.createSketchScanner = (artifact, options) => createSketchScanner(loadNodeEngine, artifact, options);
211
- Pancake.buildSketchArtifact = buildSketchArtifact;
212
- Pancake.buildSketchArtifactBytes = buildSketchArtifactBytes;
213
- Pancake.buildSketchArtifactFile = buildSketchArtifactFile;
209
+ Pikelet.SketchArtifact = PikeletSketchArtifact;
210
+ Pikelet.createSketchScanner = (artifact, options) => createSketchScanner(loadNodeEngine, artifact, options);
211
+ Pikelet.buildSketchArtifact = buildSketchArtifact;
212
+ Pikelet.buildSketchArtifactBytes = buildSketchArtifactBytes;
213
+ Pikelet.buildSketchArtifactFile = buildSketchArtifactFile;
214
214
 
215
- Pancake.openSketchArtifactFile = async function openSketchArtifactFile(filePath, opts) {
215
+ Pikelet.openSketchArtifactFile = async function openSketchArtifactFile(filePath, opts) {
216
216
  validateFilePath(filePath, 'openSketchArtifactFile');
217
- return PancakeSketchArtifact.openFile(filePath, opts);
217
+ return PikeletSketchArtifact.openFile(filePath, opts);
218
218
  };
219
219
 
220
- Pancake.loadSnapshotFile = async function loadSnapshotFile(filePath, opts) {
220
+ Pikelet.loadSnapshotFile = async function loadSnapshotFile(filePath, opts) {
221
221
  const {
222
222
  maxFileBytes = DEFAULT_SNAPSHOT_FILE_BYTES,
223
223
  ...createOpts
@@ -225,10 +225,10 @@ Pancake.loadSnapshotFile = async function loadSnapshotFile(filePath, opts) {
225
225
 
226
226
  const snapshot = readBinaryFileWithLimit(filePath, 'loadSnapshotFile', maxFileBytes);
227
227
  validateSnapshotBytes(snapshot, filePath);
228
- return Pancake.restore(snapshot, createOpts);
228
+ return Pikelet.restore(snapshot, createOpts);
229
229
  };
230
230
 
231
- Pancake.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
231
+ Pikelet.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
232
232
  const {
233
233
  format = inferJsonFormat(filePath),
234
234
  vectorKey = 'vector',
@@ -238,7 +238,7 @@ Pancake.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
238
238
  } = opts;
239
239
 
240
240
  if (format !== 'json' && format !== 'jsonl') {
241
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `loadJsonFile() format must be 'json' or 'jsonl', got '${format}'`, { format });
241
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `loadJsonFile() format must be 'json' or 'jsonl', got '${format}'`, { format });
242
242
  }
243
243
 
244
244
  const text = readUtf8FileWithLimit(filePath, 'loadJsonFile', maxFileBytes);
@@ -250,10 +250,10 @@ Pancake.loadJsonFile = async function loadJsonFile(filePath, opts = {}) {
250
250
  rows = JSON.parse(text);
251
251
  } catch (error) {
252
252
  const message = error && error.message ? error.message : String(error);
253
- throw pancakeError(PANCAKE_ERROR_CODES.PARSE_FAILED, `Failed to parse JSON in ${filePath}: ${message}`, { filePath }, error);
253
+ throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `Failed to parse JSON in ${filePath}: ${message}`, { filePath }, error);
254
254
  }
255
255
  }
256
- return Pancake.fromVectors(remapJsonRows(rows, vectorKey, idKey), createOpts);
256
+ return Pikelet.fromVectors(remapJsonRows(rows, vectorKey, idKey), createOpts);
257
257
  };
258
258
 
259
- export default Pancake;
259
+ export default Pikelet;
@@ -1,14 +1,14 @@
1
1
  // Types for the browser / Cloudflare Workers entrypoints (`pikelet-wasm/web`).
2
2
  // These runtimes expose the portable API, including range-readable Search
3
- // Artifacts. Only PancakeError and PANCAKE_ERROR_CODES exist as named runtime
3
+ // Artifacts. Only PikeletError and PIKELET_ERROR_CODES exist as named runtime
4
4
  // exports; every other re-export below is type-only. Node-only helpers
5
5
  // (NodeFileRangeSource, the build*/open*File functions, loadJsonFile /
6
6
  // loadSnapshotFile) are absent from this surface so using them is a compile
7
7
  // error rather than a runtime throw.
8
- export { PancakeError, PANCAKE_ERROR_CODES } from './pancake.js';
8
+ export { PikeletError, PIKELET_ERROR_CODES } from './pikelet.js';
9
9
  export type {
10
10
  Metric,
11
- PancakeErrorCode,
11
+ PikeletErrorCode,
12
12
  VectorInput,
13
13
  VectorRecord,
14
14
  CreateOptions,
@@ -20,7 +20,7 @@ export type {
20
20
  SearchResult,
21
21
  MemoryUsage,
22
22
  ResolvedConfig,
23
- PancakeIndex,
23
+ PikeletIndex,
24
24
  RangeReadSource,
25
25
  RangeArtifactSearchOptions,
26
26
  RangeArtifactNode,
@@ -28,8 +28,8 @@ export type {
28
28
  RangeArtifactRound,
29
29
  RangeArtifactSearchResult,
30
30
  RangeArtifactOpenOptions,
31
- PancakeRangeArtifact,
32
- PancakeRangeArtifactConstructor,
31
+ PikeletRangeArtifact,
32
+ PikeletRangeArtifactConstructor,
33
33
  SketchTier,
34
34
  SketchStageEvent,
35
35
  SketchArtifactOpenOptions,
@@ -38,13 +38,13 @@ export type {
38
38
  SketchArtifactSearchOptions,
39
39
  SketchArtifactSearchResult,
40
40
  SketchArtifactStats,
41
- PancakeSketchArtifact,
42
- PancakeSketchArtifactConstructor,
43
- PancakeApi,
44
- } from './pancake.js';
41
+ PikeletSketchArtifact,
42
+ PikeletSketchArtifactConstructor,
43
+ PikeletApi,
44
+ } from './pikelet.js';
45
45
 
46
- import type { PancakeApi } from './pancake.js';
46
+ import type { PikeletApi } from './pikelet.js';
47
47
 
48
- declare const Pancake: PancakeApi;
48
+ declare const Pikelet: PikeletApi;
49
49
 
50
- export default Pancake;
50
+ export default Pikelet;
@@ -2,18 +2,18 @@ import loadEngine from './dist/engine.js';
2
2
  import loadScalarEngine from './dist/engine.scalar.js';
3
3
  import simdWasmAsset from './dist/engine.wasm?url';
4
4
  import scalarWasmAsset from './dist/engine.scalar.wasm?url';
5
- import createPancakeApi from './pancake-core.js';
6
- import errorContract from './pancake-errors.js';
7
- import loaderContract from './pancake-loader.js';
8
- import artifactContract from './pancake-artifact.js';
9
- const { PancakeError, PANCAKE_ERROR_CODES, pancakeError } = errorContract;
5
+ import createPikeletApi from './pikelet-core.js';
6
+ import errorContract from './pikelet-errors.js';
7
+ import loaderContract from './pikelet-loader.js';
8
+ import artifactContract from './pikelet-artifact.js';
9
+ const { PikeletError, PIKELET_ERROR_CODES, pikeletError } = errorContract;
10
10
  const { createCachedModuleLoader } = loaderContract;
11
- const { PancakeRangeArtifact, PancakeSketchArtifact, createSketchScanner } = artifactContract;
11
+ const { PikeletRangeArtifact, PikeletSketchArtifact, createSketchScanner } = artifactContract;
12
12
  let engineVariantPromise = null;
13
13
 
14
14
  function makeLoadError(message, error) {
15
15
  const detail = error && error.message ? error.message : String(error);
16
- return pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
16
+ return pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
17
17
  }
18
18
 
19
19
  function isUrlLikeWasmAsset(asset) {
@@ -25,7 +25,7 @@ async function loadWasmAsset(asset) {
25
25
  const href = asset instanceof URL ? asset.href : asset;
26
26
  const response = await fetch(href, { credentials: 'same-origin' });
27
27
  if (!response.ok) {
28
- throw pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED,
28
+ throw pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED,
29
29
  `${response.status} ${response.statusText}`.trim(), { status: response.status });
30
30
  }
31
31
  return response.arrayBuffer();
@@ -38,7 +38,7 @@ const moduleLoader = createCachedModuleLoader((variant) =>
38
38
  function selectEngineVariant() {
39
39
  engineVariantPromise ??= moduleLoader.supports('simd')
40
40
  .then((supported) => supported ? 'simd' : 'scalar')
41
- .catch((error) => { throw makeLoadError('Failed to probe Pancake SIMD WASM support', error); });
41
+ .catch((error) => { throw makeLoadError('Failed to probe Pikelet SIMD WASM support', error); });
42
42
  return engineVariantPromise;
43
43
  }
44
44
 
@@ -49,7 +49,7 @@ async function loadWebEngine() {
49
49
  try {
50
50
  return await moduleLoader.instantiate(loadScalarEngine, 'scalar');
51
51
  } catch (error) {
52
- throw makeLoadError('Pancake failed to load the scalar WASM engine', error);
52
+ throw makeLoadError('Pikelet failed to load the scalar WASM engine', error);
53
53
  }
54
54
  }
55
55
 
@@ -62,27 +62,27 @@ async function loadWebEngine() {
62
62
  return engine;
63
63
  } catch (scalarError) {
64
64
  throw makeLoadError(
65
- `Pancake failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
65
+ `Pikelet failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
66
66
  scalarError
67
67
  );
68
68
  }
69
69
  }
70
70
  }
71
71
 
72
- const Pancake = createPancakeApi(loadWebEngine);
73
- export { PancakeError, PANCAKE_ERROR_CODES };
72
+ const Pikelet = createPikeletApi(loadWebEngine);
73
+ export { PikeletError, PIKELET_ERROR_CODES };
74
74
 
75
- Pancake.RangeArtifact = PancakeRangeArtifact;
76
- Pancake.SketchArtifact = PancakeSketchArtifact;
77
- Pancake.createSketchScanner = (artifact, options) => createSketchScanner(loadWebEngine, artifact, options);
75
+ Pikelet.RangeArtifact = PikeletRangeArtifact;
76
+ Pikelet.SketchArtifact = PikeletSketchArtifact;
77
+ Pikelet.createSketchScanner = (artifact, options) => createSketchScanner(loadWebEngine, artifact, options);
78
78
 
79
79
  function unsupportedNodeFileHelper(name) {
80
80
  return async function unsupported() {
81
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${name}() is only available in the Node.js entrypoints`);
81
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${name}() is only available in the Node.js entrypoints`);
82
82
  };
83
83
  }
84
84
 
85
- Pancake.loadSnapshotFile = unsupportedNodeFileHelper('loadSnapshotFile');
86
- Pancake.loadJsonFile = unsupportedNodeFileHelper('loadJsonFile');
85
+ Pikelet.loadSnapshotFile = unsupportedNodeFileHelper('loadSnapshotFile');
86
+ Pikelet.loadJsonFile = unsupportedNodeFileHelper('loadJsonFile');
87
87
 
88
- export default Pancake;
88
+ export default Pikelet;
@@ -2,19 +2,19 @@ import loadEngine from './dist/engine.js';
2
2
  import loadScalarEngine from './dist/engine.scalar.js';
3
3
  import simdWasmAsset from './dist/engine.wasm';
4
4
  import scalarWasmAsset from './dist/engine.scalar.wasm';
5
- import createPancakeApi from './pancake-core.js';
6
- import errorContract from './pancake-errors.js';
7
- import loaderContract from './pancake-loader.js';
8
- import artifactContract from './pancake-artifact.js';
9
- const { PancakeError, PANCAKE_ERROR_CODES, pancakeError } = errorContract;
5
+ import createPikeletApi from './pikelet-core.js';
6
+ import errorContract from './pikelet-errors.js';
7
+ import loaderContract from './pikelet-loader.js';
8
+ import artifactContract from './pikelet-artifact.js';
9
+ const { PikeletError, PIKELET_ERROR_CODES, pikeletError } = errorContract;
10
10
  const { createCachedModuleLoader } = loaderContract;
11
- const { PancakeRangeArtifact, PancakeSketchArtifact, createSketchScanner } = artifactContract;
11
+ const { PikeletRangeArtifact, PikeletSketchArtifact, createSketchScanner } = artifactContract;
12
12
 
13
13
  let engineVariantPromise = null;
14
14
 
15
15
  function makeLoadError(message, error) {
16
16
  const detail = error && error.message ? error.message : String(error);
17
- return pancakeError(PANCAKE_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
17
+ return pikeletError(PIKELET_ERROR_CODES.WASM_LOAD_FAILED, `${message}: ${detail}`, undefined, error);
18
18
  }
19
19
 
20
20
  const moduleLoader = createCachedModuleLoader((variant) =>
@@ -33,7 +33,7 @@ async function loadWorkerdEngine() {
33
33
  try {
34
34
  return await moduleLoader.instantiate(loadScalarEngine, 'scalar');
35
35
  } catch (error) {
36
- throw makeLoadError('Pancake failed to load the scalar WASM engine', error);
36
+ throw makeLoadError('Pikelet failed to load the scalar WASM engine', error);
37
37
  }
38
38
  }
39
39
 
@@ -46,27 +46,27 @@ async function loadWorkerdEngine() {
46
46
  return engine;
47
47
  } catch (scalarError) {
48
48
  throw makeLoadError(
49
- `Pancake failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
49
+ `Pikelet failed to load either the SIMD or scalar WASM engine (SIMD error: ${simdError && simdError.message ? simdError.message : String(simdError)})`,
50
50
  scalarError
51
51
  );
52
52
  }
53
53
  }
54
54
  }
55
55
 
56
- const Pancake = createPancakeApi(loadWorkerdEngine);
57
- export { PancakeError, PANCAKE_ERROR_CODES };
56
+ const Pikelet = createPikeletApi(loadWorkerdEngine);
57
+ export { PikeletError, PIKELET_ERROR_CODES };
58
58
 
59
- Pancake.RangeArtifact = PancakeRangeArtifact;
60
- Pancake.SketchArtifact = PancakeSketchArtifact;
61
- Pancake.createSketchScanner = (artifact, options) => createSketchScanner(loadWorkerdEngine, artifact, options);
59
+ Pikelet.RangeArtifact = PikeletRangeArtifact;
60
+ Pikelet.SketchArtifact = PikeletSketchArtifact;
61
+ Pikelet.createSketchScanner = (artifact, options) => createSketchScanner(loadWorkerdEngine, artifact, options);
62
62
 
63
63
  function unsupportedNodeFileHelper(name) {
64
64
  return async function unsupported() {
65
- throw pancakeError(PANCAKE_ERROR_CODES.INVALID_ARGUMENT, `${name}() is only available in the Node.js entrypoints`);
65
+ throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${name}() is only available in the Node.js entrypoints`);
66
66
  };
67
67
  }
68
68
 
69
- Pancake.loadSnapshotFile = unsupportedNodeFileHelper('loadSnapshotFile');
70
- Pancake.loadJsonFile = unsupportedNodeFileHelper('loadJsonFile');
69
+ Pikelet.loadSnapshotFile = unsupportedNodeFileHelper('loadSnapshotFile');
70
+ Pikelet.loadJsonFile = unsupportedNodeFileHelper('loadJsonFile');
71
71
 
72
- export default Pancake;
72
+ export default Pikelet;
File without changes