datahike 0.8.1877 → 0.8.1879

package/org.replikativ.persistent_sorted_set.fressian.js

@@ -1,6 +1,6 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./org.replikativ.persistent_sorted_set.impl.nodes.js");require("./fress.api.js");require("./org.replikativ.persistent_sorted_set.leaf.js");require("./org.replikativ.persistent_sorted_set.branch.js");require("./org.replikativ.persistent_sorted_set.btset.js");
-'use strict';var RF,Jla,Kla,Mla;$CLJS.QF=function(a,b){return $CLJS.fy(a,b)};RF=function(a){if(a!=null&&a.Eo!=null)a=a.Eo(a);else{var b=RF[$CLJS.ab(a==null?null:a)];if(b!=null)a=b.g?b.g(a):b.call(null,a);else if(b=RF._,b!=null)a=b.g?b.g(a):b.call(null,a);else throw $CLJS.Vb("PBoundary.-descriptor",a);}return a};
-Jla=function(a){if(a.address==null)throw $CLJS.ul("PSS root must be flushed before serialization",new $CLJS.S(null,1,[$CLJS.Tm,$CLJS.Ila],null));var b=a.K,c=function(){var d=$CLJS.iB.g(b);return $CLJS.u(d)?RF(d):null}();a=new $CLJS.S(null,5,[$CLJS.Hk,$CLJS.vf(a),$CLJS.NF,a.address,$CLJS.Wm,a.U,$CLJS.jB,$CLJS.jB.g(b),$CLJS.AB,function(){var d=$CLJS.AB.g(b);return $CLJS.u(d)?d:0}()],null);a=$CLJS.u($CLJS.PF.g(b))?$CLJS.ak.i(a,$CLJS.PF,$CLJS.PF.g(b)):a;return $CLJS.u(c)?$CLJS.ak.i(a,$CLJS.iB,c):a};
-Kla=function(a){var b=a.K;a=function(){var d=$CLJS.iB.g(b);return $CLJS.u(d)?RF(d):null}();var c=new $CLJS.S(null,2,[$CLJS.jB,$CLJS.jB.g(b),$CLJS.AB,function(){var d=$CLJS.AB.g(b);return $CLJS.u(d)?d:0}()],null);c=$CLJS.u($CLJS.PF.g(b))?$CLJS.ak.i(c,$CLJS.PF,$CLJS.PF.g(b)):c;return $CLJS.u(a)?$CLJS.ak.i(c,$CLJS.iB,a):c};
-$CLJS.Lla=function(a){var b=a.ya;if(b==null)return null;for(var c=a.keys.length,d=a.level===1,e=0,f=$CLJS.dh;;){if(e>=c)return $CLJS.Ye(f)>0?f:null;var g=b[e];if(g==null){var h=f;e+=1;f=h}else h=e+1,f=$CLJS.ak.i(f,e,new $CLJS.S(null,4,[$CLJS.Wm,$CLJS.Wm.g(g),$CLJS.lB,$CLJS.lB.g(g),$CLJS.qB,d?$CLJS.LC($CLJS.qB.g(g)):$CLJS.qB.g(g),$CLJS.xB,a.keys[e]],null)),e=h}};
-Mla=function(a){var b=$CLJS.Eo.l;if(a instanceof $CLJS.NC){var c=$CLJS.Lla(a);var d=new $CLJS.S(null,4,[$CLJS.vp,a.Yi(null),$CLJS.op,$CLJS.Fi(a.keys),$CLJS.uB,$CLJS.Fi(a.ua),$CLJS.rB,a.tc],null);d=a.pa!=null?$CLJS.ak.i(d,$CLJS.lB,a.pa):d;c=$CLJS.u(c)?$CLJS.ak.i(d,$CLJS.mm,c):d}else c=new $CLJS.S(null,1,[$CLJS.op,$CLJS.Fi(a.keys)],null),c=a.pa!=null?$CLJS.ak.i(c,$CLJS.lB,a.pa):c;return b.call($CLJS.Eo,$CLJS.gf([c,Kla(a)]))};$CLJS.Nla=$CLJS.ch([$CLJS.KC,function(a,b){$CLJS.cy(a,"pss/leaf",1);return $CLJS.QF(a,Mla(b))},$CLJS.NC,function(a,b){$CLJS.cy(a,"pss/branch",1);return $CLJS.QF(a,Mla(b))}]);$CLJS.Ola=$CLJS.ch([$CLJS.hD,function(a,b){$CLJS.cy(a,"pss/set",1);return $CLJS.QF(a,Jla(b))}]);
+'use strict';var TF,Qla,Rla,Tla;$CLJS.SF=function(a,b){return $CLJS.dy(a,b)};TF=function(a){if(a!=null&&a.Ho!=null)a=a.Ho(a);else{var b=TF[$CLJS.ab(a==null?null:a)];if(b!=null)a=b.g?b.g(a):b.call(null,a);else if(b=TF._,b!=null)a=b.g?b.g(a):b.call(null,a);else throw $CLJS.Wb("PBoundary.-descriptor",a);}return a};
+Qla=function(a){if(a.address==null)throw $CLJS.ul("PSS root must be flushed before serialization",new $CLJS.S(null,1,[$CLJS.Tm,$CLJS.Pla],null));var b=a.K,c=function(){var d=$CLJS.gB.g(b);return $CLJS.u(d)?TF(d):null}();a=new $CLJS.S(null,5,[$CLJS.Hk,$CLJS.uf(a),$CLJS.PF,a.address,$CLJS.Wm,a.U,$CLJS.hB,$CLJS.hB.g(b),$CLJS.yB,function(){var d=$CLJS.yB.g(b);return $CLJS.u(d)?d:0}()],null);a=$CLJS.u($CLJS.RF.g(b))?$CLJS.ak.i(a,$CLJS.RF,$CLJS.RF.g(b)):a;return $CLJS.u(c)?$CLJS.ak.i(a,$CLJS.gB,c):a};
+Rla=function(a){var b=a.K;a=function(){var d=$CLJS.gB.g(b);return $CLJS.u(d)?TF(d):null}();var c=new $CLJS.S(null,2,[$CLJS.hB,$CLJS.hB.g(b),$CLJS.yB,function(){var d=$CLJS.yB.g(b);return $CLJS.u(d)?d:0}()],null);c=$CLJS.u($CLJS.RF.g(b))?$CLJS.ak.i(c,$CLJS.RF,$CLJS.RF.g(b)):c;return $CLJS.u(a)?$CLJS.ak.i(c,$CLJS.gB,a):c};
+$CLJS.Sla=function(a){var b=a.ya;if(b==null)return null;for(var c=a.keys.length,d=a.level===1,e=0,f=$CLJS.dh;;){if(e>=c)return $CLJS.Ye(f)>0?f:null;var g=b[e];if(g==null){var h=f;e+=1;f=h}else h=e+1,f=$CLJS.ak.i(f,e,new $CLJS.S(null,4,[$CLJS.Wm,$CLJS.Wm.g(g),$CLJS.jB,$CLJS.jB.g(g),$CLJS.oB,d?$CLJS.JC($CLJS.oB.g(g)):$CLJS.oB.g(g),$CLJS.vB,a.keys[e]],null)),e=h}};
+Tla=function(a){var b=$CLJS.Co.l;if(a instanceof $CLJS.LC){var c=$CLJS.Sla(a);var d=new $CLJS.S(null,4,[$CLJS.tp,a.Yi(null),$CLJS.mp,$CLJS.Fi(a.keys),$CLJS.sB,$CLJS.Fi(a.ua),$CLJS.pB,a.tc],null);d=a.pa!=null?$CLJS.ak.i(d,$CLJS.jB,a.pa):d;c=$CLJS.u(c)?$CLJS.ak.i(d,$CLJS.lm,c):d}else c=new $CLJS.S(null,1,[$CLJS.mp,$CLJS.Fi(a.keys)],null),c=a.pa!=null?$CLJS.ak.i(c,$CLJS.jB,a.pa):c;return b.call($CLJS.Co,$CLJS.gf([c,Rla(a)]))};$CLJS.Ula=$CLJS.ch([$CLJS.IC,function(a,b){$CLJS.ay(a,"pss/leaf",1);return $CLJS.SF(a,Tla(b))},$CLJS.LC,function(a,b){$CLJS.ay(a,"pss/branch",1);return $CLJS.SF(a,Tla(b))}]);$CLJS.Vla=$CLJS.ch([$CLJS.fD,function(a,b){$CLJS.ay(a,"pss/set",1);return $CLJS.SF(a,Qla(b))}]);

