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

package/dist/entity-BYQR1uoe.js

@@ -0,0 +1,67 @@
+import { bytesToString } from "viem";
+
+//#region src/types/entity.ts
+/**
+* An entity as it comes back from a query.
+*
+* Which fields are populated is decided by the query's selection — `select({ key: true })` gives
+* back an entity carrying only its key. The static type of a `select()` result is narrowed to
+* exactly the selected fields, so in typed code the `undefined`s here are not reachable.
+*/
+var Entity = class {
+	key;
+	owner;
+	creator;
+	createdAt;
+	updatedAt;
+	expiresAt;
+	creationFlags;
+	contentType;
+	payload;
+	attributeSchema;
+	attributes;
+	constructor(fields = {}) {
+		this.key = fields.key;
+		this.owner = fields.owner;
+		this.creator = fields.creator;
+		this.createdAt = fields.createdAt;
+		this.updatedAt = fields.updatedAt;
+		this.expiresAt = fields.expiresAt;
+		this.creationFlags = fields.creationFlags;
+		this.contentType = fields.contentType;
+		this.payload = fields.payload;
+		this.attributeSchema = fields.attributeSchema;
+		this.attributes = fields.attributes;
+	}
+	/**
+	* The payload decoded as UTF-8 text.
+	*
+	* @throws If the payload was not selected, or is not valid UTF-8.
+	*/
+	toText() {
+		if (this.payload === void 0) throw new Error("Entity has no payload — the query did not select it. Use select({ payload: true }).");
+		try {
+			return bytesToString(this.payload);
+		} catch (e) {
+			throw new Error(`Failed to convert entity payload to text: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+		}
+	}
+	/**
+	* The payload parsed as JSON.
+	*
+	* @throws If the payload was not selected, is empty, or is not valid JSON.
+	*/
+	toJson() {
+		const text = this.toText();
+		if (!text) throw new Error("Entity has empty payload, cannot parse as JSON");
+		try {
+			return JSON.parse(text);
+		} catch (e) {
+			throw new Error(`Failed to parse entity payload as JSON: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+		}
+	}
+};
+
+//#endregion
+export { Entity as t };
+//# sourceMappingURL=entity-BYQR1uoe.js.map

package/dist/entity-BYQR1uoe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-BYQR1uoe.js","names":[],"sources":["../src/types/entity.ts"],"sourcesContent":["import { bytesToString, type Hex } from \"viem\"\nimport type { AttributeSchema, Attributes } from \"../attr\"\nimport type { ResolvedCreationFlags } from \"../entity/flags\"\n\n/**\n * The fields an {@link Entity} can carry. Every one is optional: a query returns exactly the parts\n * it selected, and `undefined` means \"not asked for\" rather than \"empty\".\n */\nexport type EntityFields = {\n  key?: Hex | undefined\n  owner?: Hex | undefined\n  creator?: Hex | undefined\n  /** Block the entity was created at. */\n  createdAt?: bigint | undefined\n  /** Block the entity was last patched at. */\n  updatedAt?: bigint | undefined\n  /** Block the entity expires at. */\n  expiresAt?: bigint | undefined\n  /** The immutable properties the entity was created with. */\n  creationFlags?: ResolvedCreationFlags | undefined\n  contentType?: string | undefined\n  payload?: Uint8Array | undefined\n  /** Attribute names and types, with no values. */\n  attributeSchema?: AttributeSchema | undefined\n  /** Attribute names, types and values. */\n  attributes?: Attributes | undefined\n}\n\n/**\n * An entity as it comes back from a query.\n *\n * Which fields are populated is decided by the query's selection — `select({ key: true })` gives\n * back an entity carrying only its key. The static type of a `select()` result is narrowed to\n * exactly the selected fields, so in typed code the `undefined`s here are not reachable.\n */\nexport class Entity implements EntityFields {\n  key: Hex | undefined\n  owner: Hex | undefined\n  creator: Hex | undefined\n  createdAt: bigint | undefined\n  updatedAt: bigint | undefined\n  expiresAt: bigint | undefined\n  creationFlags: ResolvedCreationFlags | undefined\n  contentType: string | undefined\n  payload: Uint8Array | undefined\n  attributeSchema: AttributeSchema | undefined\n  attributes: Attributes | undefined\n\n  constructor(fields: EntityFields = {}) {\n    this.key = fields.key\n    this.owner = fields.owner\n    this.creator = fields.creator\n    this.createdAt = fields.createdAt\n    this.updatedAt = fields.updatedAt\n    this.expiresAt = fields.expiresAt\n    this.creationFlags = fields.creationFlags\n    this.contentType = fields.contentType\n    this.payload = fields.payload\n    this.attributeSchema = fields.attributeSchema\n    this.attributes = fields.attributes\n  }\n\n  /**\n   * The payload decoded as UTF-8 text.\n   *\n   * @throws If the payload was not selected, or is not valid UTF-8.\n   */\n  toText(): string {\n    if (this.payload === undefined) {\n      throw new Error(\n        \"Entity has no payload — the query did not select it. Use select({ payload: true }).\",\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   * The payload parsed as JSON.\n   *\n   * @throws If the payload was not selected, is empty, or is not valid JSON.\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: JSON.parse returns whatever the payload holds.\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"],"mappings":";;;;;;;;;;AAmCA,IAAa,SAAb,MAA4C;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,SAAuB,EAAE,EAAE;AACrC,OAAK,MAAM,OAAO;AAClB,OAAK,QAAQ,OAAO;AACpB,OAAK,UAAU,OAAO;AACtB,OAAK,YAAY,OAAO;AACxB,OAAK,YAAY,OAAO;AACxB,OAAK,YAAY,OAAO;AACxB,OAAK,gBAAgB,OAAO;AAC5B,OAAK,cAAc,OAAO;AAC1B,OAAK,UAAU,OAAO;AACtB,OAAK,kBAAkB,OAAO;AAC9B,OAAK,aAAa,OAAO;;;;;;;CAQ3B,SAAiB;AACf,MAAI,KAAK,YAAY,OACnB,OAAM,IAAI,MACR,sFACD;AAEH,MAAI;AACF,UAAO,cAAc,KAAK,QAAQ;WAC3B,GAAG;AACV,SAAM,IAAI,MACR,6CAA6C,aAAa,QAAQ,EAAE,UAAU,OAAO,EAAE,IACvF,EAAE,OAAO,GAAG,CACb;;;;;;;;CAUL,SAAc;EACZ,MAAM,OAAO,KAAK,QAAQ;AAC1B,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,iDAAiD;AAEnE,MAAI;AACF,UAAO,KAAK,MAAM,KAAK;WAChB,GAAG;AACV,SAAM,IAAI,MACR,2CAA2C,aAAa,QAAQ,EAAE,UAAU,OAAO,EAAE,IACrF,EAAE,OAAO,GAAG,CACb"}

