datalevin-node 0.10.18 → 1.0.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/src/interop.js CHANGED
@@ -1,5 +1,9 @@
1
1
  import { toEdnForm, toJava, toJs, toQueryInput } from "./convert.js";
2
- import { callJavaMethod, classes, jvmStarted, startJvm } from "./jvm.js";
2
+ import { DatalevinError } from "./errors.js";
3
+ import { callJavaMethod, classes, javaBridgeModule, jvmStarted, startJvm } from "./jvm.js";
4
+
5
+ export const CONNECTION_WITH_TRANSACTION_UNSUPPORTED =
6
+ "Connection withTransaction is not exposed by the JavaScript binding because Java interface callbacks deadlock when the callback calls back into Datalevin. Use transact() for a single Datalog transaction, or KV withTransaction for explicit KV transactions.";
3
7
 
4
8
  async function unwrapInteropHandle(value) {
5
9
  if (typeof value?.rawHandle === "function") {
@@ -8,6 +12,24 @@ async function unwrapInteropHandle(value) {
8
12
  return value;
9
13
  }
10
14
 
15
+ function hasValue(value) {
16
+ return value !== null && value !== undefined;
17
+ }
18
+
19
+ function datomMapValue(value, key) {
20
+ return value?.[`:${key}`] ?? value?.[key] ?? null;
21
+ }
22
+
23
+ function datomField(value, key, index) {
24
+ if (Array.isArray(value)) {
25
+ return index < value.length ? value[index] : null;
26
+ }
27
+ if (value !== null && typeof value === "object") {
28
+ return datomMapValue(value, key);
29
+ }
30
+ throw new TypeError("Expected datom-shaped array or object.");
31
+ }
32
+
11
33
  async function normalizeInteropArgs(args = []) {
12
34
  const normalized = [];
13
35
  for (const arg of args) {
@@ -16,6 +38,36 @@ async function normalizeInteropArgs(args = []) {
16
38
  return normalized;
17
39
  }
18
40
 
41
+ async function createFunctionProxy(fn) {
42
+ const { newProxy } = await javaBridgeModule();
43
+ return newProxy("java.util.function.Function", {
44
+ apply: async (value) => {
45
+ const result = await fn(value);
46
+ return toJava(result === undefined ? null : result);
47
+ }
48
+ });
49
+ }
50
+
51
+ let interfaceProxyEventLoopDepth = 0;
52
+ let interfaceProxyEventLoopPrevious = false;
53
+
54
+ async function withInterfaceProxyEventLoop(fn) {
55
+ const bridge = await javaBridgeModule();
56
+ if (interfaceProxyEventLoopDepth === 0) {
57
+ interfaceProxyEventLoopPrevious = bridge.config.runEventLoopWhenInterfaceProxyIsActive;
58
+ bridge.config.runEventLoopWhenInterfaceProxyIsActive = true;
59
+ }
60
+ interfaceProxyEventLoopDepth += 1;
61
+ try {
62
+ return await fn();
63
+ } finally {
64
+ interfaceProxyEventLoopDepth -= 1;
65
+ if (interfaceProxyEventLoopDepth === 0) {
66
+ bridge.config.runEventLoopWhenInterfaceProxyIsActive = interfaceProxyEventLoopPrevious;
67
+ }
68
+ }
69
+ }
70
+
19
71
  class InteropBindings {
20
72
  async apiInfoRaw() {
21
73
  const cls = await classes();
@@ -30,79 +82,1181 @@ class InteropBindings {
30
82
  return callJavaMethod(cls.datalevin, "exec", op, await toJava(args));
31
83
  }
32
84
 
33
- async coreInvoke(functionName, args = null) {
85
+ async coreInvoke(functionName, args = null) {
86
+ const cls = await classes();
87
+ return callJavaMethod(
88
+ cls.interop,
89
+ "coreInvokeBridge",
90
+ functionName,
91
+ await toJava(await normalizeInteropArgs([...(args || [])]))
92
+ );
93
+ }
94
+
95
+ async coreInvokeRaw(functionName, args = null) {
96
+ const cls = await classes();
97
+ return callJavaMethod(
98
+ cls.interop,
99
+ "coreInvoke",
100
+ functionName,
101
+ await toJava(await normalizeInteropArgs([...(args || [])]))
102
+ );
103
+ }
104
+
105
+ async clientInvoke(functionName, args = null) {
106
+ const cls = await classes();
107
+ return callJavaMethod(
108
+ cls.interop,
109
+ "clientInvokeBridge",
110
+ functionName,
111
+ await toJava(await normalizeInteropArgs([...(args || [])]))
112
+ );
113
+ }
114
+
115
+ async createConnection(dir = null, schema = null, opts = null, { shared = false } = {}) {
116
+ const cls = await classes();
117
+ const target = shared ? "getConn" : "createConn";
118
+
119
+ if (opts !== null && opts !== undefined) {
120
+ return callJavaMethod(cls.datalevin, target, dir, await toJava(schema), await toJava(opts));
121
+ }
122
+ if (schema !== null && schema !== undefined) {
123
+ return callJavaMethod(cls.datalevin, target, dir, await toJava(schema));
124
+ }
125
+ if (dir !== null && dir !== undefined) {
126
+ return callJavaMethod(cls.datalevin, target, dir);
127
+ }
128
+ return callJavaMethod(cls.datalevin, target);
129
+ }
130
+
131
+ async initDb(datoms, dir = null, schema = null, opts = null) {
132
+ const cls = await classes();
133
+ if (opts !== null && opts !== undefined) {
134
+ return callJavaMethod(cls.datalevin, "initDb", await toJava(datoms), dir, await toJava(schema), await toJava(opts));
135
+ }
136
+ if (schema !== null && schema !== undefined) {
137
+ return callJavaMethod(cls.datalevin, "initDb", await toJava(datoms), dir, await toJava(schema));
138
+ }
139
+ if (dir !== null && dir !== undefined) {
140
+ return callJavaMethod(cls.datalevin, "initDb", await toJava(datoms), dir);
141
+ }
142
+ return callJavaMethod(cls.datalevin, "initDb", await toJava(datoms));
143
+ }
144
+
145
+ async fillDb(conn, datoms) {
146
+ const handle = await unwrapInteropHandle(conn);
147
+ await callJavaMethod(handle, "fillDb", await toJava(datoms));
148
+ return handle;
149
+ }
150
+
151
+ async closeConnection(handle) {
152
+ await callJavaMethod(handle, "close");
153
+ }
154
+
155
+ async connectionClosed(handle) {
156
+ return Boolean(await callJavaMethod(handle, "closed"));
157
+ }
158
+
159
+ async connectionDb(handle) {
160
+ const cls = await classes();
161
+ return callJavaMethod(cls.interop, "connectionDbBridge", handle);
162
+ }
163
+
164
+ async connectionEntity(handle, eid) {
165
+ const cls = await classes();
166
+ return callJavaMethod(
167
+ cls.interop,
168
+ "connectionEntity",
169
+ await unwrapInteropHandle(handle),
170
+ await toJava(eid)
171
+ );
172
+ }
173
+
174
+ async databaseEntid(db, eid) {
175
+ const cls = await classes();
176
+ return callJavaMethod(
177
+ cls.interop,
178
+ "databaseEntid",
179
+ await unwrapInteropHandle(db),
180
+ await toJava(eid)
181
+ );
182
+ }
183
+
184
+ async databaseEntity(db, eid) {
185
+ const cls = await classes();
186
+ return callJavaMethod(
187
+ cls.interop,
188
+ "databaseEntity",
189
+ await unwrapInteropHandle(db),
190
+ await toJava(eid)
191
+ );
192
+ }
193
+
194
+ async databaseEntityMap(db, eid) {
195
+ const cls = await classes();
196
+ return callJavaMethod(
197
+ cls.interop,
198
+ "databaseEntityMap",
199
+ await unwrapInteropHandle(db),
200
+ await toJava(eid)
201
+ );
202
+ }
203
+
204
+ async databasePull(db, selector, eid) {
205
+ const cls = await classes();
206
+ return callJavaMethod(
207
+ cls.interop,
208
+ "databasePull",
209
+ await unwrapInteropHandle(db),
210
+ selector,
211
+ await toJava(eid)
212
+ );
213
+ }
214
+
215
+ async databasePullMany(db, selector, eids) {
216
+ const cls = await classes();
217
+ return callJavaMethod(
218
+ cls.interop,
219
+ "databasePullMany",
220
+ await unwrapInteropHandle(db),
221
+ selector,
222
+ await toJava(eids)
223
+ );
224
+ }
225
+
226
+ async databaseCardinality(db, attr) {
227
+ const cls = await classes();
228
+ return callJavaMethod(
229
+ cls.interop,
230
+ "databaseCardinality",
231
+ await unwrapInteropHandle(db),
232
+ await toJava(attr)
233
+ );
234
+ }
235
+
236
+ async databaseAnalyze(db, attr = null) {
237
+ const cls = await classes();
238
+ const rawDb = await unwrapInteropHandle(db);
239
+ if (attr === null || attr === undefined) {
240
+ return callJavaMethod(cls.interop, "databaseAnalyze", rawDb);
241
+ }
242
+ return callJavaMethod(cls.interop, "databaseAnalyze", rawDb, await toJava(attr));
243
+ }
244
+
245
+ async entityIs(value) {
246
+ if (value === null || value === undefined || (typeof value !== "object" && typeof value !== "function")) {
247
+ return false;
248
+ }
249
+ const cls = await classes();
250
+ return Boolean(await callJavaMethod(cls.interop, "entityIs", value));
251
+ }
252
+
253
+ async entityId(entity) {
254
+ const cls = await classes();
255
+ return callJavaMethod(cls.interop, "entityId", await unwrapInteropHandle(entity));
256
+ }
257
+
258
+ async entityGet(entity, attr) {
259
+ const cls = await classes();
260
+ return callJavaMethod(
261
+ cls.interop,
262
+ "entityGet",
263
+ await unwrapInteropHandle(entity),
264
+ await toJava(attr)
265
+ );
266
+ }
267
+
268
+ async entityContains(entity, attr) {
269
+ const cls = await classes();
270
+ return Boolean(
271
+ await callJavaMethod(
272
+ cls.interop,
273
+ "entityContains",
274
+ await unwrapInteropHandle(entity),
275
+ await toJava(attr)
276
+ )
277
+ );
278
+ }
279
+
280
+ async entityTouch(entity) {
281
+ const cls = await classes();
282
+ return callJavaMethod(cls.interop, "entityTouch", await unwrapInteropHandle(entity));
283
+ }
284
+
285
+ async connectionTransactAsync(handle, txData, txMeta = null) {
286
+ const cls = await classes();
287
+ return callJavaMethod(
288
+ cls.interop,
289
+ "connectionTransactAsync",
290
+ await unwrapInteropHandle(handle),
291
+ await toJava(txData),
292
+ hasValue(txMeta) ? await toJava(txMeta) : null
293
+ );
294
+ }
295
+
296
+ async connectionTransact(handle, txData, txMeta = null) {
297
+ const cls = await classes();
298
+ return callJavaMethod(
299
+ cls.interop,
300
+ "connectionTransact",
301
+ await unwrapInteropHandle(handle),
302
+ await toJava(txData),
303
+ hasValue(txMeta) ? await toJava(txMeta) : null
304
+ );
305
+ }
306
+
307
+ async connectionAbortTransact(handle) {
308
+ const cls = await classes();
309
+ return callJavaMethod(
310
+ cls.interop,
311
+ "connectionAbortTransact",
312
+ await unwrapInteropHandle(handle)
313
+ );
314
+ }
315
+
316
+ async connectionTxDataToSimulatedReport(handle, txData) {
317
+ const cls = await classes();
318
+ return callJavaMethod(
319
+ cls.interop,
320
+ "connectionTxDataToSimulatedReportBridge",
321
+ await unwrapInteropHandle(handle),
322
+ await toJava(txData)
323
+ );
324
+ }
325
+
326
+ async connectionListen(handle, keyOrListener, listener = null) {
327
+ const cls = await classes();
328
+ if (hasValue(listener)) {
329
+ return callJavaMethod(
330
+ cls.interop,
331
+ "connectionListen",
332
+ await unwrapInteropHandle(handle),
333
+ await toJava(keyOrListener),
334
+ listener
335
+ );
336
+ }
337
+ return callJavaMethod(
338
+ cls.interop,
339
+ "connectionListen",
340
+ await unwrapInteropHandle(handle),
341
+ keyOrListener
342
+ );
343
+ }
344
+
345
+ async connectionUnlisten(handle, key) {
346
+ const cls = await classes();
347
+ await callJavaMethod(
348
+ cls.interop,
349
+ "connectionUnlisten",
350
+ await unwrapInteropHandle(handle),
351
+ await toJava(key)
352
+ );
353
+ }
354
+
355
+ async connectionDatoms(handle, index, c1 = null, c2 = null, c3 = null, limit = null) {
356
+ const cls = await classes();
357
+ return callJavaMethod(
358
+ cls.interop,
359
+ "connectionDatoms",
360
+ await unwrapInteropHandle(handle),
361
+ await toJava(index),
362
+ await toJava(c1),
363
+ await toJava(c2),
364
+ await toJava(c3),
365
+ hasValue(limit) ? await toJava(limit) : null
366
+ );
367
+ }
368
+
369
+ async connectionSearchDatoms(handle, e = null, attr = null, value = null) {
370
+ const cls = await classes();
371
+ return callJavaMethod(
372
+ cls.interop,
373
+ "connectionSearchDatoms",
374
+ await unwrapInteropHandle(handle),
375
+ await toJava(e),
376
+ await toJava(attr),
377
+ await toJava(value)
378
+ );
379
+ }
380
+
381
+ async connectionCountDatoms(handle, e = null, attr = null, value = null) {
382
+ const cls = await classes();
383
+ return callJavaMethod(
384
+ cls.interop,
385
+ "connectionCountDatoms",
386
+ await unwrapInteropHandle(handle),
387
+ await toJava(e),
388
+ await toJava(attr),
389
+ await toJava(value)
390
+ );
391
+ }
392
+
393
+ async connectionSeekDatoms(handle, index, c1 = null, c2 = null, c3 = null, limit = null) {
394
+ const cls = await classes();
395
+ return callJavaMethod(
396
+ cls.interop,
397
+ "connectionSeekDatoms",
398
+ await unwrapInteropHandle(handle),
399
+ await toJava(index),
400
+ await toJava(c1),
401
+ await toJava(c2),
402
+ await toJava(c3),
403
+ hasValue(limit) ? await toJava(limit) : null
404
+ );
405
+ }
406
+
407
+ async connectionRseekDatoms(handle, index, c1 = null, c2 = null, c3 = null, limit = null) {
408
+ const cls = await classes();
409
+ return callJavaMethod(
410
+ cls.interop,
411
+ "connectionRseekDatoms",
412
+ await unwrapInteropHandle(handle),
413
+ await toJava(index),
414
+ await toJava(c1),
415
+ await toJava(c2),
416
+ await toJava(c3),
417
+ hasValue(limit) ? await toJava(limit) : null
418
+ );
419
+ }
420
+
421
+ async connectionIndexRange(handle, attr, start, end) {
422
+ const cls = await classes();
423
+ return callJavaMethod(
424
+ cls.interop,
425
+ "connectionIndexRange",
426
+ await unwrapInteropHandle(handle),
427
+ await toJava(attr),
428
+ await toJava(start),
429
+ await toJava(end)
430
+ );
431
+ }
432
+
433
+ async connectionFulltextDatoms(handle, query, opts = null) {
434
+ const cls = await classes();
435
+ return callJavaMethod(
436
+ cls.interop,
437
+ "connectionFulltextDatoms",
438
+ await unwrapInteropHandle(handle),
439
+ query,
440
+ hasValue(opts) ? await toJava(opts) : null
441
+ );
442
+ }
443
+
444
+ async connectionCopy(handle, dest, compact = null) {
445
+ const cls = await classes();
446
+ await callJavaMethod(
447
+ cls.interop,
448
+ "connectionCopy",
449
+ await unwrapInteropHandle(handle),
450
+ dest,
451
+ hasValue(compact) ? Boolean(compact) : null
452
+ );
453
+ }
454
+
455
+ async connectionTxLogWatermarks(handle) {
456
+ const cls = await classes();
457
+ return callJavaMethod(cls.interop, "connectionTxLogWatermarks", await unwrapInteropHandle(handle));
458
+ }
459
+
460
+ async connectionOpenTxLog(handle, fromLsn, uptoLsn = null) {
461
+ const cls = await classes();
462
+ return callJavaMethod(
463
+ cls.interop,
464
+ "connectionOpenTxLog",
465
+ await unwrapInteropHandle(handle),
466
+ await toJava(fromLsn),
467
+ hasValue(uptoLsn) ? await toJava(uptoLsn) : null
468
+ );
469
+ }
470
+
471
+ async connectionCreateSnapshot(handle) {
472
+ const cls = await classes();
473
+ return callJavaMethod(cls.interop, "connectionCreateSnapshot", await unwrapInteropHandle(handle));
474
+ }
475
+
476
+ async connectionListSnapshots(handle) {
477
+ const cls = await classes();
478
+ return callJavaMethod(cls.interop, "connectionListSnapshots", await unwrapInteropHandle(handle));
479
+ }
480
+
481
+ async connectionGcTxLogSegments(handle, retainFloorLsn = null) {
482
+ const cls = await classes();
483
+ return callJavaMethod(
484
+ cls.interop,
485
+ "connectionGcTxLogSegments",
486
+ await unwrapInteropHandle(handle),
487
+ hasValue(retainFloorLsn) ? await toJava(retainFloorLsn) : null
488
+ );
489
+ }
490
+
491
+ async connectionReIndex(handle, schema = null, opts = null) {
492
+ const cls = await classes();
493
+ return callJavaMethod(
494
+ cls.interop,
495
+ "connectionReIndex",
496
+ await unwrapInteropHandle(handle),
497
+ hasValue(schema) ? await toJava(schema) : null,
498
+ hasValue(opts) ? await toJava(opts) : null
499
+ );
500
+ }
501
+
502
+ async openKeyValue(dir, opts = null) {
503
+ const cls = await classes();
504
+ if (opts !== null && opts !== undefined) {
505
+ return callJavaMethod(cls.datalevin, "openKV", dir, await toJava(opts));
506
+ }
507
+ return callJavaMethod(cls.datalevin, "openKV", dir);
508
+ }
509
+
510
+ async closeKeyValue(handle) {
511
+ await callJavaMethod(handle, "close");
512
+ }
513
+
514
+ async keyValueClosed(handle) {
515
+ return Boolean(await callJavaMethod(handle, "closed"));
516
+ }
517
+
518
+ async keyValueBeginTransaction(handle) {
519
+ const cls = await classes();
520
+ return callJavaMethod(cls.interop, "keyValueBeginTransaction", await unwrapInteropHandle(handle));
521
+ }
522
+
523
+ async keyValueCommitTransaction(tx) {
524
+ const cls = await classes();
525
+ return callJavaMethod(cls.interop, "keyValueCommitTransaction", await unwrapInteropHandle(tx));
526
+ }
527
+
528
+ async keyValueAbortTransaction(tx) {
529
+ const cls = await classes();
530
+ return callJavaMethod(cls.interop, "keyValueAbortTransaction", await unwrapInteropHandle(tx));
531
+ }
532
+
533
+ async keyValueWithTransaction(handle, fn) {
534
+ const cls = await classes();
535
+ const proxy = await createFunctionProxy(fn);
536
+ try {
537
+ return await withInterfaceProxyEventLoop(async () => (
538
+ callJavaMethod(
539
+ cls.interop,
540
+ "keyValueWithTransaction",
541
+ await unwrapInteropHandle(handle),
542
+ proxy
543
+ )
544
+ ));
545
+ } finally {
546
+ proxy.reset?.();
547
+ }
548
+ }
549
+
550
+ async keyValueReIndex(handle, opts = null) {
551
+ const cls = await classes();
552
+ return callJavaMethod(
553
+ cls.interop,
554
+ "keyValueReIndex",
555
+ await unwrapInteropHandle(handle),
556
+ hasValue(opts) ? await toJava(opts) : null
557
+ );
558
+ }
559
+
560
+ async kvGetByRank(handle, dbiName, rank, kType, vType, ignoreKey) {
561
+ const cls = await classes();
562
+ return callJavaMethod(
563
+ cls.interop,
564
+ "kvGetByRank",
565
+ await unwrapInteropHandle(handle),
566
+ dbiName,
567
+ await toJava(rank),
568
+ await toJava(kType),
569
+ await toJava(vType),
570
+ Boolean(ignoreKey)
571
+ );
572
+ }
573
+
574
+ async kvGetEntryByRank(handle, dbiName, rank, kType, vType) {
575
+ const cls = await classes();
576
+ return callJavaMethod(
577
+ cls.interop,
578
+ "kvGetEntryByRank",
579
+ await unwrapInteropHandle(handle),
580
+ dbiName,
581
+ await toJava(rank),
582
+ await toJava(kType),
583
+ await toJava(vType)
584
+ );
585
+ }
586
+
587
+ async kvSample(handle, dbiName, n, kType, vType, ignoreKey) {
588
+ const cls = await classes();
589
+ return callJavaMethod(
590
+ cls.interop,
591
+ "kvSample",
592
+ await unwrapInteropHandle(handle),
593
+ dbiName,
594
+ await toJava(n),
595
+ await toJava(kType),
596
+ await toJava(vType),
597
+ Boolean(ignoreKey)
598
+ );
599
+ }
600
+
601
+ async kvVisit(handle, dbiName, visitor, kRange, kType, vType) {
602
+ const cls = await classes();
603
+ return callJavaMethod(
604
+ cls.interop,
605
+ "kvVisit",
606
+ await unwrapInteropHandle(handle),
607
+ dbiName,
608
+ visitor,
609
+ await toJava(kRange),
610
+ await toJava(kType),
611
+ await toJava(vType)
612
+ );
613
+ }
614
+
615
+ async kvVisitRaw(handle, dbiName, visitor, kRange, kType, vType) {
616
+ const cls = await classes();
617
+ return callJavaMethod(
618
+ cls.interop,
619
+ "kvVisitRaw",
620
+ await unwrapInteropHandle(handle),
621
+ dbiName,
622
+ visitor,
623
+ await toJava(kRange),
624
+ await toJava(kType),
625
+ await toJava(vType)
626
+ );
627
+ }
628
+
629
+ async kvVisitKeyRange(handle, dbiName, visitor, kRange, kType) {
630
+ const cls = await classes();
631
+ return callJavaMethod(
632
+ cls.interop,
633
+ "kvVisitKeyRange",
634
+ await unwrapInteropHandle(handle),
635
+ dbiName,
636
+ visitor,
637
+ await toJava(kRange),
638
+ await toJava(kType)
639
+ );
640
+ }
641
+
642
+ async kvVisitKeyRangeRaw(handle, dbiName, visitor, kRange, kType) {
643
+ const cls = await classes();
644
+ return callJavaMethod(
645
+ cls.interop,
646
+ "kvVisitKeyRangeRaw",
647
+ await unwrapInteropHandle(handle),
648
+ dbiName,
649
+ visitor,
650
+ await toJava(kRange),
651
+ await toJava(kType)
652
+ );
653
+ }
654
+
655
+ async kvVisitList(handle, listName, visitor, key, kType, vType) {
656
+ const cls = await classes();
657
+ return callJavaMethod(
658
+ cls.interop,
659
+ "kvVisitList",
660
+ await unwrapInteropHandle(handle),
661
+ listName,
662
+ visitor,
663
+ await toJava(key),
664
+ await toJava(kType),
665
+ await toJava(vType)
666
+ );
667
+ }
668
+
669
+ async kvVisitListRaw(handle, listName, visitor, key, kType) {
670
+ const cls = await classes();
671
+ return callJavaMethod(
672
+ cls.interop,
673
+ "kvVisitListRaw",
674
+ await unwrapInteropHandle(handle),
675
+ listName,
676
+ visitor,
677
+ await toJava(key),
678
+ await toJava(kType)
679
+ );
680
+ }
681
+
682
+ async kvVisitListRange(handle, listName, visitor, kRange, kType, vRange, vType) {
683
+ const cls = await classes();
684
+ return callJavaMethod(
685
+ cls.interop,
686
+ "kvVisitListRange",
687
+ await unwrapInteropHandle(handle),
688
+ listName,
689
+ visitor,
690
+ await toJava(kRange),
691
+ await toJava(kType),
692
+ await toJava(vRange),
693
+ await toJava(vType)
694
+ );
695
+ }
696
+
697
+ async kvVisitListRangeRaw(handle, listName, visitor, kRange, kType, vRange, vType) {
698
+ const cls = await classes();
699
+ return callJavaMethod(
700
+ cls.interop,
701
+ "kvVisitListRangeRaw",
702
+ await unwrapInteropHandle(handle),
703
+ listName,
704
+ visitor,
705
+ await toJava(kRange),
706
+ await toJava(kType),
707
+ await toJava(vRange),
708
+ await toJava(vType)
709
+ );
710
+ }
711
+
712
+ async kvListRangeFilter(handle, listName, predicate, kRange, kType, vRange, vType) {
713
+ const cls = await classes();
714
+ return callJavaMethod(
715
+ cls.interop,
716
+ "kvListRangeFilter",
717
+ await unwrapInteropHandle(handle),
718
+ listName,
719
+ predicate,
720
+ await toJava(kRange),
721
+ await toJava(kType),
722
+ await toJava(vRange),
723
+ await toJava(vType)
724
+ );
725
+ }
726
+
727
+ async kvListRangeFilterRaw(handle, listName, predicate, kRange, kType, vRange, vType) {
728
+ const cls = await classes();
729
+ return callJavaMethod(
730
+ cls.interop,
731
+ "kvListRangeFilterRaw",
732
+ await unwrapInteropHandle(handle),
733
+ listName,
734
+ predicate,
735
+ await toJava(kRange),
736
+ await toJava(kType),
737
+ await toJava(vRange),
738
+ await toJava(vType)
739
+ );
740
+ }
741
+
742
+ async kvListRangeFilterCount(handle, listName, predicate, kRange, kType, vRange, vType) {
743
+ const cls = await classes();
744
+ return callJavaMethod(
745
+ cls.interop,
746
+ "kvListRangeFilterCount",
747
+ await unwrapInteropHandle(handle),
748
+ listName,
749
+ predicate,
750
+ await toJava(kRange),
751
+ await toJava(kType),
752
+ await toJava(vRange),
753
+ await toJava(vType)
754
+ );
755
+ }
756
+
757
+ async kvListRangeFilterCountRaw(handle, listName, predicate, kRange, kType, vRange, vType) {
758
+ const cls = await classes();
759
+ return callJavaMethod(
760
+ cls.interop,
761
+ "kvListRangeFilterCountRaw",
762
+ await unwrapInteropHandle(handle),
763
+ listName,
764
+ predicate,
765
+ await toJava(kRange),
766
+ await toJava(kType),
767
+ await toJava(vRange),
768
+ await toJava(vType)
769
+ );
770
+ }
771
+
772
+ async kvListRangeKeep(handle, listName, fn, kRange, kType, vRange, vType) {
773
+ const cls = await classes();
774
+ return callJavaMethod(
775
+ cls.interop,
776
+ "kvListRangeKeep",
777
+ await unwrapInteropHandle(handle),
778
+ listName,
779
+ fn,
780
+ await toJava(kRange),
781
+ await toJava(kType),
782
+ await toJava(vRange),
783
+ await toJava(vType)
784
+ );
785
+ }
786
+
787
+ async kvListRangeKeepRaw(handle, listName, fn, kRange, kType, vRange, vType) {
788
+ const cls = await classes();
789
+ return callJavaMethod(
790
+ cls.interop,
791
+ "kvListRangeKeepRaw",
792
+ await unwrapInteropHandle(handle),
793
+ listName,
794
+ fn,
795
+ await toJava(kRange),
796
+ await toJava(kType),
797
+ await toJava(vRange),
798
+ await toJava(vType)
799
+ );
800
+ }
801
+
802
+ async kvListRangeSome(handle, listName, fn, kRange, kType, vRange, vType) {
803
+ const cls = await classes();
804
+ return callJavaMethod(
805
+ cls.interop,
806
+ "kvListRangeSome",
807
+ await unwrapInteropHandle(handle),
808
+ listName,
809
+ fn,
810
+ await toJava(kRange),
811
+ await toJava(kType),
812
+ await toJava(vRange),
813
+ await toJava(vType)
814
+ );
815
+ }
816
+
817
+ async kvListRangeSomeRaw(handle, listName, fn, kRange, kType, vRange, vType) {
818
+ const cls = await classes();
819
+ return callJavaMethod(
820
+ cls.interop,
821
+ "kvListRangeSomeRaw",
822
+ await unwrapInteropHandle(handle),
823
+ listName,
824
+ fn,
825
+ await toJava(kRange),
826
+ await toJava(kType),
827
+ await toJava(vRange),
828
+ await toJava(vType)
829
+ );
830
+ }
831
+
832
+ async newSearchEngine(kv, opts = null) {
833
+ const cls = await classes();
834
+ return callJavaMethod(
835
+ cls.interop,
836
+ "newSearchEngine",
837
+ await unwrapInteropHandle(kv),
838
+ hasValue(opts) ? await toJava(opts) : null
839
+ );
840
+ }
841
+
842
+ async searchAddDoc(search, docRef, docText, checkExist = null) {
843
+ const cls = await classes();
844
+ return callJavaMethod(
845
+ cls.interop,
846
+ "searchAddDoc",
847
+ await unwrapInteropHandle(search),
848
+ await toJava(docRef),
849
+ docText,
850
+ hasValue(checkExist) ? Boolean(checkExist) : null
851
+ );
852
+ }
853
+
854
+ async searchRemoveDoc(search, docRef) {
855
+ const cls = await classes();
856
+ return callJavaMethod(
857
+ cls.interop,
858
+ "searchRemoveDoc",
859
+ await unwrapInteropHandle(search),
860
+ await toJava(docRef)
861
+ );
862
+ }
863
+
864
+ async searchClearDocs(search) {
865
+ const cls = await classes();
866
+ return callJavaMethod(cls.interop, "searchClearDocs", await unwrapInteropHandle(search));
867
+ }
868
+
869
+ async searchDocIndexed(search, docRef) {
870
+ const cls = await classes();
871
+ return Boolean(
872
+ await callJavaMethod(
873
+ cls.interop,
874
+ "searchDocIndexed",
875
+ await unwrapInteropHandle(search),
876
+ await toJava(docRef)
877
+ )
878
+ );
879
+ }
880
+
881
+ async searchDocCount(search) {
882
+ const cls = await classes();
883
+ return callJavaMethod(cls.interop, "searchDocCount", await unwrapInteropHandle(search));
884
+ }
885
+
886
+ async search(search, query, opts = null) {
887
+ const cls = await classes();
888
+ return callJavaMethod(
889
+ cls.interop,
890
+ "search",
891
+ await unwrapInteropHandle(search),
892
+ query,
893
+ hasValue(opts) ? await toJava(opts) : null
894
+ );
895
+ }
896
+
897
+ async searchReIndex(search, opts = null) {
898
+ const cls = await classes();
899
+ return callJavaMethod(
900
+ cls.interop,
901
+ "searchReIndex",
902
+ await unwrapInteropHandle(search),
903
+ hasValue(opts) ? await toJava(opts) : null
904
+ );
905
+ }
906
+
907
+ async searchIndexWriter(kv, opts = null) {
908
+ const cls = await classes();
909
+ return callJavaMethod(
910
+ cls.interop,
911
+ "searchIndexWriter",
912
+ await unwrapInteropHandle(kv),
913
+ hasValue(opts) ? await toJava(opts) : null
914
+ );
915
+ }
916
+
917
+ async searchUtilsCreateAnalyzer(opts = null) {
918
+ const cls = await classes();
919
+ return callJavaMethod(cls.searchUtils, "createAnalyzer", await toJava(opts ?? {}));
920
+ }
921
+
922
+ async searchUtilsLowerCaseTokenFilter() {
923
+ const cls = await classes();
924
+ return callJavaMethod(cls.searchUtils, "lowerCaseTokenFilter");
925
+ }
926
+
927
+ async searchUtilsUnaccentTokenFilter() {
928
+ const cls = await classes();
929
+ return callJavaMethod(cls.searchUtils, "unaccentTokenFilter");
930
+ }
931
+
932
+ async searchUtilsCreateStopWordsTokenFilter(stopWordsOrPredicate) {
933
+ const cls = await classes();
934
+ return callJavaMethod(
935
+ cls.searchUtils,
936
+ "createStopWordsTokenFilter",
937
+ await toJava(stopWordsOrPredicate)
938
+ );
939
+ }
940
+
941
+ async searchUtilsEnStopWordsTokenFilter() {
942
+ const cls = await classes();
943
+ return callJavaMethod(cls.searchUtils, "enStopWordsTokenFilter");
944
+ }
945
+
946
+ async searchUtilsPrefixTokenFilter() {
947
+ const cls = await classes();
948
+ return callJavaMethod(cls.searchUtils, "prefixTokenFilter");
949
+ }
950
+
951
+ async searchUtilsCreateNgramTokenFilter(minGramSize, maxGramSize = null) {
952
+ const cls = await classes();
953
+ if (!hasValue(maxGramSize)) {
954
+ return callJavaMethod(cls.searchUtils, "createNgramTokenFilter", await toJava(minGramSize));
955
+ }
956
+ return callJavaMethod(
957
+ cls.searchUtils,
958
+ "createNgramTokenFilter",
959
+ await toJava(minGramSize),
960
+ await toJava(maxGramSize)
961
+ );
962
+ }
963
+
964
+ async searchUtilsCreateMinLengthTokenFilter(minLength) {
965
+ const cls = await classes();
966
+ return callJavaMethod(cls.searchUtils, "createMinLengthTokenFilter", await toJava(minLength));
967
+ }
968
+
969
+ async searchUtilsCreateMaxLengthTokenFilter(maxLength) {
970
+ const cls = await classes();
971
+ return callJavaMethod(cls.searchUtils, "createMaxLengthTokenFilter", await toJava(maxLength));
972
+ }
973
+
974
+ async searchUtilsCreateStemmingTokenFilter(language) {
975
+ const cls = await classes();
976
+ return callJavaMethod(cls.searchUtils, "createStemmingTokenFilter", language);
977
+ }
978
+
979
+ async searchUtilsCreateRegexpTokenizer(pattern) {
980
+ const cls = await classes();
981
+ return callJavaMethod(cls.searchUtils, "createRegexpTokenizer", pattern);
982
+ }
983
+
984
+ async searchWrite(writer, docRef, docText) {
985
+ const cls = await classes();
986
+ return callJavaMethod(
987
+ cls.interop,
988
+ "searchWrite",
989
+ await unwrapInteropHandle(writer),
990
+ await toJava(docRef),
991
+ docText
992
+ );
993
+ }
994
+
995
+ async searchCommit(writer) {
996
+ const cls = await classes();
997
+ return callJavaMethod(cls.interop, "searchCommit", await unwrapInteropHandle(writer));
998
+ }
999
+
1000
+ async newVectorIndex(kv, opts) {
1001
+ const cls = await classes();
1002
+ return callJavaMethod(
1003
+ cls.interop,
1004
+ "newVectorIndex",
1005
+ await unwrapInteropHandle(kv),
1006
+ hasValue(opts) ? await toJava(opts) : null
1007
+ );
1008
+ }
1009
+
1010
+ async closeVectorIndex(index) {
1011
+ const cls = await classes();
1012
+ await callJavaMethod(cls.interop, "closeVectorIndex", await unwrapInteropHandle(index));
1013
+ }
1014
+
1015
+ async vectorIndexClosed(index) {
1016
+ const cls = await classes();
1017
+ return Boolean(await callJavaMethod(cls.interop, "vectorIndexClosed", await unwrapInteropHandle(index)));
1018
+ }
1019
+
1020
+ async vectorAddVec(index, vecRef, vecData) {
1021
+ const cls = await classes();
1022
+ return callJavaMethod(
1023
+ cls.interop,
1024
+ "vectorAddVec",
1025
+ await unwrapInteropHandle(index),
1026
+ await toJava(vecRef),
1027
+ await toJava(vecData)
1028
+ );
1029
+ }
1030
+
1031
+ async vectorRemoveVec(index, vecRef) {
1032
+ const cls = await classes();
1033
+ return callJavaMethod(
1034
+ cls.interop,
1035
+ "vectorRemoveVec",
1036
+ await unwrapInteropHandle(index),
1037
+ await toJava(vecRef)
1038
+ );
1039
+ }
1040
+
1041
+ async vectorIndexed(index, vecRef) {
1042
+ const cls = await classes();
1043
+ return Boolean(
1044
+ await callJavaMethod(
1045
+ cls.interop,
1046
+ "vectorIndexed",
1047
+ await unwrapInteropHandle(index),
1048
+ await toJava(vecRef)
1049
+ )
1050
+ );
1051
+ }
1052
+
1053
+ async vectorSearch(index, queryVec, opts = null) {
1054
+ const cls = await classes();
1055
+ return callJavaMethod(
1056
+ cls.interop,
1057
+ "vectorSearch",
1058
+ await unwrapInteropHandle(index),
1059
+ await toJava(queryVec),
1060
+ hasValue(opts) ? await toJava(opts) : null
1061
+ );
1062
+ }
1063
+
1064
+ async vectorReIndex(index, opts = null) {
1065
+ const cls = await classes();
1066
+ return callJavaMethod(
1067
+ cls.interop,
1068
+ "vectorReIndex",
1069
+ await unwrapInteropHandle(index),
1070
+ hasValue(opts) ? await toJava(opts) : null
1071
+ );
1072
+ }
1073
+
1074
+ async vectorClear(index) {
1075
+ const cls = await classes();
1076
+ return callJavaMethod(cls.interop, "vectorClear", await unwrapInteropHandle(index));
1077
+ }
1078
+
1079
+ async vectorForceCheckpoint(index) {
1080
+ const cls = await classes();
1081
+ return callJavaMethod(cls.interop, "vectorForceCheckpoint", await unwrapInteropHandle(index));
1082
+ }
1083
+
1084
+ async vectorInfo(index) {
1085
+ const cls = await classes();
1086
+ return callJavaMethod(cls.interop, "vectorInfo", await unwrapInteropHandle(index));
1087
+ }
1088
+
1089
+ async vectorCheckpointState(index) {
1090
+ const cls = await classes();
1091
+ return callJavaMethod(cls.interop, "vectorCheckpointState", await unwrapInteropHandle(index));
1092
+ }
1093
+
1094
+ async newLlamaEmbedder(modelPath, { gpuLayers = 0, ctxSize = 0, batchSize = 0, threads = 0 } = {}) {
1095
+ const cls = await classes();
1096
+ return callJavaMethod(
1097
+ cls.interop,
1098
+ "newLlamaEmbedder",
1099
+ modelPath,
1100
+ Number(gpuLayers),
1101
+ Number(ctxSize),
1102
+ Number(batchSize),
1103
+ Number(threads)
1104
+ );
1105
+ }
1106
+
1107
+ async closeLlamaEmbedder(embedder) {
1108
+ const cls = await classes();
1109
+ await callJavaMethod(cls.interop, "closeLlamaEmbedder", await unwrapInteropHandle(embedder));
1110
+ }
1111
+
1112
+ async llamaEmbedderClosed(embedder) {
1113
+ const cls = await classes();
1114
+ return callJavaMethod(cls.interop, "llamaEmbedderClosed", await unwrapInteropHandle(embedder));
1115
+ }
1116
+
1117
+ async llamaEmbedderModelPath(embedder) {
1118
+ const cls = await classes();
1119
+ return callJavaMethod(cls.interop, "llamaEmbedderModelPath", await unwrapInteropHandle(embedder));
1120
+ }
1121
+
1122
+ async llamaEmbedderGpuLayers(embedder) {
1123
+ const cls = await classes();
1124
+ return callJavaMethod(cls.interop, "llamaEmbedderGpuLayers", await unwrapInteropHandle(embedder));
1125
+ }
1126
+
1127
+ async llamaEmbedderCtxSize(embedder) {
1128
+ const cls = await classes();
1129
+ return callJavaMethod(cls.interop, "llamaEmbedderCtxSize", await unwrapInteropHandle(embedder));
1130
+ }
1131
+
1132
+ async llamaEmbedderContextSize(embedder) {
1133
+ const cls = await classes();
1134
+ return callJavaMethod(cls.interop, "llamaEmbedderContextSize", await unwrapInteropHandle(embedder));
1135
+ }
1136
+
1137
+ async llamaEmbedderBatchSize(embedder) {
1138
+ const cls = await classes();
1139
+ return callJavaMethod(cls.interop, "llamaEmbedderBatchSize", await unwrapInteropHandle(embedder));
1140
+ }
1141
+
1142
+ async llamaEmbedderThreads(embedder) {
1143
+ const cls = await classes();
1144
+ return callJavaMethod(cls.interop, "llamaEmbedderThreads", await unwrapInteropHandle(embedder));
1145
+ }
1146
+
1147
+ async llamaEmbedderDimensions(embedder) {
1148
+ const cls = await classes();
1149
+ return callJavaMethod(cls.interop, "llamaEmbedderDimensions", await unwrapInteropHandle(embedder));
1150
+ }
1151
+
1152
+ async llamaEmbedderEmbed(embedder, text) {
1153
+ const cls = await classes();
1154
+ return callJavaMethod(cls.interop, "llamaEmbedderEmbed", await unwrapInteropHandle(embedder), text);
1155
+ }
1156
+
1157
+ async llamaEmbedderEmbedAll(embedder, texts) {
1158
+ const cls = await classes();
1159
+ return callJavaMethod(cls.interop, "llamaEmbedderEmbedAll", await unwrapInteropHandle(embedder), await toJava(texts));
1160
+ }
1161
+
1162
+ async llamaEmbedderTokenCount(embedder, text) {
1163
+ const cls = await classes();
1164
+ return callJavaMethod(cls.interop, "llamaEmbedderTokenCount", await unwrapInteropHandle(embedder), text);
1165
+ }
1166
+
1167
+ async llamaEmbedderTokenize(embedder, text) {
1168
+ const cls = await classes();
1169
+ return callJavaMethod(cls.interop, "llamaEmbedderTokenize", await unwrapInteropHandle(embedder), text);
1170
+ }
1171
+
1172
+ async llamaEmbedderDetokenize(embedder, tokens) {
1173
+ const cls = await classes();
1174
+ return callJavaMethod(cls.interop, "llamaEmbedderDetokenize", await unwrapInteropHandle(embedder), await toJava(tokens));
1175
+ }
1176
+
1177
+ async llamaEmbedderTruncateText(embedder, text, maxTokens) {
34
1178
  const cls = await classes();
35
1179
  return callJavaMethod(
36
1180
  cls.interop,
37
- "coreInvokeBridge",
38
- functionName,
39
- await toJava(await normalizeInteropArgs([...(args || [])]))
1181
+ "llamaEmbedderTruncateText",
1182
+ await unwrapInteropHandle(embedder),
1183
+ text,
1184
+ Number(maxTokens)
40
1185
  );
41
1186
  }
42
1187
 
43
- async coreInvokeRaw(functionName, args = null) {
1188
+ async newLlamaGenerator(modelPath, { gpuLayers = 0, ctxSize = 0, threads = 0 } = {}) {
44
1189
  const cls = await classes();
45
1190
  return callJavaMethod(
46
1191
  cls.interop,
47
- "coreInvoke",
48
- functionName,
49
- await toJava(await normalizeInteropArgs([...(args || [])]))
1192
+ "newLlamaGenerator",
1193
+ modelPath,
1194
+ Number(gpuLayers),
1195
+ Number(ctxSize),
1196
+ Number(threads)
50
1197
  );
51
1198
  }
52
1199
 
53
- async clientInvoke(functionName, args = null) {
1200
+ async closeLlamaGenerator(generator) {
54
1201
  const cls = await classes();
55
- return callJavaMethod(
56
- cls.interop,
57
- "clientInvokeBridge",
58
- functionName,
59
- await toJava(await normalizeInteropArgs([...(args || [])]))
60
- );
1202
+ await callJavaMethod(cls.interop, "closeLlamaGenerator", await unwrapInteropHandle(generator));
61
1203
  }
62
1204
 
63
- async createConnection(dir = null, schema = null, opts = null, { shared = false } = {}) {
1205
+ async llamaGeneratorClosed(generator) {
64
1206
  const cls = await classes();
65
- const target = shared ? "getConn" : "createConn";
1207
+ return callJavaMethod(cls.interop, "llamaGeneratorClosed", await unwrapInteropHandle(generator));
1208
+ }
66
1209
 
67
- if (opts !== null && opts !== undefined) {
68
- return callJavaMethod(cls.datalevin, target, dir, await toJava(schema), await toJava(opts));
69
- }
70
- if (schema !== null && schema !== undefined) {
71
- return callJavaMethod(cls.datalevin, target, dir, await toJava(schema));
72
- }
73
- if (dir !== null && dir !== undefined) {
74
- return callJavaMethod(cls.datalevin, target, dir);
75
- }
76
- return callJavaMethod(cls.datalevin, target);
1210
+ async llamaGeneratorModelPath(generator) {
1211
+ const cls = await classes();
1212
+ return callJavaMethod(cls.interop, "llamaGeneratorModelPath", await unwrapInteropHandle(generator));
77
1213
  }
78
1214
 
79
- async closeConnection(handle) {
80
- await callJavaMethod(handle, "close");
1215
+ async llamaGeneratorGpuLayers(generator) {
1216
+ const cls = await classes();
1217
+ return callJavaMethod(cls.interop, "llamaGeneratorGpuLayers", await unwrapInteropHandle(generator));
81
1218
  }
82
1219
 
83
- async connectionClosed(handle) {
84
- return Boolean(await callJavaMethod(handle, "closed"));
1220
+ async llamaGeneratorCtxSize(generator) {
1221
+ const cls = await classes();
1222
+ return callJavaMethod(cls.interop, "llamaGeneratorCtxSize", await unwrapInteropHandle(generator));
85
1223
  }
86
1224
 
87
- async connectionDb(handle) {
1225
+ async llamaGeneratorContextSize(generator) {
88
1226
  const cls = await classes();
89
- return callJavaMethod(cls.interop, "connectionDb", handle);
1227
+ return callJavaMethod(cls.interop, "llamaGeneratorContextSize", await unwrapInteropHandle(generator));
90
1228
  }
91
1229
 
92
- async openKeyValue(dir, opts = null) {
1230
+ async llamaGeneratorThreads(generator) {
93
1231
  const cls = await classes();
94
- if (opts !== null && opts !== undefined) {
95
- return callJavaMethod(cls.datalevin, "openKV", dir, await toJava(opts));
96
- }
97
- return callJavaMethod(cls.datalevin, "openKV", dir);
1232
+ return callJavaMethod(cls.interop, "llamaGeneratorThreads", await unwrapInteropHandle(generator));
98
1233
  }
99
1234
 
100
- async closeKeyValue(handle) {
101
- await callJavaMethod(handle, "close");
1235
+ async llamaGeneratorTokenCount(generator, text) {
1236
+ const cls = await classes();
1237
+ return callJavaMethod(cls.interop, "llamaGeneratorTokenCount", await unwrapInteropHandle(generator), text);
102
1238
  }
103
1239
 
104
- async keyValueClosed(handle) {
105
- return Boolean(await callJavaMethod(handle, "closed"));
1240
+ async llamaGeneratorGenerate(generator, prompt, maxTokens) {
1241
+ const cls = await classes();
1242
+ return callJavaMethod(
1243
+ cls.interop,
1244
+ "llamaGeneratorGenerate",
1245
+ await unwrapInteropHandle(generator),
1246
+ prompt,
1247
+ Number(maxTokens)
1248
+ );
1249
+ }
1250
+
1251
+ async llamaGeneratorSummarize(generator, text, maxTokens) {
1252
+ const cls = await classes();
1253
+ return callJavaMethod(
1254
+ cls.interop,
1255
+ "llamaGeneratorSummarize",
1256
+ await unwrapInteropHandle(generator),
1257
+ text,
1258
+ Number(maxTokens)
1259
+ );
106
1260
  }
107
1261
 
108
1262
  async newClient(uri, opts = null) {
@@ -131,6 +1285,11 @@ class InteropBindings {
131
1285
  return callJavaMethod(cls.interop, "readEdn", edn);
132
1286
  }
133
1287
 
1288
+ async writeEdn(value) {
1289
+ const cls = await classes();
1290
+ return callJavaMethod(cls.interop, "writeEdn", await toJava(value));
1291
+ }
1292
+
134
1293
  async keyword(value) {
135
1294
  const cls = await classes();
136
1295
  return callJavaMethod(cls.interop, "keyword", value);
@@ -211,6 +1370,35 @@ class InteropBindings {
211
1370
  return callJavaMethod(cls.interop, "lookupRef", await toJava(value));
212
1371
  }
213
1372
 
1373
+ async datom(e, attr, value, tx = undefined, added = undefined) {
1374
+ const cls = await classes();
1375
+ if (added !== undefined) {
1376
+ if (tx === undefined) {
1377
+ throw new TypeError("tx is required when added is provided");
1378
+ }
1379
+ return callJavaMethod(
1380
+ cls.datalevin,
1381
+ "datom",
1382
+ await toJava(e),
1383
+ await toJava(attr),
1384
+ await toJava(value),
1385
+ await toJava(tx),
1386
+ await toJava(added)
1387
+ );
1388
+ }
1389
+ if (tx !== undefined) {
1390
+ return callJavaMethod(
1391
+ cls.datalevin,
1392
+ "datom",
1393
+ await toJava(e),
1394
+ await toJava(attr),
1395
+ await toJava(value),
1396
+ await toJava(tx)
1397
+ );
1398
+ }
1399
+ return callJavaMethod(cls.datalevin, "datom", await toJava(e), await toJava(attr), await toJava(value));
1400
+ }
1401
+
214
1402
  async txData(txData) {
215
1403
  if (txData === null || txData === undefined) {
216
1404
  return null;
@@ -301,14 +1489,607 @@ export async function connect(dir = null, { schema = null, opts = null, shared =
301
1489
  return new Connection(await _BINDINGS.createConnection(dir, schema, opts, { shared }));
302
1490
  }
303
1491
 
1492
+ export async function initDb(datoms, { dir = null, schema = null, opts = null } = {}) {
1493
+ const { Connection } = await import("./connection.js");
1494
+ return new Connection(await _BINDINGS.initDb(datoms, dir, schema, opts));
1495
+ }
1496
+
1497
+ export async function fillDb(conn, datoms) {
1498
+ await _BINDINGS.fillDb(conn, datoms);
1499
+ return conn;
1500
+ }
1501
+
1502
+ export async function transact(conn, txData, txMeta = null) {
1503
+ return conn.transact(txData, txMeta);
1504
+ }
1505
+
1506
+ export async function transactAsync(conn, txData, txMeta = null) {
1507
+ return conn.transactAsync(txData, txMeta);
1508
+ }
1509
+
1510
+ export async function abortTransact(conn) {
1511
+ return conn.abortTransact();
1512
+ }
1513
+
1514
+ export async function txDataToSimulatedReport(conn, txData) {
1515
+ return conn.txDataToSimulatedReport(txData);
1516
+ }
1517
+
1518
+ export async function datalogKv(conn) {
1519
+ return conn.datalogKv();
1520
+ }
1521
+
1522
+ export async function maxEid(conn) {
1523
+ return conn.maxEid();
1524
+ }
1525
+
1526
+ export async function cardinality(conn, attr) {
1527
+ return conn.cardinality(attr);
1528
+ }
1529
+
1530
+ export async function analyze(conn, attr = null) {
1531
+ return conn.analyze(attr);
1532
+ }
1533
+
1534
+ export async function explicitTransactionTimeout(timeoutMs = undefined) {
1535
+ const args = hasValue(timeoutMs) ? [timeoutMs] : [];
1536
+ return toJsResult(await _BINDINGS.coreInvoke("explicit-transaction-timeout", args));
1537
+ }
1538
+
1539
+ export async function setExplicitTransactionTimeout(timeoutMs) {
1540
+ return toJsResult(
1541
+ await _BINDINGS.coreInvoke("set-explicit-transaction-timeout!", [timeoutMs])
1542
+ );
1543
+ }
1544
+
1545
+ export async function reIndex(target, opts = null, options = {}) {
1546
+ if (typeof target?.reIndex !== "function") {
1547
+ throw new TypeError("target must provide reIndex().");
1548
+ }
1549
+ return target.reIndex(opts, options);
1550
+ }
1551
+
1552
+ export async function withTransaction(target, fnOrOptions, maybeFnOrOptions = null) {
1553
+ if (target?.constructor?.name === "Connection" &&
1554
+ typeof target.rawHandle === "function" &&
1555
+ typeof target.transact === "function" &&
1556
+ typeof target.query === "function") {
1557
+ throw new DatalevinError(CONNECTION_WITH_TRANSACTION_UNSUPPORTED);
1558
+ }
1559
+ if (typeof target?.withTransaction !== "function") {
1560
+ throw new TypeError("target must provide withTransaction().");
1561
+ }
1562
+ return target.withTransaction(fnOrOptions, maybeFnOrOptions);
1563
+ }
1564
+
1565
+ export async function keyword(value) {
1566
+ return _BINDINGS.keyword(value);
1567
+ }
1568
+
1569
+ export async function symbol(value) {
1570
+ return _BINDINGS.symbol(value);
1571
+ }
1572
+
1573
+ export async function readEdn(edn) {
1574
+ return _BINDINGS.readEdn(edn);
1575
+ }
1576
+
1577
+ export async function writeEdn(value) {
1578
+ return _BINDINGS.writeEdn(await toEdnForm(value));
1579
+ }
1580
+
1581
+ export function schemaAttr({
1582
+ valueType = null,
1583
+ cardinality = null,
1584
+ unique = null,
1585
+ index = null,
1586
+ fulltext = null,
1587
+ isComponent = null,
1588
+ noHistory = null,
1589
+ doc = null,
1590
+ tupleType = null,
1591
+ tupleTypes = null,
1592
+ tupleAttrs = null,
1593
+ attrPreds = null,
1594
+ fulltextDomains = null,
1595
+ fulltextAutoDomain = null,
1596
+ embedding = null,
1597
+ embeddingDomains = null,
1598
+ embeddingAutoDomain = null,
1599
+ vectorDomains = null,
1600
+ idocFormat = null,
1601
+ idocDomain = null,
1602
+ idocIndexedPaths = null,
1603
+ idocExcludedPaths = null,
1604
+ extra = null,
1605
+ ...props
1606
+ } = {}) {
1607
+ const spec = { ...props };
1608
+ if (valueType !== null && valueType !== undefined) {
1609
+ spec[":db/valueType"] = valueType;
1610
+ }
1611
+ if (cardinality !== null && cardinality !== undefined) {
1612
+ spec[":db/cardinality"] = cardinality;
1613
+ }
1614
+ if (unique !== null && unique !== undefined) {
1615
+ spec[":db/unique"] = unique;
1616
+ }
1617
+ if (index !== null && index !== undefined) {
1618
+ spec[":db/index"] = Boolean(index);
1619
+ }
1620
+ if (fulltext !== null && fulltext !== undefined) {
1621
+ spec[":db/fulltext"] = Boolean(fulltext);
1622
+ }
1623
+ if (isComponent !== null && isComponent !== undefined) {
1624
+ spec[":db/isComponent"] = Boolean(isComponent);
1625
+ }
1626
+ if (noHistory !== null && noHistory !== undefined) {
1627
+ spec[":db/noHistory"] = Boolean(noHistory);
1628
+ }
1629
+ if (doc !== null && doc !== undefined) {
1630
+ spec[":db/doc"] = doc;
1631
+ }
1632
+ if (tupleType !== null && tupleType !== undefined) {
1633
+ spec[":db/tupleType"] = tupleType;
1634
+ }
1635
+ if (tupleTypes !== null && tupleTypes !== undefined) {
1636
+ spec[":db/tupleTypes"] = [...tupleTypes];
1637
+ }
1638
+ if (tupleAttrs !== null && tupleAttrs !== undefined) {
1639
+ spec[":db/tupleAttrs"] = [...tupleAttrs];
1640
+ }
1641
+ if (attrPreds !== null && attrPreds !== undefined) {
1642
+ spec[":db.attr/preds"] = attrPreds;
1643
+ }
1644
+ if (fulltextDomains !== null && fulltextDomains !== undefined) {
1645
+ spec[":db.fulltext/domains"] = [...fulltextDomains];
1646
+ }
1647
+ if (fulltextAutoDomain !== null && fulltextAutoDomain !== undefined) {
1648
+ spec[":db.fulltext/autoDomain"] = Boolean(fulltextAutoDomain);
1649
+ }
1650
+ if (embedding !== null && embedding !== undefined) {
1651
+ spec[":db/embedding"] = Boolean(embedding);
1652
+ }
1653
+ if (embeddingDomains !== null && embeddingDomains !== undefined) {
1654
+ spec[":db.embedding/domains"] = [...embeddingDomains];
1655
+ }
1656
+ if (embeddingAutoDomain !== null && embeddingAutoDomain !== undefined) {
1657
+ spec[":db.embedding/autoDomain"] = Boolean(embeddingAutoDomain);
1658
+ }
1659
+ if (vectorDomains !== null && vectorDomains !== undefined) {
1660
+ spec[":db.vec/domains"] = [...vectorDomains];
1661
+ }
1662
+ if (idocFormat !== null && idocFormat !== undefined) {
1663
+ spec[":db/idocFormat"] = keywordValue(idocFormat);
1664
+ }
1665
+ if (idocDomain !== null && idocDomain !== undefined) {
1666
+ spec[":db/domain"] = idocDomain;
1667
+ }
1668
+ if (idocIndexedPaths !== null && idocIndexedPaths !== undefined) {
1669
+ spec[":db.idoc/indexedPaths"] = [...idocIndexedPaths];
1670
+ }
1671
+ if (idocExcludedPaths !== null && idocExcludedPaths !== undefined) {
1672
+ spec[":db.idoc/excludedPaths"] = [...idocExcludedPaths];
1673
+ }
1674
+ if (extra !== null && extra !== undefined) {
1675
+ Object.assign(spec, extra);
1676
+ }
1677
+ return spec;
1678
+ }
1679
+
1680
+ export function fulltextAttr({
1681
+ valueType = ":db.type/string",
1682
+ domains = null,
1683
+ autoDomain = null,
1684
+ extra = null,
1685
+ ...schemaProps
1686
+ } = {}) {
1687
+ const merged = { ":db/fulltext": true };
1688
+ if (domains !== null && domains !== undefined) {
1689
+ merged[":db.fulltext/domains"] = [...domains];
1690
+ }
1691
+ if (autoDomain !== null && autoDomain !== undefined) {
1692
+ merged[":db.fulltext/autoDomain"] = Boolean(autoDomain);
1693
+ }
1694
+ if (extra !== null && extra !== undefined) {
1695
+ Object.assign(merged, extra);
1696
+ }
1697
+ return schemaAttr({ valueType, extra: merged, ...schemaProps });
1698
+ }
1699
+
1700
+ export function embeddingAttr({
1701
+ valueType = ":db.type/string",
1702
+ domains = null,
1703
+ autoDomain = null,
1704
+ extra = null,
1705
+ ...schemaProps
1706
+ } = {}) {
1707
+ const merged = { ":db/embedding": true };
1708
+ if (domains !== null && domains !== undefined) {
1709
+ merged[":db.embedding/domains"] = [...domains];
1710
+ }
1711
+ if (autoDomain !== null && autoDomain !== undefined) {
1712
+ merged[":db.embedding/autoDomain"] = Boolean(autoDomain);
1713
+ }
1714
+ if (extra !== null && extra !== undefined) {
1715
+ Object.assign(merged, extra);
1716
+ }
1717
+ return schemaAttr({ valueType, extra: merged, ...schemaProps });
1718
+ }
1719
+
1720
+ export function vectorAttr({ domains = null, extra = null, ...schemaProps } = {}) {
1721
+ const merged = {};
1722
+ if (domains !== null && domains !== undefined) {
1723
+ merged[":db.vec/domains"] = [...domains];
1724
+ }
1725
+ if (extra !== null && extra !== undefined) {
1726
+ Object.assign(merged, extra);
1727
+ }
1728
+ return schemaAttr({ valueType: ":db.type/vec", extra: merged, ...schemaProps });
1729
+ }
1730
+
1731
+ export function idocAttr({
1732
+ format = null,
1733
+ domain = null,
1734
+ indexedPaths = null,
1735
+ excludedPaths = null,
1736
+ extra = null,
1737
+ ...schemaProps
1738
+ } = {}) {
1739
+ const merged = {};
1740
+ if (format !== null && format !== undefined) {
1741
+ merged[":db/idocFormat"] = keywordValue(format);
1742
+ }
1743
+ if (domain !== null && domain !== undefined) {
1744
+ merged[":db/domain"] = domain;
1745
+ }
1746
+ if (indexedPaths !== null && indexedPaths !== undefined) {
1747
+ merged[":db.idoc/indexedPaths"] = [...indexedPaths];
1748
+ }
1749
+ if (excludedPaths !== null && excludedPaths !== undefined) {
1750
+ merged[":db.idoc/excludedPaths"] = [...excludedPaths];
1751
+ }
1752
+ if (extra !== null && extra !== undefined) {
1753
+ Object.assign(merged, extra);
1754
+ }
1755
+ return schemaAttr({ valueType: ":db.type/idoc", extra: merged, ...schemaProps });
1756
+ }
1757
+
1758
+ export function searchOptions({
1759
+ top = null,
1760
+ limit = null,
1761
+ offset = null,
1762
+ pagingCachePages = null,
1763
+ display = null,
1764
+ domains = null,
1765
+ proximityExpansion = null,
1766
+ proximityMaxDist = null,
1767
+ indexingMode = null,
1768
+ analyzer = null,
1769
+ queryAnalyzer = null,
1770
+ extra = null
1771
+ } = {}) {
1772
+ const opts = {};
1773
+ if (top !== null && top !== undefined) {
1774
+ opts[":top"] = top;
1775
+ }
1776
+ if (limit !== null && limit !== undefined) {
1777
+ opts[":limit"] = limit;
1778
+ }
1779
+ if (offset !== null && offset !== undefined) {
1780
+ opts[":offset"] = offset;
1781
+ }
1782
+ if (pagingCachePages !== null && pagingCachePages !== undefined) {
1783
+ opts[":paging-cache-pages"] = pagingCachePages;
1784
+ }
1785
+ if (display !== null && display !== undefined) {
1786
+ opts[":display"] = keywordValue(display);
1787
+ }
1788
+ if (domains !== null && domains !== undefined) {
1789
+ opts[":domains"] = [...domains];
1790
+ }
1791
+ if (proximityExpansion !== null && proximityExpansion !== undefined) {
1792
+ opts[":proximity-expansion"] = proximityExpansion;
1793
+ }
1794
+ if (proximityMaxDist !== null && proximityMaxDist !== undefined) {
1795
+ opts[":proximity-max-dist"] = proximityMaxDist;
1796
+ }
1797
+ if (indexingMode !== null && indexingMode !== undefined) {
1798
+ opts[":indexing-mode"] = keywordValue(indexingMode);
1799
+ }
1800
+ if (analyzer !== null && analyzer !== undefined) {
1801
+ opts[":analyzer"] = analyzer;
1802
+ }
1803
+ if (queryAnalyzer !== null && queryAnalyzer !== undefined) {
1804
+ opts[":query-analyzer"] = queryAnalyzer;
1805
+ }
1806
+ if (extra !== null && extra !== undefined) {
1807
+ Object.assign(opts, extra);
1808
+ }
1809
+ return opts;
1810
+ }
1811
+
1812
+ export function searchDomain({
1813
+ domain = null,
1814
+ indexPosition = null,
1815
+ includeText = null,
1816
+ indexingMode = null,
1817
+ analyzer = null,
1818
+ queryAnalyzer = null,
1819
+ extra = null
1820
+ } = {}) {
1821
+ const opts = {};
1822
+ if (domain !== null && domain !== undefined) {
1823
+ opts[":domain"] = domain;
1824
+ }
1825
+ if (indexPosition !== null && indexPosition !== undefined) {
1826
+ opts[":index-position?"] = Boolean(indexPosition);
1827
+ }
1828
+ if (includeText !== null && includeText !== undefined) {
1829
+ opts[":include-text?"] = Boolean(includeText);
1830
+ }
1831
+ if (indexingMode !== null && indexingMode !== undefined) {
1832
+ opts[":indexing-mode"] = keywordValue(indexingMode);
1833
+ }
1834
+ if (analyzer !== null && analyzer !== undefined) {
1835
+ opts[":analyzer"] = analyzer;
1836
+ }
1837
+ if (queryAnalyzer !== null && queryAnalyzer !== undefined) {
1838
+ opts[":query-analyzer"] = queryAnalyzer;
1839
+ }
1840
+ if (extra !== null && extra !== undefined) {
1841
+ Object.assign(opts, extra);
1842
+ }
1843
+ return opts;
1844
+ }
1845
+
1846
+ export function vectorOptions({
1847
+ dimensions = null,
1848
+ metricType = null,
1849
+ quantization = null,
1850
+ connectivity = null,
1851
+ expansionAdd = null,
1852
+ expansionSearch = null,
1853
+ domain = null,
1854
+ indexingMode = null,
1855
+ extra = null
1856
+ } = {}) {
1857
+ const opts = {};
1858
+ if (dimensions !== null && dimensions !== undefined) {
1859
+ opts[":dimensions"] = dimensions;
1860
+ }
1861
+ if (metricType !== null && metricType !== undefined) {
1862
+ opts[":metric-type"] = keywordValue(metricType);
1863
+ }
1864
+ if (quantization !== null && quantization !== undefined) {
1865
+ opts[":quantization"] = keywordValue(quantization);
1866
+ }
1867
+ if (connectivity !== null && connectivity !== undefined) {
1868
+ opts[":connectivity"] = connectivity;
1869
+ }
1870
+ if (expansionAdd !== null && expansionAdd !== undefined) {
1871
+ opts[":expansion-add"] = expansionAdd;
1872
+ }
1873
+ if (expansionSearch !== null && expansionSearch !== undefined) {
1874
+ opts[":expansion-search"] = expansionSearch;
1875
+ }
1876
+ if (domain !== null && domain !== undefined) {
1877
+ opts[":domain"] = domain;
1878
+ }
1879
+ if (indexingMode !== null && indexingMode !== undefined) {
1880
+ opts[":indexing-mode"] = keywordValue(indexingMode);
1881
+ }
1882
+ if (extra !== null && extra !== undefined) {
1883
+ Object.assign(opts, extra);
1884
+ }
1885
+ return opts;
1886
+ }
1887
+
1888
+ export function embeddingOptions({
1889
+ provider = null,
1890
+ model = null,
1891
+ baseUrl = null,
1892
+ endpoint = null,
1893
+ apiKey = null,
1894
+ apiKeyEnv = null,
1895
+ headers = null,
1896
+ timeoutMs = null,
1897
+ queryPrefix = null,
1898
+ documentPrefix = null,
1899
+ requestDimensions = null,
1900
+ embeddingMetadata = null,
1901
+ dimensions = null,
1902
+ metricType = null,
1903
+ indexingMode = null,
1904
+ extra = null
1905
+ } = {}) {
1906
+ const opts = {};
1907
+ if (provider !== null && provider !== undefined) {
1908
+ opts[":provider"] = keywordValue(provider);
1909
+ }
1910
+ if (model !== null && model !== undefined) {
1911
+ opts[":model"] = model;
1912
+ }
1913
+ if (baseUrl !== null && baseUrl !== undefined) {
1914
+ opts[":base-url"] = baseUrl;
1915
+ }
1916
+ if (endpoint !== null && endpoint !== undefined) {
1917
+ opts[":endpoint"] = endpoint;
1918
+ }
1919
+ if (apiKey !== null && apiKey !== undefined) {
1920
+ opts[":api-key"] = apiKey;
1921
+ }
1922
+ if (apiKeyEnv !== null && apiKeyEnv !== undefined) {
1923
+ opts[":api-key-env"] = apiKeyEnv;
1924
+ }
1925
+ if (headers !== null && headers !== undefined) {
1926
+ opts[":headers"] = { ...headers };
1927
+ }
1928
+ if (timeoutMs !== null && timeoutMs !== undefined) {
1929
+ opts[":timeout-ms"] = timeoutMs;
1930
+ }
1931
+ if (queryPrefix !== null && queryPrefix !== undefined) {
1932
+ opts[":query-prefix"] = queryPrefix;
1933
+ }
1934
+ if (documentPrefix !== null && documentPrefix !== undefined) {
1935
+ opts[":document-prefix"] = documentPrefix;
1936
+ }
1937
+ if (requestDimensions !== null && requestDimensions !== undefined) {
1938
+ opts[":request-dimensions"] = requestDimensions;
1939
+ }
1940
+ if (embeddingMetadata !== null && embeddingMetadata !== undefined) {
1941
+ opts[":embedding-metadata"] = { ...embeddingMetadata };
1942
+ }
1943
+ if (dimensions !== null && dimensions !== undefined) {
1944
+ opts[":dimensions"] = dimensions;
1945
+ }
1946
+ if (metricType !== null && metricType !== undefined) {
1947
+ opts[":metric-type"] = keywordValue(metricType);
1948
+ }
1949
+ if (indexingMode !== null && indexingMode !== undefined) {
1950
+ opts[":indexing-mode"] = keywordValue(indexingMode);
1951
+ }
1952
+ if (extra !== null && extra !== undefined) {
1953
+ Object.assign(opts, extra);
1954
+ }
1955
+ return opts;
1956
+ }
1957
+
1958
+ export function idocDomain({ indexedPaths = null, excludedPaths = null, extra = null } = {}) {
1959
+ const opts = {};
1960
+ if (indexedPaths !== null && indexedPaths !== undefined) {
1961
+ opts[":indexed-paths"] = [...indexedPaths];
1962
+ }
1963
+ if (excludedPaths !== null && excludedPaths !== undefined) {
1964
+ opts[":excluded-paths"] = [...excludedPaths];
1965
+ }
1966
+ if (extra !== null && extra !== undefined) {
1967
+ Object.assign(opts, extra);
1968
+ }
1969
+ return opts;
1970
+ }
1971
+
1972
+ export function idocOptions({ domains = null, extra = null } = {}) {
1973
+ const opts = {};
1974
+ if (domains !== null && domains !== undefined) {
1975
+ opts[":domains"] = [...domains];
1976
+ }
1977
+ if (extra !== null && extra !== undefined) {
1978
+ Object.assign(opts, extra);
1979
+ }
1980
+ return opts;
1981
+ }
1982
+
1983
+ export function txEntity(dbId = null, attrs = {}) {
1984
+ const entity = { ...attrs };
1985
+ if (dbId !== null && dbId !== undefined) {
1986
+ entity[":db/id"] = dbId;
1987
+ }
1988
+ return entity;
1989
+ }
1990
+
1991
+ export function txAdd(entityId, attr, value) {
1992
+ return [":db/add", entityId, attrKey(attr), value];
1993
+ }
1994
+
1995
+ export function txRetract(entityId, attr, value) {
1996
+ return [":db/retract", entityId, attrKey(attr), value];
1997
+ }
1998
+
1999
+ export function txRetractEntity(entityId) {
2000
+ return [":db/retractEntity", entityId];
2001
+ }
2002
+
2003
+ export function txEnsure(predicate, ...args) {
2004
+ return [":db/ensure", predicate, ...args];
2005
+ }
2006
+
2007
+ export function datom(e, attr, value, tx = undefined, added = undefined) {
2008
+ if (added !== undefined && tx === undefined) {
2009
+ throw new TypeError("tx is required when added is provided");
2010
+ }
2011
+ if (added !== undefined) {
2012
+ return [e, attr, value, tx, added];
2013
+ }
2014
+ if (tx !== undefined) {
2015
+ return [e, attr, value, tx];
2016
+ }
2017
+ return [e, attr, value];
2018
+ }
2019
+
2020
+ export function datomIs(value) {
2021
+ if (Array.isArray(value)) {
2022
+ return value.length >= 3 && value.length <= 5;
2023
+ }
2024
+ return value !== null
2025
+ && typeof value === "object"
2026
+ && datomMapValue(value, "e") !== null
2027
+ && datomMapValue(value, "a") !== null
2028
+ && datomMapValue(value, "v") !== null;
2029
+ }
2030
+
2031
+ export function datomE(value) {
2032
+ return datomField(value, "e", 0);
2033
+ }
2034
+
2035
+ export function datomA(value) {
2036
+ return datomField(value, "a", 1);
2037
+ }
2038
+
2039
+ export function datomV(value) {
2040
+ return datomField(value, "v", 2);
2041
+ }
2042
+
2043
+ export function datomTx(value) {
2044
+ return datomField(value, "tx", 3);
2045
+ }
2046
+
2047
+ export function datomAdded(value) {
2048
+ return datomField(value, "added", 4);
2049
+ }
2050
+
304
2051
  export async function openKv(dir, opts = null) {
305
2052
  const { KV } = await import("./kv.js");
306
2053
  return new KV(await _BINDINGS.openKeyValue(dir, opts));
307
2054
  }
308
2055
 
2056
+ export async function newSearchEngine(kv, opts = null) {
2057
+ const { SearchEngine } = await import("./search.js");
2058
+ return new SearchEngine(await _BINDINGS.newSearchEngine(kv, opts));
2059
+ }
2060
+
2061
+ export async function newVectorIndex(kv, opts) {
2062
+ const { VectorIndex } = await import("./vector.js");
2063
+ return new VectorIndex(await _BINDINGS.newVectorIndex(kv, opts));
2064
+ }
2065
+
2066
+ export async function newLlamaEmbedder(modelPath, opts = {}) {
2067
+ const { LlamaEmbedder } = await import("./llm.js");
2068
+ return new LlamaEmbedder(await _BINDINGS.newLlamaEmbedder(modelPath, opts));
2069
+ }
2070
+
2071
+ export async function newLlamaGenerator(modelPath, opts = {}) {
2072
+ const { LlamaGenerator } = await import("./llm.js");
2073
+ return new LlamaGenerator(await _BINDINGS.newLlamaGenerator(modelPath, opts));
2074
+ }
2075
+
2076
+ export async function searchIndexWriter(kv, opts = null) {
2077
+ const { SearchIndexWriter } = await import("./search.js");
2078
+ return new SearchIndexWriter(await _BINDINGS.searchIndexWriter(kv, opts));
2079
+ }
2080
+
309
2081
  export async function newClient(uri, opts = null) {
310
2082
  const { Client } = await import("./client.js");
311
2083
  return new Client(await _BINDINGS.newClient(uri, opts));
312
2084
  }
313
2085
 
314
2086
  export { jvmStarted, startJvm, toEdnForm, toJava, toJs, toQueryInput };
2087
+
2088
+ function attrKey(attr) {
2089
+ return typeof attr === "string" && attr.startsWith(":") ? attr : `:${attr}`;
2090
+ }
2091
+
2092
+ function keywordValue(value) {
2093
+ const text = String(value);
2094
+ return text.startsWith(":") ? text : `:${text}`;
2095
+ }