@arkiv-network/sdk 0.8.0-advanced.2 → 0.8.0-dev.2

package/dist/payload-DE7wMztL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-DE7wMztL.js","names":[],"sources":["../src/utils/expirationTime.ts","../src/utils/payload.ts"],"sourcesContent":["import { InvalidExpiryError } from \"../entity/errors\"\nimport { type Expiry, type Lifetime, makeExpiry, toBlocks } from \"../entity/expiry\"\nimport { MAX_EXPIRES_AT } from \"../entity/params\"\n\n/**\n * The optional floor a deadline can carry.\n *\n * `atLeast` takes a duration — one of the `from*` helpers — and never another deadline, so\n * `atBlock(x, { atLeast: atBlock(y) })` does not compile. Two deadlines are not a thing the engine\n * can resolve.\n */\nexport type DeadlineOptions = {\n  /** Live at least this long from now, even if the deadline is sooner. */\n  atLeast?: Lifetime | undefined\n}\n\nfunction lifetimeOf(seconds: number): Lifetime {\n  return makeExpiry(toBlocks(seconds), 0n) as Lifetime\n}\n\nfunction deadlineOf(expiresAt: bigint | Date, options?: DeadlineOptions): Expiry {\n  return makeExpiry(options?.atLeast?.minLifetime ?? 0n, expiresAt)\n}\n\n/**\n * Builds the `expires` of a create or an extension.\n *\n * Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is\n * what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;\n * {@link ExpirationTime.atBlock} and {@link ExpirationTime.atDate} do the reverse. The engine takes\n * whichever comes later, which is why a deadline can also carry a floor.\n *\n * Values are plain data — no methods, no prototype — so they log, clone and compare like any other\n * object.\n *\n * @example The 90% case: a duration, and nothing else to think about.\n * await client.createEntity({ payload, contentType, expires: ExpirationTime.fromDays(30) })\n *\n * @example An exact block, or a wall-clock date.\n * expires: ExpirationTime.atBlock(1_200_000n)\n * expires: ExpirationTime.atDate(new Date(\"2027-01-01\"))\n *\n * @example A deadline that still guarantees a minimum life.\n * expires: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })\n */\nexport const ExpirationTime = {\n  /**\n   * A raw number of seconds. Must be a whole number of blocks' worth — see the other helpers, which\n   * all produce one by construction.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromSeconds: (seconds: number): Lifetime => lifetimeOf(seconds),\n  /**\n   * A number of minutes.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromMinutes: (minutes: number): Lifetime => lifetimeOf(minutes * 60),\n\n  /**\n   * A number of hours.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromHours: (hours: number): Lifetime => lifetimeOf(hours * 60 * 60),\n\n  /**\n   * A number of days. The everyday form — `fromDays(30)` is what most creates want.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromDays: (days: number): Lifetime => lifetimeOf(days * 24 * 60 * 60),\n\n  /**\n   * A number of weeks, each of 7 days.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromWeeks: (weeks: number): Lifetime => lifetimeOf(weeks * 7 * 24 * 60 * 60),\n\n  /**\n   * A number of months, each of exactly **30 days** — calendar months are not all the same length,\n   * and a lifetime is a duration rather than a date. Use {@link ExpirationTime.atDate} when the\n   * expiry has to land on a particular calendar day.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromMonths: (months: number): Lifetime => lifetimeOf(months * 30 * 24 * 60 * 60),\n\n  /**\n   * A number of years, each of exactly **365 days** — leap days are not counted, so `fromYears(4)`\n   * is a day short of four calendar years. Use {@link ExpirationTime.atDate} for a calendar\n   * deadline.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromYears: (years: number): Lifetime => lifetimeOf(years * 365 * 24 * 60 * 60),\n\n  /**\n   * A number of blocks, for callers who think in the chain's own unit. Always exact — there is no\n   * conversion to be approximate about.\n   *\n   * @throws {InvalidExpiryError} If the count is not a positive whole number.\n   */\n  fromBlocks: (blocks: number): Lifetime => {\n    if (!Number.isInteger(blocks) || blocks <= 0) {\n      throw new InvalidExpiryError(\n        `a lifetime must be a positive whole number of blocks, got ${blocks}`,\n      )\n    }\n    return makeExpiry(BigInt(blocks), 0n) as Lifetime\n  },\n\n  /**\n   * An absolute block height.\n   *\n   * @param block - The block the entity expires at.\n   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.\n   * @throws {InvalidExpiryError} If the height is negative.\n   */\n  atBlock: (block: bigint, options?: DeadlineOptions): Expiry => {\n    if (typeof block !== \"bigint\" || block < 0n) {\n      throw new InvalidExpiryError(`a deadline must be a non-negative block height, got ${block}`)\n    }\n    return deadlineOf(block, options)\n  },\n\n  /**\n   * A wall-clock instant, placed against the block the transaction is built on.\n   *\n   * A date cannot land on a block boundary in general, so it rounds **up** to the next block: the\n   * entity lives until at least the instant asked for. This is why a date is never rejected for\n   * \"not being a whole number of blocks\" the way a duration is — it becomes a block height, not a\n   * duration.\n   *\n   * @param date - When the entity should expire.\n   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.\n   * @throws {InvalidExpiryError} If the value is not a valid `Date`.\n   */\n  atDate: (date: Date, options?: DeadlineOptions): Expiry => {\n    if (!(date instanceof Date) || Number.isNaN(date.getTime())) {\n      throw new InvalidExpiryError(`a deadline must be a valid Date, got ${String(date)}`)\n    }\n    return deadlineOf(date, options)\n  },\n\n  /**\n   * An entity that should never expire.\n   *\n   * This is `atBlock(MAX_EXPIRES_AT)` — the largest expiry the `uint64` field holds — and the\n   * engine treats it as an ordinary deadline rather than a special case. There is no permanence\n   * flag; a block height no chain will reach is what permanence is.\n   */\n  permanent: (): Expiry => deadlineOf(MAX_EXPIRES_AT),\n}\n","import { stringToBytes, toBytes } from \"viem\"\n\n/**\n * A JSON-serialisable value as an entity payload — `JSON.stringify` then UTF-8.\n *\n * Pair it with `contentType: \"application/json\"`, which is what lets `entity.toJson()` read it back.\n *\n * @example\n * await client.createEntity({\n *   payload: jsonToPayload({ hello: \"world\" }),\n *   contentType: \"application/json\",\n *   expires: ExpirationTime.fromDays(30),\n * })\n */\nexport function jsonToPayload(json: object): Uint8Array {\n  return toBytes(JSON.stringify(json))\n}\n\n/**\n * A string as an entity payload, encoded as UTF-8.\n *\n * Hex-looking text is encoded as text: `stringToPayload(\"0xab\")` gives the four bytes of that\n * string, not the single byte `0xab`. Read it back with `entity.toText()`.\n *\n * @example\n * await client.createEntity({\n *   payload: stringToPayload(\"hello\"),\n *   contentType: \"text/plain\",\n *   expires: ExpirationTime.fromDays(30),\n * })\n */\nexport function stringToPayload(data: string): Uint8Array {\n  // stringToBytes, not toBytes: toBytes hex-decodes hex-looking strings, which\n  // would corrupt payloads like \"0xab\" instead of UTF-8 encoding them\n  return stringToBytes(data)\n}\n"],"mappings":";;;;;AAgBA,SAAS,WAAW,SAA2B;AAC7C,QAAO,WAAW,SAAS,QAAQ,EAAE,GAAG;;AAG1C,SAAS,WAAW,WAA0B,SAAmC;AAC/E,QAAO,WAAW,SAAS,SAAS,eAAe,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;AAwBnE,MAAa,iBAAiB;CAO5B,cAAc,YAA8B,WAAW,QAAQ;CAM/D,cAAc,YAA8B,WAAW,UAAU,GAAG;CAOpE,YAAY,UAA4B,WAAW,QAAQ,KAAK,GAAG;CAOnE,WAAW,SAA2B,WAAW,OAAO,KAAK,KAAK,GAAG;CAOrE,YAAY,UAA4B,WAAW,QAAQ,IAAI,KAAK,KAAK,GAAG;CAS5E,aAAa,WAA6B,WAAW,SAAS,KAAK,KAAK,KAAK,GAAG;CAShF,YAAY,UAA4B,WAAW,QAAQ,MAAM,KAAK,KAAK,GAAG;CAQ9E,aAAa,WAA6B;AACxC,MAAI,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACzC,OAAM,IAAI,mBACR,6DAA6D,SAC9D;AAEH,SAAO,WAAW,OAAO,OAAO,EAAE,GAAG;;CAUvC,UAAU,OAAe,YAAsC;AAC7D,MAAI,OAAO,UAAU,YAAY,QAAQ,GACvC,OAAM,IAAI,mBAAmB,uDAAuD,QAAQ;AAE9F,SAAO,WAAW,OAAO,QAAQ;;CAenC,SAAS,MAAY,YAAsC;AACzD,MAAI,EAAE,gBAAgB,SAAS,OAAO,MAAM,KAAK,SAAS,CAAC,CACzD,OAAM,IAAI,mBAAmB,wCAAwC,OAAO,KAAK,GAAG;AAEtF,SAAO,WAAW,MAAM,QAAQ;;CAUlC,iBAAyB,WAAW,eAAe;CACpD;;;;;;;;;;;;;;;;AC7ID,SAAgB,cAAc,MAA0B;AACtD,QAAO,QAAQ,KAAK,UAAU,KAAK,CAAC;;;;;;;;;;;;;;;AAgBtC,SAAgB,gBAAgB,MAA0B;AAGxD,QAAO,cAAc,KAAK"}