package/org.replikativ.persistent_sorted_set.impl.boundary.js

@@ -1,2 +1,2 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");
-'use strict';$CLJS.iB=new $CLJS.H(null,"boundary","boundary",-2000996754);$CLJS.Fka=$CLJS.xh(null);
+'use strict';$CLJS.gB=new $CLJS.H(null,"boundary","boundary",-2000996754);$CLJS.Mka=$CLJS.xh(null);

package/org.replikativ.persistent_sorted_set.impl.nodes.js

@@ -1,3 +1,3 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./org.replikativ.persistent_sorted_set.impl.boundary.js");require("./org.replikativ.persistent_sorted_set.leaf.js");require("./org.replikativ.persistent_sorted_set.branch.js");require("./org.replikativ.persistent_sorted_set.btset.js");
-'use strict';$CLJS.KF=new $CLJS.H(null,"default-bf","default-bf",-1431077803);$CLJS.LF=new $CLJS.H(null,"resolve-measure","resolve-measure",1235395818);$CLJS.MF=new $CLJS.H(null,"resolve-cmp","resolve-cmp",125224489);$CLJS.Fla=new $CLJS.H(null,"mk-settings","mk-settings",-829192421);$CLJS.Gla=new $CLJS.H("pss","storage-id","pss/storage-id",1127028971);$CLJS.Hla=new $CLJS.H(null,"measure-ops","measure-ops",188679997);$CLJS.NF=new $CLJS.H(null,"address","address",559499426);
-$CLJS.Ila=new $CLJS.H(null,"must-be-flushed","must-be-flushed",468354549);$CLJS.OF=new $CLJS.H(null,"resolve-storage","resolve-storage",1895103074);$CLJS.PF=new $CLJS.H(null,"ref-type","ref-type",-1367328851);
+'use strict';$CLJS.MF=new $CLJS.H(null,"default-bf","default-bf",-1431077803);$CLJS.NF=new $CLJS.H(null,"resolve-measure","resolve-measure",1235395818);$CLJS.OF=new $CLJS.H(null,"resolve-cmp","resolve-cmp",125224489);$CLJS.Mla=new $CLJS.H(null,"mk-settings","mk-settings",-829192421);$CLJS.Nla=new $CLJS.H("pss","storage-id","pss/storage-id",1127028971);$CLJS.Ola=new $CLJS.H(null,"measure-ops","measure-ops",188679997);$CLJS.PF=new $CLJS.H(null,"address","address",559499426);
+$CLJS.Pla=new $CLJS.H(null,"must-be-flushed","must-be-flushed",468354549);$CLJS.QF=new $CLJS.H(null,"resolve-storage","resolve-storage",1895103074);$CLJS.RF=new $CLJS.H(null,"ref-type","ref-type",-1367328851);