package/dist/errors-BVbjKVMN.cjs

@@ -0,0 +1,56 @@
+
+//#region src/entity/errors.ts
+/** An expiry could not be expressed, or would be rejected by the engine. */
+var InvalidExpiryError = class extends Error {
+	constructor(reason) {
+		super(`Invalid expiry: ${reason}`);
+		this.name = "InvalidExpiryError";
+	}
+};
+/** A `creationFlags` byte could not be built or read. */
+var InvalidCreationFlagsError = class extends Error {
+	constructor(reason) {
+		super(`Invalid creation flags: ${reason}`);
+		this.name = "InvalidCreationFlagsError";
+	}
+};
+/** A key salt was outside the `uint128` the wire carries. */
+var InvalidSaltError = class extends Error {
+	constructor(salt) {
+		super(`Invalid salt ${salt}. A salt is a uint128, so it must be between 0 and ${2n ** 128n - 1n}. Omit it to get 128 random bits, or pass 0 for a predictable key.`);
+		this.name = "InvalidSaltError";
+	}
+};
+/** No cryptographic randomness was available to generate a salt. */
+var NoRandomSourceError = class extends Error {
+	constructor() {
+		super("No cryptographic random source is available (globalThis.crypto.getRandomValues is missing), so a key salt cannot be generated. Upgrade to Node 18+ or a modern browser, or pass an explicit salt.");
+		this.name = "NoRandomSourceError";
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'InvalidCreationFlagsError', {
+  enumerable: true,
+  get: function () {
+    return InvalidCreationFlagsError;
+  }
+});
+Object.defineProperty(exports, 'InvalidExpiryError', {
+  enumerable: true,
+  get: function () {
+    return InvalidExpiryError;
+  }
+});
+Object.defineProperty(exports, 'InvalidSaltError', {
+  enumerable: true,
+  get: function () {
+    return InvalidSaltError;
+  }
+});
+Object.defineProperty(exports, 'NoRandomSourceError', {
+  enumerable: true,
+  get: function () {
+    return NoRandomSourceError;
+  }
+});

package/dist/errors-LTe7bOYS.js

@@ -0,0 +1,33 @@
+//#region src/entity/errors.ts
+/** An expiry could not be expressed, or would be rejected by the engine. */
+var InvalidExpiryError = class extends Error {
+	constructor(reason) {
+		super(`Invalid expiry: ${reason}`);
+		this.name = "InvalidExpiryError";
+	}
+};
+/** A `creationFlags` byte could not be built or read. */
+var InvalidCreationFlagsError = class extends Error {
+	constructor(reason) {
+		super(`Invalid creation flags: ${reason}`);
+		this.name = "InvalidCreationFlagsError";
+	}
+};
+/** A key salt was outside the `uint128` the wire carries. */
+var InvalidSaltError = class extends Error {
+	constructor(salt) {
+		super(`Invalid salt ${salt}. A salt is a uint128, so it must be between 0 and ${2n ** 128n - 1n}. Omit it to get 128 random bits, or pass 0 for a predictable key.`);
+		this.name = "InvalidSaltError";
+	}
+};
+/** No cryptographic randomness was available to generate a salt. */
+var NoRandomSourceError = class extends Error {
+	constructor() {
+		super("No cryptographic random source is available (globalThis.crypto.getRandomValues is missing), so a key salt cannot be generated. Upgrade to Node 18+ or a modern browser, or pass an explicit salt.");
+		this.name = "NoRandomSourceError";
+	}
+};
+
+//#endregion
+export { NoRandomSourceError as i, InvalidExpiryError as n, InvalidSaltError as r, InvalidCreationFlagsError as t };
+//# sourceMappingURL=errors-LTe7bOYS.js.map

package/dist/errors-LTe7bOYS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-LTe7bOYS.js","names":[],"sources":["../src/entity/errors.ts"],"sourcesContent":["/** An expiry could not be expressed, or would be rejected by the engine. */\nexport class InvalidExpiryError extends Error {\n  constructor(reason: string) {\n    super(`Invalid expiry: ${reason}`)\n    this.name = \"InvalidExpiryError\"\n  }\n}\n\n/** A `creationFlags` byte could not be built or read. */\nexport class InvalidCreationFlagsError extends Error {\n  constructor(reason: string) {\n    super(`Invalid creation flags: ${reason}`)\n    this.name = \"InvalidCreationFlagsError\"\n  }\n}\n\n/** A key salt was outside the `uint128` the wire carries. */\nexport class InvalidSaltError extends Error {\n  constructor(salt: bigint) {\n    super(\n      `Invalid salt ${salt}. A salt is a uint128, so it must be between 0 and ` +\n        `${2n ** 128n - 1n}. Omit it to get 128 random bits, or pass 0 for a predictable key.`,\n    )\n    this.name = \"InvalidSaltError\"\n  }\n}\n\n/** No cryptographic randomness was available to generate a salt. */\nexport class NoRandomSourceError extends Error {\n  constructor() {\n    super(\n      \"No cryptographic random source is available (globalThis.crypto.getRandomValues is \" +\n        \"missing), so a key salt cannot be generated. Upgrade to Node 18+ or a modern browser, \" +\n        \"or pass an explicit salt.\",\n    )\n    this.name = \"NoRandomSourceError\"\n  }\n}\n"],"mappings":";;AACA,IAAa,qBAAb,cAAwC,MAAM;CAC5C,YAAY,QAAgB;AAC1B,QAAM,mBAAmB,SAAS;AAClC,OAAK,OAAO;;;;AAKhB,IAAa,4BAAb,cAA+C,MAAM;CACnD,YAAY,QAAgB;AAC1B,QAAM,2BAA2B,SAAS;AAC1C,OAAK,OAAO;;;;AAKhB,IAAa,mBAAb,cAAsC,MAAM;CAC1C,YAAY,MAAc;AACxB,QACE,gBAAgB,KAAK,qDAChB,MAAM,OAAO,GAAG,oEACtB;AACD,OAAK,OAAO;;;;AAKhB,IAAa,sBAAb,cAAyC,MAAM;CAC7C,cAAc;AACZ,QACE,oMAGD;AACD,OAAK,OAAO"}

package/dist/expiry-BELY2Kpw.cjs

@@ -0,0 +1,135 @@
+const require_errors = require('./errors-BVbjKVMN.cjs');
+
+//#region src/consts.ts
+const ARKIV_ADDRESS = "0x4400000000000000000000000000000000000044";
+const BLOCK_TIME = 2;
+
+//#endregion
+//#region src/entity/params.ts
+/**
+* Max uint64 value
+*/
+const MAX_EXPIRES_AT = 2n ** 64n - 1n;
+/** The operation tags of the `execute` ABI's tagged union. */
+const OperationType = {
+	Create: 1,
+	Patch: 2,
+	ExtendExpiry: 3,
+	TransferOwnership: 4,
+	Delete: 5
+};
+
+//#endregion
+//#region src/entity/expiry.ts
+/**
+* Builds a branded {@link Expiry}.
+*
+* Internal seam for {@link ExpirationTime}, which is the only thing that should call it — it is not
+* part of the package's public surface.
+*/
+function makeExpiry(minLifetime, expiresAt) {
+	return {
+		minLifetime,
+		expiresAt
+	};
+}
+/**
+* Resolves an expiry into the wire pair and the block the entity will expire at.
+*
+* Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them
+* **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the
+* chain runs fast or slow. The block it was converted to comes back as
+* {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.
+*
+* @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire
+* carries, or would leave the entity dead on arrival.
+*/
+function resolveExpiry(expiry, context) {
+	const { currentBlock } = context;
+	if (typeof expiry?.minLifetime !== "bigint" || expiry.expiresAt === void 0) throw new require_errors.InvalidExpiryError("expires must be built with ExpirationTime, e.g. ExpirationTime.fromDays(30) or ExpirationTime.atBlock(1_200_000n)");
+	const { minLifetime } = expiry;
+	const absolute = typeof expiry.expiresAt === "bigint" ? expiry.expiresAt : blockAtDate(expiry.expiresAt, currentBlock);
+	if (minLifetime === 0n && absolute === 0n) throw new require_errors.InvalidExpiryError("no expiry given. Pass ExpirationTime.fromDays(30) for a lifetime, ExpirationTime.atBlock(n) for an absolute deadline, or a deadline with { atLeast } to take whichever is later.");
+	if (absolute > MAX_EXPIRES_AT) throw new require_errors.InvalidExpiryError(`expiresAt resolves to block ${absolute}, which does not fit the uint64 the wire carries (max ${MAX_EXPIRES_AT}). Use ExpirationTime.permanent() for an entity that should not expire.`);
+	if (minLifetime > MAX_EXPIRES_AT) throw new require_errors.InvalidExpiryError(`the lifetime is ${minLifetime} blocks, which does not fit the uint64 the wire carries (max ${MAX_EXPIRES_AT})`);
+	const relative = minLifetime === 0n ? 0n : currentBlock + minLifetime;
+	const target = absolute > relative ? absolute : relative;
+	if (target <= currentBlock) throw new require_errors.InvalidExpiryError(`the entity would expire at block ${target}, which is not after the current block ${currentBlock}, so it would be dead on arrival`);
+	if (target > MAX_EXPIRES_AT) throw new require_errors.InvalidExpiryError(`a lifetime of ${minLifetime} blocks from block ${currentBlock} lands at ${target}, past the largest expiry the wire carries (${MAX_EXPIRES_AT})`);
+	return {
+		expiresAt: absolute,
+		minLifetime,
+		target
+	};
+}
+/**
+* A duration in seconds as a whole number of blocks.
+*
+* Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not
+* describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks
+* — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple
+* of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.
+*
+* @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.
+*/
+function toBlocks(seconds) {
+	if (!Number.isInteger(seconds) || seconds <= 0) throw new require_errors.InvalidExpiryError(`a lifetime must be a positive whole number of seconds, got ${seconds}. Use the ExpirationTime helpers, e.g. ExpirationTime.fromDays(30).`);
+	if (seconds % BLOCK_TIME !== 0) throw new require_errors.InvalidExpiryError(`a lifetime must be a multiple of the ${BLOCK_TIME}s block time, got ${seconds}, which is ${seconds / BLOCK_TIME} blocks. Try ${seconds - seconds % BLOCK_TIME} or ${seconds + BLOCK_TIME - seconds % BLOCK_TIME}, or ExpirationTime.fromBlocks(n).`);
+	return BigInt(seconds / BLOCK_TIME);
+}
+/**
+* The block a wall-clock instant lands on.
+*
+* Rounds **up**: a date almost never falls on a block boundary, and unlike a duration — which the
+* caller states and can state exactly — there is nothing here to reject, so the entity lives until
+* at least the instant asked for.
+*/
+function blockAtDate(date, currentBlock) {
+	const secondsAway = (date.getTime() - Date.now()) / 1e3;
+	if (secondsAway <= 0) throw new require_errors.InvalidExpiryError(`the deadline ${date.toISOString()} is in the past, so the entity would be dead on arrival`);
+	return currentBlock + BigInt(Math.ceil(secondsAway / BLOCK_TIME));
+}
+
+//#endregion
+Object.defineProperty(exports, 'ARKIV_ADDRESS', {
+  enumerable: true,
+  get: function () {
+    return ARKIV_ADDRESS;
+  }
+});
+Object.defineProperty(exports, 'BLOCK_TIME', {
+  enumerable: true,
+  get: function () {
+    return BLOCK_TIME;
+  }
+});
+Object.defineProperty(exports, 'MAX_EXPIRES_AT', {
+  enumerable: true,
+  get: function () {
+    return MAX_EXPIRES_AT;
+  }
+});
+Object.defineProperty(exports, 'OperationType', {
+  enumerable: true,
+  get: function () {
+    return OperationType;
+  }
+});
+Object.defineProperty(exports, 'makeExpiry', {
+  enumerable: true,
+  get: function () {
+    return makeExpiry;
+  }
+});
+Object.defineProperty(exports, 'resolveExpiry', {
+  enumerable: true,
+  get: function () {
+    return resolveExpiry;
+  }
+});
+Object.defineProperty(exports, 'toBlocks', {
+  enumerable: true,
+  get: function () {
+    return toBlocks;
+  }
+});

package/dist/expiry-BjpxZZQU.js

@@ -0,0 +1,95 @@
+import { n as InvalidExpiryError } from "./errors-LTe7bOYS.js";
+
+//#region src/consts.ts
+const ARKIV_ADDRESS = "0x4400000000000000000000000000000000000044";
+const BLOCK_TIME = 2;
+
+//#endregion
+//#region src/entity/params.ts
+/**
+* Max uint64 value
+*/
+const MAX_EXPIRES_AT = 2n ** 64n - 1n;
+/** The operation tags of the `execute` ABI's tagged union. */
+const OperationType = {
+	Create: 1,
+	Patch: 2,
+	ExtendExpiry: 3,
+	TransferOwnership: 4,
+	Delete: 5
+};
+
+//#endregion
+//#region src/entity/expiry.ts
+/**
+* Builds a branded {@link Expiry}.
+*
+* Internal seam for {@link ExpirationTime}, which is the only thing that should call it — it is not
+* part of the package's public surface.
+*/
+function makeExpiry(minLifetime, expiresAt) {
+	return {
+		minLifetime,
+		expiresAt
+	};
+}
+/**
+* Resolves an expiry into the wire pair and the block the entity will expire at.
+*
+* Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them
+* **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the
+* chain runs fast or slow. The block it was converted to comes back as
+* {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.
+*
+* @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire
+* carries, or would leave the entity dead on arrival.
+*/
+function resolveExpiry(expiry, context) {
+	const { currentBlock } = context;
+	if (typeof expiry?.minLifetime !== "bigint" || expiry.expiresAt === void 0) throw new InvalidExpiryError("expires must be built with ExpirationTime, e.g. ExpirationTime.fromDays(30) or ExpirationTime.atBlock(1_200_000n)");
+	const { minLifetime } = expiry;
+	const absolute = typeof expiry.expiresAt === "bigint" ? expiry.expiresAt : blockAtDate(expiry.expiresAt, currentBlock);
+	if (minLifetime === 0n && absolute === 0n) throw new InvalidExpiryError("no expiry given. Pass ExpirationTime.fromDays(30) for a lifetime, ExpirationTime.atBlock(n) for an absolute deadline, or a deadline with { atLeast } to take whichever is later.");
+	if (absolute > MAX_EXPIRES_AT) throw new InvalidExpiryError(`expiresAt resolves to block ${absolute}, which does not fit the uint64 the wire carries (max ${MAX_EXPIRES_AT}). Use ExpirationTime.permanent() for an entity that should not expire.`);
+	if (minLifetime > MAX_EXPIRES_AT) throw new InvalidExpiryError(`the lifetime is ${minLifetime} blocks, which does not fit the uint64 the wire carries (max ${MAX_EXPIRES_AT})`);
+	const relative = minLifetime === 0n ? 0n : currentBlock + minLifetime;
+	const target = absolute > relative ? absolute : relative;
+	if (target <= currentBlock) throw new InvalidExpiryError(`the entity would expire at block ${target}, which is not after the current block ${currentBlock}, so it would be dead on arrival`);
+	if (target > MAX_EXPIRES_AT) throw new InvalidExpiryError(`a lifetime of ${minLifetime} blocks from block ${currentBlock} lands at ${target}, past the largest expiry the wire carries (${MAX_EXPIRES_AT})`);
+	return {
+		expiresAt: absolute,
+		minLifetime,
+		target
+	};
+}
+/**
+* A duration in seconds as a whole number of blocks.
+*
+* Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not
+* describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks
+* — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple
+* of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.
+*
+* @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.
+*/
+function toBlocks(seconds) {
+	if (!Number.isInteger(seconds) || seconds <= 0) throw new InvalidExpiryError(`a lifetime must be a positive whole number of seconds, got ${seconds}. Use the ExpirationTime helpers, e.g. ExpirationTime.fromDays(30).`);
+	if (seconds % BLOCK_TIME !== 0) throw new InvalidExpiryError(`a lifetime must be a multiple of the ${BLOCK_TIME}s block time, got ${seconds}, which is ${seconds / BLOCK_TIME} blocks. Try ${seconds - seconds % BLOCK_TIME} or ${seconds + BLOCK_TIME - seconds % BLOCK_TIME}, or ExpirationTime.fromBlocks(n).`);
+	return BigInt(seconds / BLOCK_TIME);
+}
+/**
+* The block a wall-clock instant lands on.
+*
+* Rounds **up**: a date almost never falls on a block boundary, and unlike a duration — which the
+* caller states and can state exactly — there is nothing here to reject, so the entity lives until
+* at least the instant asked for.
+*/
+function blockAtDate(date, currentBlock) {
+	const secondsAway = (date.getTime() - Date.now()) / 1e3;
+	if (secondsAway <= 0) throw new InvalidExpiryError(`the deadline ${date.toISOString()} is in the past, so the entity would be dead on arrival`);
+	return currentBlock + BigInt(Math.ceil(secondsAway / BLOCK_TIME));
+}
+
+//#endregion
+export { OperationType as a, MAX_EXPIRES_AT as i, resolveExpiry as n, ARKIV_ADDRESS as o, toBlocks as r, BLOCK_TIME as s, makeExpiry as t };
+//# sourceMappingURL=expiry-BjpxZZQU.js.map

package/dist/expiry-BjpxZZQU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry-BjpxZZQU.js","names":[],"sources":["../src/consts.ts","../src/entity/params.ts","../src/entity/expiry.ts"],"sourcesContent":["//export const ARKIV_ADDRESS = \"0x00000000000000000000000000000061726b6976\" as `0x${string}`\nexport const ARKIV_ADDRESS = \"0x4400000000000000000000000000000000000044\" as `0x${string}`\nexport const BLOCK_TIME = 2 // 2 seconds\n","/**\n * Max uint64 value\n */\nexport const MAX_EXPIRES_AT = 2n ** 64n - 1n\n\n/** The operation tags of the `execute` ABI's tagged union. */\nexport const OperationType = {\n  Create: 1,\n  Patch: 2,\n  ExtendExpiry: 3,\n  TransferOwnership: 4,\n  Delete: 5,\n} as const\n\nexport type OperationType = (typeof OperationType)[keyof typeof OperationType]\n","import { BLOCK_TIME } from \"../consts\"\nimport { InvalidExpiryError } from \"./errors\"\nimport { MAX_EXPIRES_AT } from \"./params\"\n\n/**\n * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to\n * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will\n * not typecheck, and neither will a bare number of seconds.\n */\ndeclare const validated: unique symbol\n\n/**\n * How long an entity should live.\n *\n * This is the pair the ABI carries, and the engine resolves it as\n * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with\n * {@link ExpirationTime}; there is no other way to make one.\n *\n * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so\n * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number\n * by construction, so a wall-clock date rounds into it rather than being rejected.\n */\nexport type Expiry = {\n  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */\n  readonly minLifetime: bigint\n  /**\n   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.\n   * `0n` if unset.\n   */\n  readonly expiresAt: bigint | Date\n  readonly [validated]: true\n}\n\n/**\n * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.\n *\n * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what\n * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.\n */\nexport type Lifetime = Expiry & { readonly expiresAt: 0n }\n\n/**\n * Builds a branded {@link Expiry}.\n *\n * Internal seam for {@link ExpirationTime}, which is the only thing that should call it — it is not\n * part of the package's public surface.\n */\nexport function makeExpiry(minLifetime: bigint, expiresAt: bigint | Date): Expiry {\n  return { minLifetime, expiresAt } as Expiry\n}\n\n/** The two `uint256` values the ABI carries, with every `Date` already placed. */\nexport type EncodedExpiry = {\n  /** Absolute target block height, or `0n` for a purely relative lifetime. */\n  expiresAt: bigint\n  /** Relative floor in blocks, or `0n` for a purely absolute expiry. */\n  minLifetime: bigint\n}\n\n/** What an expiry resolves to, given the chain's current block. */\nexport type ResolvedExpiry = EncodedExpiry & {\n  /** The block the entity will expire at — `max(expiresAt, currentBlock + minLifetime)`. */\n  target: bigint\n}\n\n/** What the SDK needs to know about the chain to resolve an expiry. */\nexport type ExpiryContext = {\n  currentBlock: bigint\n}\n\n/**\n * Resolves an expiry into the wire pair and the block the entity will expire at.\n *\n * Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them\n * **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the\n * chain runs fast or slow. The block it was converted to comes back as\n * {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.\n *\n * @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire\n * carries, or would leave the entity dead on arrival.\n */\nexport function resolveExpiry(expiry: Expiry, context: ExpiryContext): ResolvedExpiry {\n  const { currentBlock } = context\n\n  if (typeof expiry?.minLifetime !== \"bigint\" || expiry.expiresAt === undefined) {\n    throw new InvalidExpiryError(\n      \"expires must be built with ExpirationTime, e.g. ExpirationTime.fromDays(30) or \" +\n        \"ExpirationTime.atBlock(1_200_000n)\",\n    )\n  }\n\n  const { minLifetime } = expiry\n  const absolute =\n    typeof expiry.expiresAt === \"bigint\"\n      ? expiry.expiresAt\n      : blockAtDate(expiry.expiresAt, currentBlock)\n\n  if (minLifetime === 0n && absolute === 0n) {\n    throw new InvalidExpiryError(\n      \"no expiry given. Pass ExpirationTime.fromDays(30) for a lifetime, \" +\n        \"ExpirationTime.atBlock(n) for an absolute deadline, or a deadline with \" +\n        \"{ atLeast } to take whichever is later.\",\n    )\n  }\n\n  if (absolute > MAX_EXPIRES_AT) {\n    throw new InvalidExpiryError(\n      `expiresAt resolves to block ${absolute}, which does not fit the uint64 the wire carries ` +\n        `(max ${MAX_EXPIRES_AT}). Use ExpirationTime.permanent() for an entity that should not ` +\n        \"expire.\",\n    )\n  }\n  if (minLifetime > MAX_EXPIRES_AT) {\n    throw new InvalidExpiryError(\n      `the lifetime is ${minLifetime} blocks, which does not fit the uint64 the wire carries ` +\n        `(max ${MAX_EXPIRES_AT})`,\n    )\n  }\n\n  const relative = minLifetime === 0n ? 0n : currentBlock + minLifetime\n  const target = absolute > relative ? absolute : relative\n\n  if (target <= currentBlock) {\n    throw new InvalidExpiryError(\n      `the entity would expire at block ${target}, which is not after the current block ` +\n        `${currentBlock}, so it would be dead on arrival`,\n    )\n  }\n  if (target > MAX_EXPIRES_AT) {\n    throw new InvalidExpiryError(\n      `a lifetime of ${minLifetime} blocks from block ${currentBlock} lands at ${target}, past ` +\n        `the largest expiry the wire carries (${MAX_EXPIRES_AT})`,\n    )\n  }\n\n  return { expiresAt: absolute, minLifetime, target }\n}\n\n/**\n * A duration in seconds as a whole number of blocks.\n *\n * Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not\n * describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks\n * — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple\n * of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.\n *\n * @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.\n */\nexport function toBlocks(seconds: number): bigint {\n  if (!Number.isInteger(seconds) || seconds <= 0) {\n    throw new InvalidExpiryError(\n      `a lifetime must be a positive whole number of seconds, got ${seconds}. Use the ` +\n        \"ExpirationTime helpers, e.g. ExpirationTime.fromDays(30).\",\n    )\n  }\n  if (seconds % BLOCK_TIME !== 0) {\n    throw new InvalidExpiryError(\n      `a lifetime must be a multiple of the ${BLOCK_TIME}s block time, got ${seconds}, which is ` +\n        `${seconds / BLOCK_TIME} blocks. Try ${seconds - (seconds % BLOCK_TIME)} or ` +\n        `${seconds + BLOCK_TIME - (seconds % BLOCK_TIME)}, or ExpirationTime.fromBlocks(n).`,\n    )\n  }\n  return BigInt(seconds / BLOCK_TIME)\n}\n\n/**\n * The block a wall-clock instant lands on.\n *\n * Rounds **up**: a date almost never falls on a block boundary, and unlike a duration — which the\n * caller states and can state exactly — there is nothing here to reject, so the entity lives until\n * at least the instant asked for.\n */\nfunction blockAtDate(date: Date, currentBlock: bigint): bigint {\n  const secondsAway = (date.getTime() - Date.now()) / 1000\n  if (secondsAway <= 0) {\n    throw new InvalidExpiryError(\n      `the deadline ${date.toISOString()} is in the past, so the entity would be dead on arrival`,\n    )\n  }\n  return currentBlock + BigInt(Math.ceil(secondsAway / BLOCK_TIME))\n}\n"],"mappings":";;;AACA,MAAa,gBAAgB;AAC7B,MAAa,aAAa;;;;;;;ACC1B,MAAa,iBAAiB,MAAM,MAAM;;AAG1C,MAAa,gBAAgB;CAC3B,QAAQ;CACR,OAAO;CACP,cAAc;CACd,mBAAmB;CACnB,QAAQ;CACT;;;;;;;;;;ACmCD,SAAgB,WAAW,aAAqB,WAAkC;AAChF,QAAO;EAAE;EAAa;EAAW;;;;;;;;;;;;;AAiCnC,SAAgB,cAAc,QAAgB,SAAwC;CACpF,MAAM,EAAE,iBAAiB;AAEzB,KAAI,OAAO,QAAQ,gBAAgB,YAAY,OAAO,cAAc,OAClE,OAAM,IAAI,mBACR,oHAED;CAGH,MAAM,EAAE,gBAAgB;CACxB,MAAM,WACJ,OAAO,OAAO,cAAc,WACxB,OAAO,YACP,YAAY,OAAO,WAAW,aAAa;AAEjD,KAAI,gBAAgB,MAAM,aAAa,GACrC,OAAM,IAAI,mBACR,mLAGD;AAGH,KAAI,WAAW,eACb,OAAM,IAAI,mBACR,+BAA+B,SAAS,wDAC9B,eAAe,yEAE1B;AAEH,KAAI,cAAc,eAChB,OAAM,IAAI,mBACR,mBAAmB,YAAY,+DACrB,eAAe,GAC1B;CAGH,MAAM,WAAW,gBAAgB,KAAK,KAAK,eAAe;CAC1D,MAAM,SAAS,WAAW,WAAW,WAAW;AAEhD,KAAI,UAAU,aACZ,OAAM,IAAI,mBACR,oCAAoC,OAAO,yCACtC,aAAa,kCACnB;AAEH,KAAI,SAAS,eACX,OAAM,IAAI,mBACR,iBAAiB,YAAY,qBAAqB,aAAa,YAAY,OAAO,8CACxC,eAAe,GAC1D;AAGH,QAAO;EAAE,WAAW;EAAU;EAAa;EAAQ;;;;;;;;;;;;AAarD,SAAgB,SAAS,SAAyB;AAChD,KAAI,CAAC,OAAO,UAAU,QAAQ,IAAI,WAAW,EAC3C,OAAM,IAAI,mBACR,8DAA8D,QAAQ,qEAEvE;AAEH,KAAI,UAAU,eAAe,EAC3B,OAAM,IAAI,mBACR,wCAAwC,WAAW,oBAAoB,QAAQ,aAC1E,UAAU,WAAW,eAAe,UAAW,UAAU,WAAY,MACrE,UAAU,aAAc,UAAU,WAAY,oCACpD;AAEH,QAAO,OAAO,UAAU,WAAW;;;;;;;;;AAUrC,SAAS,YAAY,MAAY,cAA8B;CAC7D,MAAM,eAAe,KAAK,SAAS,GAAG,KAAK,KAAK,IAAI;AACpD,KAAI,eAAe,EACjB,OAAM,IAAI,mBACR,gBAAgB,KAAK,aAAa,CAAC,yDACpC;AAEH,QAAO,eAAe,OAAO,KAAK,KAAK,cAAc,WAAW,CAAC"}

package/dist/expiry-DRV29F1r.d.cts

@@ -0,0 +1,79 @@
+//#region src/entity/expiry.d.ts
+/**
+ * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to
+ * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will
+ * not typecheck, and neither will a bare number of seconds.
+ */
+declare const validated: unique symbol;
+/**
+ * How long an entity should live.
+ *
+ * This is the pair the ABI carries, and the engine resolves it as
+ * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with
+ * {@link ExpirationTime}; there is no other way to make one.
+ *
+ * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so
+ * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number
+ * by construction, so a wall-clock date rounds into it rather than being rejected.
+ */
+type Expiry = {
+  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */
+  readonly minLifetime: bigint;
+  /**
+   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.
+   * `0n` if unset.
+   */
+  readonly expiresAt: bigint | Date;
+  readonly [validated]: true;
+};
+/**
+ * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.
+ *
+ * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what
+ * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.
+ */
+type Lifetime = Expiry & {
+  readonly expiresAt: 0n;
+};
+/** The two `uint256` values the ABI carries, with every `Date` already placed. */
+type EncodedExpiry = {
+  /** Absolute target block height, or `0n` for a purely relative lifetime. */
+  expiresAt: bigint;
+  /** Relative floor in blocks, or `0n` for a purely absolute expiry. */
+  minLifetime: bigint;
+};
+/** What an expiry resolves to, given the chain's current block. */
+type ResolvedExpiry = EncodedExpiry & {
+  /** The block the entity will expire at — `max(expiresAt, currentBlock + minLifetime)`. */
+  target: bigint;
+};
+/** What the SDK needs to know about the chain to resolve an expiry. */
+type ExpiryContext = {
+  currentBlock: bigint;
+};
+/**
+ * Resolves an expiry into the wire pair and the block the entity will expire at.
+ *
+ * Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them
+ * **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the
+ * chain runs fast or slow. The block it was converted to comes back as
+ * {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.
+ *
+ * @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire
+ * carries, or would leave the entity dead on arrival.
+ */
+declare function resolveExpiry(expiry: Expiry, context: ExpiryContext): ResolvedExpiry;
+/**
+ * A duration in seconds as a whole number of blocks.
+ *
+ * Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not
+ * describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks
+ * — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple
+ * of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.
+ *
+ * @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.
+ */
+declare function toBlocks(seconds: number): bigint;
+//#endregion
+export { ResolvedExpiry as a, Lifetime as i, Expiry as n, resolveExpiry as o, ExpiryContext as r, toBlocks as s, EncodedExpiry as t };
+//# sourceMappingURL=expiry-DRV29F1r.d.cts.map

package/dist/expiry-DRV29F1r.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry-DRV29F1r.d.cts","names":[],"sources":["../src/entity/expiry.ts"],"sourcesContent":[],"mappings":";;;AAsBA;AAiBA;AAaA;AAQA,cAnDc,SAmDY,EAAA,OAAA,MAAG;AAM7B;AAeA;;;;;AAmEA;;;;;KA9HY,MAAA;;;;;;;+BAOmB;YACnB,SAAA;;;;;;;;KASA,QAAA,GAAW;;;;KAaX,aAAA;;;;;;;KAQA,cAAA,GAAiB;;;;;KAMjB,aAAA;;;;;;;;;;;;;;iBAeI,aAAA,SAAsB,iBAAiB,gBAAgB;;;;;;;;;;;iBAmEvD,QAAA"}

package/dist/expiry-nDbCgZX4.d.ts

@@ -0,0 +1,79 @@
+//#region src/entity/expiry.d.ts
+/**
+ * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to
+ * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will
+ * not typecheck, and neither will a bare number of seconds.
+ */
+declare const validated: unique symbol;
+/**
+ * How long an entity should live.
+ *
+ * This is the pair the ABI carries, and the engine resolves it as
+ * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with
+ * {@link ExpirationTime}; there is no other way to make one.
+ *
+ * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so
+ * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number
+ * by construction, so a wall-clock date rounds into it rather than being rejected.
+ */
+type Expiry = {
+  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */
+  readonly minLifetime: bigint;
+  /**
+   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.
+   * `0n` if unset.
+   */
+  readonly expiresAt: bigint | Date;
+  readonly [validated]: true;
+};
+/**
+ * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.
+ *
+ * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what
+ * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.
+ */
+type Lifetime = Expiry & {
+  readonly expiresAt: 0n;
+};
+/** The two `uint256` values the ABI carries, with every `Date` already placed. */
+type EncodedExpiry = {
+  /** Absolute target block height, or `0n` for a purely relative lifetime. */
+  expiresAt: bigint;
+  /** Relative floor in blocks, or `0n` for a purely absolute expiry. */
+  minLifetime: bigint;
+};
+/** What an expiry resolves to, given the chain's current block. */
+type ResolvedExpiry = EncodedExpiry & {
+  /** The block the entity will expire at — `max(expiresAt, currentBlock + minLifetime)`. */
+  target: bigint;
+};
+/** What the SDK needs to know about the chain to resolve an expiry. */
+type ExpiryContext = {
+  currentBlock: bigint;
+};
+/**
+ * Resolves an expiry into the wire pair and the block the entity will expire at.
+ *
+ * Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them
+ * **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the
+ * chain runs fast or slow. The block it was converted to comes back as
+ * {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.
+ *
+ * @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire
+ * carries, or would leave the entity dead on arrival.
+ */
+declare function resolveExpiry(expiry: Expiry, context: ExpiryContext): ResolvedExpiry;
+/**
+ * A duration in seconds as a whole number of blocks.
+ *
+ * Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not
+ * describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks
+ * — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple
+ * of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.
+ *
+ * @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.
+ */
+declare function toBlocks(seconds: number): bigint;
+//#endregion
+export { ResolvedExpiry as a, Lifetime as i, Expiry as n, resolveExpiry as o, ExpiryContext as r, toBlocks as s, EncodedExpiry as t };
+//# sourceMappingURL=expiry-nDbCgZX4.d.ts.map

package/dist/expiry-nDbCgZX4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry-nDbCgZX4.d.ts","names":[],"sources":["../src/entity/expiry.ts"],"sourcesContent":[],"mappings":";;;AAsBA;AAiBA;AAaA;AAQA,cAnDc,SAmDY,EAAA,OAAA,MAAG;AAM7B;AAeA;;;;;AAmEA;;;;;KA9HY,MAAA;;;;;;;+BAOmB;YACnB,SAAA;;;;;;;;KASA,QAAA,GAAW;;;;KAaX,aAAA;;;;;;;KAQA,cAAA,GAAiB;;;;;KAMjB,aAAA;;;;;;;;;;;;;;iBAeI,aAAA,SAAsB,iBAAiB,gBAAgB;;;;;;;;;;;iBAmEvD,QAAA"}

package/dist/flags-5dTNRnow.d.ts

@@ -0,0 +1,41 @@
+//#region src/entity/flags.d.ts
+/**
+ * The immutable properties an entity is created with. Both default to `false`.
+ *
+ * Creation flags are fixed at creation: there is no operation that changes them, so an entity is
+ * whatever it was created as for its whole life.
+ */
+type CreationFlags = {
+  /**
+   * The entity's attributes and payload can never be changed — only its expiry extended, its
+   * ownership transferred, and the entity deleted.
+   */
+  readonly?: boolean;
+  /**
+   * Anyone, not just the owner, may extend the entity's expiry. Lets a third party keep something
+   * alive without being able to change it.
+   */
+  permissionlessExtension?: boolean;
+};
+/** {@link CreationFlags} as read back, with every flag resolved and the raw byte alongside. */
+type ResolvedCreationFlags = {
+  readonly: boolean;
+  permissionlessExtension: boolean;
+  raw: number;
+};
+/**
+ * Packs creation flags into the `creationFlags` byte.
+ *
+ * @throws {InvalidCreationFlagsError} If a value is not a boolean.
+ */
+declare function encodeCreationFlags(flags?: CreationFlags): number;
+/**
+ * Reads the `creationFlags` byte back.
+ *
+ * @param raw - The `creationFlags` byte.
+ * @throws {InvalidCreationFlagsError} Malformed input
+ */
+declare function decodeCreationFlags(raw: number): ResolvedCreationFlags;
+//#endregion
+export { encodeCreationFlags as i, ResolvedCreationFlags as n, decodeCreationFlags as r, CreationFlags as t };
+//# sourceMappingURL=flags-5dTNRnow.d.ts.map

package/dist/flags-5dTNRnow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags-5dTNRnow.d.ts","names":[],"sources":["../src/entity/flags.ts"],"sourcesContent":[],"mappings":";;AAYA;AAcA;AAWA;AAkBA;;KA3CY,aAAA;;;;;;;;;;;;;KAcA,qBAAA;;;;;;;;;;iBAWI,mBAAA,SAA2B;;;;;;;iBAkB3B,mBAAA,eAAkC"}