package/dist/{payload-BNoud2KZ.d.cts → payload-Dfu30njp.d.cts}

@@ -42,11 +42,45 @@ declare const ExpirationTime: {
    * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
    */
   fromSeconds: (seconds: number) => Lifetime;
+  /**
+   * A number of minutes.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
   fromMinutes: (minutes: number) => Lifetime;
+  /**
+   * A number of hours.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
   fromHours: (hours: number) => Lifetime;
+  /**
+   * A number of days. The everyday form — `fromDays(30)` is what most creates want.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
   fromDays: (days: number) => Lifetime;
+  /**
+   * A number of weeks, each of 7 days.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
   fromWeeks: (weeks: number) => Lifetime;
+  /**
+   * A number of months, each of exactly **30 days** — calendar months are not all the same length,
+   * and a lifetime is a duration rather than a date. Use {@link ExpirationTime.atDate} when the
+   * expiry has to land on a particular calendar day.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
   fromMonths: (months: number) => Lifetime;
+  /**
+   * A number of years, each of exactly **365 days** — leap days are not counted, so `fromYears(4)`
+   * is a day short of four calendar years. Use {@link ExpirationTime.atDate} for a calendar
+   * deadline.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
   fromYears: (years: number) => Lifetime;
   /**
    * A number of blocks, for callers who think in the chain's own unit. Always exact — there is no
@@ -87,8 +121,33 @@ declare const ExpirationTime: {
 };
 //#endregion
 //#region src/utils/payload.d.ts
+/**
+ * A JSON-serialisable value as an entity payload — `JSON.stringify` then UTF-8.
+ *
+ * Pair it with `contentType: "application/json"`, which is what lets `entity.toJson()` read it back.
+ *
+ * @example
+ * await client.createEntity({
+ *   payload: jsonToPayload({ hello: "world" }),
+ *   contentType: "application/json",
+ *   expires: ExpirationTime.fromDays(30),
+ * })
+ */
 declare function jsonToPayload(json: object): Uint8Array;
+/**
+ * A string as an entity payload, encoded as UTF-8.
+ *
+ * Hex-looking text is encoded as text: `stringToPayload("0xab")` gives the four bytes of that
+ * string, not the single byte `0xab`. Read it back with `entity.toText()`.
+ *
+ * @example
+ * await client.createEntity({
+ *   payload: stringToPayload("hello"),
+ *   contentType: "text/plain",
+ *   expires: ExpirationTime.fromDays(30),
+ * })
+ */
 declare function stringToPayload(data: string): Uint8Array;
 //#endregion
 export { ExpirationTime as i, stringToPayload as n, DeadlineOptions as r, jsonToPayload as t };
-//# sourceMappingURL=payload-BNoud2KZ.d.cts.map
+//# sourceMappingURL=payload-Dfu30njp.d.cts.map

package/dist/payload-Dfu30njp.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-Dfu30njp.d.cts","names":[],"sources":["../src/utils/expirationTime.ts","../src/utils/payload.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;AAkCA;;;;AA2B4B,KA7DhB,eAAA,GA6DgB;EAOE;EASE,OAAA,CAAA,EA3EpB,QA2EoB,GAAA,SAAA;CASF;;;;;;;;;;;;ACnF9B;AAiBA;;;;;;;;;cDca;;;;;;;oCAOqB;;;;;;oCAMA;;;;;;gCAOJ;;;;;;8BAOF;;;;;;gCAOE;;;;;;;;kCASE;;;;;;;;gCASF;;;;;;;kCAQE;;;;;;;;qCAgBK,oBAAkB;;;;;;;;;;;;;iBAmBtC,gBAAgB,oBAAkB;;;;;;;;mBAclC;;;;;;;AA/IjB;AAkCA;;;;;;;;AA4DgC,iBC3FhB,aAAA,CD2FgB,IAAA,EAAA,MAAA,CAAA,EC3Fa,UD2Fb;;;;;;;;;;;AC3FhC;AAiBA;;iBAAgB,eAAA,gBAA+B"}

package/dist/{payload-KC14SDlN.cjs → payload-DqFweqiO.cjs}

@@ -1,5 +1,5 @@
-const require_expiry = require('./expiry-BELY2Kpw.cjs');
-const require_errors = require('./errors-BVbjKVMN.cjs');
+const require_errors = require('./errors-DhV00966.cjs');
+const require_expiry = require('./expiry-CG9GhVXv.cjs');
 let viem = require("viem");
 
 //#region src/utils/expirationTime.ts
@@ -55,9 +55,34 @@ const ExpirationTime = {
 
 //#endregion
 //#region src/utils/payload.ts
+/**
+* A JSON-serialisable value as an entity payload — `JSON.stringify` then UTF-8.
+*
+* Pair it with `contentType: "application/json"`, which is what lets `entity.toJson()` read it back.
+*
+* @example
+* await client.createEntity({
+*   payload: jsonToPayload({ hello: "world" }),
+*   contentType: "application/json",
+*   expires: ExpirationTime.fromDays(30),
+* })
+*/
 function jsonToPayload(json) {
 	return (0, viem.toBytes)(JSON.stringify(json));
 }
+/**
+* A string as an entity payload, encoded as UTF-8.
+*
+* Hex-looking text is encoded as text: `stringToPayload("0xab")` gives the four bytes of that
+* string, not the single byte `0xab`. Read it back with `entity.toText()`.
+*
+* @example
+* await client.createEntity({
+*   payload: stringToPayload("hello"),
+*   contentType: "text/plain",
+*   expires: ExpirationTime.fromDays(30),
+* })
+*/
 function stringToPayload(data) {
 	return (0, viem.stringToBytes)(data);
 }

package/dist/query/index.cjs

@@ -1,10 +1,8 @@
-require('../attributes-Df9IsCVs.cjs');
-require('../errors-BVbjKVMN.cjs');
-require('../flags-kr276q6i.cjs');
-require('../logger-Cr15lPAQ.cjs');
-require('../attr-DlmErkvR.cjs');
-require('../entity-B00Li04j.cjs');
-const require_queryBuilder = require('../queryBuilder-DbUMEZln.cjs');
+require('../attr-BXTkpnoc.cjs');
+const require_queryBuilder = require('../queryBuilder-zHGhDmaG.cjs');
+require('../errors-DhV00966.cjs');
+require('../flags-DCD26uhe.cjs');
+require('../entity-B0t6sN7F.cjs');
 
 exports.InvalidPredicateError = require_queryBuilder.InvalidPredicateError;
 exports.MAX_LIMIT = require_queryBuilder.MAX_LIMIT;

package/dist/query/index.d.cts

@@ -1,5 +1,5 @@
-import { A as startsWith, C as hasType, D as not, E as ne, O as or, S as gte, T as lte, _ as TypeOfNode, a as SelectionFields, b as exists, d as ComparisonOperator, f as ExistsNode, g as StartsWithNode, h as OrNode, i as SelectArg, k as render, l as AndNode, m as NotNode, n as FullEntity, o as toRpcSelect, p as Expression, r as ProjectedEntity, t as EntitySelection, u as ComparisonNode, v as and, w as lt, x as gt, y as eq } from "../selection-DPg0uyJf.cjs";
-import "../index-CV5zCdpa.cjs";
-import "../flags-CRjPpoh3.cjs";
-import { a as QueryErrorKind, c as QueryRequest, i as QueryError, l as QueryResponse, n as QueryResult, o as UnsupportedOperatorError, r as InvalidPredicateError, s as MAX_LIMIT, t as SelectQueryBuilder, u as runQuery } from "../index-BF7Mq9Is.cjs";
+import "../index-CIcHPx2j.cjs";
+import "../flags-0Vl5rrHq.cjs";
+import { C as lte, D as render, E as or, O as startsWith, S as lt, T as not, _ as eq, a as SelectionFields, b as gte, c as ComparisonNode, d as Expression, f as NotNode, g as and, h as TypeOfNode, i as SelectArg, l as ComparisonOperator, m as StartsWithNode, n as FullEntity, o as toRpcSelect, p as OrNode, r as ProjectedEntity, s as AndNode, t as EntitySelection, u as ExistsNode, v as exists, w as ne, x as hasType, y as gt } from "../selection-Bv8_o-7i.cjs";
+import { a as QueryErrorKind, c as QueryRequest, i as QueryError, l as QueryResponse, n as QueryResult, o as UnsupportedOperatorError, r as InvalidPredicateError, s as MAX_LIMIT, t as SelectQueryBuilder, u as runQuery } from "../index-rINthNuU.cjs";
 export { AndNode, ComparisonNode, ComparisonOperator, EntitySelection, ExistsNode, Expression, FullEntity, InvalidPredicateError, MAX_LIMIT, NotNode, OrNode, ProjectedEntity, QueryError, QueryErrorKind, QueryRequest, QueryResponse, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, StartsWithNode, TypeOfNode, UnsupportedOperatorError, and, eq, exists, gt, gte, hasType, lt, lte, ne, not, or, render, runQuery, startsWith, toRpcSelect };

package/dist/query/index.d.ts

@@ -1,6 +1,5 @@
-import { A as startsWith, C as hasType, D as not, E as ne, O as or, S as gte, T as lte, _ as TypeOfNode, a as SelectionFields, b as exists, d as ComparisonOperator, f as ExistsNode, g as StartsWithNode, h as OrNode, i as SelectArg, k as render, l as AndNode, m as NotNode, n as FullEntity, o as toRpcSelect, p as Expression, r as ProjectedEntity, t as EntitySelection, u as ComparisonNode, v as and, w as lt, x as gt, y as eq } from "../selection-C4UhsMOO.js";
-import "../codec-Car3KkFF.js";
-import "../index-DvYvrkdk.js";
-import "../flags-5dTNRnow.js";
-import { a as QueryErrorKind, c as QueryRequest, i as QueryError, l as QueryResponse, n as QueryResult, o as UnsupportedOperatorError, r as InvalidPredicateError, s as MAX_LIMIT, t as SelectQueryBuilder, u as runQuery } from "../index-DHDud2hC.js";
+import "../index-Cd2aaWme.js";
+import "../flags-wmcMoAnN.js";
+import { C as lte, D as render, E as or, O as startsWith, S as lt, T as not, _ as eq, a as SelectionFields, b as gte, c as ComparisonNode, d as Expression, f as NotNode, g as and, h as TypeOfNode, i as SelectArg, l as ComparisonOperator, m as StartsWithNode, n as FullEntity, o as toRpcSelect, p as OrNode, r as ProjectedEntity, s as AndNode, t as EntitySelection, u as ExistsNode, v as exists, w as ne, x as hasType, y as gt } from "../selection-ox7zdtVm.js";
+import { a as QueryErrorKind, c as QueryRequest, i as QueryError, l as QueryResponse, n as QueryResult, o as UnsupportedOperatorError, r as InvalidPredicateError, s as MAX_LIMIT, t as SelectQueryBuilder, u as runQuery } from "../index-BKB875Um.js";
 export { AndNode, ComparisonNode, ComparisonOperator, EntitySelection, ExistsNode, Expression, FullEntity, InvalidPredicateError, MAX_LIMIT, NotNode, OrNode, ProjectedEntity, QueryError, QueryErrorKind, QueryRequest, QueryResponse, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, StartsWithNode, TypeOfNode, UnsupportedOperatorError, and, eq, exists, gt, gte, hasType, lt, lte, ne, not, or, render, runQuery, startsWith, toRpcSelect };

package/dist/query/index.js

@@ -1,9 +1,7 @@
-import "../attributes-BhY5DwJp.js";
-import "../errors-LTe7bOYS.js";
-import "../flags-DFBs2J94.js";
-import "../logger-CVpvU8ik.js";
-import "../attr-GcQKatub.js";
-import "../entity-BYQR1uoe.js";
-import { _ as MAX_LIMIT, a as eq, b as QueryError, c as gte, d as lte, f as ne, g as startsWith, h as render, i as and, l as hasType, m as or, n as QueryResult, o as exists, p as not, r as toRpcSelect, s as gt, t as SelectQueryBuilder, u as lt, v as runQuery, x as UnsupportedOperatorError, y as InvalidPredicateError } from "../queryBuilder-DM6AWCBa.js";
+import "../attr-tmyREHtw.js";
+import { _ as MAX_LIMIT, a as eq, b as QueryError, c as gte, d as lte, f as ne, g as startsWith, h as render, i as and, l as hasType, m as or, n as QueryResult, o as exists, p as not, r as toRpcSelect, s as gt, t as SelectQueryBuilder, u as lt, v as runQuery, x as UnsupportedOperatorError, y as InvalidPredicateError } from "../queryBuilder-wvA8sn--.js";
+import "../errors-D2E1GRjw.js";
+import "../flags-DUT2gHEU.js";
+import "../entity-BIp_df9u.js";
 
 export { InvalidPredicateError, MAX_LIMIT, QueryError, QueryResult, SelectQueryBuilder, UnsupportedOperatorError, and, eq, exists, gt, gte, hasType, lt, lte, ne, not, or, render, runQuery, startsWith, toRpcSelect };

package/dist/{queryBuilder-DM6AWCBa.js → queryBuilder-wvA8sn--.js}

@@ -1,9 +1,159 @@
-import { C as str, D as TYPE_IDS, c as asTypeTag, h as addr, l as decodeRpcValue, s as validateAttributeName, w as toValue } from "./attributes-BhY5DwJp.js";
-import { n as encodeCreationFlags, t as decodeCreationFlags } from "./flags-DFBs2J94.js";
-import { o as NoMoreResultsError, t as getLogger } from "./logger-CVpvU8ik.js";
-import { t as Entity } from "./entity-BYQR1uoe.js";
+import { C as str, D as TYPE_IDS, c as asTypeTag, h as addr, l as decodeRpcValue, s as validateAttributeName, w as toValue } from "./attr-tmyREHtw.js";
+import { n as encodeCreationFlags, t as decodeCreationFlags } from "./flags-DUT2gHEU.js";
+import { t as Entity } from "./entity-BIp_df9u.js";
 import { checksumAddress, hexToBytes, numberToHex } from "viem";
 
+//#region src/utils/logger.ts
+const ROOT_NAMESPACE = "arkiv";
+function getDebugEnv() {
+	if (typeof process !== "undefined") {
+		const debugEnv = process?.env?.DEBUG;
+		if (debugEnv) return debugEnv;
+	}
+	if (typeof globalThis !== "undefined" && "localStorage" in globalThis) try {
+		return globalThis.localStorage?.getItem("DEBUG") || "";
+	} catch {}
+	return "";
+}
+function matchesPattern(namespace, pattern) {
+	if (pattern === namespace) return true;
+	if (pattern.endsWith("*")) {
+		const prefix = pattern.slice(0, -1);
+		return namespace.startsWith(prefix);
+	}
+	if (pattern.startsWith("-")) return !matchesPattern(namespace, pattern.slice(1));
+	return false;
+}
+function isEnabled(namespace) {
+	const debugEnv = getDebugEnv();
+	if (!debugEnv) return false;
+	const patterns = debugEnv.split(/[\s,]+/).filter((p) => p.length > 0);
+	if (patterns.length === 0) return false;
+	let enabled = false;
+	for (const pattern of patterns) if (pattern.startsWith("-")) {
+		if (matchesPattern(namespace, pattern)) return false;
+	} else if (matchesPattern(namespace, pattern)) enabled = true;
+	return enabled;
+}
+const enabledNamespaces = /* @__PURE__ */ new Set();
+const disabledNamespaces = /* @__PURE__ */ new Set();
+const COLOR_PALETTE = [
+	"#0000FF",
+	"#008000",
+	"#FF0000",
+	"#FF00FF",
+	"#FFA500",
+	"#800080",
+	"#00CED1",
+	"#FF1493",
+	"#32CD32",
+	"#1E90FF",
+	"#FF4500",
+	"#9370DB",
+	"#00FA9A",
+	"#FFD700",
+	"#DC143C",
+	"#00BFFF",
+	"#FF69B4",
+	"#20B2AA",
+	"#DA70D6",
+	"#4682B4"
+];
+const isNode = typeof process !== "undefined" && process.versions?.node != null;
+const ANSI_COLORS = [
+	"\x1B[94m",
+	"\x1B[92m",
+	"\x1B[91m",
+	"\x1B[95m",
+	"\x1B[93m",
+	"\x1B[96m",
+	"\x1B[35m",
+	"\x1B[36m",
+	"\x1B[32m",
+	"\x1B[34m",
+	"\x1B[33m",
+	"\x1B[31m",
+	"\x1B[90m",
+	"\x1B[37m",
+	"\x1B[1m"
+];
+const ANSI_RESET = "\x1B[0m";
+const ANSI_BOLD = "\x1B[1m";
+const namespaceColors = /* @__PURE__ */ new Map();
+function getColorForNamespace(namespace) {
+	const cachedColor = namespaceColors.get(namespace);
+	if (cachedColor) return cachedColor;
+	let hash = 0;
+	for (let i = 0; i < namespace.length; i++) {
+		const char = namespace.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	const colorIndex = Math.abs(hash) % COLOR_PALETTE.length;
+	const color = {
+		css: COLOR_PALETTE[colorIndex] ?? "inherit",
+		ansi: ANSI_COLORS[colorIndex % ANSI_COLORS.length] ?? ""
+	};
+	namespaceColors.set(namespace, color);
+	return color;
+}
+function createDebugLogger(namespace) {
+	const colors = getColorForNamespace(namespace);
+	return (...args) => {
+		const envEnabled = isEnabled(namespace);
+		const progEnabled = enabledNamespaces.has(namespace) && !disabledNamespaces.has(namespace);
+		if (envEnabled || progEnabled) if (isNode) {
+			const coloredNamespace = `${ANSI_BOLD}${colors.ansi}${namespace}${ANSI_RESET}`;
+			console.log(coloredNamespace, ...args);
+		} else {
+			const style1 = `color: ${colors.css}; font-weight: bold`;
+			console.log(`%c${namespace}%c`, style1, "color: inherit; font-weight: normal", ...args);
+		}
+	};
+}
+const getLogger = (scope) => {
+	return createDebugLogger(`${ROOT_NAMESPACE}:${scope}`);
+};
+
+//#endregion
+//#region src/errors.ts
+var EntityMutationError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "EntityMutationError";
+	}
+};
+var NoMoreResultsError = class extends Error {
+	constructor() {
+		super("No more results — the last page carried no cursor. Check hasNextPage() before next().");
+		this.name = "NoMoreResultsError";
+	}
+};
+var NoEntityFoundError = class extends Error {
+	/** The key that matched nothing, when the lookup was by key. */
+	entityKey;
+	constructor(entityKey) {
+		super(entityKey === void 0 ? "No entity found" : `No live entity with key ${entityKey}. It was never created, or it has been deleted or has expired.`);
+		this.name = "NoEntityFoundError";
+		this.entityKey = entityKey;
+	}
+};
+var EmptyPatchError = class extends Error {
+	entityKey;
+	constructor(entityKey) {
+		super(`The patch for entity ${entityKey} has nothing to apply. Pass "set" to write attributes, "unset" to remove them, or "payload"/"contentType" to replace the contents.`);
+		this.name = "EmptyPatchError";
+		this.entityKey = entityKey;
+	}
+};
+var InvalidContentTypeError = class extends Error {
+	constructor(contentType) {
+		super(`Invalid content type "${contentType}". Must follow RFC 2045 MIME grammar and be lowercase only (e.g. "text/plain").`);
+		this.name = "InvalidContentTypeError";
+	}
+};
+
+//#endregion
 //#region src/utils/entities.ts
 const logger$1 = getLogger("utils:entities");
 /**
@@ -90,7 +240,7 @@ function toFlagsByte(value) {
 * | | `=` `!=` | `<` `<=` `>` `>=` | `STARTSWITH` |
 * | --- | --- | --- | --- |
 * | `bool` | yes | no | no |
-* | `i32` `u256` `dec` | yes | yes | no |
+* | `i32` `u64` `u256` `dec` | yes | yes | no |
 * | `str` | yes | no | yes |
 * | `addr` `key` `bytes32` | yes | no | no |
 */
@@ -203,7 +353,6 @@ const MAX_LIMIT = 200;
 */
 async function runQuery(client, request) {
 	const { query, select, limit, cursor, atBlock } = request;
-	if (cursor !== void 0 && atBlock === void 0) throw new Error("a cursor must be resumed with `atBlock` set to the `blockNumber` of the page it came from — persist the two together.");
 	if (limit !== void 0) {
 		if (!Number.isInteger(limit) || limit < 1) throw new Error(`limit must be a positive integer, got ${limit}.`);
 		if (limit > MAX_LIMIT) throw new Error(`limit ${limit} exceeds the node maximum of ${MAX_LIMIT}. Page through the results with the cursor instead.`);
@@ -341,7 +490,7 @@ function ne(name, value) {
 	return comparison(name, "!=", value);
 }
 /**
-* Attribute is greater than value. Ordered types only (`i32`, `u256`, `dec`).
+* Attribute is greater than value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
 *
 * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
 *
@@ -353,7 +502,7 @@ function gt(name, value) {
 	return comparison(name, ">", value);
 }
 /**
-* Attribute is greater than or equal to value. Ordered types only (`i32`, `u256`, `dec`).
+* Attribute is greater than or equal to value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
 *
 * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
 *
@@ -364,7 +513,7 @@ function gte(name, value) {
 	return comparison(name, ">=", value);
 }
 /**
-* Attribute is less than value. Ordered types only (`i32`, `u256`, `dec`).
+* Attribute is less than value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
 *
 * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
 *
@@ -375,7 +524,7 @@ function lt(name, value) {
 	return comparison(name, "<", value);
 }
 /**
-* Attribute is less than or equal to value. Ordered types only (`i32`, `u256`, `dec`).
+* Attribute is less than or equal to value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
 *
 * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
 *
@@ -392,7 +541,9 @@ function lte(name, value) {
 * `startsWith("name", "é")` matches only the same byte sequence, not another normal form of it.
 *
 * @param prefix - The prefix, as a bare string or a `str` value.
-* @throws {UnsupportedOperatorError} If given a value that is not a `str`.
+* @throws {InvalidPredicateError} If the name is not a queryable attribute.
+* @throws {UnsupportedOperatorError} If given a value that is not a `str`, or a system attribute
+* (none of which is a `str`).
 *
 * @example
 * startsWith("desc", "ab") // desc STARTSWITH str('ab')
@@ -431,7 +582,8 @@ function exists(name) {
 * Useful when the same name is written with different types across entities — a comparison already
 * asserts the type, so this is for asking about the type alone.
 *
-* @param tag - The type tag: `bool`, `i32`, `u256`, `dec`, `bytes32`, `str`, `addr` or `key`.
+* @param tag - The type tag: `bool`, `i32`, `u64`, `u256`, `dec`, `bytes32`, `str`, `addr` or
+* `key`.
 * @throws {InvalidPredicateError} If the tag is not a settable type, or the name is a system
 * attribute (whose type is fixed).
 *
@@ -441,7 +593,7 @@ function exists(name) {
 function hasType(name, tag) {
 	const system = resolveReference(name);
 	if (system !== void 0) throw new InvalidPredicateError(`"${name}" is always a ${system} — a system attribute has a fixed type, so TYPEOF(${name}) is a constant.`, name);
-	if (!isUserTypeTag(tag)) throw new InvalidPredicateError(`"${tag}" is not a settable attribute type. Use one of bool, i32, u256, dec, bytes32, str, addr, key.`, name);
+	if (!isUserTypeTag(tag)) throw new InvalidPredicateError(`"${tag}" is not a settable attribute type. Use one of bool, i32, u64, u256, dec, bytes32, str, addr, key.`, name);
 	return node({
 		kind: "typeOf",
 		name,
@@ -730,9 +882,7 @@ var SelectQueryBuilder = class {
 	*
 	* Pagination normally goes through {@link QueryResult.next}, which carries the cursor for you;
 	* this is for resuming a walk in a later process. A cursor is bound to the query, block and
-	* selection it came from, so it must be used with an identically-built query — {@link atBlock}
-	* set to the `blockNumber` of the page the cursor came from is required (persist the two
-	* together), and a fetch with a cursor but no block rejects locally.
+	* selection it came from, so it must be used with an identically-built query.
 	*/
 	cursor(cursor) {
 		this._cursor = cursor;
@@ -808,13 +958,9 @@ async function fetchPage(client, request, cursor) {
 		...request,
 		cursor
 	});
-	const pinned = Object.freeze({
-		...request,
-		atBlock: response.blockNumber
-	});
-	return new QueryResult(response.entities, response.blockNumber, response.cursor, (next) => fetchPage(client, pinned, next));
+	return new QueryResult(response.entities, response.blockNumber, response.cursor, (next) => fetchPage(client, request, next));
 }
 
 //#endregion
-export { MAX_LIMIT as _, eq as a, QueryError as b, gte as c, lte as d, ne as f, startsWith as g, render as h, and as i, hasType as l, or as m, QueryResult as n, exists as o, not as p, toRpcSelect as r, gt as s, SelectQueryBuilder as t, lt as u, runQuery as v, UnsupportedOperatorError as x, InvalidPredicateError as y };
-//# sourceMappingURL=queryBuilder-DM6AWCBa.js.map
+export { EntityMutationError as C, getLogger as D, NoMoreResultsError as E, EmptyPatchError as S, NoEntityFoundError as T, MAX_LIMIT as _, eq as a, QueryError as b, gte as c, lte as d, ne as f, startsWith as g, render as h, and as i, hasType as l, or as m, QueryResult as n, exists as o, not as p, toRpcSelect as r, gt as s, SelectQueryBuilder as t, lt as u, runQuery as v, InvalidContentTypeError as w, UnsupportedOperatorError as x, InvalidPredicateError as y };
+//# sourceMappingURL=queryBuilder-wvA8sn--.js.map