package/org.replikativ.persistent_sorted_set.js

@@ -1,2 +1,2 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./clojure.string.js");require("./org.replikativ.persistent_sorted_set.btset.js");
-'use strict';$CLJS.MD=function(a,b,c){return $CLJS.gD(a,b,c)};$CLJS.gla=new $CLJS.S(null,2,[$CLJS.jB,512,$CLJS.AB,0],null);
+'use strict';$CLJS.KD=function(a,b,c){return $CLJS.eD(a,b,c)};$CLJS.nla=new $CLJS.S(null,2,[$CLJS.hB,512,$CLJS.yB,0],null);

package/org.replikativ.persistent_sorted_set.leaf.js

@@ -1,2 +1,2 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./clojure.string.js");require("./org.replikativ.persistent_sorted_set.impl.boundary.js");require("./org.replikativ.persistent_sorted_set.util.js");
-'use strict';$CLJS.kB=new $CLJS.H(null,"removed-out","removed-out",780264512);$CLJS.lB=new $CLJS.H(null,"measure","measure",-1857519826);
+'use strict';$CLJS.iB=new $CLJS.H(null,"removed-out","removed-out",780264512);$CLJS.jB=new $CLJS.H(null,"measure","measure",-1857519826);

package/org.replikativ.persistent_sorted_set.util.js

@@ -1,2 +1,2 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./clojure.string.js");
-'use strict';$CLJS.jB=new $CLJS.H(null,"branching-factor","branching-factor",1903198601);
+'use strict';$CLJS.hB=new $CLJS.H(null,"branching-factor","branching-factor",1903198601);

package/org.replikativ.persistent_sorted_set.warm.js

@@ -1,2 +1,2 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./org.replikativ.persistent_sorted_set.btset.js");require("./org.replikativ.persistent_sorted_set.branch.js");require("./org.replikativ.persistent_sorted_set.util.js");require("./clojure.string.js");
-'use strict';$CLJS.Pla=new $CLJS.H(null,"done","done",-889844188);$CLJS.SF=new $CLJS.H(null,"depth","depth",1768663640);
+'use strict';$CLJS.Wla=new $CLJS.H(null,"done","done",-889844188);$CLJS.UF=new $CLJS.H(null,"depth","depth",1768663640);

package/package.json

@@ -16,8 +16,8 @@
   "keywords" : [ "database", "datalog", "datomic", "clojurescript", "immutable", "functional" ],
   "types" : "index.d.ts",
   "author" : "Christian Weilbach",
