@arkiv-network/sdk 0.6.8-dev.3 → 0.6.8-dev.4

package/dist/chains/index.d.cts

@@ -1,4 +1,4 @@
-import * as viem17 from "viem";
+import * as viem8 from "viem";
 
 //#region src/chains/braga.d.ts
 declare const braga: {
@@ -11,13 +11,13 @@ declare const braga: {
   };
   blockTime?: number | undefined | undefined;
   contracts?: {
-    [x: string]: viem17.ChainContract | {
-      [sourceId: number]: viem17.ChainContract | undefined;
+    [x: string]: viem8.ChainContract | {
+      [sourceId: number]: viem8.ChainContract | undefined;
     } | undefined;
-    ensRegistry?: viem17.ChainContract | undefined;
-    ensUniversalResolver?: viem17.ChainContract | undefined;
-    multicall3?: viem17.ChainContract | undefined;
-    erc6492Verifier?: viem17.ChainContract | undefined;
+    ensRegistry?: viem8.ChainContract | undefined;
+    ensUniversalResolver?: viem8.ChainContract | undefined;
+    multicall3?: viem8.ChainContract | undefined;
+    erc6492Verifier?: viem8.ChainContract | undefined;
   } | undefined;
   ensTlds?: readonly string[] | undefined;
   id: 60138453102;
@@ -37,9 +37,9 @@ declare const braga: {
   sourceId?: number | undefined | undefined;
   testnet: true;
   custom?: Record<string, unknown> | undefined;
-  fees?: viem17.ChainFees<undefined> | undefined;
+  fees?: viem8.ChainFees<undefined> | undefined;
   formatters?: undefined;
-  serializers?: viem17.ChainSerializers<undefined, viem17.TransactionSerializable> | undefined;
+  serializers?: viem8.ChainSerializers<undefined, viem8.TransactionSerializable> | undefined;
   readonly network: "braga";
 };
 //#endregion
@@ -57,13 +57,13 @@ declare const kaolin: {
   };
   blockTime?: number | undefined | undefined;
   contracts?: {
-    [x: string]: viem17.ChainContract | {
-      [sourceId: number]: viem17.ChainContract | undefined;
+    [x: string]: viem8.ChainContract | {
+      [sourceId: number]: viem8.ChainContract | undefined;
     } | undefined;
-    ensRegistry?: viem17.ChainContract | undefined;
-    ensUniversalResolver?: viem17.ChainContract | undefined;
-    multicall3?: viem17.ChainContract | undefined;
-    erc6492Verifier?: viem17.ChainContract | undefined;
+    ensRegistry?: viem8.ChainContract | undefined;
+    ensUniversalResolver?: viem8.ChainContract | undefined;
+    multicall3?: viem8.ChainContract | undefined;
+    erc6492Verifier?: viem8.ChainContract | undefined;
   } | undefined;
   ensTlds?: readonly string[] | undefined;
   id: 60138453025;
@@ -83,9 +83,9 @@ declare const kaolin: {
   sourceId?: number | undefined | undefined;
   testnet: true;
   custom?: Record<string, unknown> | undefined;
-  fees?: viem17.ChainFees<undefined> | undefined;
+  fees?: viem8.ChainFees<undefined> | undefined;
   formatters?: undefined;
-  serializers?: viem17.ChainSerializers<undefined, viem17.TransactionSerializable> | undefined;
+  serializers?: viem8.ChainSerializers<undefined, viem8.TransactionSerializable> | undefined;
   readonly network: "kaolin";
 };
 //#endregion
@@ -105,13 +105,13 @@ declare const localhost: {
   } | undefined | undefined;
   blockTime?: number | undefined | undefined;
   contracts?: {
-    [x: string]: viem17.ChainContract | {
-      [sourceId: number]: viem17.ChainContract | undefined;
+    [x: string]: viem8.ChainContract | {
+      [sourceId: number]: viem8.ChainContract | undefined;
     } | undefined;
-    ensRegistry?: viem17.ChainContract | undefined;
-    ensUniversalResolver?: viem17.ChainContract | undefined;
-    multicall3?: viem17.ChainContract | undefined;
-    erc6492Verifier?: viem17.ChainContract | undefined;
+    ensRegistry?: viem8.ChainContract | undefined;
+    ensUniversalResolver?: viem8.ChainContract | undefined;
+    multicall3?: viem8.ChainContract | undefined;
+    erc6492Verifier?: viem8.ChainContract | undefined;
   } | undefined;
   ensTlds?: readonly string[] | undefined;
   id: 1337;
@@ -130,9 +130,9 @@ declare const localhost: {
   sourceId?: number | undefined | undefined;
   testnet?: boolean | undefined | undefined;
   custom?: Record<string, unknown> | undefined;
-  fees?: viem17.ChainFees<undefined> | undefined;
+  fees?: viem8.ChainFees<undefined> | undefined;
   formatters?: undefined;
-  serializers?: viem17.ChainSerializers<undefined, viem17.TransactionSerializable> | undefined;
+  serializers?: viem8.ChainSerializers<undefined, viem8.TransactionSerializable> | undefined;
 };
 //#endregion
 export { braga, kaolin, localhost };

package/dist/chains/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/chains/braga.ts","../../src/chains/kaolin.ts","../../src/chains/localhost.ts"],"sourcesContent":[],"mappings":";;;cAEa;;;MAuBX,SAAA,IAAA,EAAA,sBAAA;MAAA,SAAA,GAAA,EAAA,4CAAA;;;;;;iBAAA,MAAA,CAAA,aAAA;;;;;;;;ECpBW,OAAA,CAAA,EAuBX,SAAA,MAAA,EAAA,GAAA,SAAA;EAAA,EAAA,EAAA,WAAA;;;;;;;;;;;;;;EC1BW,QAAA,CAAA,EAAA,MAWX,GAAA,SAAA,GAAA,SAAA;EAAA,OAAA,EAAA,IAAA;;;;;;;;;;;;AFXW,cCGA,MDoBX,EAAA;EAAA,cAAA,EAAA;;;;;;;;;iBCGA,MAAA,CAAA,aAAA;;;;;IAvBW,UAuBX,CAAA,yBAAA,SAAA;IAAA,eAAA,CAAA,yBAAA,SAAA;;;;;;;;;;;;;;MC1BW,SAWX,SAAA,EAAA,SAAA,CAAA,yCAAA,CAAA;IAAA,CAAA;;;;;;;;;;;;cAXW;;;MFuBX,IAAA,EAAA,MAAA;MAAA,GAAA,EAAA,MAAA;;;;;;;;;;;iBEZA,MAAA,CAAA,aAAA;;;IDRW,WAuBX,CAAA,yBAAA,SAAA;IAAA,oBAAA,CAAA,yBAAA,SAAA;;;;;;;;;;;;;;IC1BW,SAWX,OAAA,EAAA;MAAA,SAAA,IAAA,EAAA,SAAA,CAAA,uBAAA,CAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/chains/braga.ts","../../src/chains/kaolin.ts","../../src/chains/localhost.ts"],"sourcesContent":[],"mappings":";;;cAEa;;;MAuBX,SAAA,IAAA,EAAA,sBAAA;MAAA,SAAA,GAAA,EAAA,4CAAA;;;;;;iBAAA,KAAA,CAAA,aAAA;;;;;;;;ECpBW,OAAA,CAAA,EAuBX,SAAA,MAAA,EAAA,GAAA,SAAA;EAAA,EAAA,EAAA,WAAA;;;;;;;;;;;;;;EC1BW,QAAA,CAAA,EAAA,MAWX,GAAA,SAAA,GAAA,SAAA;EAAA,OAAA,EAAA,IAAA;;;;;;;;;;;;AFXW,cCGA,MDoBX,EAAA;EAAA,cAAA,EAAA;;;;;;;;;iBCGA,KAAA,CAAA,aAAA;;;;;IAvBW,UAuBX,CAAA,wBAAA,SAAA;IAAA,eAAA,CAAA,wBAAA,SAAA;;;;;;;;;;;;;;MC1BW,SAWX,SAAA,EAAA,SAAA,CAAA,yCAAA,CAAA;IAAA,CAAA;;;;;;;;;;;;cAXW;;;MFuBX,IAAA,EAAA,MAAA;MAAA,GAAA,EAAA,MAAA;;;;;;;;;;;iBEZA,KAAA,CAAA,aAAA;;;IDRW,WAuBX,CAAA,wBAAA,SAAA;IAAA,oBAAA,CAAA,wBAAA,SAAA;;;;;;;;;;;;;;IC1BW,SAWX,OAAA,EAAA;MAAA,SAAA,IAAA,EAAA,SAAA,CAAA,uBAAA,CAAA"}

package/dist/chains/index.d.ts

@@ -1,4 +1,4 @@
-import * as viem0 from "viem";
+import * as viem8 from "viem";
 
 //#region src/chains/braga.d.ts
 declare const braga: {
@@ -11,13 +11,13 @@ declare const braga: {
   };
   blockTime?: number | undefined | undefined;
   contracts?: {
-    [x: string]: viem0.ChainContract | {
-      [sourceId: number]: viem0.ChainContract | undefined;
+    [x: string]: viem8.ChainContract | {
+      [sourceId: number]: viem8.ChainContract | undefined;
     } | undefined;
-    ensRegistry?: viem0.ChainContract | undefined;
-    ensUniversalResolver?: viem0.ChainContract | undefined;
-    multicall3?: viem0.ChainContract | undefined;
-    erc6492Verifier?: viem0.ChainContract | undefined;
+    ensRegistry?: viem8.ChainContract | undefined;
+    ensUniversalResolver?: viem8.ChainContract | undefined;
+    multicall3?: viem8.ChainContract | undefined;
+    erc6492Verifier?: viem8.ChainContract | undefined;
   } | undefined;
   ensTlds?: readonly string[] | undefined;
   id: 60138453102;
@@ -37,9 +37,9 @@ declare const braga: {
   sourceId?: number | undefined | undefined;
   testnet: true;
   custom?: Record<string, unknown> | undefined;
-  fees?: viem0.ChainFees<undefined> | undefined;
+  fees?: viem8.ChainFees<undefined> | undefined;
   formatters?: undefined;
-  serializers?: viem0.ChainSerializers<undefined, viem0.TransactionSerializable> | undefined;
+  serializers?: viem8.ChainSerializers<undefined, viem8.TransactionSerializable> | undefined;
   readonly network: "braga";
 };
 //#endregion
@@ -57,13 +57,13 @@ declare const kaolin: {
   };
   blockTime?: number | undefined | undefined;
   contracts?: {
-    [x: string]: viem0.ChainContract | {
-      [sourceId: number]: viem0.ChainContract | undefined;
+    [x: string]: viem8.ChainContract | {
+      [sourceId: number]: viem8.ChainContract | undefined;
     } | undefined;
-    ensRegistry?: viem0.ChainContract | undefined;
-    ensUniversalResolver?: viem0.ChainContract | undefined;
-    multicall3?: viem0.ChainContract | undefined;
-    erc6492Verifier?: viem0.ChainContract | undefined;
+    ensRegistry?: viem8.ChainContract | undefined;
+    ensUniversalResolver?: viem8.ChainContract | undefined;
+    multicall3?: viem8.ChainContract | undefined;
+    erc6492Verifier?: viem8.ChainContract | undefined;
   } | undefined;
   ensTlds?: readonly string[] | undefined;
   id: 60138453025;
@@ -83,9 +83,9 @@ declare const kaolin: {
   sourceId?: number | undefined | undefined;
   testnet: true;
   custom?: Record<string, unknown> | undefined;
-  fees?: viem0.ChainFees<undefined> | undefined;
+  fees?: viem8.ChainFees<undefined> | undefined;
   formatters?: undefined;
-  serializers?: viem0.ChainSerializers<undefined, viem0.TransactionSerializable> | undefined;
+  serializers?: viem8.ChainSerializers<undefined, viem8.TransactionSerializable> | undefined;
   readonly network: "kaolin";
 };
 //#endregion
@@ -105,13 +105,13 @@ declare const localhost: {
   } | undefined | undefined;
   blockTime?: number | undefined | undefined;
   contracts?: {
-    [x: string]: viem0.ChainContract | {
-      [sourceId: number]: viem0.ChainContract | undefined;
+    [x: string]: viem8.ChainContract | {
+      [sourceId: number]: viem8.ChainContract | undefined;
     } | undefined;
-    ensRegistry?: viem0.ChainContract | undefined;
-    ensUniversalResolver?: viem0.ChainContract | undefined;
-    multicall3?: viem0.ChainContract | undefined;
-    erc6492Verifier?: viem0.ChainContract | undefined;
+    ensRegistry?: viem8.ChainContract | undefined;
+    ensUniversalResolver?: viem8.ChainContract | undefined;
+    multicall3?: viem8.ChainContract | undefined;
+    erc6492Verifier?: viem8.ChainContract | undefined;
   } | undefined;
   ensTlds?: readonly string[] | undefined;
   id: 1337;
@@ -130,9 +130,9 @@ declare const localhost: {
   sourceId?: number | undefined | undefined;
   testnet?: boolean | undefined | undefined;
   custom?: Record<string, unknown> | undefined;
-  fees?: viem0.ChainFees<undefined> | undefined;
+  fees?: viem8.ChainFees<undefined> | undefined;
   formatters?: undefined;
-  serializers?: viem0.ChainSerializers<undefined, viem0.TransactionSerializable> | undefined;
+  serializers?: viem8.ChainSerializers<undefined, viem8.TransactionSerializable> | undefined;
 };
 //#endregion
 export { braga, kaolin, localhost };

package/dist/{index-CzqHiUAo.d.ts → index-ByaanQGD.d.ts}

@@ -14,28 +14,30 @@ type Predicate = {
 };
 /**
  * Creates an OR predicate
- * @param predicates - The predicates to combine
+ * @param predicates - The predicates to combine, either as a single array or as separate arguments
  * @returns The OR predicate
  *
  * @example
- * const predicates = [eq("name", "John"), eq("age", 30)]
- * const result = or(predicates)
+ * const result = or(eq("name", "John"), eq("age", 30))
+ * // or equivalently: or([eq("name", "John"), eq("age", 30)])
  * // result = { type: "or", predicates: [eq("name", "John"), eq("age", 30)] }
  *
  */
 declare function or(predicates: Predicate[]): Predicate;
+declare function or(...predicates: Predicate[]): Predicate;
 /**
  * Creates an AND predicate
- * @param predicates - The predicates to combine
+ * @param predicates - The predicates to combine, either as a single array or as separate arguments
  * @returns The AND predicate
  *
  * @example
- * const predicates = [eq("name", "John"), eq("age", 30)]
- * const result = and(predicates)
+ * const result = and(eq("name", "John"), eq("age", 30))
+ * // or equivalently: and([eq("name", "John"), eq("age", 30)])
  * // result = { type: "and", predicates: [eq("name", "John"), eq("age", 30)] }
  *
  */
 declare function and(predicates: Predicate[]): Predicate;
+declare function and(...predicates: Predicate[]): Predicate;
 /**
  * Creates an equality predicate
  * @param key - The key to compare
@@ -325,22 +327,24 @@ declare abstract class BaseQueryBuilder<TEntity> {
    */
   validAtBlock(validAtBlock: bigint): this;
   /**
-   * Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.
+   * Sets the predicates for the query limiting the results. It can be a single predicate,
+   * multiple predicates passed as separate arguments, or an array of predicates - all combined with 'and'.
    * Predicates can be nested using 'or' and 'and' predicates.
-   * @param predicates - The predicates to set
+   * @param predicates - The predicates to set, either as a single array or as separate arguments
    * @returns The query builder instance
    *
    * @example
    * const builder = client.select()
    * builder.where(eq("name", "John"))
+   * builder.where(eq("name", "John"), eq("age", 30))
    * builder.where([eq("name", "John"), eq("age", 30)])
-   * builder.where([eq("name", "John"), or([eq("age", 30), eq("age", 31)])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), eq("age", 31)])])
-   * builder.where([eq("name", "John"), or([eq("age", 30), and([eq("age", 31), eq("age", 32)])])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), eq("age", 32)])])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), and([eq("age", 32), eq("age", 33)])])])])
+   * builder.where(eq("name", "John"), or(eq("age", 30), eq("age", 31)))
+   * builder.where(eq("name", "John"), and(eq("age", 30), eq("age", 31)))
+   * builder.where(eq("name", "John"), or(eq("age", 30), and(eq("age", 31), eq("age", 32))))
+   * builder.where(eq("name", "John"), and(eq("age", 30), or(eq("age", 31), eq("age", 32))))
    */
-  where(predicates: Predicate[] | Predicate): this;
+  where(predicates: Predicate[]): this;
+  where(...predicates: Predicate[]): this;
   /**
    * Returns the data-selection parameters forwarded to the query engine.
    * Subclasses decide which parts of an entity are fetched.
@@ -453,4 +457,4 @@ declare class SelectQueryBuilder<TEntity> extends BaseQueryBuilder<TEntity> {
 }
 //#endregion
 export { neq as C, lte as S, or as T, and as _, asc as a, gte as b, FullEntity as c, SelectionFields as d, selectionToIncludeData as f, PredicateType as g, PredicateContainerType as h, SelectQueryBuilder as i, ProjectedEntity as l, Predicate as m, OrderByAttribute as n, desc as o, QueryResult as p, QueryBuilder as r, EntitySelection as s, BaseQueryBuilder as t, SelectArg as u, eq as v, not as w, lt as x, gt as y };
-//# sourceMappingURL=index-CzqHiUAo.d.ts.map
+//# sourceMappingURL=index-ByaanQGD.d.ts.map

package/dist/index-ByaanQGD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-ByaanQGD.d.ts","names":[],"sources":["../src/query/predicate.ts","../src/query/queryResult.ts","../src/query/selection.ts","../src/query/queryBuilder.ts"],"sourcesContent":[],"mappings":";;;;KAAY,aAAA;KACA,sBAAA;KAEA,SAAA;QAEA;EALA,GAAA,EAAA,MAAA;EACA,KAAA,EAAA,MAAA,GAAA,MAAA;AAEZ,CAAA,GAAY;EAEA,IAAA,EAKA,sBALA;EAKA,UAAA,EACM,SADN,EAAA;CACM;;AAclB;AACA;AAgBA;AACA;AAeA;AAcA;AAcA;AAcA;AAcA;AAcA;AAagB,iBApHA,EAAA,CAoHkB,UAAS,EApHZ,SAoHY,EAAA,CAAA,EApHE,SAoHF;iBAnH3B,EAAA,gBAAkB,cAAc;;;ACbhD;;;;;;;;;AAgCY,iBDHI,GAAA,CCGJ,UAAA,EDHoB,SCGpB,EAAA,CAAA,EDHkC,SCGlC;iBDFI,GAAA,gBAAmB,cAAc;;;AE1CO;AAoBxD;AAA0D;;;;;;AAOrC,iBF8BL,EAAA,CE9BK,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EF8BoC,SE9BpC;;;;;;;;AAOrB;AAGA;AAWA;AACuB,iBFsBP,GAAA,CEtBO,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EFsBmC,SEtBnC;;;;;;;;;;;AAGY,iBFiCnB,EAAA,CEjCmB,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EFiCsB,SEjCtB;;AAA4C;AAM/E;AAiBA;;;;AClEA;AAeA;AAiBA;AAYK,iBH8CW,GAAA,CG9CI,GAAA,EAAA,MAIJ,EAAA,KAAA,EAAA,MAAc,GAAA,MAAA,CAAA,EH0C4B,SG1C5B;AAa9B;;;;;;;;;;AAsKoB,iBH3HJ,EAAA,CG2HI,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EH3HqC,SG2HrC;;;;;;;;;;;AA0DP,iBHvKG,GAAA,CGuKH,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EHvK6C,SGuK7C;AAiCb;;;;;;;;AAgFA;AAAkE,iBH3QlD,GAAA,CG2QkD,GAAA,EAAA,MAAA,CAAA,EH3QhC,SG2QgC;;;;;AHxZlE;AACA;AAEA;;AAOY,cCGC,WDHD,CAAA,UCGuB,MDHvB,CAAA,CAAA;EACM,QAAA,ECGN,ODHM,EAAA;EAAS,QAAA,eAAA;EAcX,QAAE,OAAA;EACF,QAAE,MAAA;EAgBF,QAAG,aAAa;EAChB,QAAG,aAAgB;EAenB,IAAA,YAAE,CAAA,CAAuC,ECpCnC,gBDoC4C,CCpC3B,ODoC2B,CAAA;EAclD,IAAA,MAAG,CAAA,CAAA,EAAA,MAAuC,GAAA,SAAS;EAcnD,WAAE,CAAA,QAAuC,ECvD3C,ODuDoD,EAAA,EAAA,YAAA,ECtDhD,gBDsDgD,CCtD/B,ODsD+B,CAAA,EAAA,MAAA,EAAA,MAAA,GAAA,SAAA,EAAA,KAAA,EAAA,MAAA,GAAA,SAAA,EAAA,YAAA,EAAA,MAAA,GAAA,SAAA;EAclD,IAAA,CAAA,CAAG,ECvDP,ODuDO,CAAA,IAAuC,CAAA;EAc1C,WAAE,CAAA,CAAA,EAAA,OAAuC;AAczD;;;;KE5HK,OAAA;AFJL;AACA;AAEA;;AAOY,KEWA,eAAA,GFXA,QEW0B,OFVpB,IAAA,OAAA,EAAS;AAc3B;AACA;AAgBA;AACA;AAeA,KE/BK,UF+Ba,CAAA,CAAA,EAAA,YAAuC,ME/BtB,CF+B+B,GAAA,ME/BrB,CF+BqB,CAAA,GAAA,QE9B1D,GF4CW,GE5CP,QF4C8C,CE5CrC,IF4CqC,CE5ChC,CF4CgC,EE5C7B,CF4CsC,CAAA,CAAA,GE5ChC,OF4CgC,CE5CxB,IF4CwB,CE5CnB,CF4CmB,EE5ChB,CF4CgB,CAAA,CAAA,EAcnE,CEzDE,GFyDF,CAAgB;AAchB;AAcA;AAcA;AAaA;KE1GY,eAAA,GAAkB,WAAW;;KAG7B,SAAA,GAAY;ADzBxB;;;;;;;;;AAgCY,KCIA,eDJA,CAAA,CAAA,CAAA,GAAA,uBCKW,KAAK,EAAE,kBAAkB,YAAY,gBAAgB,SACtE,YAAY,OAAO,iBAEpB;;AApDmD,CAAA,GAoDrB,IAjD9B,CAiDmC,MAjD5B,EAAA,QAAA,GAAA,QAAA,CAAA,GAAA,OAAA,CAAA;AAiBZ;AAA0D,KAmCrD,WAAA,GA7BU,QA6BY,OA7BQ,GAAA,IAAA,EAAU;;AACnB,KA+Bd,UAAA,GAAa,eA/BC,CA+Be,WA/Bf,CAAA;;;;;;;;;;AAO1B;AAGA;AAWA;;;;AACgD,iBA0BhC,sBAAA,CA1BgC,SAAA,CAAA,EA0BG,SA1BH,CAAA,EA0Be,cA1Bf;;;AF7CpC,KGKA,gBAAA,GHLA;EAKA,IAAA,EAAA,MAAA;EACM,IAAA,EAAA,QAAA,GAAA,QAAA;EAAS,KAAA,EAAA,KAAA,GAAA,MAAA;AAc3B,CAAA;AACA;AAgBA;AACA;AAeA;AAcA;AAcA;AAcA;AAcA;AAcA;AAagB,iBGpHA,GAAA,CHoHkB,aAAS,EAAA,MAAA,EAAA,aAAA,EAAA,QAAA,GAAA,QAAA,CAAA,EGpHqC,gBHoHrC;;;;AChI3C;;;;;;AAmBmC,iBEUnB,IAAA,CFVmB,aAAA,EAAA,MAAA,EAAA,aAAA,EAAA,QAAA,GAAA,QAAA,CAAA,EEU8C,gBFV9C;;;;;KEsB9B,eAAA;;EDlDA,YAAO,CAAA,EAAA,OAAA,GAAA,SAAA;EAiBA,WAAA,CAAA,EAAA,OAAe,GAAA,SAAW;EAMjC,WAAA,CAAA,EC+BW,cD/BD,GAAA,SAAA;CAAoB;;;;;;;;;;;AAEjC,uBC0CoB,gBD1CpB,CAAA,OAAA,CAAA,CAAA;EAAC,UAAA,OAAA,EC2CkB,WD3ClB;EAMS,UAAA,QAAe,ECsCL,GDtCK,GAAA,SAAc;EAG7B,UAAA,UAAS,ECoCG,GDpCA,GAAA,SAAA;EAWZ,UAAA,QAAe,EC0BL,mBD1BK,EAAA,GAAA,SAAA;EACJ,UAAA,aAAA,EAAA,MAAA,GAAA,SAAA;EAAK,UAAA,MAAA,EAAA,MAAA,GAAA,SAAA;EAAE,UAAA,OAAA,EAAA,MAAA,GAAA,SAAA;EAAkB,UAAA,WAAA,EC6BvB,SD7BuB,EAAA;EAAY,WAAA,CAAA,MAAA,EC+BtC,WD/BsC;EAAgB;;;;;;;;AAGG;EAMnE,OAAA,CAAA,OAAU,ECoCH,GDpCG,CAAA,EAAA,IAAmB;EAiBzB;;;;AClEhB;AAeA;AAiBA;AAMC;AAuBD;EACqB,SAAA,CAAA,SAAA,EAqCE,GArCF,CAAA,EAAA,IAAA;EACC;;;;;;;;;;;;;;;;EAiMG,OAAA,CAAA,aAAA,EAAA,MAAA,EAAA,aAAA,EAAA,QAAA,GAAA,QAAA,EAAA,KAAA,CAAA,EAAA,KAAA,GAAA,MAAA,CAAA,EAAA,IAAA;EAAR;;;AA8DjB;;;;;;;;AAgFA;EAAkE,OAAA,CAAA,gBAAA,EAzQtC,gBAyQsC,CAAA,EAAA,IAAA;EAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA9KF;uBACG;;;;;wCAUiB;;;;;8CAMM,YAAY,UAAU,QAAQ;;;;;;;;;;;WAY3D,QAAQ,YAAY;;;;;;;;;;WA6BxB;;;;;;;;;;;;;;;;;cAiCA,YAAA,SAAqB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA+CpB;qCAQM,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;cAyB5C,oCAAoC,iBAAiB;;sBAG5C,yBAAyB;+BAKhB;qCAIY,YAAY,QAAQ"}

package/dist/{index-gj33r3rd.d.cts → index-CS6sxVJC.d.cts}

@@ -14,28 +14,30 @@ type Predicate = {
 };
 /**
  * Creates an OR predicate
- * @param predicates - The predicates to combine
+ * @param predicates - The predicates to combine, either as a single array or as separate arguments
  * @returns The OR predicate
  *
  * @example
- * const predicates = [eq("name", "John"), eq("age", 30)]
- * const result = or(predicates)
+ * const result = or(eq("name", "John"), eq("age", 30))
+ * // or equivalently: or([eq("name", "John"), eq("age", 30)])
  * // result = { type: "or", predicates: [eq("name", "John"), eq("age", 30)] }
  *
  */
 declare function or(predicates: Predicate[]): Predicate;
+declare function or(...predicates: Predicate[]): Predicate;
 /**
  * Creates an AND predicate
- * @param predicates - The predicates to combine
+ * @param predicates - The predicates to combine, either as a single array or as separate arguments
  * @returns The AND predicate
  *
  * @example
- * const predicates = [eq("name", "John"), eq("age", 30)]
- * const result = and(predicates)
+ * const result = and(eq("name", "John"), eq("age", 30))
+ * // or equivalently: and([eq("name", "John"), eq("age", 30)])
  * // result = { type: "and", predicates: [eq("name", "John"), eq("age", 30)] }
  *
  */
 declare function and(predicates: Predicate[]): Predicate;
+declare function and(...predicates: Predicate[]): Predicate;
 /**
  * Creates an equality predicate
  * @param key - The key to compare
@@ -325,22 +327,24 @@ declare abstract class BaseQueryBuilder<TEntity> {
    */
   validAtBlock(validAtBlock: bigint): this;
   /**
-   * Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.
+   * Sets the predicates for the query limiting the results. It can be a single predicate,
+   * multiple predicates passed as separate arguments, or an array of predicates - all combined with 'and'.
    * Predicates can be nested using 'or' and 'and' predicates.
-   * @param predicates - The predicates to set
+   * @param predicates - The predicates to set, either as a single array or as separate arguments
    * @returns The query builder instance
    *
    * @example
    * const builder = client.select()
    * builder.where(eq("name", "John"))
+   * builder.where(eq("name", "John"), eq("age", 30))
    * builder.where([eq("name", "John"), eq("age", 30)])
-   * builder.where([eq("name", "John"), or([eq("age", 30), eq("age", 31)])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), eq("age", 31)])])
-   * builder.where([eq("name", "John"), or([eq("age", 30), and([eq("age", 31), eq("age", 32)])])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), eq("age", 32)])])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), and([eq("age", 32), eq("age", 33)])])])])
+   * builder.where(eq("name", "John"), or(eq("age", 30), eq("age", 31)))
+   * builder.where(eq("name", "John"), and(eq("age", 30), eq("age", 31)))
+   * builder.where(eq("name", "John"), or(eq("age", 30), and(eq("age", 31), eq("age", 32))))
+   * builder.where(eq("name", "John"), and(eq("age", 30), or(eq("age", 31), eq("age", 32))))
    */
-  where(predicates: Predicate[] | Predicate): this;
+  where(predicates: Predicate[]): this;
+  where(...predicates: Predicate[]): this;
   /**
    * Returns the data-selection parameters forwarded to the query engine.
    * Subclasses decide which parts of an entity are fetched.
@@ -453,4 +457,4 @@ declare class SelectQueryBuilder<TEntity> extends BaseQueryBuilder<TEntity> {
 }
 //#endregion
 export { neq as C, lte as S, or as T, and as _, asc as a, gte as b, FullEntity as c, SelectionFields as d, selectionToIncludeData as f, PredicateType as g, PredicateContainerType as h, SelectQueryBuilder as i, ProjectedEntity as l, Predicate as m, OrderByAttribute as n, desc as o, QueryResult as p, QueryBuilder as r, EntitySelection as s, BaseQueryBuilder as t, SelectArg as u, eq as v, not as w, lt as x, gt as y };
-//# sourceMappingURL=index-gj33r3rd.d.cts.map
+//# sourceMappingURL=index-CS6sxVJC.d.cts.map

package/dist/index-CS6sxVJC.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CS6sxVJC.d.cts","names":[],"sources":["../src/query/predicate.ts","../src/query/queryResult.ts","../src/query/selection.ts","../src/query/queryBuilder.ts"],"sourcesContent":[],"mappings":";;;;KAAY,aAAA;KACA,sBAAA;KAEA,SAAA;QAEA;EALA,GAAA,EAAA,MAAA;EACA,KAAA,EAAA,MAAA,GAAA,MAAA;AAEZ,CAAA,GAAY;EAEA,IAAA,EAKA,sBALA;EAKA,UAAA,EACM,SADN,EAAA;CACM;;AAclB;AACA;AAgBA;AACA;AAeA;AAcA;AAcA;AAcA;AAcA;AAcA;AAagB,iBApHA,EAAA,CAoHkB,UAAS,EApHZ,SAoHY,EAAA,CAAA,EApHE,SAoHF;iBAnH3B,EAAA,gBAAkB,cAAc;;;ACbhD;;;;;;;;;AAgCY,iBDHI,GAAA,CCGJ,UAAA,EDHoB,SCGpB,EAAA,CAAA,EDHkC,SCGlC;iBDFI,GAAA,gBAAmB,cAAc;;;AE1CO;AAoBxD;AAA0D;;;;;;AAOrC,iBF8BL,EAAA,CE9BK,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EF8BoC,SE9BpC;;;;;;;;AAOrB;AAGA;AAWA;AACuB,iBFsBP,GAAA,CEtBO,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EFsBmC,SEtBnC;;;;;;;;;;;AAGY,iBFiCnB,EAAA,CEjCmB,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EFiCsB,SEjCtB;;AAA4C;AAM/E;AAiBA;;;;AClEA;AAeA;AAiBA;AAYK,iBH8CW,GAAA,CG9CI,GAAA,EAAA,MAIJ,EAAA,KAAA,EAAA,MAAc,GAAA,MAAA,CAAA,EH0C4B,SG1C5B;AAa9B;;;;;;;;;;AAsKoB,iBH3HJ,EAAA,CG2HI,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EH3HqC,SG2HrC;;;;;;;;;;;AA0DP,iBHvKG,GAAA,CGuKH,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EHvK6C,SGuK7C;AAiCb;;;;;;;;AAgFA;AAAkE,iBH3QlD,GAAA,CG2QkD,GAAA,EAAA,MAAA,CAAA,EH3QhC,SG2QgC;;;;;AHxZlE;AACA;AAEA;;AAOY,cCGC,WDHD,CAAA,UCGuB,MDHvB,CAAA,CAAA;EACM,QAAA,ECGN,ODHM,EAAA;EAAS,QAAA,eAAA;EAcX,QAAE,OAAA;EACF,QAAE,MAAA;EAgBF,QAAG,aAAa;EAChB,QAAG,aAAgB;EAenB,IAAA,YAAE,CAAA,CAAuC,ECpCnC,gBDoC4C,CCpC3B,ODoC2B,CAAA;EAclD,IAAA,MAAG,CAAA,CAAA,EAAA,MAAuC,GAAA,SAAS;EAcnD,WAAE,CAAA,QAAuC,ECvD3C,ODuDoD,EAAA,EAAA,YAAA,ECtDhD,gBDsDgD,CCtD/B,ODsD+B,CAAA,EAAA,MAAA,EAAA,MAAA,GAAA,SAAA,EAAA,KAAA,EAAA,MAAA,GAAA,SAAA,EAAA,YAAA,EAAA,MAAA,GAAA,SAAA;EAclD,IAAA,CAAA,CAAG,ECvDP,ODuDO,CAAA,IAAuC,CAAA;EAc1C,WAAE,CAAA,CAAA,EAAA,OAAuC;AAczD;;;;KE5HK,OAAA;AFJL;AACA;AAEA;;AAOY,KEWA,eAAA,GFXA,QEW0B,OFVpB,IAAA,OAAA,EAAS;AAc3B;AACA;AAgBA;AACA;AAeA,KE/BK,UF+Ba,CAAA,CAAA,EAAA,YAAuC,ME/BtB,CF+B+B,GAAA,ME/BrB,CF+BqB,CAAA,GAAA,QE9B1D,GF4CW,GE5CP,QF4C8C,CE5CrC,IF4CqC,CE5ChC,CF4CgC,EE5C7B,CF4CsC,CAAA,CAAA,GE5ChC,OF4CgC,CE5CxB,IF4CwB,CE5CnB,CF4CmB,EE5ChB,CF4CgB,CAAA,CAAA,EAcnE,CEzDE,GFyDF,CAAgB;AAchB;AAcA;AAcA;AAaA;KE1GY,eAAA,GAAkB,WAAW;;KAG7B,SAAA,GAAY;ADzBxB;;;;;;;;;AAgCY,KCIA,eDJA,CAAA,CAAA,CAAA,GAAA,uBCKW,KAAK,EAAE,kBAAkB,YAAY,gBAAgB,SACtE,YAAY,OAAO,iBAEpB;;AApDmD,CAAA,GAoDrB,IAjD9B,CAiDmC,MAjD5B,EAAA,QAAA,GAAA,QAAA,CAAA,GAAA,OAAA,CAAA;AAiBZ;AAA0D,KAmCrD,WAAA,GA7BU,QA6BY,OA7BQ,GAAA,IAAA,EAAU;;AACnB,KA+Bd,UAAA,GAAa,eA/BC,CA+Be,WA/Bf,CAAA;;;;;;;;;;AAO1B;AAGA;AAWA;;;;AACgD,iBA0BhC,sBAAA,CA1BgC,SAAA,CAAA,EA0BG,SA1BH,CAAA,EA0Be,cA1Bf;;;AF7CpC,KGKA,gBAAA,GHLA;EAKA,IAAA,EAAA,MAAA;EACM,IAAA,EAAA,QAAA,GAAA,QAAA;EAAS,KAAA,EAAA,KAAA,GAAA,MAAA;AAc3B,CAAA;AACA;AAgBA;AACA;AAeA;AAcA;AAcA;AAcA;AAcA;AAcA;AAagB,iBGpHA,GAAA,CHoHkB,aAAS,EAAA,MAAA,EAAA,aAAA,EAAA,QAAA,GAAA,QAAA,CAAA,EGpHqC,gBHoHrC;;;;AChI3C;;;;;;AAmBmC,iBEUnB,IAAA,CFVmB,aAAA,EAAA,MAAA,EAAA,aAAA,EAAA,QAAA,GAAA,QAAA,CAAA,EEU8C,gBFV9C;;;;;KEsB9B,eAAA;;EDlDA,YAAO,CAAA,EAAA,OAAA,GAAA,SAAA;EAiBA,WAAA,CAAA,EAAA,OAAe,GAAA,SAAW;EAMjC,WAAA,CAAA,EC+BW,cD/BD,GAAA,SAAA;CAAoB;;;;;;;;;;;AAEjC,uBC0CoB,gBD1CpB,CAAA,OAAA,CAAA,CAAA;EAAC,UAAA,OAAA,EC2CkB,WD3ClB;EAMS,UAAA,QAAe,ECsCL,GDtCK,GAAA,SAAc;EAG7B,UAAA,UAAS,ECoCG,GDpCA,GAAA,SAAA;EAWZ,UAAA,QAAe,EC0BL,mBD1BK,EAAA,GAAA,SAAA;EACJ,UAAA,aAAA,EAAA,MAAA,GAAA,SAAA;EAAK,UAAA,MAAA,EAAA,MAAA,GAAA,SAAA;EAAE,UAAA,OAAA,EAAA,MAAA,GAAA,SAAA;EAAkB,UAAA,WAAA,EC6BvB,SD7BuB,EAAA;EAAY,WAAA,CAAA,MAAA,EC+BtC,WD/BsC;EAAgB;;;;;;;;AAGG;EAMnE,OAAA,CAAA,OAAU,ECoCH,GDpCG,CAAA,EAAA,IAAmB;EAiBzB;;;;AClEhB;AAeA;AAiBA;AAMC;AAuBD;EACqB,SAAA,CAAA,SAAA,EAqCE,GArCF,CAAA,EAAA,IAAA;EACC;;;;;;;;;;;;;;;;EAiMG,OAAA,CAAA,aAAA,EAAA,MAAA,EAAA,aAAA,EAAA,QAAA,GAAA,QAAA,EAAA,KAAA,CAAA,EAAA,KAAA,GAAA,MAAA,CAAA,EAAA,IAAA;EAAR;;;AA8DjB;;;;;;;;AAgFA;EAAkE,OAAA,CAAA,gBAAA,EAzQtC,gBAyQsC,CAAA,EAAA,IAAA;EAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA9KF;uBACG;;;;;wCAUiB;;;;;8CAMM,YAAY,UAAU,QAAQ;;;;;;;;;;;WAY3D,QAAQ,YAAY;;;;;;;;;;WA6BxB;;;;;;;;;;;;;;;;;cAiCA,YAAA,SAAqB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA+CpB;qCAQM,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;cAyB5C,oCAAoC,iBAAiB;;sBAG5C,yBAAyB;+BAKhB;qCAIY,YAAY,QAAQ"}

package/dist/index.cjs

@@ -1,5 +1,5 @@
 const require_chains = require('./chains-BifaY04V.cjs');
-const require_queryBuilder = require('./queryBuilder-CTPwve9u.cjs');
+const require_queryBuilder = require('./queryBuilder-K0ZkQGnx.cjs');
 const require_consts = require('./consts-AUoL-v42.cjs');
 require('./types-o3zWarRp.cjs');
 const require_payload = require('./payload-DpA5PA-w.cjs');

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { A as RpcIncludeData, C as QueryOptionsIncludeData, D as ArkivClient, E as GetBlockTimingReturnType, M as RpcQueryOptions, N as MimeType, O as ArkivRpcSchema, S as QueryOptions, T as QueryReturnType, _ as DeleteEntityReturnType, a as OnEntityExpiredEvent, b as ChangeOwnershipParameters, c as OnEntityUpdatedEvent, d as MutateEntitiesReturnType, f as UpdateEntityParameters, g as DeleteEntityParameters, h as ExtendEntityReturnType, i as OnEntityDeletedEvent, j as RpcOrderByAttribute, k as RpcEntity, l as Attribute, m as ExtendEntityParameters, n as TxParams, o as OnEntityExpiresInExtendedEvent, p as UpdateEntityReturnType, r as OnEntityCreatedEvent, s as OnEntityOwnerChangedEvent, t as Entity, u as MutateEntitiesParameters, v as CreateEntityParameters, w as QueryOptionsOrderBy, x as ChangeOwnershipReturnType, y as CreateEntityReturnType } from "./entity-BSU5-vyY.cjs";
-import { c as FullEntity, i as SelectQueryBuilder, l as ProjectedEntity, r as QueryBuilder, s as EntitySelection, u as SelectArg } from "./index-gj33r3rd.cjs";
+import { c as FullEntity, i as SelectQueryBuilder, l as ProjectedEntity, r as QueryBuilder, s as EntitySelection, u as SelectArg } from "./index-CS6sxVJC.cjs";
 import { n as stringToPayload, t as jsonToPayload } from "./payload-CJN8fTvX.cjs";
 import { Account, Address, Chain, Client, Hex, ParseAccount, Prettify, PublicActions, PublicClientConfig, RpcSchema, Transport, WalletActions, WalletClientConfig } from "viem";
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { A as RpcIncludeData, C as QueryOptionsIncludeData, D as ArkivClient, E as GetBlockTimingReturnType, M as RpcQueryOptions, N as MimeType, O as ArkivRpcSchema, S as QueryOptions, T as QueryReturnType, _ as DeleteEntityReturnType, a as OnEntityExpiredEvent, b as ChangeOwnershipParameters, c as OnEntityUpdatedEvent, d as MutateEntitiesReturnType, f as UpdateEntityParameters, g as DeleteEntityParameters, h as ExtendEntityReturnType, i as OnEntityDeletedEvent, j as RpcOrderByAttribute, k as RpcEntity, l as Attribute, m as ExtendEntityParameters, n as TxParams, o as OnEntityExpiresInExtendedEvent, p as UpdateEntityReturnType, r as OnEntityCreatedEvent, s as OnEntityOwnerChangedEvent, t as Entity, u as MutateEntitiesParameters, v as CreateEntityParameters, w as QueryOptionsOrderBy, x as ChangeOwnershipReturnType, y as CreateEntityReturnType } from "./entity-CHiZ2Qu1.js";
-import { c as FullEntity, i as SelectQueryBuilder, l as ProjectedEntity, r as QueryBuilder, s as EntitySelection, u as SelectArg } from "./index-CzqHiUAo.js";
+import { c as FullEntity, i as SelectQueryBuilder, l as ProjectedEntity, r as QueryBuilder, s as EntitySelection, u as SelectArg } from "./index-ByaanQGD.js";
 import { n as stringToPayload, t as jsonToPayload } from "./payload-B2kFJyah.js";
 import { Account, Address, Chain, Client, Hex, ParseAccount, Prettify, PublicActions, PublicClientConfig, RpcSchema, Transport, WalletActions, WalletClientConfig } from "viem";
 

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as chains_exports } from "./chains-CrtkVbBh.js";
-import { c as entityFromRpcResult, d as InvalidExpirationError, f as NoCursorOrLimitError, h as getLogger, l as EntityMutationError, m as NoMoreResultsError, n as QueryBuilder, p as NoEntityFoundError, r as SelectQueryBuilder, u as InvalidAttributeError } from "./queryBuilder-D-ACo-g_.js";
+import { c as entityFromRpcResult, d as InvalidExpirationError, f as NoCursorOrLimitError, h as getLogger, l as EntityMutationError, m as NoMoreResultsError, n as QueryBuilder, p as NoEntityFoundError, r as SelectQueryBuilder, u as InvalidAttributeError } from "./queryBuilder-C3XSUYpn.js";
 import { n as BLOCK_TIME, t as ARKIV_ADDRESS } from "./consts-BV4PR-de.js";
 import "./types-H-TSmRpm.js";
 import { n as stringToPayload, t as jsonToPayload } from "./payload-Claf2jUO.js";

package/dist/query/index.cjs

@@ -1,39 +1,17 @@
-const require_queryBuilder = require('../queryBuilder-CTPwve9u.cjs');
+const require_queryBuilder = require('../queryBuilder-K0ZkQGnx.cjs');
 require('../consts-AUoL-v42.cjs');
 
 //#region src/query/predicate.ts
-/**
-* Creates an OR predicate
-* @param predicates - The predicates to combine
-* @returns The OR predicate
-*
-* @example
-* const predicates = [eq("name", "John"), eq("age", 30)]
-* const result = or(predicates)
-* // result = { type: "or", predicates: [eq("name", "John"), eq("age", 30)] }
-*
-*/
-function or(predicates) {
+function or(...predicates) {
 	return {
 		type: "or",
-		predicates
+		predicates: predicates.flat()
 	};
 }
-/**
-* Creates an AND predicate
-* @param predicates - The predicates to combine
-* @returns The AND predicate
-*
-* @example
-* const predicates = [eq("name", "John"), eq("age", 30)]
-* const result = and(predicates)
-* // result = { type: "and", predicates: [eq("name", "John"), eq("age", 30)] }
-*
-*/
-function and(predicates) {
+function and(...predicates) {
 	return {
 		type: "and",
-		predicates
+		predicates: predicates.flat()
 	};
 }
 /**

package/dist/query/index.d.cts

@@ -1,3 +1,3 @@
 import "../entity-BSU5-vyY.cjs";
-import { C as neq, S as lte, T as or, _ as and, a as asc, b as gte, c as FullEntity, d as SelectionFields, f as selectionToIncludeData, g as PredicateType, h as PredicateContainerType, i as SelectQueryBuilder, l as ProjectedEntity, m as Predicate, n as OrderByAttribute, o as desc, p as QueryResult, r as QueryBuilder, s as EntitySelection, t as BaseQueryBuilder, u as SelectArg, v as eq, w as not, x as lt, y as gt } from "../index-gj33r3rd.cjs";
+import { C as neq, S as lte, T as or, _ as and, a as asc, b as gte, c as FullEntity, d as SelectionFields, f as selectionToIncludeData, g as PredicateType, h as PredicateContainerType, i as SelectQueryBuilder, l as ProjectedEntity, m as Predicate, n as OrderByAttribute, o as desc, p as QueryResult, r as QueryBuilder, s as EntitySelection, t as BaseQueryBuilder, u as SelectArg, v as eq, w as not, x as lt, y as gt } from "../index-CS6sxVJC.cjs";
 export { BaseQueryBuilder, EntitySelection, FullEntity, OrderByAttribute, Predicate, PredicateContainerType, PredicateType, ProjectedEntity, QueryBuilder, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, and, asc, desc, eq, gt, gte, lt, lte, neq, not, or, selectionToIncludeData };

package/dist/query/index.d.ts

@@ -1,3 +1,3 @@
 import "../entity-CHiZ2Qu1.js";
-import { C as neq, S as lte, T as or, _ as and, a as asc, b as gte, c as FullEntity, d as SelectionFields, f as selectionToIncludeData, g as PredicateType, h as PredicateContainerType, i as SelectQueryBuilder, l as ProjectedEntity, m as Predicate, n as OrderByAttribute, o as desc, p as QueryResult, r as QueryBuilder, s as EntitySelection, t as BaseQueryBuilder, u as SelectArg, v as eq, w as not, x as lt, y as gt } from "../index-CzqHiUAo.js";
+import { C as neq, S as lte, T as or, _ as and, a as asc, b as gte, c as FullEntity, d as SelectionFields, f as selectionToIncludeData, g as PredicateType, h as PredicateContainerType, i as SelectQueryBuilder, l as ProjectedEntity, m as Predicate, n as OrderByAttribute, o as desc, p as QueryResult, r as QueryBuilder, s as EntitySelection, t as BaseQueryBuilder, u as SelectArg, v as eq, w as not, x as lt, y as gt } from "../index-ByaanQGD.js";
 export { BaseQueryBuilder, EntitySelection, FullEntity, OrderByAttribute, Predicate, PredicateContainerType, PredicateType, ProjectedEntity, QueryBuilder, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, and, asc, desc, eq, gt, gte, lt, lte, neq, not, or, selectionToIncludeData };

package/dist/query/index.js

@@ -1,39 +1,17 @@
-import { a as desc, i as asc, n as QueryBuilder, o as selectionToIncludeData, r as SelectQueryBuilder, s as QueryResult, t as BaseQueryBuilder } from "../queryBuilder-D-ACo-g_.js";
+import { a as desc, i as asc, n as QueryBuilder, o as selectionToIncludeData, r as SelectQueryBuilder, s as QueryResult, t as BaseQueryBuilder } from "../queryBuilder-C3XSUYpn.js";
 import "../consts-BV4PR-de.js";
 
 //#region src/query/predicate.ts
-/**
-* Creates an OR predicate
-* @param predicates - The predicates to combine
-* @returns The OR predicate
-*
-* @example
-* const predicates = [eq("name", "John"), eq("age", 30)]
-* const result = or(predicates)
-* // result = { type: "or", predicates: [eq("name", "John"), eq("age", 30)] }
-*
-*/
-function or(predicates) {
+function or(...predicates) {
 	return {
 		type: "or",
-		predicates
+		predicates: predicates.flat()
 	};
 }
-/**
-* Creates an AND predicate
-* @param predicates - The predicates to combine
-* @returns The AND predicate
-*
-* @example
-* const predicates = [eq("name", "John"), eq("age", 30)]
-* const result = and(predicates)
-* // result = { type: "and", predicates: [eq("name", "John"), eq("age", 30)] }
-*
-*/
-function and(predicates) {
+function and(...predicates) {
 	return {
 		type: "and",
-		predicates
+		predicates: predicates.flat()
 	};
 }
 /**

package/dist/query/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/query/predicate.ts"],"sourcesContent":["export type PredicateType = \"eq\" | \"neq\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"not\"\nexport type PredicateContainerType = \"or\" | \"and\"\n\nexport type Predicate =\n  | {\n      type: PredicateType\n      key: string\n      value: string | number\n    }\n  | {\n      type: PredicateContainerType\n      predicates: Predicate[]\n    }\n\n/**\n * Creates an OR predicate\n * @param predicates - The predicates to combine\n * @returns The OR predicate\n *\n * @example\n * const predicates = [eq(\"name\", \"John\"), eq(\"age\", 30)]\n * const result = or(predicates)\n * // result = { type: \"or\", predicates: [eq(\"name\", \"John\"), eq(\"age\", 30)] }\n *\n */\nexport function or(predicates: Predicate[]): Predicate {\n  return { type: \"or\", predicates }\n}\n\n/**\n * Creates an AND predicate\n * @param predicates - The predicates to combine\n * @returns The AND predicate\n *\n * @example\n * const predicates = [eq(\"name\", \"John\"), eq(\"age\", 30)]\n * const result = and(predicates)\n * // result = { type: \"and\", predicates: [eq(\"name\", \"John\"), eq(\"age\", 30)] }\n *\n */\nexport function and(predicates: Predicate[]): Predicate {\n  return { type: \"and\", predicates }\n}\n\n/**\n * Creates an equality predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The equality predicate\n *\n * @example\n * const predicate = eq(\"name\", \"John\")\n * // result = { type: \"eq\", key: \"name\", value: \"John\" }\n */\nexport function eq(key: string, value: string | number): Predicate {\n  return { type: \"eq\", key, value }\n}\n\n/**\n * Creates a not equal predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The not equal predicate\n *\n * @example\n * const predicate = neq(\"name\", \"John\")\n * // result = { type: \"neq\", key: \"name\", value: \"John\" }\n */\nexport function neq(key: string, value: string | number): Predicate {\n  return { type: \"neq\", key, value }\n}\n\n/**\n * Creates a greater than predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The greater than predicate\n *\n * @example\n * const predicate = gt(\"name\", \"John\")\n * // result = { type: \"gt\", key: \"name\", value: \"John\" }\n */\nexport function gt(key: string, value: string | number): Predicate {\n  return { type: \"gt\", key, value }\n}\n\n/**\n * Creates a greater than or equal predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The greater than or equal predicate\n *\n * @example\n * const predicate = gte(\"name\", \"John\")\n * // result = { type: \"gte\", key: \"name\", value: \"John\" }\n */\nexport function gte(key: string, value: string | number): Predicate {\n  return { type: \"gte\", key, value }\n}\n\n/**\n * Creates a less than predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The less than predicate\n *\n * @example\n * const predicate = lt(\"name\", \"John\")\n * // result = { type: \"lt\", key: \"name\", value: \"John\" }\n */\nexport function lt(key: string, value: string | number): Predicate {\n  return { type: \"lt\", key, value }\n}\n\n/**\n * Creates a less than or equal predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The less than or equal predicate\n *\n * @example\n * const predicate = lte(\"name\", \"John\")\n * // result = { type: \"lte\", key: \"name\", value: \"John\" }\n */\nexport function lte(key: string, value: string | number): Predicate {\n  return { type: \"lte\", key, value }\n}\n\n/**\n * Creates a not predicate\n * @param key - The key to compare\n * @returns The not predicate\n *\n * @example\n * const predicate = not(\"name\")\n * // result = { type: \"not\", key: \"name\", value: \"\" }\n */\nexport function not(key: string): Predicate {\n  return { type: \"not\", key, value: \"\" }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,SAAgB,GAAG,YAAoC;AACrD,QAAO;EAAE,MAAM;EAAM;EAAY;;;;;;;;;;;;;AAcnC,SAAgB,IAAI,YAAoC;AACtD,QAAO;EAAE,MAAM;EAAO;EAAY;;;;;;;;;;;;AAapC,SAAgB,GAAG,KAAa,OAAmC;AACjE,QAAO;EAAE,MAAM;EAAM;EAAK;EAAO;;;;;;;;;;;;AAanC,SAAgB,IAAI,KAAa,OAAmC;AAClE,QAAO;EAAE,MAAM;EAAO;EAAK;EAAO;;;;;;;;;;;;AAapC,SAAgB,GAAG,KAAa,OAAmC;AACjE,QAAO;EAAE,MAAM;EAAM;EAAK;EAAO;;;;;;;;;;;;AAanC,SAAgB,IAAI,KAAa,OAAmC;AAClE,QAAO;EAAE,MAAM;EAAO;EAAK;EAAO;;;;;;;;;;;;AAapC,SAAgB,GAAG,KAAa,OAAmC;AACjE,QAAO;EAAE,MAAM;EAAM;EAAK;EAAO;;;;;;;;;;;;AAanC,SAAgB,IAAI,KAAa,OAAmC;AAClE,QAAO;EAAE,MAAM;EAAO;EAAK;EAAO;;;;;;;;;;;AAYpC,SAAgB,IAAI,KAAwB;AAC1C,QAAO;EAAE,MAAM;EAAO;EAAK,OAAO;EAAI"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/query/predicate.ts"],"sourcesContent":["export type PredicateType = \"eq\" | \"neq\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"not\"\nexport type PredicateContainerType = \"or\" | \"and\"\n\nexport type Predicate =\n  | {\n      type: PredicateType\n      key: string\n      value: string | number\n    }\n  | {\n      type: PredicateContainerType\n      predicates: Predicate[]\n    }\n\n/**\n * Creates an OR predicate\n * @param predicates - The predicates to combine, either as a single array or as separate arguments\n * @returns The OR predicate\n *\n * @example\n * const result = or(eq(\"name\", \"John\"), eq(\"age\", 30))\n * // or equivalently: or([eq(\"name\", \"John\"), eq(\"age\", 30)])\n * // result = { type: \"or\", predicates: [eq(\"name\", \"John\"), eq(\"age\", 30)] }\n *\n */\nexport function or(predicates: Predicate[]): Predicate\nexport function or(...predicates: Predicate[]): Predicate\nexport function or(...predicates: (Predicate | Predicate[])[]): Predicate {\n  return { type: \"or\", predicates: predicates.flat() }\n}\n\n/**\n * Creates an AND predicate\n * @param predicates - The predicates to combine, either as a single array or as separate arguments\n * @returns The AND predicate\n *\n * @example\n * const result = and(eq(\"name\", \"John\"), eq(\"age\", 30))\n * // or equivalently: and([eq(\"name\", \"John\"), eq(\"age\", 30)])\n * // result = { type: \"and\", predicates: [eq(\"name\", \"John\"), eq(\"age\", 30)] }\n *\n */\nexport function and(predicates: Predicate[]): Predicate\nexport function and(...predicates: Predicate[]): Predicate\nexport function and(...predicates: (Predicate | Predicate[])[]): Predicate {\n  return { type: \"and\", predicates: predicates.flat() }\n}\n\n/**\n * Creates an equality predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The equality predicate\n *\n * @example\n * const predicate = eq(\"name\", \"John\")\n * // result = { type: \"eq\", key: \"name\", value: \"John\" }\n */\nexport function eq(key: string, value: string | number): Predicate {\n  return { type: \"eq\", key, value }\n}\n\n/**\n * Creates a not equal predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The not equal predicate\n *\n * @example\n * const predicate = neq(\"name\", \"John\")\n * // result = { type: \"neq\", key: \"name\", value: \"John\" }\n */\nexport function neq(key: string, value: string | number): Predicate {\n  return { type: \"neq\", key, value }\n}\n\n/**\n * Creates a greater than predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The greater than predicate\n *\n * @example\n * const predicate = gt(\"name\", \"John\")\n * // result = { type: \"gt\", key: \"name\", value: \"John\" }\n */\nexport function gt(key: string, value: string | number): Predicate {\n  return { type: \"gt\", key, value }\n}\n\n/**\n * Creates a greater than or equal predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The greater than or equal predicate\n *\n * @example\n * const predicate = gte(\"name\", \"John\")\n * // result = { type: \"gte\", key: \"name\", value: \"John\" }\n */\nexport function gte(key: string, value: string | number): Predicate {\n  return { type: \"gte\", key, value }\n}\n\n/**\n * Creates a less than predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The less than predicate\n *\n * @example\n * const predicate = lt(\"name\", \"John\")\n * // result = { type: \"lt\", key: \"name\", value: \"John\" }\n */\nexport function lt(key: string, value: string | number): Predicate {\n  return { type: \"lt\", key, value }\n}\n\n/**\n * Creates a less than or equal predicate\n * @param key - The key to compare\n * @param value - The value to compare\n * @returns The less than or equal predicate\n *\n * @example\n * const predicate = lte(\"name\", \"John\")\n * // result = { type: \"lte\", key: \"name\", value: \"John\" }\n */\nexport function lte(key: string, value: string | number): Predicate {\n  return { type: \"lte\", key, value }\n}\n\n/**\n * Creates a not predicate\n * @param key - The key to compare\n * @returns The not predicate\n *\n * @example\n * const predicate = not(\"name\")\n * // result = { type: \"not\", key: \"name\", value: \"\" }\n */\nexport function not(key: string): Predicate {\n  return { type: \"not\", key, value: \"\" }\n}\n"],"mappings":";;;;AA2BA,SAAgB,GAAG,GAAG,YAAoD;AACxE,QAAO;EAAE,MAAM;EAAM,YAAY,WAAW,MAAM;EAAE;;AAgBtD,SAAgB,IAAI,GAAG,YAAoD;AACzE,QAAO;EAAE,MAAM;EAAO,YAAY,WAAW,MAAM;EAAE;;;;;;;;;;;;AAavD,SAAgB,GAAG,KAAa,OAAmC;AACjE,QAAO;EAAE,MAAM;EAAM;EAAK;EAAO;;;;;;;;;;;;AAanC,SAAgB,IAAI,KAAa,OAAmC;AAClE,QAAO;EAAE,MAAM;EAAO;EAAK;EAAO;;;;;;;;;;;;AAapC,SAAgB,GAAG,KAAa,OAAmC;AACjE,QAAO;EAAE,MAAM;EAAM;EAAK;EAAO;;;;;;;;;;;;AAanC,SAAgB,IAAI,KAAa,OAAmC;AAClE,QAAO;EAAE,MAAM;EAAO;EAAK;EAAO;;;;;;;;;;;;AAapC,SAAgB,GAAG,KAAa,OAAmC;AACjE,QAAO;EAAE,MAAM;EAAM;EAAK;EAAO;;;;;;;;;;;;AAanC,SAAgB,IAAI,KAAa,OAAmC;AAClE,QAAO;EAAE,MAAM;EAAO;EAAK;EAAO;;;;;;;;;;;AAYpC,SAAgB,IAAI,KAAwB;AAC1C,QAAO;EAAE,MAAM;EAAO;EAAK,OAAO;EAAI"}

package/dist/{queryBuilder-D-ACo-g_.js → queryBuilder-C3XSUYpn.js}

@@ -534,25 +534,8 @@ var BaseQueryBuilder = class {
 		this._validAtBlock = validAtBlock;
 		return this;
 	}
-	/**
-	* Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.
-	* Predicates can be nested using 'or' and 'and' predicates.
-	* @param predicates - The predicates to set
-	* @returns The query builder instance
-	*
-	* @example
-	* const builder = client.select()
-	* builder.where(eq("name", "John"))
-	* builder.where([eq("name", "John"), eq("age", 30)])
-	* builder.where([eq("name", "John"), or([eq("age", 30), eq("age", 31)])])
-	* builder.where([eq("name", "John"), and([eq("age", 30), eq("age", 31)])])
-	* builder.where([eq("name", "John"), or([eq("age", 30), and([eq("age", 31), eq("age", 32)])])])
-	* builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), eq("age", 32)])])])
-	* builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), and([eq("age", 32), eq("age", 33)])])])])
-	*/
-	where(predicates) {
-		if (Array.isArray(predicates)) this._predicates.push(...predicates);
-		else this._predicates.push(predicates);
+	where(...predicates) {
+		this._predicates.push(...predicates.flat());
 		return this;
 	}
 	/**
@@ -710,4 +693,4 @@ var SelectQueryBuilder = class extends BaseQueryBuilder {
 
 //#endregion
 export { desc as a, entityFromRpcResult as c, InvalidExpirationError as d, NoCursorOrLimitError as f, getLogger as h, asc as i, EntityMutationError as l, NoMoreResultsError as m, QueryBuilder as n, selectionToIncludeData as o, NoEntityFoundError as p, SelectQueryBuilder as r, QueryResult as s, BaseQueryBuilder as t, InvalidAttributeError as u };
-//# sourceMappingURL=queryBuilder-D-ACo-g_.js.map
+//# sourceMappingURL=queryBuilder-C3XSUYpn.js.map

package/dist/{queryBuilder-D-ACo-g_.js.map → queryBuilder-C3XSUYpn.js.map}

@@ -1 +1 @@
-{"version":3,"file":"queryBuilder-D-ACo-g_.js","names":["enabledNamespaces: Set<string>","disabledNamespaces: Set<string>","logger","logger","predicate","queryOptions: RpcQueryOptions","order"],"sources":["../src/utils/logger.ts","../src/errors.ts","../src/types/entity.ts","../src/utils/entities.ts","../src/query/engine.ts","../src/query/queryResult.ts","../src/query/selection.ts","../src/query/queryBuilder.ts"],"sourcesContent":["const ROOT_NAMESPACE = \"arkiv\"\n\n// Debug logger type - returns a function that can be called to log messages\ntype DebugLogger = (...args: unknown[]) => void\n\n// Get DEBUG environment variable (works in both Node.js and browser)\nfunction getDebugEnv(): string {\n  if (typeof process !== \"undefined\") {\n    const debugEnv = process?.env?.DEBUG\n    if (debugEnv) {\n      return debugEnv\n    }\n  }\n  // Browser: check localStorage\n  if (typeof globalThis !== \"undefined\" && \"localStorage\" in globalThis) {\n    try {\n      const storage = (globalThis as { localStorage?: Storage }).localStorage\n      return storage?.getItem(\"DEBUG\") || \"\"\n    } catch {\n      // localStorage might not be available\n    }\n  }\n  return \"\"\n}\n\n// Parse debug patterns and check if a namespace matches\nfunction matchesPattern(namespace: string, pattern: string): boolean {\n  // Exact match\n  if (pattern === namespace) return true\n\n  // Wildcard match: \"arkiv:*\" matches \"arkiv:query\", \"arkiv:rpc\", etc.\n  if (pattern.endsWith(\"*\")) {\n    const prefix = pattern.slice(0, -1)\n    return namespace.startsWith(prefix)\n  }\n\n  // Negative match: \"-arkiv:query\" excludes \"arkiv:query\"\n  if (pattern.startsWith(\"-\")) {\n    const excludePattern = pattern.slice(1)\n    return !matchesPattern(namespace, excludePattern)\n  }\n\n  return false\n}\n\n// Check if a namespace is enabled for debugging\nfunction isEnabled(namespace: string): boolean {\n  const debugEnv = getDebugEnv()\n  if (!debugEnv) return false\n\n  // Split by comma/space and check each pattern\n  const patterns = debugEnv.split(/[\\s,]+/).filter((p) => p.length > 0)\n\n  // If no patterns, nothing is enabled\n  if (patterns.length === 0) return false\n\n  // Check if any pattern matches (or if explicitly excluded)\n  let enabled = false\n  for (const pattern of patterns) {\n    if (pattern.startsWith(\"-\")) {\n      // Exclude pattern - if it matches, disable\n      if (matchesPattern(namespace, pattern)) {\n        return false\n      }\n    } else if (matchesPattern(namespace, pattern)) {\n      enabled = true\n    }\n  }\n\n  return enabled\n}\n\n// Store enabled namespaces (for programmatic enable/disable)\nconst enabledNamespaces: Set<string> = new Set()\nconst disabledNamespaces: Set<string> = new Set()\n\n// Color palette for namespace coloring (distinct, readable colors)\nconst COLOR_PALETTE = [\n  \"#0000FF\", // blue\n  \"#008000\", // green\n  \"#FF0000\", // red\n  \"#FF00FF\", // magenta\n  \"#FFA500\", // orange\n  \"#800080\", // purple\n  \"#00CED1\", // dark turquoise\n  \"#FF1493\", // deep pink\n  \"#32CD32\", // lime green\n  \"#1E90FF\", // dodger blue\n  \"#FF4500\", // orange red\n  \"#9370DB\", // medium purple\n  \"#00FA9A\", // medium spring green\n  \"#FFD700\", // gold\n  \"#DC143C\", // crimson\n  \"#00BFFF\", // deep sky blue\n  \"#FF69B4\", // hot pink\n  \"#20B2AA\", // light sea green\n  \"#DA70D6\", // orchid\n  \"#4682B4\", // steel blue\n]\n\n// Detect if we're in Node.js (for ANSI colors) or browser (for CSS colors)\nconst isNode = typeof process !== \"undefined\" && process.versions?.node != null\n\n// ANSI color codes for Node.js (bright, distinct colors)\nconst ANSI_COLORS = [\n  \"\\x1b[94m\", // bright blue\n  \"\\x1b[92m\", // bright green\n  \"\\x1b[91m\", // bright red\n  \"\\x1b[95m\", // bright magenta\n  \"\\x1b[93m\", // bright yellow\n  \"\\x1b[96m\", // bright cyan\n  \"\\x1b[35m\", // magenta\n  \"\\x1b[36m\", // cyan\n  \"\\x1b[32m\", // green\n  \"\\x1b[34m\", // blue\n  \"\\x1b[33m\", // yellow\n  \"\\x1b[31m\", // red\n  \"\\x1b[90m\", // bright black (gray)\n  \"\\x1b[37m\", // white\n  \"\\x1b[1m\", // bold (as a color option)\n]\n\nconst ANSI_RESET = \"\\x1b[0m\"\nconst ANSI_BOLD = \"\\x1b[1m\"\n\n// Cache colors for namespaces (same namespace = same color)\nconst namespaceColors = new Map<string, { css: string; ansi: string }>()\n\n// Generate a consistent color for a namespace based on its hash\nfunction getColorForNamespace(namespace: string): { css: string; ansi: string } {\n  // Check cache first\n  const cachedColor = namespaceColors.get(namespace)\n  if (cachedColor) {\n    return cachedColor\n  }\n\n  // Simple hash function to convert string to number\n  let hash = 0\n  for (let i = 0; i < namespace.length; i++) {\n    const char = namespace.charCodeAt(i)\n    hash = (hash << 5) - hash + char\n    hash = hash & hash // Convert to 32-bit integer\n  }\n\n  // Use absolute value and modulo to get index\n  const colorIndex = Math.abs(hash) % COLOR_PALETTE.length\n  const cssColor = COLOR_PALETTE[colorIndex]\n  const ansiColor = ANSI_COLORS[colorIndex % ANSI_COLORS.length]\n\n  const color = { css: cssColor, ansi: ansiColor }\n\n  // Cache the color\n  namespaceColors.set(namespace, color)\n\n  return color\n}\n\n// Create a debug logger function\nfunction createDebugLogger(namespace: string): DebugLogger {\n  // Get the color for this namespace (consistent across calls)\n  const colors = getColorForNamespace(namespace)\n\n  return (...args: unknown[]) => {\n    // Check if enabled via environment variable or programmatically\n    const envEnabled = isEnabled(namespace)\n    const progEnabled = enabledNamespaces.has(namespace) && !disabledNamespaces.has(namespace)\n\n    if (envEnabled || progEnabled) {\n      if (isNode) {\n        // Node.js: use ANSI color codes\n        const coloredNamespace = `${ANSI_BOLD}${colors.ansi}${namespace}${ANSI_RESET}`\n        console.log(coloredNamespace, ...args)\n      } else {\n        // Browser: use CSS styling with %c\n        // The format is: console.log(\"%cstyled%cnormal\", style1, style2, ...args)\n        // This colors the namespace, then resets for the rest\n        const style1 = `color: ${colors.css}; font-weight: bold`\n        const style2 = \"color: inherit; font-weight: normal\"\n        // Combine namespace with a space, then log with styles\n        console.log(`%c${namespace}%c`, style1, style2, ...args)\n      }\n    }\n  }\n}\n\nexport const getLogger = (scope: string): DebugLogger => {\n  const namespace = `${ROOT_NAMESPACE}:${scope}`\n  return createDebugLogger(namespace)\n}\n\nexport const enableDebug = (namespaces: string): void => {\n  // Parse and add namespaces to enabled set\n  const patterns = namespaces.split(/[\\s,]+/).filter((p) => p.length > 0)\n  for (const pattern of patterns) {\n    if (pattern.startsWith(\"-\")) {\n      // Remove from enabled, add to disabled\n      const namespace = pattern.slice(1)\n      enabledNamespaces.delete(namespace)\n      disabledNamespaces.add(namespace)\n    } else {\n      enabledNamespaces.add(pattern)\n      disabledNamespaces.delete(pattern)\n    }\n  }\n}\n\nexport const disableDebug = (): void => {\n  enabledNamespaces.clear()\n  disabledNamespaces.clear()\n}\n","import { BLOCK_TIME } from \"./consts\"\n\nexport class EntityMutationError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = \"EntityMutationError\"\n  }\n}\nexport class InvalidExpirationError extends Error {\n  constructor(expiresIn: unknown) {\n    super(\n      `Invalid expiresIn: ${String(expiresIn)}. expiresIn must be a positive integer and a multiple of the Arkiv block time (${BLOCK_TIME} seconds), because expiration is measured in whole blocks (1 block = ${BLOCK_TIME} seconds).`,\n    )\n    this.name = \"InvalidExpirationError\"\n  }\n}\nexport class InvalidAttributeError extends Error {\n  constructor(key: string, value: number) {\n    super(\n      `Invalid numeric value for attribute \"${key}\": ${String(value)}. Numeric attribute values must be integers. To keep numeric ordering/range queries, scale it to an integer (e.g. Math.round(${String(value)} * 1000), dividing by 1000 on read); otherwise store it as a string (e.g. \"${String(value)}\").`,\n    )\n    this.name = \"InvalidAttributeError\"\n  }\n}\n\nexport class NoMoreResultsError extends Error {\n  constructor() {\n    super(\"No more results\")\n    this.name = \"NoMoreResultsError\"\n  }\n}\n\nexport class NoCursorOrLimitError extends Error {\n  constructor() {\n    super(\"Cursor and limit must be defined to fetch next\")\n    this.name = \"NoCursorOrLimitError\"\n  }\n}\n\nexport class NoEntityFoundError extends Error {\n  constructor() {\n    super(\"No entity found\")\n    this.name = \"NoEntityFoundError\"\n  }\n}\n","import { bytesToString, type Hex } from \"viem\"\nimport type { MimeType } from \"../types\"\nimport type { Attribute } from \"./attributes\"\n\nexport class Entity {\n  key: Hex\n  contentType: MimeType | undefined\n  owner: Hex | undefined\n  creator: Hex | undefined\n  expiresAtBlock: bigint | undefined\n  createdAtBlock: bigint | undefined\n  lastModifiedAtBlock: bigint | undefined\n  transactionIndexInBlock: bigint | undefined\n  operationIndexInTransaction: bigint | undefined\n  payload: Uint8Array | undefined\n  attributes: Attribute[]\n\n  constructor(\n    key: Hex,\n    contentType: MimeType | undefined = undefined,\n    owner: Hex | undefined = undefined,\n    creator: Hex | undefined = undefined,\n    expiresAtBlock: bigint | undefined = undefined,\n    createdAtBlock: bigint | undefined = undefined,\n    lastModifiedAtBlock: bigint | undefined = undefined,\n    transactionIndexInBlock: bigint | undefined = undefined,\n    operationIndexInTransaction: bigint | undefined = undefined,\n    payload: Uint8Array | undefined = undefined,\n    attributes: Attribute[],\n  ) {\n    this.key = key\n    this.owner = owner\n    this.creator = creator\n    this.expiresAtBlock = expiresAtBlock\n    this.createdAtBlock = createdAtBlock\n    this.lastModifiedAtBlock = lastModifiedAtBlock\n    this.transactionIndexInBlock = transactionIndexInBlock\n    this.operationIndexInTransaction = operationIndexInTransaction\n    this.payload = payload\n    this.attributes = attributes\n    this.contentType = contentType\n  }\n\n  /**\n   * Converts the entity payload from bytes to a string and returns it.\n   * Throws an error if the payload is undefined, which may occur if the entity was not queried with the withPayload option.\n   * Throws an error if the conversion from bytes to string fails.\n   * @returns The entity payload as a string.\n   */\n  toText(): string {\n    if (this.payload === undefined) {\n      throw new Error(\n        \"Entity has no payload – it was probably queried without withPayload(true) via QueryBuilder\",\n      )\n    }\n    try {\n      return bytesToString(this.payload)\n    } catch (e) {\n      throw new Error(\n        `Failed to convert entity payload to text: ${e instanceof Error ? e.message : String(e)}`,\n        { cause: e },\n      )\n    }\n  }\n\n  /**\n   * Parses the entity payload as JSON and returns the resulting object.\n   * Throws an error if the payload is undefined, which may occur if the entity was not queried with the withPayload option.\n   * Throws an error if the payload is empty or cannot be parsed as JSON.\n   * @returns The parsed JSON object from the entity payload.\n   */\n  toJson(): any {\n    const text = this.toText()\n    if (!text) {\n      throw new Error(\"Entity has empty payload, cannot parse as JSON\")\n    }\n    try {\n      return JSON.parse(text)\n    } catch (e) {\n      throw new Error(\n        `Failed to parse entity payload as JSON: ${e instanceof Error ? e.message : String(e)}`,\n        { cause: e },\n      )\n    }\n  }\n}\n","import { toBytes } from \"viem\"\nimport { Entity } from \"../types/entity\"\nimport type { RpcEntity } from \"../types/rpcSchema\"\nimport { getLogger } from \"./logger\"\n\nconst logger = getLogger(\"utils:entities\")\n\nexport async function entityFromRpcResult(rpcEntity: RpcEntity) {\n  logger(\"entityFromRpcResult %o\", rpcEntity)\n\n  return new Entity(\n    rpcEntity.key,\n    rpcEntity.contentType,\n    rpcEntity.owner,\n    rpcEntity.creator,\n    rpcEntity.expiresAt !== undefined ? BigInt(rpcEntity.expiresAt) : undefined,\n    rpcEntity.createdAtBlock !== undefined ? BigInt(rpcEntity.createdAtBlock) : undefined,\n    rpcEntity.lastModifiedAtBlock !== undefined ? BigInt(rpcEntity.lastModifiedAtBlock) : undefined,\n    rpcEntity.transactionIndexInBlock !== undefined\n      ? BigInt(rpcEntity.transactionIndexInBlock)\n      : undefined,\n    rpcEntity.operationIndexInTransaction !== undefined\n      ? BigInt(rpcEntity.operationIndexInTransaction)\n      : undefined,\n    rpcEntity.value !== undefined ? toBytes(rpcEntity.value) : undefined,\n    [\n      ...(rpcEntity.stringAttributes ?? []).map(({ key, value }) => ({\n        key,\n        value,\n      })),\n      ...(rpcEntity.numericAttributes ?? []).map(({ key, value }) => ({\n        key,\n        value: Number(value),\n      })),\n    ],\n  )\n}\n","import type { Hex } from \"viem\"\nimport { hexToNumber, numberToHex } from \"viem\"\nimport type { ArkivClient } from \"../clients/baseClient\"\nimport type { RpcIncludeData, RpcOrderByAttribute, RpcQueryOptions } from \"../types/rpcSchema\"\nimport { getLogger } from \"../utils/logger\"\nimport type { Predicate } from \"./predicate\"\n\nconst logger = getLogger(\"query:engine\")\n\nfunction processPredicates(predicates: Predicate[]): string {\n  const processValue = (value: string | number) => {\n    if (typeof value === \"string\") {\n      return `\"${value}\"`\n    }\n    return value\n  }\n  return predicates\n    .map((predicate) => {\n      switch (predicate.type) {\n        case \"eq\":\n          return `${predicate.key} = ${processValue(predicate.value)}`\n        case \"neq\":\n          return `${predicate.key} != ${processValue(predicate.value)}`\n        case \"gt\":\n          return `${predicate.key} > ${processValue(predicate.value)}`\n        case \"gte\":\n          return `${predicate.key} >= ${processValue(predicate.value)}`\n        case \"lt\":\n          return `${predicate.key} < ${processValue(predicate.value)}`\n        case \"lte\":\n          return `${predicate.key} <= ${processValue(predicate.value)}`\n        case \"not\":\n          return `!${predicate.key}`\n        case \"or\":\n          return `(${predicate.predicates.map((predicate) => processPredicates([predicate])).join(\" || \")})`\n        case \"and\":\n          return `(${predicate.predicates.map((predicate) => processPredicates([predicate])).join(\" && \")})`\n        default:\n          return \"\"\n      }\n    })\n    .join(\" && \")\n}\n\nexport async function processQuery(\n  client: ArkivClient,\n  queryParams: {\n    predicates: Predicate[]\n    limit: number | undefined\n    cursor: string | undefined\n    ownedBy: Hex | undefined\n    createdBy: Hex | undefined\n    orderBy: RpcOrderByAttribute[] | undefined\n    validAtBlock?: bigint | undefined\n    withAttributes?: boolean | undefined\n    withMetadata?: boolean | undefined\n    withPayload?: boolean | undefined\n    /**\n     * Fully-resolved include-data for fine-grained selection. When provided it takes\n     * precedence over the `withAttributes`/`withMetadata`/`withPayload` booleans.\n     */\n    includeData?: RpcIncludeData | undefined\n  },\n) {\n  const {\n    predicates,\n    limit,\n    cursor,\n    ownedBy,\n    createdBy,\n    orderBy,\n    validAtBlock,\n    withAttributes,\n    withMetadata,\n    withPayload,\n    includeData,\n  } = queryParams\n\n  logger(\"Processing query with params %o\", {\n    predicates,\n    cursor,\n    limit,\n    ownedBy,\n    createdBy,\n    orderBy,\n    validAtBlock,\n    withAttributes,\n    withMetadata,\n    withPayload,\n    includeData,\n  })\n\n  let query = processPredicates(predicates)\n  if (ownedBy) {\n    query += ` && $owner=${ownedBy}`\n  }\n  if (createdBy) {\n    query += ` && $creator=${createdBy}`\n  }\n\n  // remove leading and trailing spaces and leading &&\n  query = query.trim()\n  if (query.startsWith(\"&& \")) {\n    query = query.slice(3)\n  }\n\n  const queryOptions: RpcQueryOptions = {\n    includeData:\n      includeData ??\n      ({\n        key: true,\n        attributes: withAttributes ?? false,\n        payload: withPayload ?? false,\n        contentType: withMetadata ?? false,\n        expiration: withMetadata ?? false,\n        owner: withMetadata ?? false,\n        creator: withMetadata ?? false,\n        createdAtBlock: withMetadata ?? false,\n        lastModifiedAtBlock: withMetadata ?? false,\n        transactionIndexInBlock: withMetadata ?? false,\n        operationIndexInTransaction: withMetadata ?? false,\n      } as RpcIncludeData),\n  }\n\n  if (validAtBlock !== undefined) {\n    queryOptions.atBlock = numberToHex(validAtBlock)\n  }\n  if (limit !== undefined) {\n    queryOptions.resultsPerPage = numberToHex(limit)\n  }\n  if (cursor !== undefined) {\n    queryOptions.cursor = cursor\n  }\n  if (orderBy !== undefined) {\n    queryOptions.orderBy = orderBy\n  }\n\n  logger(\"Built query to send %s %o\", query, {\n    includeData: queryOptions.includeData,\n    atBlock: queryOptions.atBlock ? hexToNumber(queryOptions.atBlock) : undefined,\n    orderBy: queryOptions.orderBy,\n    resultsPerPage: queryOptions.resultsPerPage,\n    cursor: queryOptions.cursor,\n  })\n\n  const result = await client.request({\n    method: \"arkiv_query\",\n    params: [query, queryOptions],\n  })\n  logger(\"Raw result from query %o\", result)\n\n  return result\n}\n","import { NoCursorOrLimitError, NoMoreResultsError } from \"../errors\"\nimport type { Entity } from \"../types/entity\"\nimport { getLogger } from \"../utils/logger\"\nimport type { BaseQueryBuilder } from \"./queryBuilder\"\n\nconst logger = getLogger(\"query:result\")\n\n/**\n * The result of a query. Holds the fetched entities and supports cursor-based pagination.\n *\n * @typeParam TEntity - The shape of each entity, inferred from the query builder\n *   (a full {@link Entity}, or a projected object inferred from a `select()` selection).\n */\nexport class QueryResult<TEntity = Entity> {\n  entities: TEntity[]\n  private _endOfIteration: boolean\n  private _cursor: string | undefined\n  private _limit: number | undefined\n  private _validAtBlock: bigint | undefined\n  private _queryBuilder: BaseQueryBuilder<TEntity>\n\n  // Public getters for internal state\n  get queryBuilder(): BaseQueryBuilder<TEntity> {\n    return this._queryBuilder\n  }\n\n  get cursor(): string | undefined {\n    return this._cursor\n  }\n\n  constructor(\n    entities: TEntity[],\n    queryBuilder: BaseQueryBuilder<TEntity>,\n    cursor: string | undefined,\n    limit: number | undefined,\n    validAtBlock: bigint | undefined,\n  ) {\n    this.entities = entities\n    this._queryBuilder = queryBuilder\n    this._endOfIteration = !limit || entities.length < limit\n    this._cursor = cursor\n    this._limit = limit\n    this._validAtBlock = validAtBlock\n  }\n\n  async next() {\n    if (this._cursor === undefined || this._limit === undefined) {\n      throw new NoCursorOrLimitError()\n    }\n    if (this._endOfIteration) {\n      throw new NoMoreResultsError()\n    }\n    this._queryBuilder.cursor(this._cursor)\n    const result = await this._queryBuilder.fetch()\n    this.entities = result.entities\n    // Update the query builder reference\n    this._queryBuilder = result.queryBuilder\n    // Check if we've reached the end (no more cursor or we got fewer entities than limit)\n    this._endOfIteration = !result.cursor || result.entities.length < this._limit\n    // Update the cursor\n    this._cursor = result.cursor\n\n    // TODO check current block height and if it is not too old\n    logger(\"Current block height for next page %s\", this._validAtBlock?.toString() ?? \"unknown\")\n  }\n\n  hasNextPage() {\n    return !this._endOfIteration\n  }\n}\n","import type { Entity } from \"../types/entity\"\nimport type { RpcIncludeData } from \"../types/rpcSchema\"\n\n/** The entity fields that can be selected. These match the fields of {@link Entity} one-to-one. */\ntype DataKey =\n  | \"key\"\n  | \"contentType\"\n  | \"owner\"\n  | \"creator\"\n  | \"expiresAtBlock\"\n  | \"createdAtBlock\"\n  | \"lastModifiedAtBlock\"\n  | \"transactionIndexInBlock\"\n  | \"operationIndexInTransaction\"\n  | \"attributes\"\n  | \"payload\"\n\n/**\n * The parts of an entity that can be selected. Every field is opt-in (including the `key`) and maps\n * directly to a field of the returned {@link Entity} — the selection is flat.\n */\nexport type SelectionFields = { [K in DataKey]?: boolean }\n\n/**\n * Requires at least one property of `T` to be present.\n * `{}` is not assignable, which is how `select({})` is rejected at compile time.\n */\ntype AtLeastOne<T, K extends keyof T = keyof T> = {\n  [P in K]: Required<Pick<T, P>> & Partial<Omit<T, P>>\n}[K]\n\n/**\n * A non-empty entity selection — the object form accepted by `select()`. At least one field must be\n * selected.\n */\nexport type EntitySelection = AtLeastOne<SelectionFields>\n\n/** Argument accepted by `select()` — a non-empty {@link EntitySelection}, or `\"*\"` for everything. */\nexport type SelectArg = EntitySelection | \"*\"\n\n/**\n * The result of a selection `S`: an {@link Entity} narrowed to exactly the selected fields (each\n * non-`undefined`). The shape is flat and backwards compatible — e.g. `select({ owner: true })`\n * yields `{ owner: Hex }` accessed as `entity.owner`. Accessing an unselected field is a compile\n * error.\n *\n * The `toText()` / `toJson()` helpers operate on the payload, so they are only present when\n * `payload` was selected — calling them otherwise would always throw.\n */\nexport type ProjectedEntity<S> = {\n  readonly [K in keyof S as S[K] extends true ? K : never]: K extends keyof Entity\n    ? NonNullable<Entity[K]>\n    : never\n} & (S extends { payload: true } ? Pick<Entity, \"toText\" | \"toJson\"> : unknown)\n\n/** A selection of every field, used to type the result of `select()` / `select(\"*\")`. */\ntype AllSelected = { [K in DataKey]: true }\n\n/** The projected entity type when everything is selected — every field, plus the methods. */\nexport type FullEntity = ProjectedEntity<AllSelected>\n\n/**\n * Converts a {@link SelectArg} into the {@link RpcIncludeData} understood by the query engine.\n * Every field is opt-in — anything not explicitly selected defaults to `false`, including the key.\n * `undefined` or `\"*\"` selects everything.\n *\n * @param selection - The selection to convert\n * @returns The fully-resolved include-data object for the RPC query\n * @throws If an empty selection object is provided\n *\n * @example\n * selectionToIncludeData() // everything\n * selectionToIncludeData(\"*\") // everything\n * selectionToIncludeData({ key: true }) // only the key\n * selectionToIncludeData({ owner: true }) // only the owner\n */\nexport function selectionToIncludeData(selection?: SelectArg): RpcIncludeData {\n  if (selection === undefined || selection === \"*\") {\n    return {\n      key: true,\n      attributes: true,\n      payload: true,\n      contentType: true,\n      expiration: true,\n      owner: true,\n      creator: true,\n      createdAtBlock: true,\n      lastModifiedAtBlock: true,\n      transactionIndexInBlock: true,\n      operationIndexInTransaction: true,\n    }\n  }\n\n  // At least one field must be opted in. This rejects both `{}` and selections whose fields are\n  // all explicitly `false` (e.g. `select({ key: false })`), which the type system permits.\n  if (!Object.values(selection).some((selected) => selected === true)) {\n    throw new Error(\n      'select() requires at least one field to be selected. Pass select() or select(\"*\") to select everything.',\n    )\n  }\n\n  return {\n    key: selection.key ?? false,\n    attributes: selection.attributes ?? false,\n    payload: selection.payload ?? false,\n    contentType: selection.contentType ?? false,\n    // The selection uses the entity field name `expiresAtBlock`; the RPC calls it `expiration`.\n    expiration: selection.expiresAtBlock ?? false,\n    owner: selection.owner ?? false,\n    creator: selection.creator ?? false,\n    createdAtBlock: selection.createdAtBlock ?? false,\n    lastModifiedAtBlock: selection.lastModifiedAtBlock ?? false,\n    transactionIndexInBlock: selection.transactionIndexInBlock ?? false,\n    operationIndexInTransaction: selection.operationIndexInTransaction ?? false,\n  }\n}\n","import type { Hex } from \"viem\"\nimport type { ArkivClient } from \"../clients/baseClient\"\nimport type { Entity } from \"../types/entity\"\nimport type { RpcEntity, RpcIncludeData, RpcOrderByAttribute } from \"../types/rpcSchema\"\nimport { entityFromRpcResult } from \"../utils/entities\"\nimport { processQuery } from \"./engine\"\nimport type { Predicate } from \"./predicate\"\nimport { QueryResult } from \"./queryResult\"\nimport { type SelectArg, selectionToIncludeData } from \"./selection\"\n\nexport type OrderByAttribute = {\n  name: string\n  type: \"string\" | \"number\"\n  order: \"asc\" | \"desc\"\n}\n\n/**\n * Helper function to create an ascending order by attribute\n * @param attributeName - The name of the attribute to order by\n * @param attributeType - The type of the attribute to order by (string or number)\n * @returns Input for orderBy method\n *\n * @example\n * const ascAttribute = asc(\"name\", \"string\")\n */\nexport function asc(attributeName: string, attributeType: \"string\" | \"number\"): OrderByAttribute {\n  return {\n    name: attributeName,\n    type: attributeType,\n    order: \"asc\",\n  }\n}\n\n/**\n * Helper function to create a descending order by attribute\n * @param attributeName - The name of the attribute to order by\n * @param attributeType - The type of the attribute to order by (string or number)\n * @returns Input for orderBy method\n *\n * @example\n * const descAttribute = desc(\"name\", \"string\")\n */\nexport function desc(attributeName: string, attributeType: \"string\" | \"number\"): OrderByAttribute {\n  return {\n    name: attributeName,\n    type: attributeType,\n    order: \"desc\",\n  }\n}\n\n/**\n * Data-selection parameters forwarded to the query engine on each fetch.\n * Subclasses of {@link BaseQueryBuilder} decide which parts of an entity are fetched.\n */\ntype SelectionParams = {\n  withAttributes?: boolean | undefined\n  withMetadata?: boolean | undefined\n  withPayload?: boolean | undefined\n  includeData?: RpcIncludeData | undefined\n}\n\n/**\n * BaseQueryBuilder holds the query-building logic shared by every query builder\n * (filtering, ordering, pagination, execution). It follows the Builder pattern,\n * allowing methods to be chained. Subclasses decide how data selection is expressed\n * by implementing the protected `selectionParams` method.\n *\n * Use {@link SelectQueryBuilder} via `client.select()` to build and execute queries.\n *\n * @typeParam TEntity - The shape of each entity produced by {@link BaseQueryBuilder.fetch}.\n */\nexport abstract class BaseQueryBuilder<TEntity> {\n  protected _client: ArkivClient\n  protected _ownedBy: Hex | undefined\n  protected _createdBy: Hex | undefined\n  protected _orderBy: RpcOrderByAttribute[] | undefined\n  protected _validAtBlock: bigint | undefined\n  protected _limit: number | undefined\n  protected _cursor: string | undefined\n  protected _predicates: Predicate[]\n\n  constructor(client: ArkivClient) {\n    this._client = client\n    this._predicates = []\n  }\n\n  /**\n   * Sets the ownedBy filter\n   * @param ownedBy - The address of the owner\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.ownedBy(\"0x1234567890123456789012345678901234567890\")\n   */\n  ownedBy(ownedBy: Hex): this {\n    this._ownedBy = ownedBy\n    return this\n  }\n\n  /**\n   * Sets the createdBy filter\n   * @param createdBy - The address of the creator\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.createdBy(\"0x1234567890123456789012345678901234567890\")\n   */\n  createdBy(createdBy: Hex): this {\n    this._createdBy = createdBy\n    return this\n  }\n\n  /**\n   * Sets the orderBy for the query.\n   * It can be called multiple times to order by multiple attributes.\n   * The order of the attributes is important. The first attribute is the primary order by attribute.\n   * You can use the helper functions asc() and desc() as input for this method.\n   * @param attributeName - The name of the attribute to order by\n   * @param attributeType - The type of the attribute to order by (string or number)\n   * @param order - The order to set the order by (asc or desc)\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.orderBy(\"name\", \"string\", \"desc\")\n   * builder.orderBy(asc(\"name\", \"string\"))\n   * builder.orderBy(desc(\"name\", \"string\"))\n   */\n  orderBy(attributeName: string, attributeType: \"string\" | \"number\", order?: \"asc\" | \"desc\"): this\n  /**\n   * Sets the orderBy for the query.\n   * This method takes the OrderByAttribute object as an argument and is mainly\n   * used to use the helper functions asc() and desc() to create the OrderByAttribute instances.\n   * @param orderByAttribute - The OrderByAttribute instance to set\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.orderBy(asc(\"name\", \"string\"))\n   * builder.orderBy(desc(\"name\", \"string\"))\n   */\n  orderBy(orderByAttribute: OrderByAttribute): this\n  orderBy(\n    attributeNameOrOrderByAttribute: string | OrderByAttribute,\n    attributeType?: \"string\" | \"number\",\n    order: \"asc\" | \"desc\" = \"asc\",\n  ): this {\n    if (!this._orderBy) {\n      this._orderBy = []\n    }\n\n    const pushOrderByAttribute = ({ name, type, order }: OrderByAttribute) => {\n      this._orderBy?.push({\n        name,\n        type: type === \"number\" ? \"numeric\" : type,\n        desc: order === \"desc\",\n      })\n    }\n\n    if (typeof attributeNameOrOrderByAttribute === \"string\") {\n      if (!attributeType) {\n        throw new Error(\"attributeType is required when using positional orderBy arguments\")\n      }\n      pushOrderByAttribute({\n        name: attributeNameOrOrderByAttribute,\n        type: attributeType,\n        order,\n      })\n    } else {\n      pushOrderByAttribute(attributeNameOrOrderByAttribute)\n    }\n\n    return this\n  }\n\n  /**\n   * Sets the limit for the query\n   * @param limit - The number of entities to return\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.limit(10)\n   */\n  limit(limit: number): this {\n    this._limit = limit\n    return this\n  }\n\n  /**\n   * Sets the cursor for the query - it is advances setting which rather shouldn't be used manually but it is provided from query result if limit is used (pagination).\n   * @param cursor - The cursor to set which tells to RPC Query server where to start or continue the query.\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.cursor(\"0xABC123\")\n   */\n  cursor(cursor: string): this {\n    this._cursor = cursor\n    return this\n  }\n\n  /**\n   * Sets the validAtBlock for the query which tells at which block height the state we are intested.\n   * If not set, the latest block is  used.\n   * @param validAtBlock - The block number to set\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.validAtBlock(10000)\n   */\n  validAtBlock(validAtBlock: bigint): this {\n    this._validAtBlock = validAtBlock\n    return this\n  }\n\n  /**\n   * Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.\n   * Predicates can be nested using 'or' and 'and' predicates.\n   * @param predicates - The predicates to set\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.where(eq(\"name\", \"John\"))\n   * builder.where([eq(\"name\", \"John\"), eq(\"age\", 30)])\n   * builder.where([eq(\"name\", \"John\"), or([eq(\"age\", 30), eq(\"age\", 31)])])\n   * builder.where([eq(\"name\", \"John\"), and([eq(\"age\", 30), eq(\"age\", 31)])])\n   * builder.where([eq(\"name\", \"John\"), or([eq(\"age\", 30), and([eq(\"age\", 31), eq(\"age\", 32)])])])\n   * builder.where([eq(\"name\", \"John\"), and([eq(\"age\", 30), or([eq(\"age\", 31), eq(\"age\", 32)])])])\n   * builder.where([eq(\"name\", \"John\"), and([eq(\"age\", 30), or([eq(\"age\", 31), and([eq(\"age\", 32), eq(\"age\", 33)])])])])\n   */\n  where(predicates: Predicate[] | Predicate): this {\n    if (Array.isArray(predicates)) {\n      this._predicates.push(...predicates)\n    } else {\n      this._predicates.push(predicates)\n    }\n    return this\n  }\n\n  /**\n   * Returns the data-selection parameters forwarded to the query engine.\n   * Subclasses decide which parts of an entity are fetched.\n   */\n  protected abstract selectionParams(): SelectionParams\n\n  /**\n   * Builds a single result entity from a raw RPC entity. Subclasses decide the produced shape\n   * (a full {@link Entity}, or a projected object inferred from the selection).\n   */\n  protected abstract projectEntity(rpcEntity: RpcEntity): TEntity | Promise<TEntity>\n\n  /**\n   * Fetches the entities from the query.\n   * It will return a QueryResult instance which can be used to fetch the next and previous pages.\n   * @returns The QueryResult instance {@link QueryResult}\n   *\n   * @example\n   * const builder = client.select()\n   * const result = await builder.where(eq(\"name\", \"John\")).fetch()\n   * // result = { entities: [Entity, Entity, Entity], next: async () => QueryResult, previous: async () => QueryResult }\n   */\n  async fetch(): Promise<QueryResult<TEntity>> {\n    const queryResult = await processQuery(this._client, {\n      predicates: this._predicates,\n      limit: this._limit,\n      cursor: this._cursor,\n      ownedBy: this._ownedBy,\n      createdBy: this._createdBy,\n      orderBy: this._orderBy,\n      validAtBlock: this._validAtBlock,\n      ...this.selectionParams(),\n    })\n\n    const entities = await Promise.all(queryResult.data.map((entity) => this.projectEntity(entity)))\n\n    this.cursor(queryResult.cursor)\n    this.validAtBlock(BigInt(queryResult.blockNumber ?? 0))\n\n    return new QueryResult<TEntity>(entities, this, this._cursor, this._limit, this._validAtBlock)\n  }\n\n  /**\n   * Counts the entities from the query.\n   * @returns The number of entities\n   *\n   * @example\n   * const builder = client.select()\n   * const result = await builder.where(eq(\"name\", \"John\")).count()\n   * // result = 10\n   */\n  async count() {\n    const queryResult = await processQuery(this._client, {\n      predicates: this._predicates,\n      limit: this._limit,\n      cursor: this._cursor,\n      ownedBy: this._ownedBy,\n      createdBy: this._createdBy,\n      orderBy: undefined,\n      validAtBlock: this._validAtBlock,\n      withAttributes: false,\n      withMetadata: false,\n      withPayload: false,\n    })\n\n    return queryResult.data.length ?? 0\n  }\n}\n\n/**\n * QueryBuilder is a helper class to build queries to the Arkiv DBChains.\n * It can be used to fetch entities from the Arkiv DBChains. It follows the Builder pattern allowing chaining of methods.\n *\n * By default the result includes only the entity `key`. Additional data is opt-in through\n * `withAttributes()`, `withMetadata()` and `withPayload()`.\n *\n * @deprecated Use {@link SelectQueryBuilder} via `client.select()` instead. Declaring the\n * selection up front avoids the common mistake of forgetting to opt in to data and getting back\n * entities with only their `key` populated. This class remains for backwards compatibility and\n * will be removed in a future release.\n *\n * @param client - The Arkiv client\n * @returns The QueryBuilder instance {@link QueryBuilder}\n */\nexport class QueryBuilder extends BaseQueryBuilder<Entity> {\n  private _withAttributes: boolean | undefined\n  private _withMetadata: boolean | undefined\n  private _withPayload: boolean | undefined\n\n  /**\n   * Sets the withAttributes flag which will return the attributes for the entities if true\n   * @param withAttributes - The boolean value to set\n   * @returns The QueryBuilder instance\n   *\n   * @example\n   * const builder = client.buildQuery()\n   * builder.withAttributes(true)\n   */\n  withAttributes(withAttributes: boolean = true): this {\n    this._withAttributes = withAttributes\n    return this\n  }\n\n  /**\n   * Sets the withMetadata flag which will return the metadata (like owner, expiredAt, etc.) for the entities if true\n   * @param withMetadata - The boolean value to set\n   * @returns The QueryBuilder instance\n   *\n   * @example\n   * const builder = client.buildQuery()\n   * builder.withMetadata(true)\n   */\n  withMetadata(withMetadata: boolean = true): this {\n    this._withMetadata = withMetadata\n    return this\n  }\n\n  /**\n   * Sets the withPayload flag which will return the payload for the entities if true\n   * @param withPayload - The boolean value to set\n   * @returns The QueryBuilder instance\n   *\n   * @example\n   * const builder = client.buildQuery()\n   * builder.withPayload(true)\n   */\n  withPayload(withPayload: boolean = true): this {\n    this._withPayload = withPayload\n    return this\n  }\n\n  protected selectionParams(): SelectionParams {\n    return {\n      withAttributes: this._withAttributes,\n      withMetadata: this._withMetadata,\n      withPayload: this._withPayload,\n    }\n  }\n\n  protected projectEntity(rpcEntity: RpcEntity): Promise<Entity> {\n    return entityFromRpcResult(rpcEntity)\n  }\n}\n\n/**\n * SelectQueryBuilder is the recommended query builder. It requires the selection to be declared\n * up front, so results always contain exactly the data you asked for — and the type of each\n * returned entity is narrowed to exactly the selected fields.\n *\n * The selection is fixed at construction time and is flat — each field maps to an entity field.\n * Create one via `client.select(...)` rather than constructing it directly, so the result type is\n * inferred from the selection.\n *\n * @typeParam TEntity - The projected entity shape, inferred from the selection by `client.select()`.\n *\n * @example\n * // everything\n * await client.select().where(eq(\"name\", \"John\")).fetch()\n * await client.select(\"*\").where(eq(\"name\", \"John\")).fetch()\n * // specific fields\n * await client.select({ owner: true, attributes: true }).fetch()\n * // a single field — result is typed (flat) { owner: Hex }\n * await client.select({ owner: true }).fetch()\n */\nexport class SelectQueryBuilder<TEntity> extends BaseQueryBuilder<TEntity> {\n  private _includeData: RpcIncludeData\n\n  constructor(client: ArkivClient, selection?: SelectArg) {\n    super(client)\n    this._includeData = selectionToIncludeData(selection)\n  }\n\n  protected selectionParams(): SelectionParams {\n    return { includeData: this._includeData }\n  }\n\n  protected async projectEntity(rpcEntity: RpcEntity): Promise<TEntity> {\n    // The runtime value is a full Entity (with methods); the static type is narrowed to the\n    // selected fields via `client.select()`'s inference.\n    return (await entityFromRpcResult(rpcEntity)) as unknown as TEntity\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"queryBuilder-C3XSUYpn.js","names":["enabledNamespaces: Set<string>","disabledNamespaces: Set<string>","logger","logger","predicate","queryOptions: RpcQueryOptions","order"],"sources":["../src/utils/logger.ts","../src/errors.ts","../src/types/entity.ts","../src/utils/entities.ts","../src/query/engine.ts","../src/query/queryResult.ts","../src/query/selection.ts","../src/query/queryBuilder.ts"],"sourcesContent":["const ROOT_NAMESPACE = \"arkiv\"\n\n// Debug logger type - returns a function that can be called to log messages\ntype DebugLogger = (...args: unknown[]) => void\n\n// Get DEBUG environment variable (works in both Node.js and browser)\nfunction getDebugEnv(): string {\n  if (typeof process !== \"undefined\") {\n    const debugEnv = process?.env?.DEBUG\n    if (debugEnv) {\n      return debugEnv\n    }\n  }\n  // Browser: check localStorage\n  if (typeof globalThis !== \"undefined\" && \"localStorage\" in globalThis) {\n    try {\n      const storage = (globalThis as { localStorage?: Storage }).localStorage\n      return storage?.getItem(\"DEBUG\") || \"\"\n    } catch {\n      // localStorage might not be available\n    }\n  }\n  return \"\"\n}\n\n// Parse debug patterns and check if a namespace matches\nfunction matchesPattern(namespace: string, pattern: string): boolean {\n  // Exact match\n  if (pattern === namespace) return true\n\n  // Wildcard match: \"arkiv:*\" matches \"arkiv:query\", \"arkiv:rpc\", etc.\n  if (pattern.endsWith(\"*\")) {\n    const prefix = pattern.slice(0, -1)\n    return namespace.startsWith(prefix)\n  }\n\n  // Negative match: \"-arkiv:query\" excludes \"arkiv:query\"\n  if (pattern.startsWith(\"-\")) {\n    const excludePattern = pattern.slice(1)\n    return !matchesPattern(namespace, excludePattern)\n  }\n\n  return false\n}\n\n// Check if a namespace is enabled for debugging\nfunction isEnabled(namespace: string): boolean {\n  const debugEnv = getDebugEnv()\n  if (!debugEnv) return false\n\n  // Split by comma/space and check each pattern\n  const patterns = debugEnv.split(/[\\s,]+/).filter((p) => p.length > 0)\n\n  // If no patterns, nothing is enabled\n  if (patterns.length === 0) return false\n\n  // Check if any pattern matches (or if explicitly excluded)\n  let enabled = false\n  for (const pattern of patterns) {\n    if (pattern.startsWith(\"-\")) {\n      // Exclude pattern - if it matches, disable\n      if (matchesPattern(namespace, pattern)) {\n        return false\n      }\n    } else if (matchesPattern(namespace, pattern)) {\n      enabled = true\n    }\n  }\n\n  return enabled\n}\n\n// Store enabled namespaces (for programmatic enable/disable)\nconst enabledNamespaces: Set<string> = new Set()\nconst disabledNamespaces: Set<string> = new Set()\n\n// Color palette for namespace coloring (distinct, readable colors)\nconst COLOR_PALETTE = [\n  \"#0000FF\", // blue\n  \"#008000\", // green\n  \"#FF0000\", // red\n  \"#FF00FF\", // magenta\n  \"#FFA500\", // orange\n  \"#800080\", // purple\n  \"#00CED1\", // dark turquoise\n  \"#FF1493\", // deep pink\n  \"#32CD32\", // lime green\n  \"#1E90FF\", // dodger blue\n  \"#FF4500\", // orange red\n  \"#9370DB\", // medium purple\n  \"#00FA9A\", // medium spring green\n  \"#FFD700\", // gold\n  \"#DC143C\", // crimson\n  \"#00BFFF\", // deep sky blue\n  \"#FF69B4\", // hot pink\n  \"#20B2AA\", // light sea green\n  \"#DA70D6\", // orchid\n  \"#4682B4\", // steel blue\n]\n\n// Detect if we're in Node.js (for ANSI colors) or browser (for CSS colors)\nconst isNode = typeof process !== \"undefined\" && process.versions?.node != null\n\n// ANSI color codes for Node.js (bright, distinct colors)\nconst ANSI_COLORS = [\n  \"\\x1b[94m\", // bright blue\n  \"\\x1b[92m\", // bright green\n  \"\\x1b[91m\", // bright red\n  \"\\x1b[95m\", // bright magenta\n  \"\\x1b[93m\", // bright yellow\n  \"\\x1b[96m\", // bright cyan\n  \"\\x1b[35m\", // magenta\n  \"\\x1b[36m\", // cyan\n  \"\\x1b[32m\", // green\n  \"\\x1b[34m\", // blue\n  \"\\x1b[33m\", // yellow\n  \"\\x1b[31m\", // red\n  \"\\x1b[90m\", // bright black (gray)\n  \"\\x1b[37m\", // white\n  \"\\x1b[1m\", // bold (as a color option)\n]\n\nconst ANSI_RESET = \"\\x1b[0m\"\nconst ANSI_BOLD = \"\\x1b[1m\"\n\n// Cache colors for namespaces (same namespace = same color)\nconst namespaceColors = new Map<string, { css: string; ansi: string }>()\n\n// Generate a consistent color for a namespace based on its hash\nfunction getColorForNamespace(namespace: string): { css: string; ansi: string } {\n  // Check cache first\n  const cachedColor = namespaceColors.get(namespace)\n  if (cachedColor) {\n    return cachedColor\n  }\n\n  // Simple hash function to convert string to number\n  let hash = 0\n  for (let i = 0; i < namespace.length; i++) {\n    const char = namespace.charCodeAt(i)\n    hash = (hash << 5) - hash + char\n    hash = hash & hash // Convert to 32-bit integer\n  }\n\n  // Use absolute value and modulo to get index\n  const colorIndex = Math.abs(hash) % COLOR_PALETTE.length\n  const cssColor = COLOR_PALETTE[colorIndex]\n  const ansiColor = ANSI_COLORS[colorIndex % ANSI_COLORS.length]\n\n  const color = { css: cssColor, ansi: ansiColor }\n\n  // Cache the color\n  namespaceColors.set(namespace, color)\n\n  return color\n}\n\n// Create a debug logger function\nfunction createDebugLogger(namespace: string): DebugLogger {\n  // Get the color for this namespace (consistent across calls)\n  const colors = getColorForNamespace(namespace)\n\n  return (...args: unknown[]) => {\n    // Check if enabled via environment variable or programmatically\n    const envEnabled = isEnabled(namespace)\n    const progEnabled = enabledNamespaces.has(namespace) && !disabledNamespaces.has(namespace)\n\n    if (envEnabled || progEnabled) {\n      if (isNode) {\n        // Node.js: use ANSI color codes\n        const coloredNamespace = `${ANSI_BOLD}${colors.ansi}${namespace}${ANSI_RESET}`\n        console.log(coloredNamespace, ...args)\n      } else {\n        // Browser: use CSS styling with %c\n        // The format is: console.log(\"%cstyled%cnormal\", style1, style2, ...args)\n        // This colors the namespace, then resets for the rest\n        const style1 = `color: ${colors.css}; font-weight: bold`\n        const style2 = \"color: inherit; font-weight: normal\"\n        // Combine namespace with a space, then log with styles\n        console.log(`%c${namespace}%c`, style1, style2, ...args)\n      }\n    }\n  }\n}\n\nexport const getLogger = (scope: string): DebugLogger => {\n  const namespace = `${ROOT_NAMESPACE}:${scope}`\n  return createDebugLogger(namespace)\n}\n\nexport const enableDebug = (namespaces: string): void => {\n  // Parse and add namespaces to enabled set\n  const patterns = namespaces.split(/[\\s,]+/).filter((p) => p.length > 0)\n  for (const pattern of patterns) {\n    if (pattern.startsWith(\"-\")) {\n      // Remove from enabled, add to disabled\n      const namespace = pattern.slice(1)\n      enabledNamespaces.delete(namespace)\n      disabledNamespaces.add(namespace)\n    } else {\n      enabledNamespaces.add(pattern)\n      disabledNamespaces.delete(pattern)\n    }\n  }\n}\n\nexport const disableDebug = (): void => {\n  enabledNamespaces.clear()\n  disabledNamespaces.clear()\n}\n","import { BLOCK_TIME } from \"./consts\"\n\nexport class EntityMutationError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = \"EntityMutationError\"\n  }\n}\nexport class InvalidExpirationError extends Error {\n  constructor(expiresIn: unknown) {\n    super(\n      `Invalid expiresIn: ${String(expiresIn)}. expiresIn must be a positive integer and a multiple of the Arkiv block time (${BLOCK_TIME} seconds), because expiration is measured in whole blocks (1 block = ${BLOCK_TIME} seconds).`,\n    )\n    this.name = \"InvalidExpirationError\"\n  }\n}\nexport class InvalidAttributeError extends Error {\n  constructor(key: string, value: number) {\n    super(\n      `Invalid numeric value for attribute \"${key}\": ${String(value)}. Numeric attribute values must be integers. To keep numeric ordering/range queries, scale it to an integer (e.g. Math.round(${String(value)} * 1000), dividing by 1000 on read); otherwise store it as a string (e.g. \"${String(value)}\").`,\n    )\n    this.name = \"InvalidAttributeError\"\n  }\n}\n\nexport class NoMoreResultsError extends Error {\n  constructor() {\n    super(\"No more results\")\n    this.name = \"NoMoreResultsError\"\n  }\n}\n\nexport class NoCursorOrLimitError extends Error {\n  constructor() {\n    super(\"Cursor and limit must be defined to fetch next\")\n    this.name = \"NoCursorOrLimitError\"\n  }\n}\n\nexport class NoEntityFoundError extends Error {\n  constructor() {\n    super(\"No entity found\")\n    this.name = \"NoEntityFoundError\"\n  }\n}\n","import { bytesToString, type Hex } from \"viem\"\nimport type { MimeType } from \"../types\"\nimport type { Attribute } from \"./attributes\"\n\nexport class Entity {\n  key: Hex\n  contentType: MimeType | undefined\n  owner: Hex | undefined\n  creator: Hex | undefined\n  expiresAtBlock: bigint | undefined\n  createdAtBlock: bigint | undefined\n  lastModifiedAtBlock: bigint | undefined\n  transactionIndexInBlock: bigint | undefined\n  operationIndexInTransaction: bigint | undefined\n  payload: Uint8Array | undefined\n  attributes: Attribute[]\n\n  constructor(\n    key: Hex,\n    contentType: MimeType | undefined = undefined,\n    owner: Hex | undefined = undefined,\n    creator: Hex | undefined = undefined,\n    expiresAtBlock: bigint | undefined = undefined,\n    createdAtBlock: bigint | undefined = undefined,\n    lastModifiedAtBlock: bigint | undefined = undefined,\n    transactionIndexInBlock: bigint | undefined = undefined,\n    operationIndexInTransaction: bigint | undefined = undefined,\n    payload: Uint8Array | undefined = undefined,\n    attributes: Attribute[],\n  ) {\n    this.key = key\n    this.owner = owner\n    this.creator = creator\n    this.expiresAtBlock = expiresAtBlock\n    this.createdAtBlock = createdAtBlock\n    this.lastModifiedAtBlock = lastModifiedAtBlock\n    this.transactionIndexInBlock = transactionIndexInBlock\n    this.operationIndexInTransaction = operationIndexInTransaction\n    this.payload = payload\n    this.attributes = attributes\n    this.contentType = contentType\n  }\n\n  /**\n   * Converts the entity payload from bytes to a string and returns it.\n   * Throws an error if the payload is undefined, which may occur if the entity was not queried with the withPayload option.\n   * Throws an error if the conversion from bytes to string fails.\n   * @returns The entity payload as a string.\n   */\n  toText(): string {\n    if (this.payload === undefined) {\n      throw new Error(\n        \"Entity has no payload – it was probably queried without withPayload(true) via QueryBuilder\",\n      )\n    }\n    try {\n      return bytesToString(this.payload)\n    } catch (e) {\n      throw new Error(\n        `Failed to convert entity payload to text: ${e instanceof Error ? e.message : String(e)}`,\n        { cause: e },\n      )\n    }\n  }\n\n  /**\n   * Parses the entity payload as JSON and returns the resulting object.\n   * Throws an error if the payload is undefined, which may occur if the entity was not queried with the withPayload option.\n   * Throws an error if the payload is empty or cannot be parsed as JSON.\n   * @returns The parsed JSON object from the entity payload.\n   */\n  toJson(): any {\n    const text = this.toText()\n    if (!text) {\n      throw new Error(\"Entity has empty payload, cannot parse as JSON\")\n    }\n    try {\n      return JSON.parse(text)\n    } catch (e) {\n      throw new Error(\n        `Failed to parse entity payload as JSON: ${e instanceof Error ? e.message : String(e)}`,\n        { cause: e },\n      )\n    }\n  }\n}\n","import { toBytes } from \"viem\"\nimport { Entity } from \"../types/entity\"\nimport type { RpcEntity } from \"../types/rpcSchema\"\nimport { getLogger } from \"./logger\"\n\nconst logger = getLogger(\"utils:entities\")\n\nexport async function entityFromRpcResult(rpcEntity: RpcEntity) {\n  logger(\"entityFromRpcResult %o\", rpcEntity)\n\n  return new Entity(\n    rpcEntity.key,\n    rpcEntity.contentType,\n    rpcEntity.owner,\n    rpcEntity.creator,\n    rpcEntity.expiresAt !== undefined ? BigInt(rpcEntity.expiresAt) : undefined,\n    rpcEntity.createdAtBlock !== undefined ? BigInt(rpcEntity.createdAtBlock) : undefined,\n    rpcEntity.lastModifiedAtBlock !== undefined ? BigInt(rpcEntity.lastModifiedAtBlock) : undefined,\n    rpcEntity.transactionIndexInBlock !== undefined\n      ? BigInt(rpcEntity.transactionIndexInBlock)\n      : undefined,\n    rpcEntity.operationIndexInTransaction !== undefined\n      ? BigInt(rpcEntity.operationIndexInTransaction)\n      : undefined,\n    rpcEntity.value !== undefined ? toBytes(rpcEntity.value) : undefined,\n    [\n      ...(rpcEntity.stringAttributes ?? []).map(({ key, value }) => ({\n        key,\n        value,\n      })),\n      ...(rpcEntity.numericAttributes ?? []).map(({ key, value }) => ({\n        key,\n        value: Number(value),\n      })),\n    ],\n  )\n}\n","import type { Hex } from \"viem\"\nimport { hexToNumber, numberToHex } from \"viem\"\nimport type { ArkivClient } from \"../clients/baseClient\"\nimport type { RpcIncludeData, RpcOrderByAttribute, RpcQueryOptions } from \"../types/rpcSchema\"\nimport { getLogger } from \"../utils/logger\"\nimport type { Predicate } from \"./predicate\"\n\nconst logger = getLogger(\"query:engine\")\n\nfunction processPredicates(predicates: Predicate[]): string {\n  const processValue = (value: string | number) => {\n    if (typeof value === \"string\") {\n      return `\"${value}\"`\n    }\n    return value\n  }\n  return predicates\n    .map((predicate) => {\n      switch (predicate.type) {\n        case \"eq\":\n          return `${predicate.key} = ${processValue(predicate.value)}`\n        case \"neq\":\n          return `${predicate.key} != ${processValue(predicate.value)}`\n        case \"gt\":\n          return `${predicate.key} > ${processValue(predicate.value)}`\n        case \"gte\":\n          return `${predicate.key} >= ${processValue(predicate.value)}`\n        case \"lt\":\n          return `${predicate.key} < ${processValue(predicate.value)}`\n        case \"lte\":\n          return `${predicate.key} <= ${processValue(predicate.value)}`\n        case \"not\":\n          return `!${predicate.key}`\n        case \"or\":\n          return `(${predicate.predicates.map((predicate) => processPredicates([predicate])).join(\" || \")})`\n        case \"and\":\n          return `(${predicate.predicates.map((predicate) => processPredicates([predicate])).join(\" && \")})`\n        default:\n          return \"\"\n      }\n    })\n    .join(\" && \")\n}\n\nexport async function processQuery(\n  client: ArkivClient,\n  queryParams: {\n    predicates: Predicate[]\n    limit: number | undefined\n    cursor: string | undefined\n    ownedBy: Hex | undefined\n    createdBy: Hex | undefined\n    orderBy: RpcOrderByAttribute[] | undefined\n    validAtBlock?: bigint | undefined\n    withAttributes?: boolean | undefined\n    withMetadata?: boolean | undefined\n    withPayload?: boolean | undefined\n    /**\n     * Fully-resolved include-data for fine-grained selection. When provided it takes\n     * precedence over the `withAttributes`/`withMetadata`/`withPayload` booleans.\n     */\n    includeData?: RpcIncludeData | undefined\n  },\n) {\n  const {\n    predicates,\n    limit,\n    cursor,\n    ownedBy,\n    createdBy,\n    orderBy,\n    validAtBlock,\n    withAttributes,\n    withMetadata,\n    withPayload,\n    includeData,\n  } = queryParams\n\n  logger(\"Processing query with params %o\", {\n    predicates,\n    cursor,\n    limit,\n    ownedBy,\n    createdBy,\n    orderBy,\n    validAtBlock,\n    withAttributes,\n    withMetadata,\n    withPayload,\n    includeData,\n  })\n\n  let query = processPredicates(predicates)\n  if (ownedBy) {\n    query += ` && $owner=${ownedBy}`\n  }\n  if (createdBy) {\n    query += ` && $creator=${createdBy}`\n  }\n\n  // remove leading and trailing spaces and leading &&\n  query = query.trim()\n  if (query.startsWith(\"&& \")) {\n    query = query.slice(3)\n  }\n\n  const queryOptions: RpcQueryOptions = {\n    includeData:\n      includeData ??\n      ({\n        key: true,\n        attributes: withAttributes ?? false,\n        payload: withPayload ?? false,\n        contentType: withMetadata ?? false,\n        expiration: withMetadata ?? false,\n        owner: withMetadata ?? false,\n        creator: withMetadata ?? false,\n        createdAtBlock: withMetadata ?? false,\n        lastModifiedAtBlock: withMetadata ?? false,\n        transactionIndexInBlock: withMetadata ?? false,\n        operationIndexInTransaction: withMetadata ?? false,\n      } as RpcIncludeData),\n  }\n\n  if (validAtBlock !== undefined) {\n    queryOptions.atBlock = numberToHex(validAtBlock)\n  }\n  if (limit !== undefined) {\n    queryOptions.resultsPerPage = numberToHex(limit)\n  }\n  if (cursor !== undefined) {\n    queryOptions.cursor = cursor\n  }\n  if (orderBy !== undefined) {\n    queryOptions.orderBy = orderBy\n  }\n\n  logger(\"Built query to send %s %o\", query, {\n    includeData: queryOptions.includeData,\n    atBlock: queryOptions.atBlock ? hexToNumber(queryOptions.atBlock) : undefined,\n    orderBy: queryOptions.orderBy,\n    resultsPerPage: queryOptions.resultsPerPage,\n    cursor: queryOptions.cursor,\n  })\n\n  const result = await client.request({\n    method: \"arkiv_query\",\n    params: [query, queryOptions],\n  })\n  logger(\"Raw result from query %o\", result)\n\n  return result\n}\n","import { NoCursorOrLimitError, NoMoreResultsError } from \"../errors\"\nimport type { Entity } from \"../types/entity\"\nimport { getLogger } from \"../utils/logger\"\nimport type { BaseQueryBuilder } from \"./queryBuilder\"\n\nconst logger = getLogger(\"query:result\")\n\n/**\n * The result of a query. Holds the fetched entities and supports cursor-based pagination.\n *\n * @typeParam TEntity - The shape of each entity, inferred from the query builder\n *   (a full {@link Entity}, or a projected object inferred from a `select()` selection).\n */\nexport class QueryResult<TEntity = Entity> {\n  entities: TEntity[]\n  private _endOfIteration: boolean\n  private _cursor: string | undefined\n  private _limit: number | undefined\n  private _validAtBlock: bigint | undefined\n  private _queryBuilder: BaseQueryBuilder<TEntity>\n\n  // Public getters for internal state\n  get queryBuilder(): BaseQueryBuilder<TEntity> {\n    return this._queryBuilder\n  }\n\n  get cursor(): string | undefined {\n    return this._cursor\n  }\n\n  constructor(\n    entities: TEntity[],\n    queryBuilder: BaseQueryBuilder<TEntity>,\n    cursor: string | undefined,\n    limit: number | undefined,\n    validAtBlock: bigint | undefined,\n  ) {\n    this.entities = entities\n    this._queryBuilder = queryBuilder\n    this._endOfIteration = !limit || entities.length < limit\n    this._cursor = cursor\n    this._limit = limit\n    this._validAtBlock = validAtBlock\n  }\n\n  async next() {\n    if (this._cursor === undefined || this._limit === undefined) {\n      throw new NoCursorOrLimitError()\n    }\n    if (this._endOfIteration) {\n      throw new NoMoreResultsError()\n    }\n    this._queryBuilder.cursor(this._cursor)\n    const result = await this._queryBuilder.fetch()\n    this.entities = result.entities\n    // Update the query builder reference\n    this._queryBuilder = result.queryBuilder\n    // Check if we've reached the end (no more cursor or we got fewer entities than limit)\n    this._endOfIteration = !result.cursor || result.entities.length < this._limit\n    // Update the cursor\n    this._cursor = result.cursor\n\n    // TODO check current block height and if it is not too old\n    logger(\"Current block height for next page %s\", this._validAtBlock?.toString() ?? \"unknown\")\n  }\n\n  hasNextPage() {\n    return !this._endOfIteration\n  }\n}\n","import type { Entity } from \"../types/entity\"\nimport type { RpcIncludeData } from \"../types/rpcSchema\"\n\n/** The entity fields that can be selected. These match the fields of {@link Entity} one-to-one. */\ntype DataKey =\n  | \"key\"\n  | \"contentType\"\n  | \"owner\"\n  | \"creator\"\n  | \"expiresAtBlock\"\n  | \"createdAtBlock\"\n  | \"lastModifiedAtBlock\"\n  | \"transactionIndexInBlock\"\n  | \"operationIndexInTransaction\"\n  | \"attributes\"\n  | \"payload\"\n\n/**\n * The parts of an entity that can be selected. Every field is opt-in (including the `key`) and maps\n * directly to a field of the returned {@link Entity} — the selection is flat.\n */\nexport type SelectionFields = { [K in DataKey]?: boolean }\n\n/**\n * Requires at least one property of `T` to be present.\n * `{}` is not assignable, which is how `select({})` is rejected at compile time.\n */\ntype AtLeastOne<T, K extends keyof T = keyof T> = {\n  [P in K]: Required<Pick<T, P>> & Partial<Omit<T, P>>\n}[K]\n\n/**\n * A non-empty entity selection — the object form accepted by `select()`. At least one field must be\n * selected.\n */\nexport type EntitySelection = AtLeastOne<SelectionFields>\n\n/** Argument accepted by `select()` — a non-empty {@link EntitySelection}, or `\"*\"` for everything. */\nexport type SelectArg = EntitySelection | \"*\"\n\n/**\n * The result of a selection `S`: an {@link Entity} narrowed to exactly the selected fields (each\n * non-`undefined`). The shape is flat and backwards compatible — e.g. `select({ owner: true })`\n * yields `{ owner: Hex }` accessed as `entity.owner`. Accessing an unselected field is a compile\n * error.\n *\n * The `toText()` / `toJson()` helpers operate on the payload, so they are only present when\n * `payload` was selected — calling them otherwise would always throw.\n */\nexport type ProjectedEntity<S> = {\n  readonly [K in keyof S as S[K] extends true ? K : never]: K extends keyof Entity\n    ? NonNullable<Entity[K]>\n    : never\n} & (S extends { payload: true } ? Pick<Entity, \"toText\" | \"toJson\"> : unknown)\n\n/** A selection of every field, used to type the result of `select()` / `select(\"*\")`. */\ntype AllSelected = { [K in DataKey]: true }\n\n/** The projected entity type when everything is selected — every field, plus the methods. */\nexport type FullEntity = ProjectedEntity<AllSelected>\n\n/**\n * Converts a {@link SelectArg} into the {@link RpcIncludeData} understood by the query engine.\n * Every field is opt-in — anything not explicitly selected defaults to `false`, including the key.\n * `undefined` or `\"*\"` selects everything.\n *\n * @param selection - The selection to convert\n * @returns The fully-resolved include-data object for the RPC query\n * @throws If an empty selection object is provided\n *\n * @example\n * selectionToIncludeData() // everything\n * selectionToIncludeData(\"*\") // everything\n * selectionToIncludeData({ key: true }) // only the key\n * selectionToIncludeData({ owner: true }) // only the owner\n */\nexport function selectionToIncludeData(selection?: SelectArg): RpcIncludeData {\n  if (selection === undefined || selection === \"*\") {\n    return {\n      key: true,\n      attributes: true,\n      payload: true,\n      contentType: true,\n      expiration: true,\n      owner: true,\n      creator: true,\n      createdAtBlock: true,\n      lastModifiedAtBlock: true,\n      transactionIndexInBlock: true,\n      operationIndexInTransaction: true,\n    }\n  }\n\n  // At least one field must be opted in. This rejects both `{}` and selections whose fields are\n  // all explicitly `false` (e.g. `select({ key: false })`), which the type system permits.\n  if (!Object.values(selection).some((selected) => selected === true)) {\n    throw new Error(\n      'select() requires at least one field to be selected. Pass select() or select(\"*\") to select everything.',\n    )\n  }\n\n  return {\n    key: selection.key ?? false,\n    attributes: selection.attributes ?? false,\n    payload: selection.payload ?? false,\n    contentType: selection.contentType ?? false,\n    // The selection uses the entity field name `expiresAtBlock`; the RPC calls it `expiration`.\n    expiration: selection.expiresAtBlock ?? false,\n    owner: selection.owner ?? false,\n    creator: selection.creator ?? false,\n    createdAtBlock: selection.createdAtBlock ?? false,\n    lastModifiedAtBlock: selection.lastModifiedAtBlock ?? false,\n    transactionIndexInBlock: selection.transactionIndexInBlock ?? false,\n    operationIndexInTransaction: selection.operationIndexInTransaction ?? false,\n  }\n}\n","import type { Hex } from \"viem\"\nimport type { ArkivClient } from \"../clients/baseClient\"\nimport type { Entity } from \"../types/entity\"\nimport type { RpcEntity, RpcIncludeData, RpcOrderByAttribute } from \"../types/rpcSchema\"\nimport { entityFromRpcResult } from \"../utils/entities\"\nimport { processQuery } from \"./engine\"\nimport type { Predicate } from \"./predicate\"\nimport { QueryResult } from \"./queryResult\"\nimport { type SelectArg, selectionToIncludeData } from \"./selection\"\n\nexport type OrderByAttribute = {\n  name: string\n  type: \"string\" | \"number\"\n  order: \"asc\" | \"desc\"\n}\n\n/**\n * Helper function to create an ascending order by attribute\n * @param attributeName - The name of the attribute to order by\n * @param attributeType - The type of the attribute to order by (string or number)\n * @returns Input for orderBy method\n *\n * @example\n * const ascAttribute = asc(\"name\", \"string\")\n */\nexport function asc(attributeName: string, attributeType: \"string\" | \"number\"): OrderByAttribute {\n  return {\n    name: attributeName,\n    type: attributeType,\n    order: \"asc\",\n  }\n}\n\n/**\n * Helper function to create a descending order by attribute\n * @param attributeName - The name of the attribute to order by\n * @param attributeType - The type of the attribute to order by (string or number)\n * @returns Input for orderBy method\n *\n * @example\n * const descAttribute = desc(\"name\", \"string\")\n */\nexport function desc(attributeName: string, attributeType: \"string\" | \"number\"): OrderByAttribute {\n  return {\n    name: attributeName,\n    type: attributeType,\n    order: \"desc\",\n  }\n}\n\n/**\n * Data-selection parameters forwarded to the query engine on each fetch.\n * Subclasses of {@link BaseQueryBuilder} decide which parts of an entity are fetched.\n */\ntype SelectionParams = {\n  withAttributes?: boolean | undefined\n  withMetadata?: boolean | undefined\n  withPayload?: boolean | undefined\n  includeData?: RpcIncludeData | undefined\n}\n\n/**\n * BaseQueryBuilder holds the query-building logic shared by every query builder\n * (filtering, ordering, pagination, execution). It follows the Builder pattern,\n * allowing methods to be chained. Subclasses decide how data selection is expressed\n * by implementing the protected `selectionParams` method.\n *\n * Use {@link SelectQueryBuilder} via `client.select()` to build and execute queries.\n *\n * @typeParam TEntity - The shape of each entity produced by {@link BaseQueryBuilder.fetch}.\n */\nexport abstract class BaseQueryBuilder<TEntity> {\n  protected _client: ArkivClient\n  protected _ownedBy: Hex | undefined\n  protected _createdBy: Hex | undefined\n  protected _orderBy: RpcOrderByAttribute[] | undefined\n  protected _validAtBlock: bigint | undefined\n  protected _limit: number | undefined\n  protected _cursor: string | undefined\n  protected _predicates: Predicate[]\n\n  constructor(client: ArkivClient) {\n    this._client = client\n    this._predicates = []\n  }\n\n  /**\n   * Sets the ownedBy filter\n   * @param ownedBy - The address of the owner\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.ownedBy(\"0x1234567890123456789012345678901234567890\")\n   */\n  ownedBy(ownedBy: Hex): this {\n    this._ownedBy = ownedBy\n    return this\n  }\n\n  /**\n   * Sets the createdBy filter\n   * @param createdBy - The address of the creator\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.createdBy(\"0x1234567890123456789012345678901234567890\")\n   */\n  createdBy(createdBy: Hex): this {\n    this._createdBy = createdBy\n    return this\n  }\n\n  /**\n   * Sets the orderBy for the query.\n   * It can be called multiple times to order by multiple attributes.\n   * The order of the attributes is important. The first attribute is the primary order by attribute.\n   * You can use the helper functions asc() and desc() as input for this method.\n   * @param attributeName - The name of the attribute to order by\n   * @param attributeType - The type of the attribute to order by (string or number)\n   * @param order - The order to set the order by (asc or desc)\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.orderBy(\"name\", \"string\", \"desc\")\n   * builder.orderBy(asc(\"name\", \"string\"))\n   * builder.orderBy(desc(\"name\", \"string\"))\n   */\n  orderBy(attributeName: string, attributeType: \"string\" | \"number\", order?: \"asc\" | \"desc\"): this\n  /**\n   * Sets the orderBy for the query.\n   * This method takes the OrderByAttribute object as an argument and is mainly\n   * used to use the helper functions asc() and desc() to create the OrderByAttribute instances.\n   * @param orderByAttribute - The OrderByAttribute instance to set\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.orderBy(asc(\"name\", \"string\"))\n   * builder.orderBy(desc(\"name\", \"string\"))\n   */\n  orderBy(orderByAttribute: OrderByAttribute): this\n  orderBy(\n    attributeNameOrOrderByAttribute: string | OrderByAttribute,\n    attributeType?: \"string\" | \"number\",\n    order: \"asc\" | \"desc\" = \"asc\",\n  ): this {\n    if (!this._orderBy) {\n      this._orderBy = []\n    }\n\n    const pushOrderByAttribute = ({ name, type, order }: OrderByAttribute) => {\n      this._orderBy?.push({\n        name,\n        type: type === \"number\" ? \"numeric\" : type,\n        desc: order === \"desc\",\n      })\n    }\n\n    if (typeof attributeNameOrOrderByAttribute === \"string\") {\n      if (!attributeType) {\n        throw new Error(\"attributeType is required when using positional orderBy arguments\")\n      }\n      pushOrderByAttribute({\n        name: attributeNameOrOrderByAttribute,\n        type: attributeType,\n        order,\n      })\n    } else {\n      pushOrderByAttribute(attributeNameOrOrderByAttribute)\n    }\n\n    return this\n  }\n\n  /**\n   * Sets the limit for the query\n   * @param limit - The number of entities to return\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.limit(10)\n   */\n  limit(limit: number): this {\n    this._limit = limit\n    return this\n  }\n\n  /**\n   * Sets the cursor for the query - it is advances setting which rather shouldn't be used manually but it is provided from query result if limit is used (pagination).\n   * @param cursor - The cursor to set which tells to RPC Query server where to start or continue the query.\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.cursor(\"0xABC123\")\n   */\n  cursor(cursor: string): this {\n    this._cursor = cursor\n    return this\n  }\n\n  /**\n   * Sets the validAtBlock for the query which tells at which block height the state we are intested.\n   * If not set, the latest block is  used.\n   * @param validAtBlock - The block number to set\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.validAtBlock(10000)\n   */\n  validAtBlock(validAtBlock: bigint): this {\n    this._validAtBlock = validAtBlock\n    return this\n  }\n\n  /**\n   * Sets the predicates for the query limiting the results. It can be a single predicate,\n   * multiple predicates passed as separate arguments, or an array of predicates - all combined with 'and'.\n   * Predicates can be nested using 'or' and 'and' predicates.\n   * @param predicates - The predicates to set, either as a single array or as separate arguments\n   * @returns The query builder instance\n   *\n   * @example\n   * const builder = client.select()\n   * builder.where(eq(\"name\", \"John\"))\n   * builder.where(eq(\"name\", \"John\"), eq(\"age\", 30))\n   * builder.where([eq(\"name\", \"John\"), eq(\"age\", 30)])\n   * builder.where(eq(\"name\", \"John\"), or(eq(\"age\", 30), eq(\"age\", 31)))\n   * builder.where(eq(\"name\", \"John\"), and(eq(\"age\", 30), eq(\"age\", 31)))\n   * builder.where(eq(\"name\", \"John\"), or(eq(\"age\", 30), and(eq(\"age\", 31), eq(\"age\", 32))))\n   * builder.where(eq(\"name\", \"John\"), and(eq(\"age\", 30), or(eq(\"age\", 31), eq(\"age\", 32))))\n   */\n  where(predicates: Predicate[]): this\n  where(...predicates: Predicate[]): this\n  where(...predicates: (Predicate | Predicate[])[]) {\n    this._predicates.push(...predicates.flat())\n    return this\n  }\n\n  /**\n   * Returns the data-selection parameters forwarded to the query engine.\n   * Subclasses decide which parts of an entity are fetched.\n   */\n  protected abstract selectionParams(): SelectionParams\n\n  /**\n   * Builds a single result entity from a raw RPC entity. Subclasses decide the produced shape\n   * (a full {@link Entity}, or a projected object inferred from the selection).\n   */\n  protected abstract projectEntity(rpcEntity: RpcEntity): TEntity | Promise<TEntity>\n\n  /**\n   * Fetches the entities from the query.\n   * It will return a QueryResult instance which can be used to fetch the next and previous pages.\n   * @returns The QueryResult instance {@link QueryResult}\n   *\n   * @example\n   * const builder = client.select()\n   * const result = await builder.where(eq(\"name\", \"John\")).fetch()\n   * // result = { entities: [Entity, Entity, Entity], next: async () => QueryResult, previous: async () => QueryResult }\n   */\n  async fetch(): Promise<QueryResult<TEntity>> {\n    const queryResult = await processQuery(this._client, {\n      predicates: this._predicates,\n      limit: this._limit,\n      cursor: this._cursor,\n      ownedBy: this._ownedBy,\n      createdBy: this._createdBy,\n      orderBy: this._orderBy,\n      validAtBlock: this._validAtBlock,\n      ...this.selectionParams(),\n    })\n\n    const entities = await Promise.all(queryResult.data.map((entity) => this.projectEntity(entity)))\n\n    this.cursor(queryResult.cursor)\n    this.validAtBlock(BigInt(queryResult.blockNumber ?? 0))\n\n    return new QueryResult<TEntity>(entities, this, this._cursor, this._limit, this._validAtBlock)\n  }\n\n  /**\n   * Counts the entities from the query.\n   * @returns The number of entities\n   *\n   * @example\n   * const builder = client.select()\n   * const result = await builder.where(eq(\"name\", \"John\")).count()\n   * // result = 10\n   */\n  async count() {\n    const queryResult = await processQuery(this._client, {\n      predicates: this._predicates,\n      limit: this._limit,\n      cursor: this._cursor,\n      ownedBy: this._ownedBy,\n      createdBy: this._createdBy,\n      orderBy: undefined,\n      validAtBlock: this._validAtBlock,\n      withAttributes: false,\n      withMetadata: false,\n      withPayload: false,\n    })\n\n    return queryResult.data.length ?? 0\n  }\n}\n\n/**\n * QueryBuilder is a helper class to build queries to the Arkiv DBChains.\n * It can be used to fetch entities from the Arkiv DBChains. It follows the Builder pattern allowing chaining of methods.\n *\n * By default the result includes only the entity `key`. Additional data is opt-in through\n * `withAttributes()`, `withMetadata()` and `withPayload()`.\n *\n * @deprecated Use {@link SelectQueryBuilder} via `client.select()` instead. Declaring the\n * selection up front avoids the common mistake of forgetting to opt in to data and getting back\n * entities with only their `key` populated. This class remains for backwards compatibility and\n * will be removed in a future release.\n *\n * @param client - The Arkiv client\n * @returns The QueryBuilder instance {@link QueryBuilder}\n */\nexport class QueryBuilder extends BaseQueryBuilder<Entity> {\n  private _withAttributes: boolean | undefined\n  private _withMetadata: boolean | undefined\n  private _withPayload: boolean | undefined\n\n  /**\n   * Sets the withAttributes flag which will return the attributes for the entities if true\n   * @param withAttributes - The boolean value to set\n   * @returns The QueryBuilder instance\n   *\n   * @example\n   * const builder = client.buildQuery()\n   * builder.withAttributes(true)\n   */\n  withAttributes(withAttributes: boolean = true): this {\n    this._withAttributes = withAttributes\n    return this\n  }\n\n  /**\n   * Sets the withMetadata flag which will return the metadata (like owner, expiredAt, etc.) for the entities if true\n   * @param withMetadata - The boolean value to set\n   * @returns The QueryBuilder instance\n   *\n   * @example\n   * const builder = client.buildQuery()\n   * builder.withMetadata(true)\n   */\n  withMetadata(withMetadata: boolean = true): this {\n    this._withMetadata = withMetadata\n    return this\n  }\n\n  /**\n   * Sets the withPayload flag which will return the payload for the entities if true\n   * @param withPayload - The boolean value to set\n   * @returns The QueryBuilder instance\n   *\n   * @example\n   * const builder = client.buildQuery()\n   * builder.withPayload(true)\n   */\n  withPayload(withPayload: boolean = true): this {\n    this._withPayload = withPayload\n    return this\n  }\n\n  protected selectionParams(): SelectionParams {\n    return {\n      withAttributes: this._withAttributes,\n      withMetadata: this._withMetadata,\n      withPayload: this._withPayload,\n    }\n  }\n\n  protected projectEntity(rpcEntity: RpcEntity): Promise<Entity> {\n    return entityFromRpcResult(rpcEntity)\n  }\n}\n\n/**\n * SelectQueryBuilder is the recommended query builder. It requires the selection to be declared\n * up front, so results always contain exactly the data you asked for — and the type of each\n * returned entity is narrowed to exactly the selected fields.\n *\n * The selection is fixed at construction time and is flat — each field maps to an entity field.\n * Create one via `client.select(...)` rather than constructing it directly, so the result type is\n * inferred from the selection.\n *\n * @typeParam TEntity - The projected entity shape, inferred from the selection by `client.select()`.\n *\n * @example\n * // everything\n * await client.select().where(eq(\"name\", \"John\")).fetch()\n * await client.select(\"*\").where(eq(\"name\", \"John\")).fetch()\n * // specific fields\n * await client.select({ owner: true, attributes: true }).fetch()\n * // a single field — result is typed (flat) { owner: Hex }\n * await client.select({ owner: true }).fetch()\n */\nexport class SelectQueryBuilder<TEntity> extends BaseQueryBuilder<TEntity> {\n  private _includeData: RpcIncludeData\n\n  constructor(client: ArkivClient, selection?: SelectArg) {\n    super(client)\n    this._includeData = selectionToIncludeData(selection)\n  }\n\n  protected selectionParams(): SelectionParams {\n    return { includeData: this._includeData }\n  }\n\n  protected async projectEntity(rpcEntity: RpcEntity): Promise<TEntity> {\n    // The runtime value is a full Entity (with methods); the static type is narrowed to the\n    // selected fields via `client.select()`'s inference.\n    return (await entityFromRpcResult(rpcEntity)) as unknown as TEntity\n  }\n}\n"],"mappings":"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"}

package/dist/{queryBuilder-CTPwve9u.cjs → queryBuilder-K0ZkQGnx.cjs}

@@ -534,25 +534,8 @@ var BaseQueryBuilder = class {
 		this._validAtBlock = validAtBlock;
 		return this;
 	}
-	/**
-	* Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.
-	* Predicates can be nested using 'or' and 'and' predicates.
-	* @param predicates - The predicates to set
-	* @returns The query builder instance
-	*
-	* @example
-	* const builder = client.select()
-	* builder.where(eq("name", "John"))
-	* builder.where([eq("name", "John"), eq("age", 30)])
-	* builder.where([eq("name", "John"), or([eq("age", 30), eq("age", 31)])])
-	* builder.where([eq("name", "John"), and([eq("age", 30), eq("age", 31)])])
-	* builder.where([eq("name", "John"), or([eq("age", 30), and([eq("age", 31), eq("age", 32)])])])
-	* builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), eq("age", 32)])])])
-	* builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), and([eq("age", 32), eq("age", 33)])])])])
-	*/
-	where(predicates) {
-		if (Array.isArray(predicates)) this._predicates.push(...predicates);
-		else this._predicates.push(predicates);
+	where(...predicates) {
+		this._predicates.push(...predicates.flat());
 		return this;
 	}
 	/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkiv-network/sdk",
-  "version": "0.6.8-dev.3",
+  "version": "0.6.8-dev.4",
   "description": "TypeScript client library for Arkiv's blockchains interactions",
   "type": "module",
   "target": "esnext",

package/src/query/predicate.test.ts

@@ -244,6 +244,27 @@ describe("Predicate Factory Functions", () => {
       })
     })
 
+    test("creates or predicate from varargs", () => {
+      const result = or(eq("type", "admin"), eq("type", "moderator"))
+
+      expect(result).toEqual({
+        type: "or",
+        predicates: [
+          { type: "eq", key: "type", value: "admin" },
+          { type: "eq", key: "type", value: "moderator" },
+        ],
+      })
+    })
+
+    test("creates or predicate with no arguments", () => {
+      const result = or()
+
+      expect(result).toEqual({
+        type: "or",
+        predicates: [],
+      })
+    })
+
     test("creates or predicate with nested and", () => {
       const nestedAnd = and([eq("verified", 1), gte("age", 18)])
       const predicates = [eq("status", "premium"), nestedAnd]
@@ -314,6 +335,28 @@ describe("Predicate Factory Functions", () => {
       })
     })
 
+    test("creates and predicate from varargs", () => {
+      const result = and(eq("status", "active"), gte("age", 18), not("deleted"))
+
+      expect(result).toEqual({
+        type: "and",
+        predicates: [
+          { type: "eq", key: "status", value: "active" },
+          { type: "gte", key: "age", value: 18 },
+          { type: "not", key: "deleted", value: "" },
+        ],
+      })
+    })
+
+    test("creates and predicate with no arguments", () => {
+      const result = and()
+
+      expect(result).toEqual({
+        type: "and",
+        predicates: [],
+      })
+    })
+
     test("creates and predicate with nested or", () => {
       const nestedOr = or([eq("type", "admin"), eq("type", "moderator")])
       const predicates = [eq("active", 1), nestedOr]

package/src/query/predicate.ts

@@ -14,32 +14,36 @@ export type Predicate =
 
 /**
  * Creates an OR predicate
- * @param predicates - The predicates to combine
+ * @param predicates - The predicates to combine, either as a single array or as separate arguments
  * @returns The OR predicate
  *
  * @example
- * const predicates = [eq("name", "John"), eq("age", 30)]
- * const result = or(predicates)
+ * const result = or(eq("name", "John"), eq("age", 30))
+ * // or equivalently: or([eq("name", "John"), eq("age", 30)])
  * // result = { type: "or", predicates: [eq("name", "John"), eq("age", 30)] }
  *
  */
-export function or(predicates: Predicate[]): Predicate {
-  return { type: "or", predicates }
+export function or(predicates: Predicate[]): Predicate
+export function or(...predicates: Predicate[]): Predicate
+export function or(...predicates: (Predicate | Predicate[])[]): Predicate {
+  return { type: "or", predicates: predicates.flat() }
 }
 
 /**
  * Creates an AND predicate
- * @param predicates - The predicates to combine
+ * @param predicates - The predicates to combine, either as a single array or as separate arguments
  * @returns The AND predicate
  *
  * @example
- * const predicates = [eq("name", "John"), eq("age", 30)]
- * const result = and(predicates)
+ * const result = and(eq("name", "John"), eq("age", 30))
+ * // or equivalently: and([eq("name", "John"), eq("age", 30)])
  * // result = { type: "and", predicates: [eq("name", "John"), eq("age", 30)] }
  *
  */
-export function and(predicates: Predicate[]): Predicate {
-  return { type: "and", predicates }
+export function and(predicates: Predicate[]): Predicate
+export function and(...predicates: Predicate[]): Predicate
+export function and(...predicates: (Predicate | Predicate[])[]): Predicate {
+  return { type: "and", predicates: predicates.flat() }
 }
 
 /**

package/src/query/queryBuilder.test.ts

@@ -78,6 +78,28 @@ describe("QueryBuilder", () => {
       })
     })
 
+    test("adds multiple predicates as varargs", async () => {
+      mockProcessQuery.mockResolvedValue({
+        data: [],
+      })
+
+      const builder = new QueryBuilder(mockClient)
+      await builder.where(eq("name", "test"), gt("age", 18), neq("status", "inactive")).fetch()
+
+      expect(mockProcessQuery).toHaveBeenCalledWith(mockClient, {
+        predicates: [eq("name", "test"), gt("age", 18), neq("status", "inactive")],
+        limit: undefined,
+        offset: undefined,
+        ownedBy: undefined,
+        createdBy: undefined,
+        orderBy: undefined,
+        validBeforeBlock: undefined,
+        withAttributes: undefined,
+        withMetadata: undefined,
+        withPayload: undefined,
+      })
+    })
+
     test("chains multiple where() calls", async () => {
       mockProcessQuery.mockResolvedValue({
         data: [],

package/src/query/queryBuilder.ts

@@ -219,27 +219,26 @@ export abstract class BaseQueryBuilder<TEntity> {
   }
 
   /**
-   * Sets the predicates for the query limiting the results. It can be a single predicate or an array of predicates combined with 'and'.
+   * Sets the predicates for the query limiting the results. It can be a single predicate,
+   * multiple predicates passed as separate arguments, or an array of predicates - all combined with 'and'.
    * Predicates can be nested using 'or' and 'and' predicates.
-   * @param predicates - The predicates to set
+   * @param predicates - The predicates to set, either as a single array or as separate arguments
    * @returns The query builder instance
    *
    * @example
    * const builder = client.select()
    * builder.where(eq("name", "John"))
+   * builder.where(eq("name", "John"), eq("age", 30))
    * builder.where([eq("name", "John"), eq("age", 30)])
-   * builder.where([eq("name", "John"), or([eq("age", 30), eq("age", 31)])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), eq("age", 31)])])
-   * builder.where([eq("name", "John"), or([eq("age", 30), and([eq("age", 31), eq("age", 32)])])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), eq("age", 32)])])])
-   * builder.where([eq("name", "John"), and([eq("age", 30), or([eq("age", 31), and([eq("age", 32), eq("age", 33)])])])])
+   * builder.where(eq("name", "John"), or(eq("age", 30), eq("age", 31)))
+   * builder.where(eq("name", "John"), and(eq("age", 30), eq("age", 31)))
+   * builder.where(eq("name", "John"), or(eq("age", 30), and(eq("age", 31), eq("age", 32))))
+   * builder.where(eq("name", "John"), and(eq("age", 30), or(eq("age", 31), eq("age", 32))))
    */
-  where(predicates: Predicate[] | Predicate): this {
-    if (Array.isArray(predicates)) {
-      this._predicates.push(...predicates)
-    } else {
-      this._predicates.push(predicates)
-    }
+  where(predicates: Predicate[]): this
+  where(...predicates: Predicate[]): this
+  where(...predicates: (Predicate | Predicate[])[]) {
+    this._predicates.push(...predicates.flat())
     return this
   }
 

package/dist/index-CzqHiUAo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CzqHiUAo.d.ts","names":[],"sources":["../src/query/predicate.ts","../src/query/queryResult.ts","../src/query/selection.ts","../src/query/queryBuilder.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-gj33r3rd.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-gj33r3rd.d.cts","names":[],"sources":["../src/query/predicate.ts","../src/query/queryResult.ts","../src/query/selection.ts","../src/query/queryBuilder.ts"],"sourcesContent":[],"mappings":"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"}