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.
- package/CHANGELOG.md +19 -3
- package/NOTICE +5 -0
- package/README.md +397 -454
- package/complete/builder.d.ts +4 -4
- package/complete/builder.mjs +8 -8
- package/complete/encoder-kernels/encoder.node.wasm +0 -0
- package/complete/encoder-kernels/encoder.wasm +0 -0
- package/complete/index.d.ts +11 -7
- package/complete/index.mjs +161 -112
- package/complete/inline-transformer.mjs +22 -9
- package/complete/lexical.mjs +11 -11
- package/complete/retrieval-abstention.mjs +18 -6
- package/complete/sources.mjs +22 -1
- package/dist/engine.js +1 -1
- package/dist/engine.scalar.js +1 -1
- package/dist/engine.scalar.wasm +0 -0
- package/dist/engine.wasm +0 -0
- package/package.json +58 -51
- package/{pancake-artifact-common.js → pikelet-artifact-common.js} +42 -42
- package/{pancake-artifact-range.js → pikelet-artifact-range.js} +36 -36
- package/{pancake-artifact-sketch.js → pikelet-artifact-sketch.js} +76 -66
- package/{pancake-artifact.d.ts → pikelet-artifact.d.ts} +11 -11
- package/{pancake-artifact.js → pikelet-artifact.js} +10 -10
- package/{pancake-core.js → pikelet-core.js} +136 -136
- package/{pancake-errors.js → pikelet-errors.js} +9 -8
- package/{pancake.d.ts → pikelet.d.ts} +55 -55
- package/{pancake.js → pikelet.js} +44 -44
- package/{pancake.node.mjs → pikelet.node.mjs} +46 -46
- package/{pancake.web.d.ts → pikelet.web.d.ts} +13 -13
- package/{pancake.web.mjs → pikelet.web.mjs} +20 -20
- package/{pancake.workerd.mjs → pikelet.workerd.mjs} +18 -18
- /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
|
|
7
|
-
import errorContract from './
|
|
8
|
-
import loaderContract from './
|
|
9
|
-
import artifactContract from './
|
|
10
|
-
const {
|
|
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 {
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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('
|
|
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
|
-
`
|
|
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
|
|
197
|
-
export {
|
|
196
|
+
const Pikelet = createPikeletApi(loadNodeEngine);
|
|
197
|
+
export { PikeletError, PIKELET_ERROR_CODES };
|
|
198
198
|
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
199
|
+
Pikelet.RangeArtifact = PikeletRangeArtifact;
|
|
200
|
+
Pikelet.NodeFileRangeSource = NodeFileRangeSource;
|
|
201
|
+
Pikelet.buildRangeArtifact = buildRangeArtifact;
|
|
202
|
+
Pikelet.buildRangeArtifactFile = buildRangeArtifactFile;
|
|
203
203
|
|
|
204
|
-
|
|
204
|
+
Pikelet.openRangeArtifactFile = async function openRangeArtifactFile(filePath, opts) {
|
|
205
205
|
validateFilePath(filePath, 'openRangeArtifactFile');
|
|
206
|
-
return
|
|
206
|
+
return PikeletRangeArtifact.openFile(filePath, opts);
|
|
207
207
|
};
|
|
208
208
|
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
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
|
-
|
|
215
|
+
Pikelet.openSketchArtifactFile = async function openSketchArtifactFile(filePath, opts) {
|
|
216
216
|
validateFilePath(filePath, 'openSketchArtifactFile');
|
|
217
|
-
return
|
|
217
|
+
return PikeletSketchArtifact.openFile(filePath, opts);
|
|
218
218
|
};
|
|
219
219
|
|
|
220
|
-
|
|
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
|
|
228
|
+
return Pikelet.restore(snapshot, createOpts);
|
|
229
229
|
};
|
|
230
230
|
|
|
231
|
-
|
|
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
|
|
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
|
|
253
|
+
throw pikeletError(PIKELET_ERROR_CODES.PARSE_FAILED, `Failed to parse JSON in ${filePath}: ${message}`, { filePath }, error);
|
|
254
254
|
}
|
|
255
255
|
}
|
|
256
|
-
return
|
|
256
|
+
return Pikelet.fromVectors(remapJsonRows(rows, vectorKey, idKey), createOpts);
|
|
257
257
|
};
|
|
258
258
|
|
|
259
|
-
export default
|
|
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
|
|
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 {
|
|
8
|
+
export { PikeletError, PIKELET_ERROR_CODES } from './pikelet.js';
|
|
9
9
|
export type {
|
|
10
10
|
Metric,
|
|
11
|
-
|
|
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
|
-
|
|
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
|
-
|
|
32
|
-
|
|
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
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
} from './
|
|
41
|
+
PikeletSketchArtifact,
|
|
42
|
+
PikeletSketchArtifactConstructor,
|
|
43
|
+
PikeletApi,
|
|
44
|
+
} from './pikelet.js';
|
|
45
45
|
|
|
46
|
-
import type {
|
|
46
|
+
import type { PikeletApi } from './pikelet.js';
|
|
47
47
|
|
|
48
|
-
declare const
|
|
48
|
+
declare const Pikelet: PikeletApi;
|
|
49
49
|
|
|
50
|
-
export default
|
|
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
|
|
6
|
-
import errorContract from './
|
|
7
|
-
import loaderContract from './
|
|
8
|
-
import artifactContract from './
|
|
9
|
-
const {
|
|
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 {
|
|
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
|
|
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
|
|
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
|
|
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('
|
|
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
|
-
`
|
|
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
|
|
73
|
-
export {
|
|
72
|
+
const Pikelet = createPikeletApi(loadWebEngine);
|
|
73
|
+
export { PikeletError, PIKELET_ERROR_CODES };
|
|
74
74
|
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
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
|
|
81
|
+
throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${name}() is only available in the Node.js entrypoints`);
|
|
82
82
|
};
|
|
83
83
|
}
|
|
84
84
|
|
|
85
|
-
|
|
86
|
-
|
|
85
|
+
Pikelet.loadSnapshotFile = unsupportedNodeFileHelper('loadSnapshotFile');
|
|
86
|
+
Pikelet.loadJsonFile = unsupportedNodeFileHelper('loadJsonFile');
|
|
87
87
|
|
|
88
|
-
export default
|
|
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
|
|
6
|
-
import errorContract from './
|
|
7
|
-
import loaderContract from './
|
|
8
|
-
import artifactContract from './
|
|
9
|
-
const {
|
|
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 {
|
|
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
|
|
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('
|
|
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
|
-
`
|
|
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
|
|
57
|
-
export {
|
|
56
|
+
const Pikelet = createPikeletApi(loadWorkerdEngine);
|
|
57
|
+
export { PikeletError, PIKELET_ERROR_CODES };
|
|
58
58
|
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
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
|
|
65
|
+
throw pikeletError(PIKELET_ERROR_CODES.INVALID_ARGUMENT, `${name}() is only available in the Node.js entrypoints`);
|
|
66
66
|
};
|
|
67
67
|
}
|
|
68
68
|
|
|
69
|
-
|
|
70
|
-
|
|
69
|
+
Pikelet.loadSnapshotFile = unsupportedNodeFileHelper('loadSnapshotFile');
|
|
70
|
+
Pikelet.loadJsonFile = unsupportedNodeFileHelper('loadJsonFile');
|
|
71
71
|
|
|
72
|
-
export default
|
|
72
|
+
export default Pikelet;
|
|
File without changes
|