-  "files" : [ "*.js", "!test*.js", "*.js.map", "browser/datahike.js", "browser/index.mjs", "browser/index.js", "s3/datahike.js", "s3/index.mjs", "s3/index.js", "kabel/datahike.js", "kabel/index.mjs", "kabel/index.js", "remote/datahike.js", "remote/index.mjs", "remote/index.js", "index.d.ts", "kabel.d.ts", "remote.d.ts", "README.md", "LICENSE", "THIRD_PARTY_LICENSES.md" ],
-  "version" : "0.8.1877",
+  "files" : [ "*.js", "!test*.js", "*.js.map", "browser/datahike.js", "browser/index.mjs", "browser/index.js", "s3/datahike.js", "s3/index.mjs", "s3/index.js", "kabel/datahike.js", "kabel/index.mjs", "kabel/index.js", "remote/index.mjs", "remote/index.js", "remote/*.d.ts", "index.d.ts", "kabel.d.ts", "README.md", "LICENSE", "THIRD_PARTY_LICENSES.md" ],
+  "version" : "0.8.1879",
   "publishConfig" : {
     "access" : "public",
     "registry" : "https://registry.npmjs.org/"
@@ -53,7 +53,7 @@
       "default": "./kabel/index.mjs"
     },
     "./remote": {
-      "types": "./remote.d.ts",
+      "types": "./remote/index.d.ts",
       "browser": {
         "import": "./remote/index.mjs",
         "require": "./remote/index.js",
@@ -64,8 +64,7 @@
     "./package.json": "./package.json",
     "./browser/datahike.js": "./browser/datahike.js",
     "./s3/datahike.js": "./s3/datahike.js",
-    "./kabel/datahike.js": "./kabel/datahike.js",
-    "./remote/datahike.js": "./remote/datahike.js"
+    "./kabel/datahike.js": "./kabel/datahike.js"
   },
   "browser" : "./browser/datahike.js"
 }

package/remote/api.generated.d.ts

