or-tools-wasm 0.5.0 → 0.7.1

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 (52) hide show
  1. package/README.md +206 -54
  2. package/build/javascript/browser/cp_sat_module_loader.js +53 -0
  3. package/build/javascript/browser/cpsat_worker.js +135 -0
  4. package/build/javascript/browser/cpsat_worker_types.js +0 -0
  5. package/build/javascript/browser/index.js +5910 -0
  6. package/build/javascript/lib/assets/cp_sat_runtime-BcQ-oG9G.js +2568 -0
  7. package/build/javascript/lib/assets/cp_sat_runtime-BcQ-oG9G.js.map +1 -0
  8. package/build/javascript/lib/assets/{cp_sat_runtime-BUuF8d7w.wasm → cp_sat_runtime.wasm} +0 -0
  9. package/build/javascript/lib/assets/cp_sat_runtime.wasm.map +1 -0
  10. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-CebveWgj.js +2642 -0
  11. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-CebveWgj.js.map +1 -0
  12. package/build/javascript/lib/assets/{cp_sat_runtime_asyncify-CjMVqM1A.wasm → cp_sat_runtime_asyncify.wasm} +0 -0
  13. package/build/javascript/lib/assets/cp_sat_runtime_asyncify.wasm.map +1 -0
  14. package/build/javascript/lib/assets/cpsat_worker-CxyMtsph.js +145 -0
  15. package/build/javascript/lib/assets/cpsat_worker-CxyMtsph.js.map +1 -0
  16. package/build/javascript/lib/chunks/cp_sat_runtime-D-Bi0Puh.js +2568 -0
  17. package/build/javascript/lib/chunks/cp_sat_runtime-D-Bi0Puh.js.map +1 -0
  18. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-pyd1qgFK.js +2642 -0
  19. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-pyd1qgFK.js.map +1 -0
  20. package/build/javascript/lib/cp_sat_api.d.ts +277 -98
  21. package/build/javascript/lib/cp_sat_api.js +3364 -219
  22. package/build/javascript/lib/cp_sat_api.js.map +1 -1
  23. package/build/javascript/wasm/cp_sat_runtime.d.ts +51 -0
  24. package/build/javascript/wasm/cp_sat_runtime.js +10 -0
  25. package/build/javascript/wasm/cp_sat_runtime.wasm +0 -0
  26. package/build/javascript/wasm/cp_sat_runtime.wasm.map +1 -0
  27. package/build/javascript/wasm/cp_sat_runtime_asyncify.js +10 -0
  28. package/build/javascript/wasm/cp_sat_runtime_asyncify.wasm +0 -0
  29. package/build/javascript/wasm/cp_sat_runtime_asyncify.wasm.map +1 -0
  30. package/javascript/lib/cp_sat_api.ts +475 -0
  31. package/javascript/lib/cp_sat_module_loader.bundled.ts +58 -0
  32. package/javascript/lib/cp_sat_module_loader.ts +57 -0
  33. package/javascript/lib/cpsat_worker.ts +160 -0
  34. package/javascript/lib/cpsat_worker_types.ts +32 -0
  35. package/javascript/lib/generated/sat_parameters.ts +2760 -0
  36. package/javascript/lib/index.ts +8 -0
  37. package/javascript/lib/internal_wasm_asyncify.d.ts +15 -0
  38. package/javascript/lib/vite-shims.d.ts +25 -0
  39. package/javascript/lib/webassembly_promising.d.ts +7 -0
  40. package/package.json +46 -7
  41. package/build/javascript/lib/assets/cp_sat_runtime-N6mpxHFm.js +0 -2565
  42. package/build/javascript/lib/assets/cp_sat_runtime-N6mpxHFm.js.map +0 -1
  43. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-DAFhCUmM.js +0 -2639
  44. package/build/javascript/lib/assets/cp_sat_runtime_asyncify-DAFhCUmM.js.map +0 -1
  45. package/build/javascript/lib/assets/cpsat_worker-Bc6EW-gj.js +0 -139
  46. package/build/javascript/lib/assets/cpsat_worker-Bc6EW-gj.js.map +0 -1
  47. package/build/javascript/lib/chunks/cp_sat_runtime-B9zhYjnh.js +0 -2565
  48. package/build/javascript/lib/chunks/cp_sat_runtime-B9zhYjnh.js.map +0 -1
  49. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-BaxdGqjW.js +0 -2639
  50. package/build/javascript/lib/chunks/cp_sat_runtime_asyncify-BaxdGqjW.js.map +0 -1
  51. package/build/javascript/lib/chunks/index-Cq3lJx2c.js +0 -3815
  52. package/build/javascript/lib/chunks/index-Cq3lJx2c.js.map +0 -1
