spacetimedb 2.4.1 → 2.5.0

package/dist/solid/index.mjs

@@ -0,0 +1,1863 @@
+import { fromByteArray } from 'base64-js';
+import { createContext, useContext, createMemo, createComputed, onCleanup, createSignal, createEffect } from 'solid-js';
+import { createStore, reconcile } from 'solid-js/store';
+
+// src/lib/time_duration.ts
+var TimeDuration = class _TimeDuration {
+  __time_duration_micros__;
+  static MICROS_PER_MILLIS = 1000n;
+  /**
+   * Get the algebraic type representation of the {@link TimeDuration} type.
+   * @returns The algebraic type representation of the type.
+   */
+  static getAlgebraicType() {
+    return AlgebraicType.Product({
+      elements: [
+        {
+          name: "__time_duration_micros__",
+          algebraicType: AlgebraicType.I64
+        }
+      ]
+    });
+  }
+  static isTimeDuration(algebraicType) {
+    if (algebraicType.tag !== "Product") {
+      return false;
+    }
+    const elements = algebraicType.value.elements;
+    if (elements.length !== 1) {
+      return false;
+    }
+    const microsElement = elements[0];
+    return microsElement.name === "__time_duration_micros__" && microsElement.algebraicType.tag === "I64";
+  }
+  get micros() {
+    return this.__time_duration_micros__;
+  }
+  get millis() {
+    return Number(this.micros / _TimeDuration.MICROS_PER_MILLIS);
+  }
+  constructor(micros) {
+    this.__time_duration_micros__ = micros;
+  }
+  static fromMillis(millis) {
+    return new _TimeDuration(BigInt(millis) * _TimeDuration.MICROS_PER_MILLIS);
+  }
+  /** This outputs the same string format that we use in the host and in Rust modules */
+  toString() {
+    const micros = this.micros;
+    const sign = micros < 0 ? "-" : "+";
+    const pos = micros < 0 ? -micros : micros;
+    const secs = pos / 1000000n;
+    const micros_remaining = pos % 1000000n;
+    return `${sign}${secs}.${String(micros_remaining).padStart(6, "0")}`;
+  }
+};
+
+// src/lib/timestamp.ts
+var Timestamp = class _Timestamp {
+  __timestamp_micros_since_unix_epoch__;
+  static MICROS_PER_MILLIS = 1000n;
+  get microsSinceUnixEpoch() {
+    return this.__timestamp_micros_since_unix_epoch__;
+  }
+  constructor(micros) {
+    this.__timestamp_micros_since_unix_epoch__ = micros;
+  }
+  /**
+   * Get the algebraic type representation of the {@link Timestamp} type.
+   * @returns The algebraic type representation of the type.
+   */
+  static getAlgebraicType() {
+    return AlgebraicType.Product({
+      elements: [
+        {
+          name: "__timestamp_micros_since_unix_epoch__",
+          algebraicType: AlgebraicType.I64
+        }
+      ]
+    });
+  }
+  static isTimestamp(algebraicType) {
+    if (algebraicType.tag !== "Product") {
+      return false;
+    }
+    const elements = algebraicType.value.elements;
+    if (elements.length !== 1) {
+      return false;
+    }
+    const microsElement = elements[0];
+    return microsElement.name === "__timestamp_micros_since_unix_epoch__" && microsElement.algebraicType.tag === "I64";
+  }
+  /**
+   * The Unix epoch, the midnight at the beginning of January 1, 1970, UTC.
+   */
+  static UNIX_EPOCH = new _Timestamp(0n);
+  /**
+   * Get a `Timestamp` representing the execution environment's belief of the current moment in time.
+   */
+  static now() {
+    return _Timestamp.fromDate(/* @__PURE__ */ new Date());
+  }
+  /** Convert to milliseconds since Unix epoch. */
+  toMillis() {
+    return this.microsSinceUnixEpoch / 1000n;
+  }
+  /**
+   * Get a `Timestamp` representing the same point in time as `date`.
+   */
+  static fromDate(date) {
+    const millis = date.getTime();
+    const micros = BigInt(millis) * _Timestamp.MICROS_PER_MILLIS;
+    return new _Timestamp(micros);
+  }
+  /**
+   * Get a `Date` representing approximately the same point in time as `this`.
+   *
+   * This method truncates to millisecond precision,
+   * and throws `RangeError` if the `Timestamp` is outside the range representable as a `Date`.
+   */
+  toDate() {
+    const micros = this.__timestamp_micros_since_unix_epoch__;
+    const millis = micros / _Timestamp.MICROS_PER_MILLIS;
+    if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) {
+      throw new RangeError(
+        "Timestamp is outside of the representable range of JS's Date"
+      );
+    }
+    return new Date(Number(millis));
+  }
+  /**
+   * Get an ISO 8601 / RFC 3339 formatted string representation of this timestamp with microsecond precision.
+   *
+   * This method preserves the full microsecond precision of the timestamp,
+   * and throws `RangeError` if the `Timestamp` is outside the range representable in ISO format.
+   *
+   * @returns ISO 8601 formatted string with microsecond precision (e.g., '2025-02-17T10:30:45.123456Z')
+   */
+  toISOString() {
+    const micros = this.__timestamp_micros_since_unix_epoch__;
+    const millis = micros / _Timestamp.MICROS_PER_MILLIS;
+    if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) {
+      throw new RangeError(
+        "Timestamp is outside of the representable range for ISO string formatting"
+      );
+    }
+    const date = new Date(Number(millis));
+    const isoBase = date.toISOString();
+    const microsRemainder = Math.abs(Number(micros % 1000000n));
+    const fractionalPart = String(microsRemainder).padStart(6, "0");
+    return isoBase.replace(/\.\d{3}Z$/, `.${fractionalPart}Z`);
+  }
+  since(other) {
+    return new TimeDuration(
+      this.__timestamp_micros_since_unix_epoch__ - other.__timestamp_micros_since_unix_epoch__
+    );
+  }
+};
+
+// src/lib/uuid.ts
+var Uuid = class _Uuid {
+  __uuid__;
+  /**
+   * The nil UUID (all zeros).
+   *
+   * @example
+   * ```ts
+   * const uuid = Uuid.NIL;
+   * console.assert(
+   *   uuid.toString() === "00000000-0000-0000-0000-000000000000"
+   * );
+   * ```
+   */
+  static NIL = new _Uuid(0n);
+  static MAX_UUID_BIGINT = 0xffffffffffffffffffffffffffffffffn;
+  /**
+   * The max UUID (all ones).
+   *
+   * @example
+   * ```ts
+   * const uuid = Uuid.MAX;
+   * console.assert(
+   *   uuid.toString() === "ffffffff-ffff-ffff-ffff-ffffffffffff"
+   * );
+   * ```
+   */
+  static MAX = new _Uuid(_Uuid.MAX_UUID_BIGINT);
+  /**
+   * Create a UUID from a raw 128-bit value.
+   *
+   * @param u - Unsigned 128-bit integer
+   * @throws {Error} If the value is outside the valid UUID range
+   */
+  constructor(u) {
+    if (u < 0n || u > _Uuid.MAX_UUID_BIGINT) {
+      throw new Error("Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`");
+    }
+    this.__uuid__ = u;
+  }
+  /**
+   * Create a UUID `v4` from explicit random bytes.
+   *
+   * This method assumes the bytes are already sufficiently random.
+   * It only sets the appropriate bits for the UUID version and variant.
+   *
+   * @param bytes - Exactly 16 random bytes
+   * @returns A UUID `v4`
+   * @throws {Error} If `bytes.length !== 16`
+   *
+   * @example
+   * ```ts
+   * const randomBytes = new Uint8Array(16);
+   * const uuid = Uuid.fromRandomBytesV4(randomBytes);
+   *
+   * console.assert(
+   *   uuid.toString() === "00000000-0000-4000-8000-000000000000"
+   * );
+   * ```
+   */
+  static fromRandomBytesV4(bytes) {
+    if (bytes.length !== 16) throw new Error("UUID v4 requires 16 bytes");
+    const arr = new Uint8Array(bytes);
+    arr[6] = arr[6] & 15 | 64;
+    arr[8] = arr[8] & 63 | 128;
+    return new _Uuid(_Uuid.bytesToBigInt(arr));
+  }
+  /**
+   * Generate a UUID `v7` using a monotonic counter from `0` to `2^31 - 1`,
+   * a timestamp, and 4 random bytes.
+   *
+   * The counter wraps around on overflow.
+   *
+   * The UUID `v7` is structured as follows:
+   *
+   * ```ascii
+   * ┌───────────────────────────────────────────────┬───────────────────┐
+   * | B0  | B1  | B2  | B3  | B4  | B5              |         B6        |
+   * ├───────────────────────────────────────────────┼───────────────────┤
+   * |                 unix_ts_ms                    |      version 7    |
+   * └───────────────────────────────────────────────┴───────────────────┘
+   * ┌──────────────┬─────────┬──────────────────┬───────────────────────┐
+   * | B7           | B8      | B9  | B10 | B11  | B12 | B13 | B14 | B15 |
+   * ├──────────────┼─────────┼──────────────────┼───────────────────────┤
+   * | counter_high | variant |    counter_low   |        random         |
+   * └──────────────┴─────────┴──────────────────┴───────────────────────┘
+   * ```
+   *
+   * @param counter - Mutable monotonic counter (31-bit)
+   * @param now - Timestamp since the Unix epoch
+   * @param randomBytes - Exactly 4 random bytes
+   * @returns A UUID `v7`
+   *
+   * @throws {Error} If the `counter` is negative
+   * @throws {Error} If the `timestamp` is before the Unix epoch
+   * @throws {Error} If `randomBytes.length !== 4`
+   *
+   * @example
+   * ```ts
+   * const now = Timestamp.fromMillis(1_686_000_000_000n);
+   * const counter = { value: 1 };
+   * const randomBytes = new Uint8Array(4);
+   *
+   * const uuid = Uuid.fromCounterV7(counter, now, randomBytes);
+   *
+   * console.assert(
+   *   uuid.toString() === "0000647e-5180-7000-8000-000200000000"
+   * );
+   * ```
+   */
+  static fromCounterV7(counter, now, randomBytes) {
+    if (randomBytes.length !== 4) {
+      throw new Error("`fromCounterV7` requires `randomBytes.length == 4`");
+    }
+    if (counter.value < 0) {
+      throw new Error("`fromCounterV7` uuid `counter` must be non-negative");
+    }
+    if (now.__timestamp_micros_since_unix_epoch__ < 0) {
+      throw new Error("`fromCounterV7` `timestamp` before unix epoch");
+    }
+    const counterVal = counter.value;
+    counter.value = counterVal + 1 & 2147483647;
+    const tsMs = now.toMillis() & 0xffffffffffffn;
+    const bytes = new Uint8Array(16);
+    bytes[0] = Number(tsMs >> 40n & 0xffn);
+    bytes[1] = Number(tsMs >> 32n & 0xffn);
+    bytes[2] = Number(tsMs >> 24n & 0xffn);
+    bytes[3] = Number(tsMs >> 16n & 0xffn);
+    bytes[4] = Number(tsMs >> 8n & 0xffn);
+    bytes[5] = Number(tsMs & 0xffn);
+    bytes[7] = counterVal >>> 23 & 255;
+    bytes[9] = counterVal >>> 15 & 255;
+    bytes[10] = counterVal >>> 7 & 255;
+    bytes[11] = (counterVal & 127) << 1 & 255;
+    bytes[12] |= randomBytes[0] & 127;
+    bytes[13] = randomBytes[1];
+    bytes[14] = randomBytes[2];
+    bytes[15] = randomBytes[3];
+    bytes[6] = bytes[6] & 15 | 112;
+    bytes[8] = bytes[8] & 63 | 128;
+    return new _Uuid(_Uuid.bytesToBigInt(bytes));
+  }
+  /**
+   * Parse a UUID from a string representation.
+   *
+   * @param s - UUID string
+   * @returns Parsed UUID
+   * @throws {Error} If the string is not a valid UUID
+   *
+   * @example
+   * ```ts
+   * const s = "01888d6e-5c00-7000-8000-000000000000";
+   * const uuid = Uuid.parse(s);
+   *
+   * console.assert(uuid.toString() === s);
+   * ```
+   */
+  static parse(s) {
+    const hex = s.replace(/-/g, "");
+    if (hex.length !== 32) throw new Error("Invalid hex UUID");
+    let v = 0n;
+    for (let i = 0; i < 32; i += 2) {
+      v = v << 8n | BigInt(parseInt(hex.slice(i, i + 2), 16));
+    }
+    return new _Uuid(v);
+  }
+  /** Convert to string (hyphenated form). */
+  toString() {
+    const bytes = _Uuid.bigIntToBytes(this.__uuid__);
+    const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20);
+  }
+  /** Convert to bigint (u128). */
+  asBigInt() {
+    return this.__uuid__;
+  }
+  /** Return a `Uint8Array` of 16 bytes. */
+  toBytes() {
+    return _Uuid.bigIntToBytes(this.__uuid__);
+  }
+  static bytesToBigInt(bytes) {
+    let result = 0n;
+    for (const b of bytes) result = result << 8n | BigInt(b);
+    return result;
+  }
+  static bigIntToBytes(value) {
+    const bytes = new Uint8Array(16);
+    for (let i = 15; i >= 0; i--) {
+      bytes[i] = Number(value & 0xffn);
+      value >>= 8n;
+    }
+    return bytes;
+  }
+  /**
+   * Returns the version of this UUID.
+   *
+   * This represents the algorithm used to generate the value.
+   *
+   * @returns A `UuidVersion`
+   * @throws {Error} If the version field is not recognized
+   */
+  getVersion() {
+    const version = this.toBytes()[6] >> 4 & 15;
+    switch (version) {
+      case 4:
+        return "V4";
+      case 7:
+        return "V7";
+      default:
+        if (this == _Uuid.NIL) {
+          return "Nil";
+        }
+        if (this == _Uuid.MAX) {
+          return "Max";
+        }
+        throw new Error(`Unsupported UUID version: ${version}`);
+    }
+  }
+  /**
+   * Extract the monotonic counter from a UUIDv7.
+   *
+   * Intended for testing and diagnostics.
+   * Behavior is undefined if called on a non-V7 UUID.
+   *
+   * @returns 31-bit counter value
+   */
+  getCounter() {
+    const bytes = this.toBytes();
+    const high = bytes[7];
+    const mid1 = bytes[9];
+    const mid2 = bytes[10];
+    const low = bytes[11] >>> 1;
+    return high << 23 | mid1 << 15 | mid2 << 7 | low | 0;
+  }
+  compareTo(other) {
+    if (this.__uuid__ < other.__uuid__) return -1;
+    if (this.__uuid__ > other.__uuid__) return 1;
+    return 0;
+  }
+  static getAlgebraicType() {
+    return AlgebraicType.Product({
+      elements: [
+        {
+          name: "__uuid__",
+          algebraicType: AlgebraicType.U128
+        }
+      ]
+    });
+  }
+};
+
+// src/lib/binary_reader.ts
+var BinaryReader = class {
+  /**
+   * The DataView used to read values from the binary data.
+   *
+   * Note: The DataView's `byteOffset` is relative to the beginning of the
+   * underlying ArrayBuffer, not the start of the provided Uint8Array input.
+   * This `BinaryReader`'s `#offset` field is used to track the current read position
+   * relative to the start of the provided Uint8Array input.
+   */
+  view;
+  /**
+   * Represents the offset (in bytes) relative to the start of the DataView
+   * and provided Uint8Array input.
+   *
+   * Note: This is *not* the absolute byte offset within the underlying ArrayBuffer.
+   */
+  offset = 0;
+  constructor(input) {
+    this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);
+    this.offset = 0;
+  }
+  reset(input) {
+    this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);
+    this.offset = 0;
+  }
+  get remaining() {
+    return this.view.byteLength - this.offset;
+  }
+  /** Ensure we have at least `n` bytes left to read */
+  #ensure(n) {
+    if (this.offset + n > this.view.byteLength) {
+      throw new RangeError(
+        `Tried to read ${n} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`
+      );
+    }
+  }
+  readUInt8Array() {
+    const length = this.readU32();
+    this.#ensure(length);
+    return this.readBytes(length);
+  }
+  readBool() {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value !== 0;
+  }
+  readByte() {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readBytes(length) {
+    const array = new Uint8Array(
+      this.view.buffer,
+      this.view.byteOffset + this.offset,
+      length
+    );
+    this.offset += length;
+    return array;
+  }
+  readI8() {
+    const value = this.view.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readU8() {
+    return this.readByte();
+  }
+  readI16() {
+    const value = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readU16() {
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readI32() {
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readU32() {
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readI64() {
+    const value = this.view.getBigInt64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  readU64() {
+    const value = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  readU128() {
+    const lowerPart = this.view.getBigUint64(this.offset, true);
+    const upperPart = this.view.getBigUint64(this.offset + 8, true);
+    this.offset += 16;
+    return (upperPart << BigInt(64)) + lowerPart;
+  }
+  readI128() {
+    const lowerPart = this.view.getBigUint64(this.offset, true);
+    const upperPart = this.view.getBigInt64(this.offset + 8, true);
+    this.offset += 16;
+    return (upperPart << BigInt(64)) + lowerPart;
+  }
+  readU256() {
+    const p0 = this.view.getBigUint64(this.offset, true);
+    const p1 = this.view.getBigUint64(this.offset + 8, true);
+    const p2 = this.view.getBigUint64(this.offset + 16, true);
+    const p3 = this.view.getBigUint64(this.offset + 24, true);
+    this.offset += 32;
+    return (p3 << BigInt(3 * 64)) + (p2 << BigInt(2 * 64)) + (p1 << BigInt(1 * 64)) + p0;
+  }
+  readI256() {
+    const p0 = this.view.getBigUint64(this.offset, true);
+    const p1 = this.view.getBigUint64(this.offset + 8, true);
+    const p2 = this.view.getBigUint64(this.offset + 16, true);
+    const p3 = this.view.getBigInt64(this.offset + 24, true);
+    this.offset += 32;
+    return (p3 << BigInt(3 * 64)) + (p2 << BigInt(2 * 64)) + (p1 << BigInt(1 * 64)) + p0;
+  }
+  readF32() {
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readF64() {
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  readString() {
+    const uint8Array = this.readUInt8Array();
+    return new TextDecoder("utf-8").decode(uint8Array);
+  }
+};
+var ArrayBufferPrototypeTransfer = ArrayBuffer.prototype.transfer ?? function(newByteLength) {
+  if (newByteLength === void 0) {
+    return this.slice();
+  } else if (newByteLength <= this.byteLength) {
+    return this.slice(0, newByteLength);
+  } else {
+    const copy = new Uint8Array(newByteLength);
+    copy.set(new Uint8Array(this));
+    return copy.buffer;
+  }
+};
+var ResizableBuffer = class {
+  buffer;
+  view;
+  constructor(init) {
+    this.buffer = typeof init === "number" ? new ArrayBuffer(init) : init;
+    this.view = new DataView(this.buffer);
+  }
+  get capacity() {
+    return this.buffer.byteLength;
+  }
+  grow(newSize) {
+    if (newSize <= this.buffer.byteLength) return;
+    this.buffer = ArrayBufferPrototypeTransfer.call(this.buffer, newSize);
+    this.view = new DataView(this.buffer);
+  }
+};
+var BinaryWriter = class {
+  buffer;
+  offset = 0;
+  constructor(init) {
+    this.buffer = typeof init === "number" ? new ResizableBuffer(init) : init;
+  }
+  clear() {
+    this.offset = 0;
+  }
+  reset(buffer) {
+    this.buffer = buffer;
+    this.offset = 0;
+  }
+  expandBuffer(additionalCapacity) {
+    const minCapacity = this.offset + additionalCapacity + 1;
+    if (minCapacity <= this.buffer.capacity) return;
+    let newCapacity = this.buffer.capacity * 2;
+    if (newCapacity < minCapacity) newCapacity = minCapacity;
+    this.buffer.grow(newCapacity);
+  }
+  toBase64() {
+    return fromByteArray(this.getBuffer());
+  }
+  getBuffer() {
+    return new Uint8Array(this.buffer.buffer, 0, this.offset);
+  }
+  get view() {
+    return this.buffer.view;
+  }
+  writeUInt8Array(value) {
+    const length = value.length;
+    this.expandBuffer(4 + length);
+    this.writeU32(length);
+    new Uint8Array(this.buffer.buffer, this.offset).set(value);
+    this.offset += length;
+  }
+  writeBool(value) {
+    this.expandBuffer(1);
+    this.view.setUint8(this.offset, value ? 1 : 0);
+    this.offset += 1;
+  }
+  writeByte(value) {
+    this.expandBuffer(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeBytes(value) {
+    this.expandBuffer(value.length);
+    new Uint8Array(this.buffer.buffer, this.offset, value.length).set(value);
+    this.offset += value.length;
+  }
+  writeI8(value) {
+    this.expandBuffer(1);
+    this.view.setInt8(this.offset, value);
+    this.offset += 1;
+  }
+  writeU8(value) {
+    this.expandBuffer(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeI16(value) {
+    this.expandBuffer(2);
+    this.view.setInt16(this.offset, value, true);
+    this.offset += 2;
+  }
+  writeU16(value) {
+    this.expandBuffer(2);
+    this.view.setUint16(this.offset, value, true);
+    this.offset += 2;
+  }
+  writeI32(value) {
+    this.expandBuffer(4);
+    this.view.setInt32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeU32(value) {
+    this.expandBuffer(4);
+    this.view.setUint32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeI64(value) {
+    this.expandBuffer(8);
+    this.view.setBigInt64(this.offset, value, true);
+    this.offset += 8;
+  }
+  writeU64(value) {
+    this.expandBuffer(8);
+    this.view.setBigUint64(this.offset, value, true);
+    this.offset += 8;
+  }
+  writeU128(value) {
+    this.expandBuffer(16);
+    const lowerPart = value & BigInt("0xFFFFFFFFFFFFFFFF");
+    const upperPart = value >> BigInt(64);
+    this.view.setBigUint64(this.offset, lowerPart, true);
+    this.view.setBigUint64(this.offset + 8, upperPart, true);
+    this.offset += 16;
+  }
+  writeI128(value) {
+    this.expandBuffer(16);
+    const lowerPart = value & BigInt("0xFFFFFFFFFFFFFFFF");
+    const upperPart = value >> BigInt(64);
+    this.view.setBigInt64(this.offset, lowerPart, true);
+    this.view.setBigInt64(this.offset + 8, upperPart, true);
+    this.offset += 16;
+  }
+  writeU256(value) {
+    this.expandBuffer(32);
+    const low_64_mask = BigInt("0xFFFFFFFFFFFFFFFF");
+    const p0 = value & low_64_mask;
+    const p1 = value >> BigInt(64 * 1) & low_64_mask;
+    const p2 = value >> BigInt(64 * 2) & low_64_mask;
+    const p3 = value >> BigInt(64 * 3);
+    this.view.setBigUint64(this.offset + 8 * 0, p0, true);
+    this.view.setBigUint64(this.offset + 8 * 1, p1, true);
+    this.view.setBigUint64(this.offset + 8 * 2, p2, true);
+    this.view.setBigUint64(this.offset + 8 * 3, p3, true);
+    this.offset += 32;
+  }
+  writeI256(value) {
+    this.expandBuffer(32);
+    const low_64_mask = BigInt("0xFFFFFFFFFFFFFFFF");
+    const p0 = value & low_64_mask;
+    const p1 = value >> BigInt(64 * 1) & low_64_mask;
+    const p2 = value >> BigInt(64 * 2) & low_64_mask;
+    const p3 = value >> BigInt(64 * 3);
+    this.view.setBigUint64(this.offset + 8 * 0, p0, true);
+    this.view.setBigUint64(this.offset + 8 * 1, p1, true);
+    this.view.setBigUint64(this.offset + 8 * 2, p2, true);
+    this.view.setBigInt64(this.offset + 8 * 3, p3, true);
+    this.offset += 32;
+  }
+  writeF32(value) {
+    this.expandBuffer(4);
+    this.view.setFloat32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeF64(value) {
+    this.expandBuffer(8);
+    this.view.setFloat64(this.offset, value, true);
+    this.offset += 8;
+  }
+  writeString(value) {
+    const encoder = new TextEncoder();
+    const encodedString = encoder.encode(value);
+    this.writeUInt8Array(encodedString);
+  }
+};
+
+// src/lib/util.ts
+function uint8ArrayToHexString(array) {
+  return Array.prototype.map.call(array.reverse(), (x) => ("00" + x.toString(16)).slice(-2)).join("");
+}
+function uint8ArrayToU128(array) {
+  if (array.length != 16) {
+    throw new Error(`Uint8Array is not 16 bytes long: ${array}`);
+  }
+  return new BinaryReader(array).readU128();
+}
+function uint8ArrayToU256(array) {
+  if (array.length != 32) {
+    throw new Error(`Uint8Array is not 32 bytes long: [${array}]`);
+  }
+  return new BinaryReader(array).readU256();
+}
+function hexStringToUint8Array(str) {
+  if (str.startsWith("0x")) {
+    str = str.slice(2);
+  }
+  const matches = str.match(/.{1,2}/g) || [];
+  const data = Uint8Array.from(
+    matches.map((byte) => parseInt(byte, 16))
+  );
+  return data.reverse();
+}
+function hexStringToU128(str) {
+  return uint8ArrayToU128(hexStringToUint8Array(str));
+}
+function hexStringToU256(str) {
+  return uint8ArrayToU256(hexStringToUint8Array(str));
+}
+function u128ToUint8Array(data) {
+  const writer = new BinaryWriter(16);
+  writer.writeU128(data);
+  return writer.getBuffer();
+}
+function u128ToHexString(data) {
+  return uint8ArrayToHexString(u128ToUint8Array(data));
+}
+function u256ToUint8Array(data) {
+  const writer = new BinaryWriter(32);
+  writer.writeU256(data);
+  return writer.getBuffer();
+}
+function u256ToHexString(data) {
+  return uint8ArrayToHexString(u256ToUint8Array(data));
+}
+var hasOwn = Object.hasOwn;
+
+// src/lib/identity.ts
+var Identity = class _Identity {
+  __identity__;
+  /**
+   * Creates a new `Identity`.
+   *
+   * `data` can be a hexadecimal string or a `bigint`.
+   */
+  constructor(data) {
+    this.__identity__ = typeof data === "string" ? hexStringToU256(data) : data;
+  }
+  /**
+   * Get the algebraic type representation of the {@link Identity} type.
+   * @returns The algebraic type representation of the type.
+   */
+  static getAlgebraicType() {
+    return AlgebraicType.Product({
+      elements: [{ name: "__identity__", algebraicType: AlgebraicType.U256 }]
+    });
+  }
+  /**
+   * Check if two identities are equal.
+   */
+  isEqual(other) {
+    return this.toHexString() === other.toHexString();
+  }
+  /**
+   * Check if two identities are equal.
+   */
+  equals(other) {
+    return this.isEqual(other);
+  }
+  /**
+   * Print the identity as a hexadecimal string.
+   */
+  toHexString() {
+    return u256ToHexString(this.__identity__);
+  }
+  /**
+   * Convert the address to a Uint8Array.
+   */
+  toUint8Array() {
+    return u256ToUint8Array(this.__identity__);
+  }
+  /**
+   * Parse an Identity from a hexadecimal string.
+   */
+  static fromString(str) {
+    return new _Identity(str);
+  }
+  /**
+   * Zero identity (0x0000000000000000000000000000000000000000000000000000000000000000)
+   */
+  static zero() {
+    return new _Identity(0n);
+  }
+  toString() {
+    return this.toHexString();
+  }
+};
+
+// src/lib/algebraic_type.ts
+var SERIALIZERS = /* @__PURE__ */ new Map();
+var DESERIALIZERS = /* @__PURE__ */ new Map();
+var AlgebraicType = {
+  Ref: (value) => ({ tag: "Ref", value }),
+  Sum: (value) => ({
+    tag: "Sum",
+    value
+  }),
+  Product: (value) => ({
+    tag: "Product",
+    value
+  }),
+  Array: (value) => ({
+    tag: "Array",
+    value
+  }),
+  String: { tag: "String" },
+  Bool: { tag: "Bool" },
+  I8: { tag: "I8" },
+  U8: { tag: "U8" },
+  I16: { tag: "I16" },
+  U16: { tag: "U16" },
+  I32: { tag: "I32" },
+  U32: { tag: "U32" },
+  I64: { tag: "I64" },
+  U64: { tag: "U64" },
+  I128: { tag: "I128" },
+  U128: { tag: "U128" },
+  I256: { tag: "I256" },
+  U256: { tag: "U256" },
+  F32: { tag: "F32" },
+  F64: { tag: "F64" },
+  makeSerializer(ty, typespace) {
+    if (ty.tag === "Ref") {
+      if (!typespace)
+        throw new Error("cannot serialize refs without a typespace");
+      while (ty.tag === "Ref") ty = typespace.types[ty.value];
+    }
+    switch (ty.tag) {
+      case "Product":
+        return ProductType.makeSerializer(ty.value, typespace);
+      case "Sum":
+        return SumType.makeSerializer(ty.value, typespace);
+      case "Array":
+        if (ty.value.tag === "U8") {
+          return serializeUint8Array;
+        } else {
+          const serialize = AlgebraicType.makeSerializer(ty.value, typespace);
+          return (writer, value) => {
+            writer.writeU32(value.length);
+            for (const elem of value) {
+              serialize(writer, elem);
+            }
+          };
+        }
+      default:
+        return primitiveSerializers[ty.tag];
+    }
+  },
+  /** @deprecated Use `makeSerializer` instead. */
+  serializeValue(writer, ty, value, typespace) {
+    AlgebraicType.makeSerializer(ty, typespace)(writer, value);
+  },
+  makeDeserializer(ty, typespace) {
+    if (ty.tag === "Ref") {
+      if (!typespace)
+        throw new Error("cannot deserialize refs without a typespace");
+      while (ty.tag === "Ref") ty = typespace.types[ty.value];
+    }
+    switch (ty.tag) {
+      case "Product":
+        return ProductType.makeDeserializer(ty.value, typespace);
+      case "Sum":
+        return SumType.makeDeserializer(ty.value, typespace);
+      case "Array":
+        if (ty.value.tag === "U8") {
+          return deserializeUint8Array;
+        } else {
+          const deserialize = AlgebraicType.makeDeserializer(
+            ty.value,
+            typespace
+          );
+          return (reader) => {
+            const length = reader.readU32();
+            const result = Array(length);
+            for (let i = 0; i < length; i++) {
+              result[i] = deserialize(reader);
+            }
+            return result;
+          };
+        }
+      default:
+        return primitiveDeserializers[ty.tag];
+    }
+  },
+  /** @deprecated Use `makeDeserializer` instead. */
+  deserializeValue(reader, ty, typespace) {
+    return AlgebraicType.makeDeserializer(ty, typespace)(reader);
+  },
+  /**
+   * Convert a value of the algebraic type into something that can be used as a key in a map.
+   * There are no guarantees about being able to order it.
+   * This is only guaranteed to be comparable to other values of the same type.
+   * @param value A value of the algebraic type
+   * @returns Something that can be used as a key in a map.
+   */
+  intoMapKey: function(ty, value) {
+    switch (ty.tag) {
+      case "U8":
+      case "U16":
+      case "U32":
+      case "U64":
+      case "U128":
+      case "U256":
+      case "I8":
+      case "I16":
+      case "I32":
+      case "I64":
+      case "I128":
+      case "I256":
+      case "F32":
+      case "F64":
+      case "String":
+      case "Bool":
+        return value;
+      case "Product":
+        return ProductType.intoMapKey(ty.value, value);
+      default: {
+        const writer = new BinaryWriter(10);
+        AlgebraicType.serializeValue(writer, ty, value);
+        return writer.toBase64();
+      }
+    }
+  }
+};
+function bindCall(f) {
+  return Function.prototype.call.bind(f);
+}
+var primitiveSerializers = {
+  Bool: bindCall(BinaryWriter.prototype.writeBool),
+  I8: bindCall(BinaryWriter.prototype.writeI8),
+  U8: bindCall(BinaryWriter.prototype.writeU8),
+  I16: bindCall(BinaryWriter.prototype.writeI16),
+  U16: bindCall(BinaryWriter.prototype.writeU16),
+  I32: bindCall(BinaryWriter.prototype.writeI32),
+  U32: bindCall(BinaryWriter.prototype.writeU32),
+  I64: bindCall(BinaryWriter.prototype.writeI64),
+  U64: bindCall(BinaryWriter.prototype.writeU64),
+  I128: bindCall(BinaryWriter.prototype.writeI128),
+  U128: bindCall(BinaryWriter.prototype.writeU128),
+  I256: bindCall(BinaryWriter.prototype.writeI256),
+  U256: bindCall(BinaryWriter.prototype.writeU256),
+  F32: bindCall(BinaryWriter.prototype.writeF32),
+  F64: bindCall(BinaryWriter.prototype.writeF64),
+  String: bindCall(BinaryWriter.prototype.writeString)
+};
+Object.freeze(primitiveSerializers);
+var serializeUint8Array = bindCall(BinaryWriter.prototype.writeUInt8Array);
+var primitiveDeserializers = {
+  Bool: bindCall(BinaryReader.prototype.readBool),
+  I8: bindCall(BinaryReader.prototype.readI8),
+  U8: bindCall(BinaryReader.prototype.readU8),
+  I16: bindCall(BinaryReader.prototype.readI16),
+  U16: bindCall(BinaryReader.prototype.readU16),
+  I32: bindCall(BinaryReader.prototype.readI32),
+  U32: bindCall(BinaryReader.prototype.readU32),
+  I64: bindCall(BinaryReader.prototype.readI64),
+  U64: bindCall(BinaryReader.prototype.readU64),
+  I128: bindCall(BinaryReader.prototype.readI128),
+  U128: bindCall(BinaryReader.prototype.readU128),
+  I256: bindCall(BinaryReader.prototype.readI256),
+  U256: bindCall(BinaryReader.prototype.readU256),
+  F32: bindCall(BinaryReader.prototype.readF32),
+  F64: bindCall(BinaryReader.prototype.readF64),
+  String: bindCall(BinaryReader.prototype.readString)
+};
+Object.freeze(primitiveDeserializers);
+var deserializeUint8Array = bindCall(BinaryReader.prototype.readUInt8Array);
+var primitiveSizes = {
+  Bool: 1,
+  I8: 1,
+  U8: 1,
+  I16: 2,
+  U16: 2,
+  I32: 4,
+  U32: 4,
+  I64: 8,
+  U64: 8,
+  I128: 16,
+  U128: 16,
+  I256: 32,
+  U256: 32,
+  F32: 4,
+  F64: 8
+};
+var fixedSizePrimitives = new Set(Object.keys(primitiveSizes));
+var isFixedSizeProduct = (ty) => ty.elements.every(
+  ({ algebraicType }) => fixedSizePrimitives.has(algebraicType.tag)
+);
+var productSize = (ty) => ty.elements.reduce(
+  (acc, { algebraicType }) => acc + primitiveSizes[algebraicType.tag],
+  0
+);
+var primitiveJSName = {
+  Bool: "Uint8",
+  I8: "Int8",
+  U8: "Uint8",
+  I16: "Int16",
+  U16: "Uint16",
+  I32: "Int32",
+  U32: "Uint32",
+  I64: "BigInt64",
+  U64: "BigUint64",
+  F32: "Float32",
+  F64: "Float64"
+};
+var specialProductDeserializers = {
+  __time_duration_micros__: (reader) => new TimeDuration(reader.readI64()),
+  __timestamp_micros_since_unix_epoch__: (reader) => new Timestamp(reader.readI64()),
+  __identity__: (reader) => new Identity(reader.readU256()),
+  __connection_id__: (reader) => new ConnectionId(reader.readU128()),
+  __uuid__: (reader) => new Uuid(reader.readU128())
+};
+Object.freeze(specialProductDeserializers);
+var unitDeserializer = () => ({});
+var getElementInitializer = (element) => {
+  let init;
+  switch (element.algebraicType.tag) {
+    case "String":
+      init = "''";
+      break;
+    case "Bool":
+      init = "false";
+      break;
+    case "I8":
+    case "U8":
+    case "I16":
+    case "U16":
+    case "I32":
+    case "U32":
+      init = "0";
+      break;
+    case "I64":
+    case "U64":
+    case "I128":
+    case "U128":
+    case "I256":
+    case "U256":
+      init = "0n";
+      break;
+    case "F32":
+    case "F64":
+      init = "0.0";
+      break;
+    default:
+      init = "undefined";
+  }
+  return `${element.name}: ${init}`;
+};
+var ProductType = {
+  makeSerializer(ty, typespace) {
+    let serializer = SERIALIZERS.get(ty);
+    if (serializer != null) return serializer;
+    if (isFixedSizeProduct(ty)) {
+      const size = productSize(ty);
+      const body2 = `"use strict";
+writer.expandBuffer(${size});
+const view = writer.view;
+${ty.elements.map(
+        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? `view.set${primitiveJSName[tag]}(writer.offset, value.${name}, ${primitiveSizes[tag] > 1 ? "true" : ""});
+writer.offset += ${primitiveSizes[tag]};` : `writer.write${tag}(value.${name});`
+      ).join("\n")}`;
+      serializer = Function("writer", "value", body2);
+      SERIALIZERS.set(ty, serializer);
+      return serializer;
+    }
+    const serializers = {};
+    const body = '"use strict";\n' + ty.elements.map(
+      (element) => `this.${element.name}(writer, value.${element.name});`
+    ).join("\n");
+    serializer = Function("writer", "value", body).bind(
+      serializers
+    );
+    SERIALIZERS.set(ty, serializer);
+    for (const { name, algebraicType } of ty.elements) {
+      serializers[name] = AlgebraicType.makeSerializer(
+        algebraicType,
+        typespace
+      );
+    }
+    Object.freeze(serializers);
+    return serializer;
+  },
+  /** @deprecated Use `makeSerializer` instead. */
+  serializeValue(writer, ty, value, typespace) {
+    ProductType.makeSerializer(ty, typespace)(writer, value);
+  },
+  makeDeserializer(ty, typespace) {
+    switch (ty.elements.length) {
+      case 0:
+        return unitDeserializer;
+      case 1: {
+        const fieldName = ty.elements[0].name;
+        if (hasOwn(specialProductDeserializers, fieldName))
+          return specialProductDeserializers[fieldName];
+      }
+    }
+    let deserializer = DESERIALIZERS.get(ty);
+    if (deserializer != null) return deserializer;
+    if (isFixedSizeProduct(ty)) {
+      const body = `"use strict";
+const result = { ${ty.elements.map(getElementInitializer).join(", ")} };
+const view = reader.view;
+${ty.elements.map(
+        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? tag === "Bool" ? `result.${name} = view.getUint8(reader.offset) !== 0;
+reader.offset += 1;` : `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? "true" : ""});
+reader.offset += ${primitiveSizes[tag]};` : `result.${name} = reader.read${tag}();`
+      ).join("\n")}
+return result;`;
+      deserializer = Function("reader", body);
+      DESERIALIZERS.set(ty, deserializer);
+      return deserializer;
+    }
+    const deserializers = {};
+    deserializer = Function(
+      "reader",
+      `"use strict";
+const result = { ${ty.elements.map(getElementInitializer).join(", ")} };
+${ty.elements.map(({ name }) => `result.${name} = this.${name}(reader);`).join("\n")}
+return result;`
+    ).bind(deserializers);
+    DESERIALIZERS.set(ty, deserializer);
+    for (const { name, algebraicType } of ty.elements) {
+      deserializers[name] = AlgebraicType.makeDeserializer(
+        algebraicType,
+        typespace
+      );
+    }
+    Object.freeze(deserializers);
+    return deserializer;
+  },
+  /** @deprecated Use `makeDeserializer` instead. */
+  deserializeValue(reader, ty, typespace) {
+    return ProductType.makeDeserializer(ty, typespace)(reader);
+  },
+  intoMapKey(ty, value) {
+    if (ty.elements.length === 1) {
+      const fieldName = ty.elements[0].name;
+      if (hasOwn(specialProductDeserializers, fieldName)) {
+        return value[fieldName];
+      }
+    }
+    const writer = new BinaryWriter(10);
+    AlgebraicType.serializeValue(writer, AlgebraicType.Product(ty), value);
+    return writer.toBase64();
+  }
+};
+var SumType = {
+  makeSerializer(ty, typespace) {
+    if (ty.variants.length == 2 && ty.variants[0].name === "some" && ty.variants[1].name === "none") {
+      const serialize = AlgebraicType.makeSerializer(
+        ty.variants[0].algebraicType,
+        typespace
+      );
+      return (writer, value) => {
+        if (value !== null && value !== void 0) {
+          writer.writeByte(0);
+          serialize(writer, value);
+        } else {
+          writer.writeByte(1);
+        }
+      };
+    } else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") {
+      const serializeOk = AlgebraicType.makeSerializer(
+        ty.variants[0].algebraicType,
+        typespace
+      );
+      const serializeErr = AlgebraicType.makeSerializer(
+        ty.variants[0].algebraicType,
+        typespace
+      );
+      return (writer, value) => {
+        if ("ok" in value) {
+          writer.writeU8(0);
+          serializeOk(writer, value.ok);
+        } else if ("err" in value) {
+          writer.writeU8(1);
+          serializeErr(writer, value.err);
+        } else {
+          throw new TypeError(
+            "could not serialize result: object had neither a `ok` nor an `err` field"
+          );
+        }
+      };
+    } else {
+      let serializer = SERIALIZERS.get(ty);
+      if (serializer != null) return serializer;
+      const serializers = {};
+      const body = `switch (value.tag) {
+${ty.variants.map(
+        ({ name }, i) => `  case ${JSON.stringify(name)}:
+    writer.writeByte(${i});
+    return this.${name}(writer, value.value);`
+      ).join("\n")}
+  default:
+    throw new TypeError(
+      \`Could not serialize sum type; unknown tag \${value.tag}\`
+    )
+}
+`;
+      serializer = Function("writer", "value", body).bind(
+        serializers
+      );
+      SERIALIZERS.set(ty, serializer);
+      for (const { name, algebraicType } of ty.variants) {
+        serializers[name] = AlgebraicType.makeSerializer(
+          algebraicType,
+          typespace
+        );
+      }
+      Object.freeze(serializers);
+      return serializer;
+    }
+  },
+  /** @deprecated Use `makeSerializer` instead. */
+  serializeValue(writer, ty, value, typespace) {
+    SumType.makeSerializer(ty, typespace)(writer, value);
+  },
+  makeDeserializer(ty, typespace) {
+    if (ty.variants.length == 2 && ty.variants[0].name === "some" && ty.variants[1].name === "none") {
+      const deserialize = AlgebraicType.makeDeserializer(
+        ty.variants[0].algebraicType,
+        typespace
+      );
+      return (reader) => {
+        const tag = reader.readU8();
+        if (tag === 0) {
+          return deserialize(reader);
+        } else if (tag === 1) {
+          return void 0;
+        } else {
+          throw `Can't deserialize an option type, couldn't find ${tag} tag`;
+        }
+      };
+    } else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") {
+      const deserializeOk = AlgebraicType.makeDeserializer(
+        ty.variants[0].algebraicType,
+        typespace
+      );
+      const deserializeErr = AlgebraicType.makeDeserializer(
+        ty.variants[1].algebraicType,
+        typespace
+      );
+      return (reader) => {
+        const tag = reader.readByte();
+        if (tag === 0) {
+          return { ok: deserializeOk(reader) };
+        } else if (tag === 1) {
+          return { err: deserializeErr(reader) };
+        } else {
+          throw `Can't deserialize a result type, couldn't find ${tag} tag`;
+        }
+      };
+    } else {
+      let deserializer = DESERIALIZERS.get(ty);
+      if (deserializer != null) return deserializer;
+      const deserializers = {};
+      deserializer = Function(
+        "reader",
+        `switch (reader.readU8()) {
+${ty.variants.map(
+          ({ name }, i) => `case ${i}: return { tag: ${JSON.stringify(name)}, value: this.${name}(reader) };`
+        ).join("\n")} }`
+      ).bind(deserializers);
+      DESERIALIZERS.set(ty, deserializer);
+      for (const { name, algebraicType } of ty.variants) {
+        deserializers[name] = AlgebraicType.makeDeserializer(
+          algebraicType,
+          typespace
+        );
+      }
+      Object.freeze(deserializers);
+      return deserializer;
+    }
+  },
+  /** @deprecated Use `makeDeserializer` instead. */
+  deserializeValue(reader, ty, typespace) {
+    return SumType.makeDeserializer(ty, typespace)(reader);
+  }
+};
+
+// src/lib/connection_id.ts
+var ConnectionId = class _ConnectionId {
+  __connection_id__;
+  /**
+   * Creates a new `ConnectionId`.
+   */
+  constructor(data) {
+    this.__connection_id__ = data;
+  }
+  /**
+   * Get the algebraic type representation of the {@link ConnectionId} type.
+   * @returns The algebraic type representation of the type.
+   */
+  static getAlgebraicType() {
+    return AlgebraicType.Product({
+      elements: [
+        { name: "__connection_id__", algebraicType: AlgebraicType.U128 }
+      ]
+    });
+  }
+  isZero() {
+    return this.__connection_id__ === BigInt(0);
+  }
+  static nullIfZero(addr) {
+    if (addr.isZero()) {
+      return null;
+    } else {
+      return addr;
+    }
+  }
+  static random() {
+    function randomU8() {
+      return Math.floor(Math.random() * 255);
+    }
+    let result = BigInt(0);
+    for (let i = 0; i < 16; i++) {
+      result = result << BigInt(8) | BigInt(randomU8());
+    }
+    return new _ConnectionId(result);
+  }
+  /**
+   * Compare two connection IDs for equality.
+   */
+  isEqual(other) {
+    return this.__connection_id__ == other.__connection_id__;
+  }
+  /**
+   * Check if two connection IDs are equal.
+   */
+  equals(other) {
+    return this.isEqual(other);
+  }
+  /**
+   * Print the connection ID as a hexadecimal string.
+   */
+  toHexString() {
+    return u128ToHexString(this.__connection_id__);
+  }
+  /**
+   * Convert the connection ID to a Uint8Array.
+   */
+  toUint8Array() {
+    return u128ToUint8Array(this.__connection_id__);
+  }
+  /**
+   * Parse a connection ID from a hexadecimal string.
+   */
+  static fromString(str) {
+    return new _ConnectionId(hexStringToU128(str));
+  }
+  static fromStringOrNull(str) {
+    const addr = _ConnectionId.fromString(str);
+    if (addr.isZero()) {
+      return null;
+    } else {
+      return addr;
+    }
+  }
+};
+function toSql(q) {
+  return q.toSql();
+}
+function isLiteralExpr(expr) {
+  return expr.type === "literal";
+}
+function evaluateBooleanExpr(expr, row) {
+  return evaluateData(expr.data, row);
+}
+function evaluateData(data, row) {
+  switch (data.type) {
+    case "eq":
+      return resolveValue(data.left, row) === resolveValue(data.right, row);
+    case "ne":
+      return resolveValue(data.left, row) !== resolveValue(data.right, row);
+    case "gt":
+      return resolveValue(data.left, row) > resolveValue(data.right, row);
+    case "gte":
+      return resolveValue(data.left, row) >= resolveValue(data.right, row);
+    case "lt":
+      return resolveValue(data.left, row) < resolveValue(data.right, row);
+    case "lte":
+      return resolveValue(data.left, row) <= resolveValue(data.right, row);
+    case "and":
+      return data.clauses.every((c) => evaluateData(c, row));
+    case "or":
+      return data.clauses.some((c) => evaluateData(c, row));
+    case "not":
+      return !evaluateData(data.clause, row);
+  }
+}
+function resolveValue(expr, row) {
+  if (isLiteralExpr(expr)) {
+    return toComparableValue(expr.value);
+  }
+  return toComparableValue(row[expr.column]);
+}
+function isHexSerializableLike(value) {
+  return !!value && typeof value === "object" && typeof value.toHexString === "function";
+}
+function isTimestampLike(value) {
+  if (!value || typeof value !== "object") return false;
+  if (value instanceof Timestamp) return true;
+  const micros = value["__timestamp_micros_since_unix_epoch__"];
+  return typeof micros === "bigint";
+}
+function toComparableValue(value) {
+  if (isHexSerializableLike(value)) {
+    return value.toHexString();
+  }
+  if (isTimestampLike(value)) {
+    return value.__timestamp_micros_since_unix_epoch__;
+  }
+  return value;
+}
+function getQueryAccessorName(query) {
+  if (query.table) return query.table.accessorName;
+  if (query.accessorName) return query.accessorName;
+  if (query.sourceQuery) return query.sourceQuery.table.accessorName;
+  throw new Error("Cannot extract accessor name from query");
+}
+function getQueryWhereClause(query) {
+  if (query.whereClause) return query.whereClause;
+  return void 0;
+}
+var SpacetimeDBContext = createContext(
+  void 0
+);
+function useSpacetimeDB() {
+  const context = useContext(SpacetimeDBContext);
+  if (!context) {
+    throw new Error(
+      "useSpacetimeDB must be used within a SpacetimeDBProvider component. Did you forget to add a `SpacetimeDBProvider` to your component tree?"
+    );
+  }
+  return context;
+}
+
+// src/sdk/connection_manager.ts
+function defaultState() {
+  return {
+    isActive: false,
+    identity: void 0,
+    token: void 0,
+    connectionId: ConnectionId.random(),
+    connectionError: void 0
+  };
+}
+var ConnectionManagerImpl = class _ConnectionManagerImpl {
+  #connections = /* @__PURE__ */ new Map();
+  /** Generates a unique key for a connection based on URI and module name. */
+  static getKey(uri, moduleName) {
+    return `${uri}::${moduleName}`;
+  }
+  /** Instance method wrapper for getKey. */
+  getKey(uri, moduleName) {
+    return _ConnectionManagerImpl.getKey(uri, moduleName);
+  }
+  #ensureEntry(key) {
+    const existing = this.#connections.get(key);
+    if (existing) {
+      return existing;
+    }
+    const managed = {
+      connection: void 0,
+      refCount: 0,
+      state: defaultState(),
+      listeners: /* @__PURE__ */ new Set(),
+      pendingRelease: null
+    };
+    this.#connections.set(key, managed);
+    return managed;
+  }
+  #notify(managed) {
+    for (const listener of managed.listeners) {
+      listener();
+    }
+  }
+  /**
+   * Retains a connection, incrementing its reference count.
+   * Creates the connection on first call; returns existing connection on subsequent calls.
+   * Cancels any pending release if the connection was about to be cleaned up.
+   *
+   * @param key - Unique identifier for the connection (use getKey to generate)
+   * @param builder - Connection builder to create the connection if needed
+   * @returns The managed connection instance
+   */
+  retain(key, builder) {
+    const managed = this.#ensureEntry(key);
+    if (managed.pendingRelease) {
+      clearTimeout(managed.pendingRelease);
+      managed.pendingRelease = null;
+    }
+    managed.refCount += 1;
+    if (managed.connection) {
+      return managed.connection;
+    }
+    const connection = builder.build();
+    managed.connection = connection;
+    const updateState = (updates) => {
+      managed.state = { ...managed.state, ...updates };
+      this.#notify(managed);
+    };
+    updateState({
+      isActive: connection.isActive,
+      identity: connection.identity,
+      token: connection.token,
+      connectionId: connection.connectionId,
+      connectionError: void 0
+    });
+    managed.onConnect = (conn) => {
+      updateState({
+        isActive: conn.isActive,
+        identity: conn.identity,
+        token: conn.token,
+        connectionId: conn.connectionId,
+        connectionError: void 0
+      });
+    };
+    managed.onDisconnect = (ctx, error) => {
+      updateState({
+        isActive: ctx.isActive,
+        connectionError: error ?? void 0
+      });
+    };
+    managed.onConnectError = (ctx, error) => {
+      updateState({
+        isActive: ctx.isActive,
+        connectionError: error
+      });
+    };
+    builder.onConnect(managed.onConnect);
+    builder.onDisconnect(managed.onDisconnect);
+    builder.onConnectError(managed.onConnectError);
+    return connection;
+  }
+  release(key) {
+    const managed = this.#connections.get(key);
+    if (!managed) {
+      return;
+    }
+    managed.refCount -= 1;
+    if (managed.refCount > 0 || managed.pendingRelease) {
+      return;
+    }
+    managed.pendingRelease = setTimeout(() => {
+      managed.pendingRelease = null;
+      if (managed.refCount > 0) {
+        return;
+      }
+      if (managed.connection) {
+        if (managed.onConnect) {
+          managed.connection.removeOnConnect(managed.onConnect);
+        }
+        if (managed.onDisconnect) {
+          managed.connection.removeOnDisconnect(managed.onDisconnect);
+        }
+        if (managed.onConnectError) {
+          managed.connection.removeOnConnectError(
+            managed.onConnectError
+          );
+        }
+        managed.connection.disconnect();
+      }
+      this.#connections.delete(key);
+    }, 0);
+  }
+  subscribe(key, listener) {
+    const managed = this.#ensureEntry(key);
+    managed.listeners.add(listener);
+    return () => {
+      managed.listeners.delete(listener);
+      if (managed.refCount <= 0 && managed.listeners.size === 0 && !managed.connection) {
+        this.#connections.delete(key);
+      }
+    };
+  }
+  getSnapshot(key) {
+    return this.#connections.get(key)?.state;
+  }
+  getConnection(key) {
+    return this.#connections.get(key)?.connection ?? null;
+  }
+};
+var ConnectionManager = new ConnectionManagerImpl();
+
+// src/solid/SpacetimeDBProvider.ts
+function SpacetimeDBProvider(props) {
+  const uri = () => props.connectionBuilder.getUri();
+  const moduleName = () => props.connectionBuilder.getModuleName();
+  const key = createMemo(() => ConnectionManager.getKey(uri(), moduleName()));
+  const fallbackState = {
+    isActive: false,
+    identity: void 0,
+    token: void 0,
+    connectionId: ConnectionId.random(),
+    connectionError: void 0
+  };
+  const [state, setState] = createStore(fallbackState);
+  createComputed(() => {
+    const currentKey = key();
+    const unsubscribe = ConnectionManager.subscribe(currentKey, () => {
+      const snapshot2 = ConnectionManager.getSnapshot(currentKey) ?? fallbackState;
+      setState(snapshot2);
+    });
+    const snapshot = ConnectionManager.getSnapshot(currentKey) ?? fallbackState;
+    setState(snapshot);
+    onCleanup(() => {
+      unsubscribe();
+    });
+  });
+  const getConnection = () => ConnectionManager.getConnection(key());
+  const contextValue = {
+    get isActive() {
+      return state.isActive;
+    },
+    get identity() {
+      return state.identity;
+    },
+    get token() {
+      return state.token;
+    },
+    get connectionId() {
+      return state.connectionId;
+    },
+    get connectionError() {
+      return state.connectionError;
+    },
+    getConnection
+  };
+  createComputed(() => {
+    const currentKey = key();
+    ConnectionManager.retain(currentKey, props.connectionBuilder);
+    onCleanup(() => {
+      ConnectionManager.release(currentKey);
+    });
+  });
+  return SpacetimeDBContext.Provider({
+    value: contextValue,
+    get children() {
+      return props.children;
+    }
+  });
+}
+function classifyMembership(whereExpr, oldRow, newRow) {
+  if (!whereExpr) return "stayIn";
+  const oldIn = evaluateBooleanExpr(whereExpr, oldRow);
+  const newIn = evaluateBooleanExpr(whereExpr, newRow);
+  if (oldIn && !newIn) return "leave";
+  if (!oldIn && newIn) return "enter";
+  if (oldIn && newIn) return "stayIn";
+  return "stayOut";
+}
+function useTable(query, callbacks) {
+  const enabled = callbacks?.enabled ?? (() => true);
+  const q = createMemo(query);
+  const accessorName = createMemo(() => getQueryAccessorName(q()));
+  const whereExpr = createMemo(() => getQueryWhereClause(q()));
+  const querySql = createMemo(() => toSql(q()));
+  let connectionState;
+  try {
+    connectionState = useSpacetimeDB();
+  } catch {
+    throw new Error(
+      "Could not find SpacetimeDB client! Did you forget to add a `SpacetimeDBProvider`? `useTable` must be used in the SolidJS component tree under a `SpacetimeDBProvider` component."
+    );
+  }
+  const [rows, setRows] = createStore([]);
+  let latestTransactionEventId = null;
+  const computeSnapshot = () => {
+    if (!enabled()) {
+      return [];
+    }
+    const connection = connectionState.getConnection();
+    if (!connection) {
+      return [];
+    }
+    const table = connection.db[accessorName()];
+    const result = whereExpr() ? Array.from(table.iter()).filter(
+      (row) => evaluateBooleanExpr(whereExpr(), row)
+    ) : Array.from(table.iter());
+    return result;
+  };
+  const [isReady, setIsReady] = createSignal(false);
+  createComputed(() => {
+    if (!enabled()) {
+      setIsReady(false);
+      return;
+    }
+    const connection = connectionState.getConnection();
+    if (!connectionState.isActive || !connection) {
+      setIsReady(false);
+      return;
+    }
+    const cancel = connection.subscriptionBuilder().onApplied(() => {
+      setIsReady(true);
+    }).subscribe(querySql());
+    onCleanup(() => {
+      cancel.unsubscribe();
+    });
+    const table = connection.db[accessorName()];
+    const onInsert = (ctx, row) => {
+      if (whereExpr() && !evaluateBooleanExpr(whereExpr(), row)) {
+        return;
+      }
+      callbacks?.onInsert?.(row);
+      if (ctx.event.id !== latestTransactionEventId) {
+        latestTransactionEventId = ctx.event.id;
+        setRows(reconcile(computeSnapshot()));
+      }
+    };
+    const onDelete = (ctx, row) => {
+      if (whereExpr() && !evaluateBooleanExpr(whereExpr(), row)) {
+        return;
+      }
+      callbacks?.onDelete?.(row);
+      if (ctx.event.id !== latestTransactionEventId) {
+        latestTransactionEventId = ctx.event.id;
+        setRows(reconcile(computeSnapshot()));
+      }
+    };
+    const onUpdate = (ctx, oldRow, newRow) => {
+      const change = classifyMembership(whereExpr(), oldRow, newRow);
+      switch (change) {
+        case "leave":
+          callbacks?.onDelete?.(oldRow);
+          break;
+        case "enter":
+          callbacks?.onInsert?.(newRow);
+          break;
+        case "stayIn":
+          callbacks?.onUpdate?.(oldRow, newRow);
+          break;
+        case "stayOut":
+          return;
+      }
+      if (ctx.event.id !== latestTransactionEventId) {
+        latestTransactionEventId = ctx.event.id;
+        setRows(reconcile(computeSnapshot()));
+      }
+    };
+    table.onInsert(onInsert);
+    table.onDelete(onDelete);
+    table.onUpdate?.(onUpdate);
+    setRows(reconcile(computeSnapshot()));
+    onCleanup(() => {
+      table.removeOnInsert(onInsert);
+      table.removeOnDelete(onDelete);
+      table.removeOnUpdate?.(onUpdate);
+    });
+  });
+  return [rows, isReady];
+}
+function useReducer(reducerDef) {
+  const { getConnection, isActive } = useSpacetimeDB();
+  const reducerName = reducerDef.accessorName;
+  const queue = [];
+  createEffect(() => {
+    if (!isActive) return;
+    const conn = getConnection();
+    if (!conn) return;
+    const fn = conn.reducers[reducerName];
+    if (queue.length) {
+      const pending = queue.splice(0);
+      for (const item of pending) {
+        fn(...item.params).then(item.resolve, item.reject);
+      }
+    }
+  });
+  return (...params) => {
+    const conn = getConnection();
+    if (!conn) {
+      return new Promise((resolve, reject) => {
+        queue.push({ params, resolve, reject });
+      });
+    }
+    const fn = conn.reducers[reducerName];
+    return fn(...params);
+  };
+}
+function useProcedure(procedureDef) {
+  const { getConnection, isActive } = useSpacetimeDB();
+  const procedureName = procedureDef.accessorName;
+  const queue = [];
+  createEffect(() => {
+    if (!isActive) return;
+    const conn = getConnection();
+    if (!conn) return;
+    const fn = conn.procedures[procedureName];
+    if (queue.length) {
+      const pending = queue.splice(0);
+      for (const item of pending) {
+        fn(...item.params).then(item.resolve, item.reject);
+      }
+    }
+  });
+  return (...params) => {
+    const conn = getConnection();
+    if (!conn) {
+      return new Promise(
+        (resolve, reject) => {
+          queue.push({ params, resolve, reject });
+        }
+      );
+    }
+    const fn = conn.procedures[procedureName];
+    return fn(...params);
+  };
+}
+
+export { SpacetimeDBProvider, useProcedure, useReducer, useSpacetimeDB, useTable };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map