@@ -0,0 +1,178 @@
+import type { Connection, ConnectOptions, Database, DatabaseConfig, DatahikeUuid, Datom, GcOptions, IndexLookupArgs, IndexRangeArgs, Keyword, Metrics, PullOptions, QueryArgs, Schema, Transaction, TransactionReport, UuidValue, VersionRef, WithArgs } from "./core.js";
+/**
+ * Returns database state at given time point (Date or transaction ID).
+ */
+export declare function asOf(arg0: Database, arg1: number | Date): Promise<Database>;
+/**
+ * Create a new branch from an existing branch or commit. Secondary indices are CoW-branched automatically.
+ */
+export declare function branch(conn: Connection, from: VersionRef, newBranch: Keyword): Promise<unknown>;
+/**
+ * Load the database at a branch head. First argument can be a connection, db value, or raw store.
+ */
+export declare function branchAsDb(source: Connection | Database, branch: Keyword): Promise<Database | null>;
+/**
+ * List all known branch names. Returns set of keywords.
+ */
+export declare function branches(conn: Connection): Promise<Array<Keyword>>;
+/**
+ * Load the database at a specific commit. First argument can be a connection, db value, or raw store.
+ */
+export declare function commitAsDb(source: Connection | Database, commit: DatahikeUuid): Promise<Database | null>;
+/**
+ * Retrieve the commit-id for this database value.
+ */
+export declare function commitId(db: Database): Promise<UuidValue | null>;
+/**
+ * Connects to a Datahike database via configuration map.
+ */
+export declare function connect(config: DatabaseConfig): Promise<Connection>;
+export declare function connect(config: DatabaseConfig, opts: ConnectOptions): Promise<Connection>;
+export declare function connect(): Promise<Connection>;
+/**
+ * Creates a database via configuration map.
+ */
+export declare function createDatabase(arg0: DatabaseConfig): Promise<DatabaseConfig>;
+export declare function createDatabase(): Promise<DatabaseConfig>;
+/**
+ * Checks if a database exists via configuration map.
+ */
+export declare function databaseExists(arg0: DatabaseConfig): Promise<boolean>;
+export declare function databaseExists(): Promise<boolean>;
+/**
+ * Index lookup. Returns sequence of datoms matching index components.
+ */
+export declare function datoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | IndexLookupArgs): Promise<Datom[] | null>;
+export declare function datoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<Datom[] | null>;
+/**
+ * Returns the underlying immutable database value from a connection. Prefer using @conn directly.
+ */
+export declare function db(conn: Connection): Promise<Database>;
+/**
+ * Remove a branch. The branch data remains accessible until the next GC.
+ */
+export declare function deleteBranch(conn: Connection, branch: Keyword): Promise<unknown>;
+/**
+ * Deletes a database given via configuration map.
+ */
+export declare function deleteDatabase(arg0: DatabaseConfig): Promise<any>;
+export declare function deleteDatabase(): Promise<any>;
+/**
+ * Retrieves an entity by its id. Returns lazy map-like structure.
+ */
+export declare function entity(db: Database, eid: number | [string, any] | string | any): Promise<any>;
+/**
+ * Returns database that entity was created from.
+ */
+export declare function entityDb(arg0: any): Promise<Database>;
+/**
+ * Invokes garbage collection on connection's store. Removes old snapshots before given time point. `:min-age-ms` spares anything written more recently than that, which is what makes collecting from outside the writer process possible — it must exceed the longest values-then-pointer window any writer can have. When omitted it defaults to 0 under an exclusive local writer (`:writer {:backend :self :writer-ownership :exclusive}`) and to 15 minutes under a shared or remote writer, where another process's commit in flight is invisible to this collector. The default is a bound on one awaited request, not a guarantee: size an explicit value above your longest in-flight window plus the largest clock difference between your processes (the stamps it compares against are each writer's own). Pass `{:min-age-ms 0}` explicitly to sweep without a floor.
+ */
+export declare function gcStorage(conn: Connection, removeBefore: number | Date, options: GcOptions): Promise<unknown[]>;
+export declare function gcStorage(conn: Connection, removeBefore: number | Date): Promise<unknown[]>;
+export declare function gcStorage(conn: Connection): Promise<unknown[]>;
+/**
+ * Returns full historical state of database including all assertions and retractions.
+ */
+export declare function history(arg0: Database): Promise<Database>;
+/**
+ * Returns part of :avet index between start and end values.
+ */
+export declare function indexRange(db: Database, options: IndexRangeArgs): Promise<Datom[]>;
+/**
+ * Load entities directly (bulk load).
+ */
+export declare function loadEntities(arg0: Connection, arg1: Transaction[]): Promise<any>;
+/**
+ * Create a merge commit combining the current branch with parent branches/commits. The caller provides the merged tx-data. Routed through the writer for serialization. Blocks until committed. WARNING: Do not call from listener callbacks — use merge-db! instead to avoid deadlocks.
+ */
+export declare function mergeDb(arg0: Connection, arg1: Array<any>, arg2: Transaction[]): Promise<TransactionReport>;
+export declare function mergeDb(arg0: Connection, arg1: Array<any>, arg2: Transaction[], arg3: any): Promise<TransactionReport>;
+/**
+ * Returns database metrics: datom counts overall, per attribute and for the indexed (AVET) attributes, plus the same for history when kept. Computed from the indices' subtree counts — O(#attributes · log n) — so it is cheap on a large database. `{:per-entity-counts? true}` adds `:per-entity-counts`, a walk over every datom with one map entry per entity.
+ */
+export declare function metrics(arg0: Database): Promise<Metrics>;
+export declare function metrics(arg0: Database, arg1: Record<string, any>): Promise<Metrics>;
+/**
+ * Retrieve parent commit ids from this database value.
+ */
+export declare function parentCommitIds(db: Database): Promise<UuidValue[] | null>;
+/**
+ * Fetches data using recursive declarative pull pattern.
+ */
+export declare function pull<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: PullOptions): Promise<T | null>;
+export declare function pull<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: Array<any>, eid: number | [string, any] | string): Promise<T | null>;
+/**
+ * Same as pull, but accepts sequence of ids and returns sequence of maps.
+ */
+export declare function pullMany<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: PullOptions): Promise<T[]>;
+export declare function pullMany<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: Array<any>, eids: Array<number | [string, any] | string>): Promise<T[]>;
+/**
+ * Executes a datalog query.
+ */
+export declare function q<T = unknown>(query: QueryArgs): Promise<T>;
+export declare function q<T = unknown>(query: Array<any> | Record<string, any> | string, ...inputs: Array<any>): Promise<T>;
+/**
+ * Executes query and returns execution statistics.
+ */
+export declare function queryStats(query: QueryArgs): Promise<Record<string, any>>;
+export declare function queryStats(query: Array<any> | Record<string, any>, ...inputs: Array<any>): Promise<Record<string, any>>;
+/**
+ * Releases a database connection.
+ */
+export declare function release(conn: Connection): Promise<null>;
+export declare function release(conn: Connection, releaseAll: any): Promise<null>;
+/**
+ * Returns reverse schema definition (attribute id to ident mapping).
+ */
+export declare function reverseSchema(arg0: Database): Promise<Record<string, any>>;
+/**
+ * Like seek-datoms, but iterates BACKWARDS: datoms <= the given components, descending to the beginning of the index. Lazy on the persistent-sorted-set index — the primitive for windowed backwards pagination (latest-N, N-before-cursor).
+ */
+export declare function rseekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | IndexLookupArgs): Promise<Datom[] | null>;
+export declare function rseekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<Datom[] | null>;
+/**
+ * Returns current schema definition.
+ */
+export declare function schema(arg0: Database): Promise<Schema>;
+/**
+ * Like datoms, but returns datoms starting from specified components through end of index.
+ */
+export declare function seekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | IndexLookupArgs): Promise<Datom[] | null>;
+export declare function seekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<Datom[] | null>;
+/**
+ * Returns database state since given time point (Date or transaction ID). Contains only datoms added since that point.
+ */
+export declare function since(arg0: Database, arg1: number | Date): Promise<Database>;
+/**
+ * Applies transaction to the database and updates connection. Blocks until committed. WARNING: Do not call from listener callbacks or transaction functions — use transact! instead to avoid deadlocks.
+ */
+export declare function transact(arg0: Connection, arg1: Transaction[] | WithArgs): Promise<TransactionReport>;
+/**
+ * Strip any valid-time markers from `db` so the full vt-history is
+ *            visible. Idempotent. Does not unwrap an existing FilteredDB; to
+ *            drop an active filter, start from the unwrapped db.
+ */
+export declare function validAll(arg0: Database): Promise<Database>;
+/**
+ * Tag `db` with a `:datahike/valid-at` marker so vt-aware secondary
+ *            indices push the filter through `-search-at-vt`. Valid-time is a
+ *            secondary-index axis; regular datalog patterns still require the
+ *            built-in `(valid-at ?tx ?at)` rule to filter by vt explicitly.
+ */
+export declare function validAt(arg0: Database, arg1: any): Promise<Database>;
+/**
+ * Filter `db` to datoms whose asserting tx's vt-window overlaps the
+ *            half-open interval `[from, to)`. SQL:2011 `FOR VALID_TIME BETWEEN
+ *            from AND to` maps to this. Carries
+ *            `:datahike/valid-between [from to]` on the result for vt-aware
+ *            secondary-index pushdown.
+ */
+export declare function validBetween(arg0: Database, arg1: any, arg2: any): Promise<Database>;
+/**
+ * Filter `db` to datoms whose tx's vt-window is *fully contained*
+ *            in `[from, to)`. Stricter than `valid-between` — overlapping
+ *            windows that extend past either endpoint are excluded. Useful
+ *            for 'corrections wholly within Q2' style queries.
+ */
+export declare function validDuring(arg0: Database, arg1: any, arg2: any): Promise<Database>;