@@ -0,0 +1,475 @@
1
+ import type { MainModule } from '#internal-wasm/cp_sat_runtime.js';
2
+ import { loadCpSat } from './cp_sat_module_loader.js';
3
+ import type { WorkerRequest, WorkerResponse } from './cpsat_worker_types.js';
4
+ import type { SatParameters } from './generated/sat_parameters.js';
5
+ import * as protobufModule from 'protobufjs';
6
+
7
+ type SchemaPair = {
8
+ cp_model: string;
9
+ sat_parameters: string;
10
+ };
11
+
12
+ export type CpSatSolveResult = {
13
+ response: Record<string, unknown> | null;
14
+ bytes: Uint8Array;
15
+ };
16
+
17
+ type SolverParams = Uint8Array | SatParameters | null;
18
+
19
+ export type CpSatApi = {
20
+ solve(model: Uint8Array, params?: SolverParams): Promise<CpSatSolveResult>;
21
+ solveRaw(model: Uint8Array, params?: Uint8Array | null): Promise<Uint8Array>;
22
+ validate(model: Uint8Array): Promise<{ ok: boolean; message: string }>;
23
+ getSchemas(): Promise<SchemaPair>;
24
+ createModel(model: Record<string, unknown>): Promise<Uint8Array>;
25
+ loadModule(): Promise<unknown>;
26
+ setWorkerBridgeEnabled(enabled: boolean): void;
27
+ isWorkerBridgeEnabled(): boolean;
28
+ cancelSolve(): Promise<void>;
29
+ };
30
+
31
+ export type CpSatModelInstance = Uint8Array;
32
+
33
+ const isBrowserMainThread = typeof window !== 'undefined' && typeof document !== 'undefined';
34
+ const isDenoMainThread = 'Deno' in globalThis && typeof WorkerGlobalScope === 'undefined';
35
+ const workerCapable = typeof Worker !== 'undefined';
36
+ const workerBridgeAvailable = (isBrowserMainThread || isDenoMainThread) && workerCapable;
37
+ let worker: Worker | null = null;
38
+ let workerReadyPromise: Promise<void> | null = null;
39
+ const pendingWorkerRequests = new Map<
40
+ number,
41
+ {
42
+ resolve(value: WorkerResponse): void;
43
+ reject(reason: unknown): void;
44
+ }
45
+ >();
46
+ let nextWorkerRequestId = 1;
47
+
48
+ let workerBridgePreferred = workerBridgeAvailable;
49
+ let activeWorkerSolveId: number | null = null;
50
+
51
+ function shouldUseWorkerBridge() {
52
+ return workerBridgePreferred && workerBridgeAvailable;
53
+ }
54
+
55
+ function setWorkerBridgePreferred(enabled: boolean) {
56
+ workerBridgePreferred = Boolean(enabled);
57
+ if (workerBridgePreferred && !workerBridgeAvailable) {
58
+ console.warn('Worker bridge requested but no worker is initialized in this environment.');
59
+ }
60
+ }
61
+
62
+
63
+ function terminateWorker(reason?: string) {
64
+ if (!worker) return;
65
+ worker.terminate();
66
+ worker = null;
67
+ workerReadyPromise = null;
68
+ const error = new Error(reason ?? 'CP-SAT worker terminated.');
69
+ for (const pending of pendingWorkerRequests.values()) {
70
+ pending.reject(error);
71
+ }
72
+ pendingWorkerRequests.clear();
73
+ }
74
+
75
+ function ensureWorker(): Worker {
76
+ if (!workerBridgeAvailable) {
77
+ throw new Error('Worker bridge is not available.');
78
+ }
79
+ if (worker) {
80
+ return worker;
81
+ }
82
+ const workerUrl = new URL('./cpsat_worker.js', import.meta.url);
83
+ const instance = new Worker(new URL('./cpsat_worker.js', import.meta.url), { type: 'module' });
84
+ worker = instance;
85
+ workerReadyPromise = new Promise<void>((resolve, reject) => {
86
+ instance.onmessage = (event: MessageEvent<WorkerResponse>) => {
87
+ const message = event.data;
88
+ if (message.type === 'ready') {
89
+ resolve();
90
+ return;
91
+ }
92
+ const pending = pendingWorkerRequests.get(message.id);
93
+ if (message.type === 'error') {
94
+ const error = new Error(message.error);
95
+ if (pending) {
96
+ pending.reject(error);
97
+ pendingWorkerRequests.delete(message.id);
98
+ } else {
99
+ reject(error);
100
+ }
101
+ return;
102
+ }
103
+ if (pending) {
104
+ pendingWorkerRequests.delete(message.id);
105
+ pending.resolve(message);
106
+ }
107
+ };
108
+ instance.onerror = (event: ErrorEvent) => {
109
+ const detail = event.error instanceof Error
110
+ ? event.error.message
111
+ : event.message || 'The browser blocked or failed to load the worker module.';
112
+ const error = new Error(`CP-SAT worker failed to load from ${workerUrl.href}: ${detail}`);
113
+ reject(error);
114
+ terminateWorker(error.message);
115
+ };
116
+ });
117
+ return instance;
118
+ }
119
+
120
+ async function waitForWorkerReady() {
121
+ if (!workerBridgeAvailable) {
122
+ throw new Error('Worker bridge is not available.');
123
+ }
124
+ ensureWorker();
125
+ if (!workerReadyPromise) {
126
+ throw new Error('Worker ready state unavailable.');
127
+ }
128
+ await workerReadyPromise;
129
+ }
130
+
131
+ async function postWorkerRequest<T extends WorkerResponse>(request: WorkerRequest): Promise<T> {
132
+ if (!workerBridgeAvailable) {
133
+ throw new Error('Worker bridge is not available.');
134
+ }
135
+ const workerInstance = ensureWorker();
136
+ await waitForWorkerReady();
137
+ return new Promise<T>((resolve, reject) => {
138
+ pendingWorkerRequests.set(request.id, {
139
+ resolve: (value: WorkerResponse) => resolve(value as T),
140
+ reject,
141
+ });
142
+ workerInstance.postMessage(request);
143
+ });
144
+ }
145
+
146
+
147
+ let modulePromise: Promise<MainModule> | null = null;
148
+
149
+ function loadModule() {
150
+ if (shouldUseWorkerBridge()) {
151
+ throw new Error("Wasm should not be loaded on main thread when Worker Bridge is enabled");
152
+ }
153
+ if (!modulePromise) {
154
+ modulePromise = loadCpSat();
155
+ }
156
+ return modulePromise;
157
+ }
158
+
159
+
160
+ let schemaPromise: Promise<SchemaPair> | null = null;
161
+
162
+ function getSchemas() {
163
+ if (!schemaPromise) {
164
+ schemaPromise = (async () => {
165
+ if (shouldUseWorkerBridge()) {
166
+ const response = await postWorkerRequest<Extract<WorkerResponse, { type: 'schemaResult' }>>({
167
+ type: 'getSchemas',
168
+ id: nextWorkerRequestId++,
169
+ });
170
+ return response.schemas;
171
+ }
172
+
173
+ const Module = await loadModule();
174
+ return {
175
+ cp_model: Module.ccall('get_cp_model_schema', 'string', [], []),
176
+ sat_parameters: Module.ccall('get_sat_parameters_schema', 'string', [], []),
177
+ };
178
+ })();
179
+ }
180
+ return schemaPromise;
181
+ }
182
+
183
+ type ProtobufRoot = import('protobufjs').Root;
184
+ type CpModelType = import('protobufjs').Type;
185
+ type CpSolverResponseType = import('protobufjs').Type;
186
+
187
+ let protobufRootPromise: Promise<ProtobufRoot> | null = null;
188
+ let cpModelTypePromise: Promise<CpModelType> | null = null;
189
+ let cpSolverResponseTypePromise: Promise<CpSolverResponseType> | null = null;
190
+ let satParametersTypePromise: Promise<import('protobufjs').Type> | null = null;
191
+
192
+ async function resolveProtobufRoot(feature: string): Promise<ProtobufRoot> {
193
+ if (!protobufRootPromise) {
194
+ protobufRootPromise = (async () => {
195
+ const schemas = await getSchemas();
196
+ const parsed = protobufModule.parse(schemas.cp_model);
197
+ return parsed.root;
198
+ })();
199
+ }
200
+ try {
201
+ return await protobufRootPromise;
202
+ } catch (error) {
203
+ protobufRootPromise = null;
204
+ throw error;
205
+ }
206
+ }
207
+
208
+ async function resolveCpModelType(): Promise<CpModelType> {
209
+ if (!cpModelTypePromise) {
210
+ cpModelTypePromise = (async () => {
211
+ const root = await resolveProtobufRoot('createModel');
212
+ const cpModelType = root.lookupType('operations_research.sat.CpModelProto');
213
+ if (!cpModelType) {
214
+ throw new Error('CpSat.createModel: cp_model schema did not expose operations_research.sat.CpModelProto.');
215
+ }
216
+ return cpModelType;
217
+ })();
218
+ }
219
+ try {
220
+ return await cpModelTypePromise;
221
+ } catch (error) {
222
+ cpModelTypePromise = null;
223
+ throw error;
224
+ }
225
+ }
226
+
227
+ async function resolveCpSolverResponseType(): Promise<CpSolverResponseType> {
228
+ if (!cpSolverResponseTypePromise) {
229
+ cpSolverResponseTypePromise = (async () => {
230
+ const root = await resolveProtobufRoot('solve');
231
+ const solverType = root.lookupType('operations_research.sat.CpSolverResponse');
232
+ if (!solverType) {
233
+ throw new Error('CpSat.solve: cp_model schema did not expose operations_research.sat.CpSolverResponse.');
234
+ }
235
+ return solverType;
236
+ })();
237
+ }
238
+ try {
239
+ return await cpSolverResponseTypePromise;
240
+ } catch (error) {
241
+ cpSolverResponseTypePromise = null;
242
+ throw error;
243
+ }
244
+ }
245
+
246
+ async function resolveSatParametersType(): Promise<import('protobufjs').Type> {
247
+ if (!satParametersTypePromise) {
248
+ satParametersTypePromise = (async () => {
249
+ const schemas = await getSchemas();
250
+ const parsed = protobufModule.parse(schemas.sat_parameters);
251
+ const root = parsed.root;
252
+ const paramsType = root.lookupType('operations_research.sat.SatParameters');
253
+ if (!paramsType) {
254
+ throw new Error('CpSat.solve: sat_parameters schema did not expose operations_research.sat.SatParameters.');
255
+ }
256
+ return paramsType;
257
+ })();
258
+ }
259
+ try {
260
+ return await satParametersTypePromise;
261
+ } catch (error) {
262
+ satParametersTypePromise = null;
263
+ throw error;
264
+ }
265
+ }
266
+
267
+ async function encodeSatParameters(params: Record<string, unknown>): Promise<Uint8Array> {
268
+ const paramsType = await resolveSatParametersType();
269
+ const validationError = paramsType.verify(params);
270
+ if (validationError) {
271
+ throw new Error(`CpSat.solve: ${validationError}`);
272
+ }
273
+ const message = paramsType.create(params);
274
+ return paramsType.encode(message).finish();
275
+ }
276
+
277
+ async function resolveParamsBytes(params?: SolverParams): Promise<Uint8Array | null> {
278
+ if (!params) {
279
+ return null;
280
+ }
281
+ if (params instanceof Uint8Array) {
282
+ return params;
283
+ }
284
+ return encodeSatParameters(params);
285
+ }
286
+
287
+ async function decodeSolverResponse(bytes: Uint8Array): Promise<Record<string, unknown>> {
288
+ const solverType = await resolveCpSolverResponseType();
289
+ const decoded = solverType.decode(bytes);
290
+ return solverType.toObject(decoded, {
291
+ enums: String,
292
+ longs: Number,
293
+ defaults: true,
294
+ arrays: true,
295
+ objects: true,
296
+ }) as Record<string, unknown>;
297
+ }
298
+
299
+ async function createModel(model: Record<string, unknown>): Promise<Uint8Array> {
300
+ const type = await resolveCpModelType();
301
+ const validationError = type.verify(model);
302
+ if (validationError) {
303
+ throw new Error(`CpSat.createModel: ${validationError}`);
304
+ }
305
+ const message = type.create(model);
306
+ return type.encode(message).finish();
307
+ }
308
+
309
+ const readUint32LE = (buffer: ArrayBuffer, ptr: number) =>
310
+ new DataView(buffer, ptr, 4).getUint32(0, true);
311
+
312
+ function copyBytesToHeap(Module: MainModule, bytes: Uint8Array | null) {
313
+ if (!bytes || !bytes.length) {
314
+ return 0;
315
+ }
316
+ const ptr = Module._malloc(bytes.length);
317
+ Module.HEAPU8.set(bytes, ptr);
318
+ return ptr;
319
+ }
320
+
321
+
322
+ type WorkerSolveResponse = Extract<WorkerResponse, { type: 'solveResult' }>;
323
+ type WorkerValidateResponse = Extract<WorkerResponse, { type: 'validateResult' }>;
324
+
325
+ async function solveRawViaWorker(modelBytes: Uint8Array, paramsBytes: Uint8Array | null = null) {
326
+ const id = nextWorkerRequestId++;
327
+ activeWorkerSolveId = id;
328
+ try {
329
+ const response = await postWorkerRequest<WorkerSolveResponse>({
330
+ type: 'solve',
331
+ id,
332
+ modelBytes,
333
+ paramsBytes: paramsBytes ?? undefined,
334
+ });
335
+ const bytes = new Uint8Array(response.bytes);
336
+ return bytes;
337
+ } finally {
338
+ if (activeWorkerSolveId === id) {
339
+ activeWorkerSolveId = null;
340
+ }
341
+ }
342
+ }
343
+
344
+ async function validateViaWorker(modelBytes: Uint8Array) {
345
+ const id = nextWorkerRequestId++;
346
+ const response = await postWorkerRequest<WorkerValidateResponse>({
347
+ type: 'validate',
348
+ id,
349
+ modelBytes,
350
+ });
351
+ return { ok: response.ok, message: response.message };
352
+ }
353
+
354
+ async function solveRawDirect(modelBytes: Uint8Array, paramsBytes: Uint8Array | null = null) {
355
+ const Module = await loadModule();
356
+
357
+ const lenPtr = Module._malloc(4);
358
+ const modelPtr = copyBytesToHeap(Module, modelBytes);
359
+ const paramsPtr = copyBytesToHeap(Module, paramsBytes);
360
+ let responsePtr = 0;
361
+
362
+ try {
363
+ responsePtr = (await Module.ccall(
364
+ 'solve_model',
365
+ 'number',
366
+ ['number', 'number', 'number', 'number', 'number'],
367
+ [
368
+ modelPtr,
369
+ modelBytes.length,
370
+ paramsPtr,
371
+ paramsBytes ? paramsBytes.length : 0,
372
+ lenPtr,
373
+ ],
374
+ { async: true },
375
+ )) as number;
376
+ } finally {
377
+ if (modelPtr) Module._free(modelPtr);
378
+ if (paramsPtr) Module._free(paramsPtr);
379
+ }
380
+
381
+ const len = readUint32LE(Module.HEAPU8.buffer, lenPtr);
382
+ Module._free(lenPtr);
383
+
384
+ let bytes = new Uint8Array();
385
+ if (responsePtr && len) {
386
+ bytes = Module.HEAPU8.slice(responsePtr, responsePtr + len);
387
+ Module._free_buffer(responsePtr);
388
+ } else if (responsePtr) {
389
+ Module._free_buffer(responsePtr);
390
+ }
391
+
392
+ return new Uint8Array(bytes);
393
+ }
394
+
395
+ async function solveRaw(modelBytes: Uint8Array, paramsBytes: Uint8Array | null = null) {
396
+ return shouldUseWorkerBridge()
397
+ ? solveRawViaWorker(modelBytes, paramsBytes)
398
+ : solveRawDirect(modelBytes, paramsBytes);
399
+ }
400
+
401
+ async function solve(modelBytes: Uint8Array, params: SolverParams = null): Promise<CpSatSolveResult> {
402
+ const paramsBytes = await resolveParamsBytes(params);
403
+ const bytes = await solveRaw(modelBytes, paramsBytes);
404
+ let response: Record<string, unknown> | null = null;
405
+ if (bytes.length > 0) {
406
+ response = await decodeSolverResponse(bytes);
407
+ }
408
+ return { bytes, response };
409
+ }
410
+
411
+ async function validateDirect(model: Uint8Array) {
412
+ const Module = await loadModule();
413
+ const lenPtr = Module._malloc(4);
414
+ const modelPtr = copyBytesToHeap(Module, model);
415
+ let msgPtr = 0;
416
+
417
+ try {
418
+ // Note: Use modelBytes.length here? Original code had 'modelBytes' not defined in arguments.
419
+ // Assuming 'model' argument is the Uint8Array.
420
+ msgPtr = Module.ccall(
421
+ 'validate_model',
422
+ 'number',
423
+ ['number', 'number', 'number'],
424
+ [modelPtr, model.length, lenPtr],
425
+ ) as number;
426
+ } finally {
427
+ if (modelPtr) Module._free(modelPtr);
428
+ }
429
+
430
+ const len = readUint32LE(Module.HEAPU8.buffer, lenPtr);
431
+ Module._free(lenPtr);
432
+
433
+ if (!msgPtr || len === 0) {
434
+ if (msgPtr) Module._free_buffer(msgPtr);
435
+ return { ok: true, message: '' };
436
+ }
437
+
438
+ const messageBytes = Module.HEAPU8.slice(msgPtr, msgPtr + len);
439
+ Module._free_buffer(msgPtr);
440
+ const message = new TextDecoder().decode(messageBytes);
441
+ return { ok: false, message };
442
+ }
443
+
444
+ async function cancelSolve() {
445
+ if (shouldUseWorkerBridge()) {
446
+ if (worker && activeWorkerSolveId !== null) {
447
+ // await postWorkerRequest<WorkerSolveResponse>({
448
+ // type: 'cancel_solve',
449
+ // });
450
+ terminateWorker('Solve canceled by user.');
451
+ activeWorkerSolveId = null;
452
+ }
453
+ } else {
454
+ const Module = await loadModule();
455
+ Module.ccall('interrupt_solve', 'void', [], []);
456
+ }
457
+ }
458
+
459
+ export const CpSat: CpSatApi = {
460
+ solve: (model, params = null) => solve(model, params),
461
+ solveRaw: (model, params = null) => solveRaw(model, params),
462
+ validate: (model) => (shouldUseWorkerBridge() ? validateViaWorker(model) : validateDirect(model)),
463
+ getSchemas,
464
+ createModel,
465
+ loadModule,
466
+ cancelSolve,
467
+ setWorkerBridgeEnabled: (enabled: boolean) => setWorkerBridgePreferred(enabled),
468
+ isWorkerBridgeEnabled: () => shouldUseWorkerBridge(),
469
+ };
470
+
471
+ if (isBrowserMainThread) {
472
+ (window as Window & { CpSat?: CpSatApi }).CpSat = CpSat;
473
+ }
474
+
475
+ export default CpSat;
@@ -0,0 +1,58 @@
1
+ import type { MainModule } from '@internal-wasm/cp_sat_runtime.js';
2
+ import cpSatRuntimeWasmUrl from '@internal-wasm/cp_sat_runtime.wasm?url&no-inline';
3
+ import cpSatRuntimeAsyncifyWasmUrl from '@internal-wasm/cp_sat_runtime_asyncify.wasm?url&no-inline';
4
+
5
+
6
+ type CpSatModuleFactory = (moduleOverrides?: Record<string, unknown>) => Promise<MainModule>;
7
+ type RuntimeFlavor = 'jspi' | 'asyncify';
8
+
9
+ let modulePromise: Promise<MainModule> | null = null;
10
+ let selectedFlavor: RuntimeFlavor | null = null;
11
+
12
+ function isJspiSupported(): boolean {
13
+ const wasm = WebAssembly as typeof WebAssembly & { promising?: unknown };
14
+ return typeof wasm !== 'undefined' && typeof wasm.promising === 'function';
15
+ }
16
+
17
+ function selectRuntimeFlavor(): RuntimeFlavor {
18
+ if (selectedFlavor) {
19
+ return selectedFlavor;
20
+ }
21
+ selectedFlavor = isJspiSupported() ? 'jspi' : 'asyncify';
22
+ if (selectedFlavor === 'jspi') {
23
+ console.log('JSPI is supported. Using ASYNCIFY=2.');
24
+ } else {
25
+ console.log('JSPI not found. Falling back to ASYNCIFY=1.');
26
+ }
27
+ return selectedFlavor;
28
+ }
29
+
30
+ async function loadFactory(): Promise<CpSatModuleFactory> {
31
+ const flavor = selectRuntimeFlavor();
32
+ if (flavor === 'jspi') {
33
+ const { default: createModule } = await import('@internal-wasm/cp_sat_runtime.js');
34
+ return createModule as CpSatModuleFactory;
35
+ }
36
+ const { default: createModule } = await import('@internal-wasm/cp_sat_runtime_asyncify.js');
37
+ return createModule as CpSatModuleFactory;
38
+ }
39
+
40
+ function locateCpSatRuntimeFile(fileName: string) {
41
+ if (fileName === 'cp_sat_runtime.wasm') {
42
+ return cpSatRuntimeWasmUrl;
43
+ }
44
+ if (fileName === 'cp_sat_runtime_asyncify.wasm') {
45
+ return cpSatRuntimeAsyncifyWasmUrl;
46
+ }
47
+ return fileName;
48
+ }
49
+
50
+ export async function loadCpSat(): Promise<MainModule> {
51
+ if (!modulePromise) {
52
+ modulePromise = (async () => {
53
+ const createModule = await loadFactory();
54
+ return createModule({ locateFile: locateCpSatRuntimeFile });
55
+ })();
56
+ }
57
+ return modulePromise;
58
+ }
@@ -0,0 +1,57 @@
1
+ import type { MainModule } from '#internal-wasm/cp_sat_runtime.js';
2
+ import cpSatRuntimeWasmUrl from '#internal-wasm/cp_sat_runtime.wasm?url&no-inline';
3
+ import cpSatRuntimeAsyncifyWasmUrl from '#internal-wasm/cp_sat_runtime_asyncify.wasm?url&no-inline';
4
+
5
+ type CpSatModuleFactory = (moduleOverrides?: Record<string, unknown>) => Promise<MainModule>;
6
+ type RuntimeFlavor = 'jspi' | 'asyncify';
7
+
8
+ let modulePromise: Promise<MainModule> | null = null;
9
+ let selectedFlavor: RuntimeFlavor | null = null;
10
+
11
+ function isJspiSupported(): boolean {
12
+ const wasm = WebAssembly as typeof WebAssembly & { promising?: unknown };
13
+ return typeof wasm !== 'undefined' && typeof wasm.promising === 'function';
14
+ }
15
+
16
+ function selectRuntimeFlavor(): RuntimeFlavor {
17
+ if (selectedFlavor) {
18
+ return selectedFlavor;
19
+ }
20
+ selectedFlavor = isJspiSupported() ? 'jspi' : 'asyncify';
21
+ if (selectedFlavor === 'jspi') {
22
+ console.log('JSPI is supported. Using ASYNCIFY=2.');
23
+ } else {
24
+ console.log('JSPI not found. Falling back to ASYNCIFY=1.');
25
+ }
26
+ return selectedFlavor;
27
+ }
28
+
29
+ async function loadFactory(): Promise<CpSatModuleFactory> {
30
+ const flavor = selectRuntimeFlavor();
31
+ if (flavor === 'jspi') {
32
+ const { default: createModule } = await import('#internal-wasm/cp_sat_runtime.js');
33
+ return createModule as CpSatModuleFactory;
34
+ }
35
+ const { default: createModule } = await import('#internal-wasm/cp_sat_runtime_asyncify.js');
36
+ return createModule as CpSatModuleFactory;
37
+ }
38
+
39
+ function locateCpSatRuntimeFile(fileName: string) {
40
+ if (fileName === 'cp_sat_runtime.wasm') {
41
+ return cpSatRuntimeWasmUrl;
42
+ }
43
+ if (fileName === 'cp_sat_runtime_asyncify.wasm') {
44
+ return cpSatRuntimeAsyncifyWasmUrl;
45
+ }
46
+ return fileName;
47
+ }
48
+
49
+ export async function loadCpSat(): Promise<MainModule> {
50
+ if (!modulePromise) {
51
+ modulePromise = (async () => {
52
+ const createModule = await loadFactory();
53
+ return createModule({ locateFile: locateCpSatRuntimeFile });
54
+ })();
55
+ }
56
+ return modulePromise;
57
+ }