package/remote/core.d.ts

@@ -0,0 +1,133 @@
+declare const uuidSymbol: unique symbol;
+export type Keyword = `:${string}`;
+export type Attribute = Keyword;
+export type UuidValue = string;
+export interface DatahikeUuid {
+    readonly [uuidSymbol]: true;
+}
+export type BranchName = Keyword;
+export type VersionRef = BranchName | DatahikeUuid;
+export interface StoreConfig {
+    backend: Keyword;
+    id?: DatahikeUuid;
+    path?: string;
+    [key: string]: any;
+}
+export interface WriterConfig {
+    backend: Keyword;
+    [key: string]: any;
+}
+export interface ConnectOptions {
+    "sync?"?: boolean;
+    [key: string]: any;
+}
+export interface DatabaseConfig {
+    store: StoreConfig;
+    writer?: WriterConfig;
+    branch?: Keyword;
+    "keep-history?"?: boolean;
+    "schema-flexibility"?: ":read" | ":write";
+    "initial-tx"?: Transaction[];
+    name?: string;
+    "remote-peer"?: RemotePeer;
+    [key: string]: any;
+}
+export interface RemotePeer {
+    backend: ":datahike-server";
+    url: string;
+    token?: string;
+    [key: string]: any;
+}
+declare const connectionBrand: unique symbol;
+export interface Connection {
+    readonly [connectionBrand]: true;
+}
+declare const databaseBrand: unique symbol;
+export interface Database {
+    readonly [databaseBrand]: true;
+}
+export type EntityId = number | string | [Attribute, any];
+export type EntityMap = Record<string, any>;
+export type Transaction = [":db/add", EntityId, Attribute, any] | [":db/retract", EntityId, Attribute, any] | [Keyword, ...any[]] | EntityMap;
+export interface WithArgs {
+    "tx-data": Transaction[];
+    "tx-meta"?: any;
+}
+export interface QueryArgs {
+    query: string | any[] | Record<string, any>;
+    args?: any[];
+    limit?: number;
+    offset?: number;
+}
+export interface PullOptions {
+    selector: any[];
+    eid: EntityId | EntityId[];
+}
+export type Index = ":eavt" | ":aevt" | ":avet";
+export interface IndexLookupArgs {
+    index: Index;
+    components?: any[] | null;
+}
+export interface IndexRangeArgs {
+    attrid: Attribute;
+    start: any;
+    end: any;
+}
+export interface Datom {
+    e: number;
+    a: Attribute;
+    v: any;
+    tx: number;
+    added: boolean;
+}
+export interface TransactionReport {
+    "db-before": Database | null;
+    "db-after": Database;
+    "tx-data": Datom[];
+    tempids: {
+        [key: string]: number;
+    };
+    "tx-meta"?: any;
+    "commit-id"?: UuidValue;
+}
+export interface Schema {
+    [key: string]: {
+        "db/valueType": Keyword;
+        "db/cardinality": Keyword;
+        "db/unique"?: Keyword;
+        "db/index"?: boolean;
+        [key: string]: any;
+    };
+}
+export interface Metrics {
+    count: number;
+    "avet-count": number;
+    "per-attr-counts": Record<string, number>;
+    "per-entity-counts"?: Record<string, number>;
+    "temporal-count"?: number;
+    "temporal-avet-count"?: number;
+}
+export interface GcOptions {
+    "min-age-ms"?: number;
+}
+export interface RemoteReport {
+    "db-after"?: Database;
+    "db-before"?: null;
+    "tx-data"?: Datom[];
+    tempids?: {
+        [key: string]: number;
+    };
+    "commit-id"?: UuidValue;
+    resync?: boolean;
+    deleted?: boolean;
+    truncated?: boolean;
+    error?: Error;
+    status?: number;
+}
+export declare function request(route: string, readable: boolean, args: unknown[], create?: boolean): Promise<any>;
+export declare function uuid(value: string): DatahikeUuid;
+export declare function randomUuid(): DatahikeUuid;
+export declare function isPromise(value: any): value is Promise<unknown>;
+export declare function listen(conn: Connection, callback: (report: RemoteReport) => void): string;
+export declare function unlisten(conn: Connection, key: string): void;
+export {};

package/remote/index.d.ts

@@ -0,0 +1,66 @@
+import { isPromise, listen, randomUuid, unlisten, uuid } from "./core.js";
+export * from "./api.generated.js";
+export type * from "./core.js";
+export { isPromise, listen, randomUuid, unlisten, uuid };
+declare const _default: {
+    isPromise: typeof isPromise;
+    listen: typeof listen;
+    randomUuid: typeof randomUuid;
+    unlisten: typeof unlisten;
+    uuid: typeof uuid;
+    asOf(arg0: import("./core.js").Database, arg1: number | Date): Promise<import("./core.js").Database>;
+    branch(conn: import("./core.js").Connection, from: import("./core.js").VersionRef, newBranch: import("./core.js").Keyword): Promise<unknown>;
+    branchAsDb(source: import("./core.js").Connection | import("./core.js").Database, branch: import("./core.js").Keyword): Promise<import("./core.js").Database | null>;
+    branches(conn: import("./core.js").Connection): Promise<Array<import("./core.js").Keyword>>;
+    commitAsDb(source: import("./core.js").Connection | import("./core.js").Database, commit: import("./core.js").DatahikeUuid): Promise<import("./core.js").Database | null>;
+    commitId(db: import("./core.js").Database): Promise<import("./core.js").UuidValue | null>;
+    connect(config: import("./core.js").DatabaseConfig): Promise<import("./core.js").Connection>;
+    connect(config: import("./core.js").DatabaseConfig, opts: import("./core.js").ConnectOptions): Promise<import("./core.js").Connection>;
+    connect(): Promise<import("./core.js").Connection>;
+    createDatabase(arg0: import("./core.js").DatabaseConfig): Promise<import("./core.js").DatabaseConfig>;
+    createDatabase(): Promise<import("./core.js").DatabaseConfig>;
+    databaseExists(arg0: import("./core.js").DatabaseConfig): Promise<boolean>;
+    databaseExists(): Promise<boolean>;
+    datoms(db: import("./core.js").Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | import("./core.js").IndexLookupArgs): Promise<import("./core.js").Datom[] | null>;
+    datoms(db: import("./core.js").Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<import("./core.js").Datom[] | null>;
+    db(conn: import("./core.js").Connection): Promise<import("./core.js").Database>;
+    deleteBranch(conn: import("./core.js").Connection, branch: import("./core.js").Keyword): Promise<unknown>;
+    deleteDatabase(arg0: import("./core.js").DatabaseConfig): Promise<any>;
+    deleteDatabase(): Promise<any>;
+    entity(db: import("./core.js").Database, eid: number | [string, any] | string | any): Promise<any>;
+    entityDb(arg0: any): Promise<import("./core.js").Database>;
+    gcStorage(conn: import("./core.js").Connection, removeBefore: number | Date, options: import("./core.js").GcOptions): Promise<unknown[]>;
+    gcStorage(conn: import("./core.js").Connection, removeBefore: number | Date): Promise<unknown[]>;
+    gcStorage(conn: import("./core.js").Connection): Promise<unknown[]>;
+    history(arg0: import("./core.js").Database): Promise<import("./core.js").Database>;
+    indexRange(db: import("./core.js").Database, options: import("./core.js").IndexRangeArgs): Promise<import("./core.js").Datom[]>;
+    loadEntities(arg0: import("./core.js").Connection, arg1: import("./core.js").Transaction[]): Promise<any>;
+    mergeDb(arg0: import("./core.js").Connection, arg1: Array<any>, arg2: import("./core.js").Transaction[]): Promise<import("./core.js").TransactionReport>;
+    mergeDb(arg0: import("./core.js").Connection, arg1: Array<any>, arg2: import("./core.js").Transaction[], arg3: any): Promise<import("./core.js").TransactionReport>;
+    metrics(arg0: import("./core.js").Database): Promise<import("./core.js").Metrics>;
+    metrics(arg0: import("./core.js").Database, arg1: Record<string, any>): Promise<import("./core.js").Metrics>;
+    parentCommitIds(db: import("./core.js").Database): Promise<import("./core.js").UuidValue[] | null>;
+    pull<T extends Record<string, any> = Record<string, any>>(db: import("./core.js").Database, patternOrOptions: import("./core.js").PullOptions): Promise<T | null>;
+    pull<T extends Record<string, any> = Record<string, any>>(db: import("./core.js").Database, patternOrOptions: Array<any>, eid: number | [string, any] | string): Promise<T | null>;
+    pullMany<T extends Record<string, any> = Record<string, any>>(db: import("./core.js").Database, patternOrOptions: import("./core.js").PullOptions): Promise<T[]>;
+    pullMany<T extends Record<string, any> = Record<string, any>>(db: import("./core.js").Database, patternOrOptions: Array<any>, eids: Array<number | [string, any] | string>): Promise<T[]>;
+    q<T = unknown>(query: import("./core.js").QueryArgs): Promise<T>;
+    q<T = unknown>(query: Array<any> | Record<string, any> | string, ...inputs: Array<any>): Promise<T>;
+    queryStats(query: import("./core.js").QueryArgs): Promise<Record<string, any>>;
+    queryStats(query: Array<any> | Record<string, any>, ...inputs: Array<any>): Promise<Record<string, any>>;
+    release(conn: import("./core.js").Connection): Promise<null>;
+    release(conn: import("./core.js").Connection, releaseAll: any): Promise<null>;
+    reverseSchema(arg0: import("./core.js").Database): Promise<Record<string, any>>;
+    rseekDatoms(db: import("./core.js").Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | import("./core.js").IndexLookupArgs): Promise<import("./core.js").Datom[] | null>;
+    rseekDatoms(db: import("./core.js").Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<import("./core.js").Datom[] | null>;
+    schema(arg0: import("./core.js").Database): Promise<import("./core.js").Schema>;
+    seekDatoms(db: import("./core.js").Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | import("./core.js").IndexLookupArgs): Promise<import("./core.js").Datom[] | null>;
+    seekDatoms(db: import("./core.js").Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<import("./core.js").Datom[] | null>;
+    since(arg0: import("./core.js").Database, arg1: number | Date): Promise<import("./core.js").Database>;
+    transact(arg0: import("./core.js").Connection, arg1: import("./core.js").Transaction[] | import("./core.js").WithArgs): Promise<import("./core.js").TransactionReport>;
+    validAll(arg0: import("./core.js").Database): Promise<import("./core.js").Database>;
+    validAt(arg0: import("./core.js").Database, arg1: any): Promise<import("./core.js").Database>;
+    validBetween(arg0: import("./core.js").Database, arg1: any, arg2: any): Promise<import("./core.js").Database>;
+    validDuring(arg0: import("./core.js").Database, arg1: any, arg2: any): Promise<import("./core.js").Database>;
+};
+export default _default;