@absolutejs/sync-expo 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,1213 +1,1214 @@
-// node_modules/@noble/ciphers/utils.js
-/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-var atitle = (title) => title ? `"${title}" ` : "";
-function abool(value, title = "") {
-  if (typeof value !== "boolean")
-    throw new TypeError(atitle(title) + "expected boolean, got type=" + typeof value);
+// src/bridge.ts
+var requireRecord = (value, label) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new TypeError(`Expo Sync bridge ${label} is invalid.`);
   return value;
-}
-function anumber(n, title = "") {
-  if (typeof n !== "number")
-    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
-  return n;
-}
-function abytes(value, length, title = "") {
-  if (isBytes(value) && (length === undefined || value.length === length))
-    return value;
-  if (length !== undefined)
-    anumber(length, "length");
-  const bytes = isBytes(value);
-  const ofLen = length !== undefined ? ` of length ${length}` : "";
-  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
-  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
-  if (!bytes)
-    throw new TypeError(message);
-  throw new RangeError(message);
-}
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("hash was destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("digest() was already called");
-}
-function aoutput(out, instance) {
-  abytes(out, undefined, "output");
-  const min = instance.outputLen;
-  if (!(out.length >= min)) {
-    throw new RangeError('"output" expected length >= ' + min);
-  }
-}
-function aoutput32(out, instance) {
-  aoutput(out, instance);
-  if (!isAligned32(out))
-    throw new Error("invalid output, must be aligned");
-}
-function u8(arr) {
-  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0;i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-function createView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function byteSwap(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n) >>> 0;
-function byteSwap32(arr) {
-  for (let i = 0;i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
-}
-var swap32IfBE = isLE ? (u) => u : byteSwap32;
-function equalBytes(a, b) {
-  a = abytes(a);
-  b = abytes(b);
-  if (a.length !== b.length)
-    return false;
-  let diff = 0;
-  for (let i = 0;i < a.length; i++)
-    diff |= a[i] ^ b[i];
-  return diff === 0;
-}
-function wrapMacConstructor(keyLen, macCons, fromMsg) {
-  const mac = macCons;
-  const getArgs = fromMsg || (() => []);
-  const macC = (msg, key) => mac(key, ...getArgs(msg)).update(msg).digest();
-  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
-  macC.outputLen = tmp.outputLen;
-  macC.blockLen = tmp.blockLen;
-  macC.create = (key, ...args) => mac(key, ...args);
-  return macC;
-}
-var wrapCipher = (params, constructor) => {
-  function wrappedCipher(key, ...args) {
-    abytes(key, undefined, "key");
-    if (params.nonceLength !== undefined) {
-      const nonce = args[0];
-      abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, "nonce");
-    }
-    const tagl = params.tagLength;
-    const aadStart = params.nonceLength !== undefined ? 1 : 0;
-    if (!params.withAAD) {
-      for (let i = aadStart;i < args.length; i++)
-        if (isBytes(args[i]))
-          throw new Error("AAD not supported");
-    }
-    if (params.withAAD && args[aadStart] !== undefined)
-      abytes(args[aadStart], undefined, "AAD");
-    const cipher = constructor(key, ...args);
-    const checkOutput = (fnLength, output) => {
-      if (output !== undefined) {
-        if (fnLength !== 2)
-          throw new Error("cipher output not supported");
-        abytes(output, undefined, "output");
-      }
-    };
-    let called = false;
-    const wrCipher = {
-      encrypt(data, output) {
-        if (called)
-          throw new Error("cannot encrypt() twice with same key + nonce");
-        called = true;
-        abytes(data, undefined, "data");
-        checkOutput(cipher.encrypt.length, output);
-        return cipher.encrypt(data, output);
-      },
-      decrypt(data, output) {
-        abytes(data, undefined, "data");
-        if (tagl && data.length < tagl)
-          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
-        checkOutput(cipher.decrypt.length, output);
-        return cipher.decrypt(data, output);
-      }
-    };
-    return wrCipher;
-  }
-  Object.assign(wrappedCipher, params);
-  return wrappedCipher;
 };
-function getOutput(expectedLength, out, onlyAligned = true) {
-  if (out === undefined)
-    return new Uint8Array(expectedLength);
-  abytes(out, expectedLength, "output");
-  if (onlyAligned && !isAligned32(out))
-    throw new Error("invalid output, must be aligned");
-  return out;
-}
-function u64Lengths(dataLength, aadLength, isLE2) {
-  anumber(dataLength);
-  anumber(aadLength);
-  abool(isLE2);
-  const num = new Uint8Array(16);
-  const view = createView(num);
-  view.setBigUint64(0, BigInt(aadLength), isLE2);
-  view.setBigUint64(8, BigInt(dataLength), isLE2);
-  return num;
-}
-function isAligned32(bytes) {
-  return bytes.byteOffset % 4 === 0;
-}
-function copyBytes(bytes) {
-  return Uint8Array.from(abytes(bytes));
-}
-function randomBytes(bytesLength = 32) {
-  anumber(bytesLength, "bytesLength");
-  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
-  if (typeof cr?.getRandomValues !== "function")
-    throw new Error("crypto.getRandomValues must be defined");
-  if (bytesLength > 65536)
-    throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
-  return cr.getRandomValues(new Uint8Array(bytesLength));
-}
-
-// node_modules/@noble/ciphers/_polyval.js
-var BLOCK_SIZE = 16;
-var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
-var ZEROS32 = /* @__PURE__ */ u32(ZEROS16);
-var POLY = 225;
-var mul2 = (s0, s1, s2, s3) => {
-  const hiBit = s3 & 1;
-  return {
-    s3: s2 << 31 | s3 >>> 1,
-    s2: s1 << 31 | s2 >>> 1,
-    s1: s0 << 31 | s1 >>> 1,
-    s0: s0 >>> 1 ^ POLY << 24 & -(hiBit & 1)
-  };
+var requireString = (value, label) => {
+  if (typeof value !== "string" || value.length === 0 || value.length > 512)
+    throw new TypeError(`Expo Sync bridge ${label} is invalid.`);
+  return value;
 };
-var swapLE = (n) => (n >>> 0 & 255) << 24 | (n >>> 8 & 255) << 16 | (n >>> 16 & 255) << 8 | n >>> 24 & 255 | 0;
-var estimateWindow = (bytes) => {
-  if (bytes > 64 * 1024)
-    return 8;
-  if (bytes > 1024)
-    return 4;
-  return 2;
+var requireCollectionRecord = (value) => {
+  const record = requireRecord(value, "collection record");
+  if (!Array.isArray(record.rows) || typeof record.version !== "number" || !Number.isSafeInteger(record.version) || record.version < 0)
+    throw new TypeError("Expo Sync bridge collection record is invalid.");
+  return structuredClone(record);
 };
-
-class GHASH {
-  blockLen = BLOCK_SIZE;
-  outputLen = BLOCK_SIZE;
-  s0 = 0;
-  s1 = 0;
-  s2 = 0;
-  s3 = 0;
-  finished = false;
-  destroyed = false;
-  t;
-  W;
-  windowSize;
-  constructor(key, expectedLength) {
-    abytes(key, 16, "key");
-    key = copyBytes(key);
-    const kView = createView(key);
-    let k0 = kView.getUint32(0, false);
-    let k1 = kView.getUint32(4, false);
-    let k2 = kView.getUint32(8, false);
-    let k3 = kView.getUint32(12, false);
-    const doubles = [];
-    for (let i = 0;i < 128; i++) {
-      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
-      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));
-    }
-    const W = estimateWindow(expectedLength || 1024);
-    if (![1, 2, 4, 8].includes(W))
-      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
-    this.W = W;
-    const bits = 128;
-    const windows = bits / W;
-    const windowSize = this.windowSize = 2 ** W;
-    const items = [];
-    for (let w = 0;w < windows; w++) {
-      for (let byte = 0;byte < windowSize; byte++) {
-        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
-        for (let j = 0;j < W; j++) {
-          const bit = byte >>> W - j - 1 & 1;
-          if (!bit)
-            continue;
-          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];
-          s0 ^= d0, s1 ^= d1, s2 ^= d2, s3 ^= d3;
-        }
-        items.push({ s0, s1, s2, s3 });
-      }
-    }
-    this.t = items;
-  }
-  _updateBlock(s0, s1, s2, s3) {
-    s0 ^= this.s0, s1 ^= this.s1, s2 ^= this.s2, s3 ^= this.s3;
-    const { W, t, windowSize } = this;
-    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
-    const mask = (1 << W) - 1;
-    let w = 0;
-    for (const num of [s0, s1, s2, s3]) {
-      for (let bytePos = 0;bytePos < 4; bytePos++) {
-        const byte = num >>> 8 * bytePos & 255;
-        for (let bitPos = 8 / W - 1;bitPos >= 0; bitPos--) {
-          const bit = byte >>> W * bitPos & mask;
-          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];
-          o0 ^= e0, o1 ^= e1, o2 ^= e2, o3 ^= e3;
-          w += 1;
-        }
-      }
+var requireMutationRecord = (value) => {
+  const record = requireRecord(value, "mutation record");
+  if (typeof record.operationId !== "string" || record.operationId.length === 0 || record.operationId.length > 512 || typeof record.name !== "string" || record.name.length === 0 || record.name.length > 512 || typeof record.createdAt !== "number" || !Number.isFinite(record.createdAt) || typeof record.attempts !== "number" || !Number.isSafeInteger(record.attempts) || record.attempts < 0 || !Array.isArray(record.optimistic) || !Array.isArray(record.inverse))
+    throw new TypeError("Expo Sync bridge mutation record is invalid.");
+  return structuredClone(record);
+};
+var rollbackMarker = Symbol("expo-sync-bridge-rollback");
+var createExpoSyncBridgeHost = ({
+  store,
+  namespace,
+  transactionTimeoutMs = 8000,
+  createId = () => crypto.randomUUID()
+}) => {
+  if (!namespace || namespace.length > 512)
+    throw new TypeError("Expo Sync bridge namespace is invalid.");
+  if (!Number.isSafeInteger(transactionTimeoutMs) || transactionTimeoutMs < 100 || transactionTimeoutMs > 30000)
+    throw new TypeError("Expo Sync bridge transactionTimeoutMs must be between 100 and 30000.");
+  const sessions = new Map;
+  const begin = async (mode) => {
+    if (sessions.size >= 8)
+      throw new Error("Expo Sync bridge has too many open transactions.");
+    const id = createId();
+    if (!/^[A-Za-z0-9._:-]{1,160}$/u.test(id) || sessions.has(id))
+      throw new Error("Expo Sync bridge generated an invalid transaction id.");
+    let readyResolve = () => {
+      return;
+    };
+    let readyReject = () => {
+      return;
+    };
+    const ready = new Promise((resolve, reject) => {
+      readyResolve = resolve;
+      readyReject = reject;
+    });
+    let finish = () => {
+      return;
+    };
+    const decision = new Promise((resolve) => {
+      finish = resolve;
+    });
+    const complete = store.transaction(namespace, mode, async (transaction2) => {
+      readyResolve(transaction2);
+      if (!await decision)
+        throw rollbackMarker;
+    }).catch((error) => {
+      readyReject(error);
+      if (error !== rollbackMarker)
+        throw error;
+    });
+    const transaction = await ready;
+    const timer = setTimeout(() => {
+      sessions.delete(id);
+      finish(false);
+    }, transactionTimeoutMs);
+    sessions.set(id, { complete, finish, timer, transaction });
+    return id;
+  };
+  const session = (params) => {
+    const id = requireString(params.transactionId, "transaction id");
+    const value = sessions.get(id);
+    if (!value)
+      throw new Error("Expo Sync bridge transaction is closed or unknown.");
+    return { id, value };
+  };
+  const end = async (params) => {
+    const { id, value } = session(params);
+    if (typeof params.commit !== "boolean")
+      throw new TypeError("Expo Sync bridge commit decision is invalid.");
+    sessions.delete(id);
+    clearTimeout(value.timer);
+    value.finish(params.commit);
+    await value.complete;
+    return null;
+  };
+  const operation = async (method, params) => {
+    const { value } = session(params);
+    const transaction = value.transaction;
+    if (method === "sync.tx.getInstallationId")
+      return await transaction.getInstallationId() ?? null;
+    if (method === "sync.tx.setInstallationId") {
+      await transaction.setInstallationId(requireString(params.installationId, "installation id"));
+      return null;
     }
-    this.s0 = o0;
-    this.s1 = o1;
-    this.s2 = o2;
-    this.s3 = o3;
-  }
-  update(data) {
-    aexists(this);
-    abytes(data);
-    data = copyBytes(data);
-    const b32 = u32(data);
-    const blocks = Math.floor(data.length / BLOCK_SIZE);
-    const left = data.length % BLOCK_SIZE;
-    for (let i = 0;i < blocks; i++) {
-      this._updateBlock(swap8IfBE(b32[i * 4 + 0]), swap8IfBE(b32[i * 4 + 1]), swap8IfBE(b32[i * 4 + 2]), swap8IfBE(b32[i * 4 + 3]));
+    if (method === "sync.tx.getCollection")
+      return await transaction.getCollection(requireString(params.key, "collection key")) ?? null;
+    if (method === "sync.tx.listCollections")
+      return transaction.listCollections();
+    if (method === "sync.tx.putCollection") {
+      await transaction.putCollection(requireString(params.key, "collection key"), requireCollectionRecord(params.record));
+      return null;
     }
-    if (left) {
-      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
-      this._updateBlock(swap8IfBE(ZEROS32[0]), swap8IfBE(ZEROS32[1]), swap8IfBE(ZEROS32[2]), swap8IfBE(ZEROS32[3]));
-      clean(ZEROS32);
+    if (method === "sync.tx.deleteCollection") {
+      await transaction.deleteCollection(requireString(params.key, "collection key"));
+      return null;
     }
-    return this;
-  }
-  destroy() {
-    this.destroyed = true;
-    const { t } = this;
-    for (const elm of t) {
-      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
+    if (method === "sync.tx.listMutations")
+      return transaction.listMutations();
+    if (method === "sync.tx.getMutation")
+      return await transaction.getMutation(requireString(params.operationId, "operation id")) ?? null;
+    if (method === "sync.tx.putMutation") {
+      await transaction.putMutation(requireMutationRecord(params.record));
+      return null;
     }
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput32(out, this);
-    this.finished = true;
-    const { s0, s1, s2, s3 } = this;
-    const o32 = u32(out);
-    o32[0] = s0;
-    o32[1] = s1;
-    o32[2] = s2;
-    o32[3] = s3;
-    if (!isLE)
-      swap32IfBE(o32.subarray(0, BLOCK_SIZE / 4));
-  }
-  digest() {
-    const res = new Uint8Array(BLOCK_SIZE);
-    this.digestInto(res);
-    this.destroy();
-    return res;
-  }
-}
-var ghash = /* @__PURE__ */ wrapMacConstructor(16, (key, expectedLength) => new GHASH(key, expectedLength), (msg) => [msg.length]);
-
-// node_modules/@noble/ciphers/aes.js
-var BLOCK_SIZE2 = 16;
-var BLOCK_SIZE32 = 4;
-var EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE2);
-var POLY2 = 283;
-function validateKeyLength(key) {
-  if (![16, 24, 32].includes(key.length))
-    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
-}
-function mul22(n) {
-  return n << 1 ^ POLY2 & -(n >> 7);
-}
-function mul(a, b) {
-  let res = 0;
-  for (;b > 0; b >>= 1) {
-    res ^= a & -(b & 1);
-    a = mul22(a);
-  }
-  return res;
-}
-var sbox = /* @__PURE__ */ (() => {
-  const t = new Uint8Array(256);
-  for (let i = 0, x = 1;i < 256; i++, x ^= mul22(x))
-    t[i] = x;
-  const box = new Uint8Array(256);
-  box[0] = 99;
-  for (let i = 0;i < 255; i++) {
-    let x = t[255 - i];
-    x |= x << 8;
-    box[t[i]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
-  }
-  clean(t);
-  return box;
-})();
-var rotr32_8 = (n) => n << 24 | n >>> 8;
-var rotl32_8 = (n) => n << 8 | n >>> 24;
-function genTtable(sbox2, fn) {
-  if (sbox2.length !== 256)
-    throw new Error("wrong sbox length");
-  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
-  const T1 = T0.map(rotl32_8);
-  const T2 = T1.map(rotl32_8);
-  const T3 = T2.map(rotl32_8);
-  const T01 = new Uint32Array(256 * 256);
-  const T23 = new Uint32Array(256 * 256);
-  const sbox22 = new Uint16Array(256 * 256);
-  for (let i = 0;i < 256; i++) {
-    for (let j = 0;j < 256; j++) {
-      const idx = i * 256 + j;
-      T01[idx] = T0[i] ^ T1[j];
-      T23[idx] = T2[i] ^ T3[j];
-      sbox22[idx] = sbox2[i] << 8 | sbox2[j];
+    if (method === "sync.tx.deleteMutation") {
+      await transaction.deleteMutation(requireString(params.operationId, "operation id"));
+      return null;
     }
-  }
-  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
-}
-var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
-var xPowers = /* @__PURE__ */ (() => {
-  const p = new Uint8Array(16);
-  for (let i = 0, x = 1;i < 16; i++, x = mul22(x))
-    p[i] = x;
-  return p;
-})();
-function expandKeyLE(key) {
-  abytes(key);
-  const len = key.length;
-  validateKeyLength(key);
-  const { sbox2 } = tableEncoding;
-  const toClean = [];
-  if (!isLE || !isAligned32(key))
-    toClean.push(key = copyBytes(key));
-  const k32 = swap32IfBE(u32(key));
-  const Nk = k32.length;
-  const subByte = (n) => applySbox(sbox2, n, n, n, n);
-  const xk = new Uint32Array(len + 28);
-  xk.set(k32);
-  for (let i = Nk;i < xk.length; i++) {
-    let t = xk[i - 1];
-    if (i % Nk === 0)
-      t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
-    else if (Nk > 6 && i % Nk === 4)
-      t = subByte(t);
-    xk[i] = xk[i - Nk] ^ t;
-  }
-  clean(...toClean);
-  return xk;
-}
-function apply0123(T01, T23, s0, s1, s2, s3) {
-  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
-}
-function applySbox(sbox2, s0, s1, s2, s3) {
-  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
-}
-function encrypt(xk, s0, s1, s2, s3) {
-  const { sbox2, T01, T23 } = tableEncoding;
-  let k = 0;
-  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
-  const rounds = xk.length / 4 - 2;
-  for (let i = 0;i < rounds; i++) {
-    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
-    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
-    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
-    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
-    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
-  }
-  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
-  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
-  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
-  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
-  return { s0: t0, s1: t1, s2: t2, s3: t3 };
-}
-function ctr32(xk, isLE2, nonce, src, dst) {
-  abytes(nonce, BLOCK_SIZE2, "nonce");
-  abytes(src);
-  dst = getOutput(src.length, dst);
-  const ctr = nonce;
-  const c32 = u32(ctr);
-  const view = createView(ctr);
-  const src32 = u32(src);
-  const dst32 = u32(dst);
-  const ctrPos = isLE2 ? 0 : 12;
-  const srcLen = src.length;
-  let ctrNum = view.getUint32(ctrPos, isLE2);
-  for (let i = 0;i + 4 <= src32.length; i += 4) {
-    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
-    dst32[i + 0] = src32[i + 0] ^ swap8IfBE(s0);
-    dst32[i + 1] = src32[i + 1] ^ swap8IfBE(s1);
-    dst32[i + 2] = src32[i + 2] ^ swap8IfBE(s2);
-    dst32[i + 3] = src32[i + 3] ^ swap8IfBE(s3);
-    ctrNum = ctrNum + 1 >>> 0;
-    view.setUint32(ctrPos, ctrNum, isLE2);
-  }
-  const start = BLOCK_SIZE2 * Math.floor(src32.length / BLOCK_SIZE32);
-  if (start < srcLen) {
-    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
-    const b32 = new Uint32Array([s0, s1, s2, s3]);
-    swap32IfBE(b32);
-    const buf = u8(b32);
-    for (let i = start, pos = 0;i < srcLen; i++, pos++)
-      dst[i] = src[i] ^ buf[pos];
-    clean(b32);
-  }
-  return dst;
-}
-function computeTag(fn, isLE2, key, data, AAD) {
-  const aadLength = AAD ? AAD.length : 0;
-  const h = fn.create(key, data.length + aadLength);
-  if (AAD)
-    h.update(AAD);
-  const num = u64Lengths(8 * data.length, 8 * aadLength, isLE2);
-  h.update(data);
-  h.update(num);
-  const res = h.digest();
-  clean(num);
-  return res;
-}
-var gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, withAAD: true, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
-  if (nonce.length < 8)
-    throw new Error("aes/gcm: invalid nonce length");
-  const tagLength = 16;
-  function _computeTag(authKey, tagMask, data) {
-    const tag = computeTag(ghash, false, authKey, data, AAD);
-    for (let i = 0;i < tagMask.length; i++)
-      tag[i] ^= tagMask[i];
-    return tag;
-  }
-  function deriveKeys() {
-    const xk = expandKeyLE(key);
-    const authKey = EMPTY_BLOCK.slice();
-    const counter = EMPTY_BLOCK.slice();
-    ctr32(xk, false, counter, counter, authKey);
-    if (nonce.length === 12) {
-      counter.set(nonce);
-    } else {
-      const nonceLen = EMPTY_BLOCK.slice();
-      const view = createView(nonceLen);
-      view.setBigUint64(8, BigInt(nonce.length * 8), false);
-      const g = ghash.create(authKey).update(nonce).update(nonceLen);
-      g.digestInto(counter);
-      g.destroy();
+    if (method === "sync.tx.resolveMutationPolicy")
+      return transaction.resolveMutationPolicy?.(requireString(params.name, "mutation name")) ?? null;
+    throw new Error("Expo Sync bridge transaction method is not allowed.");
+  };
+  return {
+    close: async () => {
+      const active = [...sessions.values()];
+      sessions.clear();
+      for (const value of active) {
+        clearTimeout(value.timer);
+        value.finish(false);
+      }
+      await Promise.allSettled(active.map((value) => value.complete));
+    },
+    request: async (method, rawParams) => {
+      const params = requireRecord(rawParams, "params");
+      if (method === "sync.store.begin") {
+        if (params.mode !== "readonly" && params.mode !== "readwrite")
+          throw new TypeError("Expo Sync bridge transaction mode is invalid.");
+        return { transactionId: await begin(params.mode) };
+      }
+      if (method === "sync.store.end")
+        return end(params);
+      if (method === "sync.store.schema")
+        return await store.getSchemaStatus?.() ?? null;
+      if (method === "sync.store.deleteNamespace") {
+        await store.deleteNamespace?.(namespace);
+        return null;
+      }
+      if (method.startsWith("sync.tx."))
+        return operation(method, params);
+      throw new Error("Expo Sync bridge method is not allowed.");
     }
-    const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
-    return { xk, authKey, counter, tagMask };
-  }
+  };
+};
+var websocketOrigin = (url) => {
+  const protocol = url.protocol === "wss:" ? "https:" : "http:";
+  return `${protocol}//${url.host}`;
+};
+var ticketSocketUrl = (url) => {
+  if (url.searchParams.has("__absolute_auth"))
+    throw new TypeError("Expo Sync socket URL contains reserved authentication.");
+  url.searchParams.set("__absolute_auth", "ticket");
+  return url.href;
+};
+var SOCKET_CHUNK_BYTES = 24 * 1024;
+var SOCKET_UPLOAD_TIMEOUT_MS = 1e4;
+var encodeBase64 = (value) => {
+  let binary = "";
+  for (const byte of value)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var decodeBase64 = (value) => {
+  if (value.length === 0 || value.length > Math.ceil(SOCKET_CHUNK_BYTES / 3) * 4 + 4 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(value))
+    throw new TypeError("Expo Sync socket chunk is invalid.");
+  return Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+};
+var createExpoSyncSocketBridgeHost = ({
+  allowedOrigin,
+  socketTicket,
+  emit,
+  webSocketImpl = globalThis.WebSocket,
+  maxSockets = 4,
+  maxFrameBytes = 4 * 1024 * 1024
+}) => {
+  const origin = new URL(allowedOrigin);
+  if (origin.protocol !== "https:" || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash)
+    throw new TypeError("Expo Sync socket allowedOrigin must be an HTTPS origin.");
+  if (!webSocketImpl)
+    throw new Error("Expo Sync socket bridge requires WebSocket support.");
+  if (!Number.isSafeInteger(maxSockets) || maxSockets < 1 || maxSockets > 16)
+    throw new TypeError("Expo Sync maxSockets must be between 1 and 16.");
+  if (!Number.isSafeInteger(maxFrameBytes) || maxFrameBytes < SOCKET_CHUNK_BYTES || maxFrameBytes > 16 * 1024 * 1024)
+    throw new TypeError("Expo Sync maxFrameBytes must be between 24 KiB and 16 MiB.");
+  const sockets = new Map;
+  const uploads = new Map;
+  let messageSequence = 0;
+  const socketId = (value) => {
+    const id = requireString(value, "socket id");
+    if (!/^[A-Za-z0-9._:-]{1,160}$/u.test(id))
+      throw new TypeError("Expo Sync bridge socket id is invalid.");
+    return id;
+  };
+  const close = (id, code, reason) => {
+    const socket = sockets.get(id);
+    if (!socket)
+      return;
+    sockets.delete(id);
+    for (const [key, upload] of uploads)
+      if (key.startsWith(`${id}:\x00`)) {
+        clearTimeout(upload.timer);
+        uploads.delete(key);
+      }
+    socket.close(code, reason);
+  };
+  const emitMessage = (id, data) => {
+    const bytes = new TextEncoder().encode(data);
+    if (bytes.byteLength > maxFrameBytes) {
+      emit({ socketId: id, type: "error" });
+      close(id, 1009, "Sync frame is too large");
+      return;
+    }
+    const total = Math.max(1, Math.ceil(bytes.byteLength / SOCKET_CHUNK_BYTES));
+    const messageId = `native_${(messageSequence += 1).toString(36)}`;
+    for (let index = 0;index < total; index += 1)
+      emit({
+        data: encodeBase64(bytes.slice(index * SOCKET_CHUNK_BYTES, Math.min(bytes.byteLength, (index + 1) * SOCKET_CHUNK_BYTES))),
+        index,
+        messageId,
+        socketId: id,
+        total,
+        type: "message-chunk"
+      });
+  };
   return {
-    encrypt(plaintext) {
-      const { xk, authKey, counter, tagMask } = deriveKeys();
-      const out = new Uint8Array(plaintext.length + tagLength);
-      const toClean = [xk, authKey, counter, tagMask];
-      if (!isAligned32(plaintext))
-        toClean.push(plaintext = copyBytes(plaintext));
-      ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));
-      const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));
-      toClean.push(tag);
-      out.set(tag, plaintext.length);
-      clean(...toClean);
-      return out;
+    close: () => {
+      for (const id of [...sockets.keys()])
+        close(id, 1000, "Host closed");
     },
-    decrypt(ciphertext) {
-      const { xk, authKey, counter, tagMask } = deriveKeys();
-      const toClean = [xk, authKey, tagMask, counter];
-      if (!isAligned32(ciphertext))
-        toClean.push(ciphertext = copyBytes(ciphertext));
-      const data = ciphertext.subarray(0, -tagLength);
-      const passedTag = ciphertext.subarray(-tagLength);
-      const tag = _computeTag(authKey, tagMask, data);
-      toClean.push(tag);
-      if (!equalBytes(tag, passedTag)) {
-        clean(...toClean);
-        throw new Error("aes-gcm: invalid tag");
+    request: async (method, rawParams) => {
+      const params = requireRecord(rawParams, "socket params");
+      const id = socketId(params.socketId);
+      if (method === "sync.socket.open") {
+        if (sockets.has(id))
+          throw new Error("Expo Sync bridge socket id is already open.");
+        if (sockets.size >= maxSockets)
+          throw new Error("Expo Sync bridge socket limit exceeded.");
+        const url = new URL(requireString(params.url, "socket URL"));
+        if (url.protocol !== "wss:" || url.username || url.password || websocketOrigin(url) !== origin.origin)
+          throw new Error("Expo Sync socket must use WSS on the configured production origin.");
+        const socket = new webSocketImpl(ticketSocketUrl(url));
+        sockets.set(id, socket);
+        socket.onopen = () => {
+          socketTicket(origin.origin).then((ticket) => {
+            if (sockets.get(id) !== socket)
+              return;
+            socket.send(JSON.stringify({ ticket, type: "authenticate" }));
+            emit({ socketId: id, type: "open" });
+          }).catch(() => {
+            if (sockets.get(id) !== socket)
+              return;
+            emit({ socketId: id, type: "error" });
+            close(id, 1008, "Authentication failed");
+          });
+        };
+        socket.onmessage = (event) => {
+          if (sockets.get(id) !== socket)
+            return;
+          if (typeof event.data !== "string") {
+            emit({ socketId: id, type: "error" });
+            close(id, 1003, "Binary frames are not supported");
+            return;
+          }
+          emitMessage(id, event.data);
+        };
+        socket.onerror = () => {
+          if (sockets.get(id) === socket)
+            emit({ socketId: id, type: "error" });
+        };
+        socket.onclose = (event) => {
+          if (sockets.get(id) === socket)
+            sockets.delete(id);
+          emit({
+            code: event.code,
+            reason: event.reason,
+            socketId: id,
+            type: "close"
+          });
+        };
+        return null;
       }
-      const out = ctr32(xk, false, counter, data);
-      clean(...toClean);
-      return out;
+      if (method === "sync.socket.sendChunk") {
+        const socket = sockets.get(id);
+        if (!socket || socket.readyState !== webSocketImpl.OPEN)
+          throw new Error("Expo Sync bridge socket is not open.");
+        const messageId = requireString(params.messageId, "message id");
+        const index = params.index;
+        const total = params.total;
+        if (typeof index !== "number" || !Number.isSafeInteger(index) || typeof total !== "number" || !Number.isSafeInteger(total) || index < 0 || total < 1 || index >= total || total > Math.ceil(maxFrameBytes / SOCKET_CHUNK_BYTES))
+          throw new TypeError("Expo Sync socket chunk position is invalid.");
+        if (typeof params.data !== "string")
+          throw new TypeError("Expo Sync socket chunk data is invalid.");
+        const key = `${id}:\x00${messageId}`;
+        let upload = uploads.get(key);
+        if (!upload) {
+          const timer = setTimeout(() => uploads.delete(key), SOCKET_UPLOAD_TIMEOUT_MS);
+          upload = { chunks: Array.from({ length: total }), timer };
+          uploads.set(key, upload);
+        }
+        if (upload.chunks.length !== total || upload.chunks[index])
+          throw new Error("Expo Sync socket chunk sequence is invalid.");
+        upload.chunks[index] = decodeBase64(params.data);
+        if (upload.chunks.every((chunk) => chunk !== undefined)) {
+          clearTimeout(upload.timer);
+          uploads.delete(key);
+          const size = upload.chunks.reduce((sum, chunk) => sum + (chunk?.byteLength ?? 0), 0);
+          if (size > maxFrameBytes)
+            throw new Error("Expo Sync socket frame exceeds its byte limit.");
+          const bytes = new Uint8Array(size);
+          let offset = 0;
+          for (const chunk of upload.chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+          }
+          socket.send(new TextDecoder().decode(bytes));
+        }
+        return null;
+      }
+      if (method === "sync.socket.close") {
+        const code = params.code === undefined ? undefined : typeof params.code === "number" && Number.isSafeInteger(params.code) && params.code >= 1000 && params.code <= 4999 ? params.code : null;
+        if (code === null)
+          throw new TypeError("Expo Sync bridge close code is invalid.");
+        const reason = params.reason === undefined ? undefined : requireString(params.reason, "close reason");
+        close(id, code, reason);
+        return null;
+      }
+      throw new Error("Expo Sync socket bridge method is not allowed.");
     }
   };
-});
-
-// src/index.ts
-import * as BackgroundTask from "expo-background-task";
-import * as Network from "expo-network";
-import * as SecureStore from "expo-secure-store";
-import * as TaskManager from "expo-task-manager";
-import { AppState } from "react-native";
-
-// src/store.ts
-import {
-  createSyncLocalSchemaStatus,
-  migrateSyncLocalCollectionRecord,
-  migrateSyncLocalMutationRecord,
-  resolveSyncLocalDataPolicy,
-  resolveSyncLocalSchemaComponents,
-  runSyncLocalPolicyTransaction
-} from "@absolutejs/sync/client";
-import * as SQLite from "expo-sqlite";
-var SCHEMA = [
-  `CREATE TABLE IF NOT EXISTS absolute_sync_schema (
-  singleton_id INTEGER PRIMARY KEY NOT NULL CHECK (singleton_id = 1),
-  logical_version INTEGER NOT NULL
-)`,
-  `CREATE TABLE IF NOT EXISTS absolute_sync_schema_components (
-  component_id TEXT PRIMARY KEY NOT NULL,
-  logical_version INTEGER NOT NULL
-)`,
-  `CREATE TABLE IF NOT EXISTS absolute_sync_metadata (
-  namespace TEXT PRIMARY KEY NOT NULL,
-  installation_id TEXT NOT NULL
-)`,
-  `CREATE TABLE IF NOT EXISTS absolute_sync_collections (
-  namespace TEXT NOT NULL,
-  collection_key TEXT NOT NULL,
-  record_json TEXT NOT NULL,
-  PRIMARY KEY (namespace, collection_key)
-)`,
-  `CREATE TABLE IF NOT EXISTS absolute_sync_mutations (
-  namespace TEXT NOT NULL,
-  operation_id TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  record_json TEXT NOT NULL,
-  PRIMARY KEY (namespace, operation_id)
-)`,
-  `CREATE INDEX IF NOT EXISTS absolute_sync_mutations_order
-  ON absolute_sync_mutations (namespace, created_at, operation_id)`
-];
-var executor = (value) => ({
-  execAsync: (source) => value.execAsync(source),
-  getAllAsync: (source, params = []) => value.getAllAsync(source, [...params]),
-  getFirstAsync: (source, params = []) => value.getFirstAsync(source, [...params]),
-  runAsync: (source, params = []) => value.runAsync(source, [...params])
-});
-var defaultDatabase = async (databaseName) => {
-  const database = await SQLite.openDatabaseAsync(databaseName);
-  const direct = executor(database);
-  return {
-    ...direct,
-    withExclusiveTransactionAsync: (run) => database.withExclusiveTransactionAsync((transaction) => run(executor(transaction)))
-  };
 };
-var parseRecord = (value, label, context, protector) => {
-  if (value === undefined || value === null)
-    return;
-  if (typeof value !== "string")
-    throw new Error(`Expo Sync SQLite returned invalid ${label} JSON.`);
-  try {
-    const parsed = JSON.parse(value);
-    if (typeof parsed === "object" && parsed !== null && "__absoluteSyncProtected" in parsed) {
-      const envelope = parsed.__absoluteSyncProtected;
-      if (!context || !protector || protector.id !== envelope.protector)
-        throw new Error(`Expo Sync ${label} requires unavailable protection provider "${envelope.protector}".`);
-      return JSON.parse(protector.open(envelope.value, {
-        ...context,
-        name: envelope.name
-      }));
-    }
-    return parsed;
-  } catch (cause) {
-    throw new Error(`Expo Sync SQLite could not parse ${label} JSON.`, {
-      cause
-    });
+
+// node_modules/@noble/ciphers/utils.js
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle = (title) => title ? `"${title}" ` : "";
+function abool(value, title = "") {
+  if (typeof value !== "boolean")
+    throw new TypeError(atitle(title) + "expected boolean, got type=" + typeof value);
+  return value;
+}
+function anumber(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === undefined || value.length === length))
+    return value;
+  if (length !== undefined)
+    anumber(length, "length");
+  const bytes = isBytes(value);
+  const ofLen = length !== undefined ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes(out, undefined, "output");
+  const min = instance.outputLen;
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
   }
-};
-var serializeRecord = (value, context, protector) => protector ? JSON.stringify({
-  __absoluteSyncProtected: {
-    name: context.name,
-    protector: protector.id,
-    value: protector.seal(JSON.stringify(value), context)
+}
+function aoutput32(out, instance) {
+  aoutput(out, instance);
+  if (!isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
   }
-}) : JSON.stringify(value);
-var requireNamespace = (namespace) => {
-  if (namespace.length === 0)
-    throw new TypeError("Sync local-store namespace must not be empty.");
-};
-var rowString = (row, field) => {
-  const value = row?.[field];
-  return typeof value === "string" ? value : undefined;
-};
-var prepareSchema = async (database, storageSchema, protector) => {
-  let status;
-  await database.withExclusiveTransactionAsync(async (transaction) => {
-    const legacy = await transaction.getFirstAsync("SELECT logical_version FROM absolute_sync_schema WHERE singleton_id = 1 LIMIT 1");
-    const componentRows = await transaction.getAllAsync("SELECT component_id, logical_version FROM absolute_sync_schema_components ORDER BY component_id");
-    const storedVersions = {};
-    for (const row of componentRows) {
-      if (typeof row.component_id !== "string" || typeof row.logical_version !== "number")
-        throw new Error("Expo Sync SQLite returned an invalid schema component ledger.");
-      storedVersions[row.component_id] = row.logical_version;
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n) >>> 0;
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function equalBytes(a, b) {
+  a = abytes(a);
+  b = abytes(b);
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0;i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+function wrapMacConstructor(keyLen, macCons, fromMsg) {
+  const mac = macCons;
+  const getArgs = fromMsg || (() => []);
+  const macC = (msg, key) => mac(key, ...getArgs(msg)).update(msg).digest();
+  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
+  macC.outputLen = tmp.outputLen;
+  macC.blockLen = tmp.blockLen;
+  macC.create = (key, ...args) => mac(key, ...args);
+  return macC;
+}
+var wrapCipher = (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key, undefined, "key");
+    if (params.nonceLength !== undefined) {
+      const nonce = args[0];
+      abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, "nonce");
     }
-    if (storedVersions["@absolutejs/app"] === undefined && typeof legacy?.logical_version === "number")
-      storedVersions["@absolutejs/app"] = legacy.logical_version;
-    const resolved = resolveSyncLocalSchemaComponents(storedVersions, storageSchema);
-    const steps = resolved.components.flatMap((component) => component.steps);
-    if (steps.length > 0) {
-      const collections = await transaction.getAllAsync("SELECT namespace, collection_key, record_json FROM absolute_sync_collections ORDER BY namespace, collection_key");
-      for (const row of collections) {
-        const namespace = row.namespace;
-        const key = row.collection_key;
-        if (typeof namespace !== "string" || typeof key !== "string")
-          throw new Error("Expo Sync SQLite returned an invalid collection identity.");
-        const record = parseRecord(row.record_json, "collection", { kind: "collection", namespace }, protector);
-        if (!record)
-          throw new Error("Expo Sync SQLite returned a missing collection record.");
-        const migrated = migrateSyncLocalCollectionRecord(record, { key, namespace }, steps);
-        if (migrated === null)
-          await transaction.runAsync("DELETE FROM absolute_sync_collections WHERE namespace = ? AND collection_key = ?", [namespace, key]);
-        else
-          await transaction.runAsync("UPDATE absolute_sync_collections SET record_json = ? WHERE namespace = ? AND collection_key = ?", [
-            serializeRecord(migrated, {
-              kind: "collection",
-              name: migrated.collection ?? key,
-              namespace
-            }, protector),
-            namespace,
-            key
-          ]);
+    const tagl = params.tagLength;
+    const aadStart = params.nonceLength !== undefined ? 1 : 0;
+    if (!params.withAAD) {
+      for (let i = aadStart;i < args.length; i++)
+        if (isBytes(args[i]))
+          throw new Error("AAD not supported");
+    }
+    if (params.withAAD && args[aadStart] !== undefined)
+      abytes(args[aadStart], undefined, "AAD");
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== undefined) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output, undefined, "output");
       }
-      const mutations = await transaction.getAllAsync("SELECT namespace, operation_id, record_json FROM absolute_sync_mutations ORDER BY namespace, operation_id");
-      for (const row of mutations) {
-        const namespace = row.namespace;
-        const operationId = row.operation_id;
-        if (typeof namespace !== "string" || typeof operationId !== "string")
-          throw new Error("Expo Sync SQLite returned an invalid mutation identity.");
-        const record = parseRecord(row.record_json, "mutation", { kind: "mutation", namespace }, protector);
-        if (!record)
-          throw new Error("Expo Sync SQLite returned a missing mutation record.");
-        const migrated = migrateSyncLocalMutationRecord(record, { key: operationId, namespace }, steps);
-        if (migrated === null)
-          await transaction.runAsync("DELETE FROM absolute_sync_mutations WHERE namespace = ? AND operation_id = ?", [namespace, operationId]);
-        else
-          await transaction.runAsync("UPDATE absolute_sync_mutations SET created_at = ?, record_json = ? WHERE namespace = ? AND operation_id = ?", [
-            migrated.createdAt,
-            serializeRecord(migrated, {
-              kind: "mutation",
-              name: migrated.name,
-              namespace
-            }, protector),
-            namespace,
-            operationId
-          ]);
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data, undefined, "data");
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data, undefined, "data");
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
       }
-    }
-    for (const component of resolved.components)
-      await transaction.runAsync("INSERT INTO absolute_sync_schema_components (component_id, logical_version) VALUES (?, ?) ON CONFLICT(component_id) DO UPDATE SET logical_version = excluded.logical_version", [component.id, component.targetVersion]);
-    const app = resolved.components.find((component) => component.id === "@absolutejs/app");
-    if (app)
-      await transaction.runAsync("INSERT INTO absolute_sync_schema (singleton_id, logical_version) VALUES (1, ?) ON CONFLICT(singleton_id) DO UPDATE SET logical_version = excluded.logical_version", [app.targetVersion]);
-    status = createSyncLocalSchemaStatus(resolved.components, resolved.orphanedComponents, "components" in storageSchema);
-  });
-  if (!status)
-    throw new Error("Expo Sync schema transaction did not run.");
-  return status;
-};
-var createExpoSyncLocalStore = ({
-  databaseName = "absolutejs-sync-local-v1.db",
-  database: createDatabase = () => defaultDatabase(databaseName),
-  storageSchema = { version: 1 },
-  protection,
-  now = Date.now
-} = {}) => {
-  if (!/^[A-Za-z0-9._-]{1,120}$/u.test(databaseName))
-    throw new TypeError("Expo Sync databaseName is invalid.");
-  const localData = resolveSyncLocalDataPolicy(storageSchema);
-  let protectorPromise;
-  const prepareProtector = () => protectorPromise ??= protection?.prepare();
-  let schemaStatus;
-  let databasePromise;
-  const database = () => {
-    databasePromise ??= Promise.all([
-      Promise.resolve(createDatabase()),
-      prepareProtector()
-    ]).then(async ([value, protector]) => {
-      await value.execAsync("PRAGMA journal_mode = WAL");
-      for (const statement of SCHEMA)
-        await value.execAsync(statement);
-      schemaStatus = await prepareSchema(value, storageSchema, protector);
-      return value;
-    });
-    return databasePromise;
-  };
-  let tail = Promise.resolve();
-  const locked = async (run) => {
-    let release = () => {
-      return;
     };
-    const previous = tail;
-    tail = new Promise((resolve) => {
-      release = resolve;
-    });
-    await previous;
-    try {
-      return await run();
-    } finally {
-      release();
-    }
-  };
-  const transaction = async (namespace, mode, run) => {
-    requireNamespace(namespace);
-    return locked(async () => {
-      const value = await database();
-      const protector = await prepareProtector();
-      let result;
-      let completed = false;
-      await value.withExclusiveTransactionAsync(async (sqlite) => {
-        const writable = () => {
-          if (mode !== "readwrite")
-            throw new Error("Cannot write in a readonly Sync local transaction");
-        };
-        const raw = {
-          deleteCollection: async (key) => {
-            writable();
-            await sqlite.runAsync("DELETE FROM absolute_sync_collections WHERE namespace = ? AND collection_key = ?", [namespace, key]);
-          },
-          deleteMutation: async (operationId) => {
-            writable();
-            await sqlite.runAsync("DELETE FROM absolute_sync_mutations WHERE namespace = ? AND operation_id = ?", [namespace, operationId]);
-          },
-          getCollection: async (key) => {
-            const row = await sqlite.getFirstAsync("SELECT record_json FROM absolute_sync_collections WHERE namespace = ? AND collection_key = ? LIMIT 1", [namespace, key]);
-            return parseRecord(row?.record_json, "collection", { kind: "collection", namespace }, protector);
-          },
-          getInstallationId: async () => {
-            const row = await sqlite.getFirstAsync("SELECT installation_id FROM absolute_sync_metadata WHERE namespace = ? LIMIT 1", [namespace]);
-            return rowString(row, "installation_id");
-          },
-          getMutation: async (operationId) => {
-            const row = await sqlite.getFirstAsync("SELECT record_json FROM absolute_sync_mutations WHERE namespace = ? AND operation_id = ? LIMIT 1", [namespace, operationId]);
-            return parseRecord(row?.record_json, "mutation", { kind: "mutation", namespace }, protector);
-          },
-          listCollections: async () => {
-            const rows = await sqlite.getAllAsync("SELECT collection_key, record_json FROM absolute_sync_collections WHERE namespace = ? ORDER BY collection_key ASC", [namespace]);
-            return rows.map((row) => {
-              const key = row.collection_key;
-              const record = parseRecord(row.record_json, "collection", { kind: "collection", namespace }, protector);
-              return typeof key === "string" && record ? { key, record } : undefined;
-            }).filter((entry) => entry !== undefined);
-          },
-          listMutations: async () => {
-            const rows = await sqlite.getAllAsync("SELECT record_json FROM absolute_sync_mutations WHERE namespace = ? ORDER BY created_at ASC, operation_id ASC", [namespace]);
-            return rows.map((row) => parseRecord(row.record_json, "mutation", { kind: "mutation", namespace }, protector)).filter((record) => record !== undefined);
-          },
-          putCollection: async (key, record) => {
-            writable();
-            await sqlite.runAsync("INSERT INTO absolute_sync_collections (namespace, collection_key, record_json) VALUES (?, ?, ?) ON CONFLICT(namespace, collection_key) DO UPDATE SET record_json = excluded.record_json", [
-              namespace,
-              key,
-              serializeRecord(record, {
-                kind: "collection",
-                name: record.collection ?? key,
-                namespace
-              }, protector)
-            ]);
-          },
-          putMutation: async (record) => {
-            writable();
-            await sqlite.runAsync("INSERT INTO absolute_sync_mutations (namespace, operation_id, created_at, record_json) VALUES (?, ?, ?, ?) ON CONFLICT(namespace, operation_id) DO UPDATE SET created_at = excluded.created_at, record_json = excluded.record_json", [
-              namespace,
-              record.operationId,
-              record.createdAt,
-              serializeRecord(record, {
-                kind: "mutation",
-                name: record.name,
-                namespace
-              }, protector)
-            ]);
-          },
-          setInstallationId: async (installationId) => {
-            writable();
-            if (installationId.length === 0)
-              throw new TypeError("Sync installation id must not be empty.");
-            await sqlite.runAsync("INSERT INTO absolute_sync_metadata (namespace, installation_id) VALUES (?, ?) ON CONFLICT(namespace) DO UPDATE SET installation_id = excluded.installation_id", [namespace, installationId]);
-          }
-        };
-        result = await runSyncLocalPolicyTransaction({
-          mode,
-          now: now(),
-          policy: localData,
-          protected: protector !== undefined,
-          raw,
-          run
-        });
-        completed = true;
-      });
-      if (!completed)
-        throw new Error("Expo Sync transaction did not complete.");
-      return result;
-    });
-  };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === undefined)
+    return new Uint8Array(expectedLength);
+  abytes(out, expectedLength, "output");
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function u64Lengths(dataLength, aadLength, isLE2) {
+  anumber(dataLength);
+  anumber(aadLength);
+  abool(isLE2);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  view.setBigUint64(0, BigInt(aadLength), isLE2);
+  view.setBigUint64(8, BigInt(dataLength), isLE2);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(abytes(bytes));
+}
+function randomBytes(bytesLength = 32) {
+  anumber(bytesLength, "bytesLength");
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  if (bytesLength > 65536)
+    throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+
+// node_modules/@noble/ciphers/_polyval.js
+var BLOCK_SIZE = 16;
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var ZEROS32 = /* @__PURE__ */ u32(ZEROS16);
+var POLY = 225;
+var mul2 = (s0, s1, s2, s3) => {
+  const hiBit = s3 & 1;
   return {
-    deleteNamespace: async (namespace) => {
-      requireNamespace(namespace);
-      await locked(async () => {
-        const value = await database();
-        await value.withExclusiveTransactionAsync(async (sqlite) => {
-          for (const table of [
-            "absolute_sync_metadata",
-            "absolute_sync_collections",
-            "absolute_sync_mutations"
-          ])
-            await sqlite.runAsync(`DELETE FROM ${table} WHERE namespace = ?`, [
-              namespace
-            ]);
-        });
-      });
-    },
-    getSchemaStatus: async () => {
-      await database();
-      if (!schemaStatus)
-        throw new Error("Expo Sync schema was not prepared.");
-      return { ...schemaStatus };
-    },
-    transaction
+    s3: s2 << 31 | s3 >>> 1,
+    s2: s1 << 31 | s2 >>> 1,
+    s1: s0 << 31 | s1 >>> 1,
+    s0: s0 >>> 1 ^ POLY << 24 & -(hiBit & 1)
   };
 };
-// src/bridge.ts
-var requireRecord = (value, label) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    throw new TypeError(`Expo Sync bridge ${label} is invalid.`);
-  return value;
-};
-var requireString = (value, label) => {
-  if (typeof value !== "string" || value.length === 0 || value.length > 512)
-    throw new TypeError(`Expo Sync bridge ${label} is invalid.`);
-  return value;
-};
-var requireCollectionRecord = (value) => {
-  const record = requireRecord(value, "collection record");
-  if (!Array.isArray(record.rows) || typeof record.version !== "number" || !Number.isSafeInteger(record.version) || record.version < 0)
-    throw new TypeError("Expo Sync bridge collection record is invalid.");
-  return structuredClone(record);
-};
-var requireMutationRecord = (value) => {
-  const record = requireRecord(value, "mutation record");
-  if (typeof record.operationId !== "string" || record.operationId.length === 0 || record.operationId.length > 512 || typeof record.name !== "string" || record.name.length === 0 || record.name.length > 512 || typeof record.createdAt !== "number" || !Number.isFinite(record.createdAt) || typeof record.attempts !== "number" || !Number.isSafeInteger(record.attempts) || record.attempts < 0 || !Array.isArray(record.optimistic) || !Array.isArray(record.inverse))
-    throw new TypeError("Expo Sync bridge mutation record is invalid.");
-  return structuredClone(record);
+var swapLE = (n) => (n >>> 0 & 255) << 24 | (n >>> 8 & 255) << 16 | (n >>> 16 & 255) << 8 | n >>> 24 & 255 | 0;
+var estimateWindow = (bytes) => {
+  if (bytes > 64 * 1024)
+    return 8;
+  if (bytes > 1024)
+    return 4;
+  return 2;
 };
-var rollbackMarker = Symbol("expo-sync-bridge-rollback");
-var createExpoSyncBridgeHost = ({
-  store,
-  namespace,
-  transactionTimeoutMs = 8000,
-  createId = () => crypto.randomUUID()
-}) => {
-  if (!namespace || namespace.length > 512)
-    throw new TypeError("Expo Sync bridge namespace is invalid.");
-  if (!Number.isSafeInteger(transactionTimeoutMs) || transactionTimeoutMs < 100 || transactionTimeoutMs > 30000)
-    throw new TypeError("Expo Sync bridge transactionTimeoutMs must be between 100 and 30000.");
-  const sessions = new Map;
-  const begin = async (mode) => {
-    if (sessions.size >= 8)
-      throw new Error("Expo Sync bridge has too many open transactions.");
-    const id = createId();
-    if (!/^[A-Za-z0-9._:-]{1,160}$/u.test(id) || sessions.has(id))
-      throw new Error("Expo Sync bridge generated an invalid transaction id.");
-    let readyResolve = () => {
-      return;
-    };
-    let readyReject = () => {
-      return;
-    };
-    const ready = new Promise((resolve, reject) => {
-      readyResolve = resolve;
-      readyReject = reject;
-    });
-    let finish = () => {
-      return;
-    };
-    const decision = new Promise((resolve) => {
-      finish = resolve;
-    });
-    const complete = store.transaction(namespace, mode, async (transaction2) => {
-      readyResolve(transaction2);
-      if (!await decision)
-        throw rollbackMarker;
-    }).catch((error) => {
-      readyReject(error);
-      if (error !== rollbackMarker)
-        throw error;
-    });
-    const transaction = await ready;
-    const timer = setTimeout(() => {
-      sessions.delete(id);
-      finish(false);
-    }, transactionTimeoutMs);
-    sessions.set(id, { complete, finish, timer, transaction });
-    return id;
-  };
-  const session = (params) => {
-    const id = requireString(params.transactionId, "transaction id");
-    const value = sessions.get(id);
-    if (!value)
-      throw new Error("Expo Sync bridge transaction is closed or unknown.");
-    return { id, value };
-  };
-  const end = async (params) => {
-    const { id, value } = session(params);
-    if (typeof params.commit !== "boolean")
-      throw new TypeError("Expo Sync bridge commit decision is invalid.");
-    sessions.delete(id);
-    clearTimeout(value.timer);
-    value.finish(params.commit);
-    await value.complete;
-    return null;
-  };
-  const operation = async (method, params) => {
-    const { value } = session(params);
-    const transaction = value.transaction;
-    if (method === "sync.tx.getInstallationId")
-      return await transaction.getInstallationId() ?? null;
-    if (method === "sync.tx.setInstallationId") {
-      await transaction.setInstallationId(requireString(params.installationId, "installation id"));
-      return null;
+
+class GHASH {
+  blockLen = BLOCK_SIZE;
+  outputLen = BLOCK_SIZE;
+  s0 = 0;
+  s1 = 0;
+  s2 = 0;
+  s3 = 0;
+  finished = false;
+  destroyed = false;
+  t;
+  W;
+  windowSize;
+  constructor(key, expectedLength) {
+    abytes(key, 16, "key");
+    key = copyBytes(key);
+    const kView = createView(key);
+    let k0 = kView.getUint32(0, false);
+    let k1 = kView.getUint32(4, false);
+    let k2 = kView.getUint32(8, false);
+    let k3 = kView.getUint32(12, false);
+    const doubles = [];
+    for (let i = 0;i < 128; i++) {
+      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
+      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));
     }
-    if (method === "sync.tx.getCollection")
-      return await transaction.getCollection(requireString(params.key, "collection key")) ?? null;
-    if (method === "sync.tx.listCollections")
-      return transaction.listCollections();
-    if (method === "sync.tx.putCollection") {
-      await transaction.putCollection(requireString(params.key, "collection key"), requireCollectionRecord(params.record));
-      return null;
+    const W = estimateWindow(expectedLength || 1024);
+    if (![1, 2, 4, 8].includes(W))
+      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
+    this.W = W;
+    const bits = 128;
+    const windows = bits / W;
+    const windowSize = this.windowSize = 2 ** W;
+    const items = [];
+    for (let w = 0;w < windows; w++) {
+      for (let byte = 0;byte < windowSize; byte++) {
+        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+        for (let j = 0;j < W; j++) {
+          const bit = byte >>> W - j - 1 & 1;
+          if (!bit)
+            continue;
+          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];
+          s0 ^= d0, s1 ^= d1, s2 ^= d2, s3 ^= d3;
+        }
+        items.push({ s0, s1, s2, s3 });
+      }
     }
-    if (method === "sync.tx.deleteCollection") {
-      await transaction.deleteCollection(requireString(params.key, "collection key"));
-      return null;
+    this.t = items;
+  }
+  _updateBlock(s0, s1, s2, s3) {
+    s0 ^= this.s0, s1 ^= this.s1, s2 ^= this.s2, s3 ^= this.s3;
+    const { W, t, windowSize } = this;
+    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
+    const mask = (1 << W) - 1;
+    let w = 0;
+    for (const num of [s0, s1, s2, s3]) {
+      for (let bytePos = 0;bytePos < 4; bytePos++) {
+        const byte = num >>> 8 * bytePos & 255;
+        for (let bitPos = 8 / W - 1;bitPos >= 0; bitPos--) {
+          const bit = byte >>> W * bitPos & mask;
+          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];
+          o0 ^= e0, o1 ^= e1, o2 ^= e2, o3 ^= e3;
+          w += 1;
+        }
+      }
+    }
+    this.s0 = o0;
+    this.s1 = o1;
+    this.s2 = o2;
+    this.s3 = o3;
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const b32 = u32(data);
+    const blocks = Math.floor(data.length / BLOCK_SIZE);
+    const left = data.length % BLOCK_SIZE;
+    for (let i = 0;i < blocks; i++) {
+      this._updateBlock(swap8IfBE(b32[i * 4 + 0]), swap8IfBE(b32[i * 4 + 1]), swap8IfBE(b32[i * 4 + 2]), swap8IfBE(b32[i * 4 + 3]));
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
+      this._updateBlock(swap8IfBE(ZEROS32[0]), swap8IfBE(ZEROS32[1]), swap8IfBE(ZEROS32[2]), swap8IfBE(ZEROS32[3]));
+      clean(ZEROS32);
+    }
+    return this;
+  }
+  destroy() {
+    this.destroyed = true;
+    const { t } = this;
+    for (const elm of t) {
+      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
     }
-    if (method === "sync.tx.listMutations")
-      return transaction.listMutations();
-    if (method === "sync.tx.getMutation")
-      return await transaction.getMutation(requireString(params.operationId, "operation id")) ?? null;
-    if (method === "sync.tx.putMutation") {
-      await transaction.putMutation(requireMutationRecord(params.record));
-      return null;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput32(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    if (!isLE)
+      swap32IfBE(o32.subarray(0, BLOCK_SIZE / 4));
+  }
+  digest() {
+    const res = new Uint8Array(BLOCK_SIZE);
+    this.digestInto(res);
+    this.destroy();
+    return res;
+  }
+}
+var ghash = /* @__PURE__ */ wrapMacConstructor(16, (key, expectedLength) => new GHASH(key, expectedLength), (msg) => [msg.length]);
+
+// node_modules/@noble/ciphers/aes.js
+var BLOCK_SIZE2 = 16;
+var BLOCK_SIZE32 = 4;
+var EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE2);
+var POLY2 = 283;
+function validateKeyLength(key) {
+  if (![16, 24, 32].includes(key.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+}
+function mul22(n) {
+  return n << 1 ^ POLY2 & -(n >> 7);
+}
+function mul(a, b) {
+  let res = 0;
+  for (;b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul22(a);
+  }
+  return res;
+}
+var sbox = /* @__PURE__ */ (() => {
+  const t = new Uint8Array(256);
+  for (let i = 0, x = 1;i < 256; i++, x ^= mul22(x))
+    t[i] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i = 0;i < 255; i++) {
+    let x = t[255 - i];
+    x |= x << 8;
+    box[t[i]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  clean(t);
+  return box;
+})();
+var rotr32_8 = (n) => n << 24 | n >>> 8;
+var rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i = 0;i < 256; i++) {
+    for (let j = 0;j < 256; j++) {
+      const idx = i * 256 + j;
+      T01[idx] = T0[i] ^ T1[j];
+      T23[idx] = T2[i] ^ T3[j];
+      sbox22[idx] = sbox2[i] << 8 | sbox2[j];
     }
-    if (method === "sync.tx.deleteMutation") {
-      await transaction.deleteMutation(requireString(params.operationId, "operation id"));
-      return null;
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+var xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i = 0, x = 1;i < 16; i++, x = mul22(x))
+    p[i] = x;
+  return p;
+})();
+function expandKeyLE(key) {
+  abytes(key);
+  const len = key.length;
+  validateKeyLength(key);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isLE || !isAligned32(key))
+    toClean.push(key = copyBytes(key));
+  const k32 = swap32IfBE(u32(key));
+  const Nk = k32.length;
+  const subByte = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i = Nk;i < xk.length; i++) {
+    let t = xk[i - 1];
+    if (i % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
+    else if (Nk > 6 && i % Nk === 4)
+      t = subByte(t);
+    xk[i] = xk[i - Nk] ^ t;
+  }
+  clean(...toClean);
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i = 0;i < rounds; i++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function ctr32(xk, isLE2, nonce, src, dst) {
+  abytes(nonce, BLOCK_SIZE2, "nonce");
+  abytes(src);
+  dst = getOutput(src.length, dst);
+  const ctr = nonce;
+  const c32 = u32(ctr);
+  const view = createView(ctr);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  const ctrPos = isLE2 ? 0 : 12;
+  const srcLen = src.length;
+  let ctrNum = view.getUint32(ctrPos, isLE2);
+  for (let i = 0;i + 4 <= src32.length; i += 4) {
+    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    dst32[i + 0] = src32[i + 0] ^ swap8IfBE(s0);
+    dst32[i + 1] = src32[i + 1] ^ swap8IfBE(s1);
+    dst32[i + 2] = src32[i + 2] ^ swap8IfBE(s2);
+    dst32[i + 3] = src32[i + 3] ^ swap8IfBE(s3);
+    ctrNum = ctrNum + 1 >>> 0;
+    view.setUint32(ctrPos, ctrNum, isLE2);
+  }
+  const start = BLOCK_SIZE2 * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    swap32IfBE(b32);
+    const buf = u8(b32);
+    for (let i = start, pos = 0;i < srcLen; i++, pos++)
+      dst[i] = src[i] ^ buf[pos];
+    clean(b32);
+  }
+  return dst;
+}
+function computeTag(fn, isLE2, key, data, AAD) {
+  const aadLength = AAD ? AAD.length : 0;
+  const h = fn.create(key, data.length + aadLength);
+  if (AAD)
+    h.update(AAD);
+  const num = u64Lengths(8 * data.length, 8 * aadLength, isLE2);
+  h.update(data);
+  h.update(num);
+  const res = h.digest();
+  clean(num);
+  return res;
+}
+var gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, withAAD: true, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
+  if (nonce.length < 8)
+    throw new Error("aes/gcm: invalid nonce length");
+  const tagLength = 16;
+  function _computeTag(authKey, tagMask, data) {
+    const tag = computeTag(ghash, false, authKey, data, AAD);
+    for (let i = 0;i < tagMask.length; i++)
+      tag[i] ^= tagMask[i];
+    return tag;
+  }
+  function deriveKeys() {
+    const xk = expandKeyLE(key);
+    const authKey = EMPTY_BLOCK.slice();
+    const counter = EMPTY_BLOCK.slice();
+    ctr32(xk, false, counter, counter, authKey);
+    if (nonce.length === 12) {
+      counter.set(nonce);
+    } else {
+      const nonceLen = EMPTY_BLOCK.slice();
+      const view = createView(nonceLen);
+      view.setBigUint64(8, BigInt(nonce.length * 8), false);
+      const g = ghash.create(authKey).update(nonce).update(nonceLen);
+      g.digestInto(counter);
+      g.destroy();
     }
-    if (method === "sync.tx.resolveMutationPolicy")
-      return transaction.resolveMutationPolicy?.(requireString(params.name, "mutation name")) ?? null;
-    throw new Error("Expo Sync bridge transaction method is not allowed.");
-  };
+    const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
+    return { xk, authKey, counter, tagMask };
+  }
   return {
-    close: async () => {
-      const active = [...sessions.values()];
-      sessions.clear();
-      for (const value of active) {
-        clearTimeout(value.timer);
-        value.finish(false);
-      }
-      await Promise.allSettled(active.map((value) => value.complete));
+    encrypt(plaintext) {
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const out = new Uint8Array(plaintext.length + tagLength);
+      const toClean = [xk, authKey, counter, tagMask];
+      if (!isAligned32(plaintext))
+        toClean.push(plaintext = copyBytes(plaintext));
+      ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));
+      const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));
+      toClean.push(tag);
+      out.set(tag, plaintext.length);
+      clean(...toClean);
+      return out;
     },
-    request: async (method, rawParams) => {
-      const params = requireRecord(rawParams, "params");
-      if (method === "sync.store.begin") {
-        if (params.mode !== "readonly" && params.mode !== "readwrite")
-          throw new TypeError("Expo Sync bridge transaction mode is invalid.");
-        return { transactionId: await begin(params.mode) };
-      }
-      if (method === "sync.store.end")
-        return end(params);
-      if (method === "sync.store.schema")
-        return await store.getSchemaStatus?.() ?? null;
-      if (method === "sync.store.deleteNamespace") {
-        await store.deleteNamespace?.(namespace);
-        return null;
+    decrypt(ciphertext) {
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const toClean = [xk, authKey, tagMask, counter];
+      if (!isAligned32(ciphertext))
+        toClean.push(ciphertext = copyBytes(ciphertext));
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = _computeTag(authKey, tagMask, data);
+      toClean.push(tag);
+      if (!equalBytes(tag, passedTag)) {
+        clean(...toClean);
+        throw new Error("aes-gcm: invalid tag");
       }
-      if (method.startsWith("sync.tx."))
-        return operation(method, params);
-      throw new Error("Expo Sync bridge method is not allowed.");
+      const out = ctr32(xk, false, counter, data);
+      clean(...toClean);
+      return out;
     }
   };
+});
+
+// src/index.ts
+import * as BackgroundTask from "expo-background-task";
+import * as Network from "expo-network";
+import * as SecureStore from "expo-secure-store";
+import * as TaskManager from "expo-task-manager";
+import { AppState } from "react-native";
+
+// src/store.ts
+import {
+  createSyncLocalSchemaStatus,
+  migrateSyncLocalCollectionRecord,
+  migrateSyncLocalMutationRecord,
+  resolveSyncLocalDataPolicy,
+  resolveSyncLocalSchemaComponents,
+  runSyncLocalPolicyTransaction
+} from "@absolutejs/sync/client";
+import * as SQLite from "expo-sqlite";
+var SCHEMA = [
+  `CREATE TABLE IF NOT EXISTS absolute_sync_schema (
+  singleton_id INTEGER PRIMARY KEY NOT NULL CHECK (singleton_id = 1),
+  logical_version INTEGER NOT NULL
+)`,
+  `CREATE TABLE IF NOT EXISTS absolute_sync_schema_components (
+  component_id TEXT PRIMARY KEY NOT NULL,
+  logical_version INTEGER NOT NULL
+)`,
+  `CREATE TABLE IF NOT EXISTS absolute_sync_metadata (
+  namespace TEXT PRIMARY KEY NOT NULL,
+  installation_id TEXT NOT NULL
+)`,
+  `CREATE TABLE IF NOT EXISTS absolute_sync_collections (
+  namespace TEXT NOT NULL,
+  collection_key TEXT NOT NULL,
+  record_json TEXT NOT NULL,
+  PRIMARY KEY (namespace, collection_key)
+)`,
+  `CREATE TABLE IF NOT EXISTS absolute_sync_mutations (
+  namespace TEXT NOT NULL,
+  operation_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  record_json TEXT NOT NULL,
+  PRIMARY KEY (namespace, operation_id)
+)`,
+  `CREATE INDEX IF NOT EXISTS absolute_sync_mutations_order
+  ON absolute_sync_mutations (namespace, created_at, operation_id)`
+];
+var executor = (value) => ({
+  execAsync: (source) => value.execAsync(source),
+  getAllAsync: (source, params = []) => value.getAllAsync(source, [...params]),
+  getFirstAsync: (source, params = []) => value.getFirstAsync(source, [...params]),
+  runAsync: (source, params = []) => value.runAsync(source, [...params])
+});
+var defaultDatabase = async (databaseName) => {
+  const database = await SQLite.openDatabaseAsync(databaseName);
+  const direct = executor(database);
+  return {
+    ...direct,
+    withExclusiveTransactionAsync: (run) => database.withExclusiveTransactionAsync((transaction) => run(executor(transaction)))
+  };
 };
-var websocketOrigin = (url) => {
-  const protocol = url.protocol === "wss:" ? "https:" : "http:";
-  return `${protocol}//${url.host}`;
-};
-var ticketSocketUrl = (url) => {
-  if (url.searchParams.has("__absolute_auth"))
-    throw new TypeError("Expo Sync socket URL contains reserved authentication.");
-  url.searchParams.set("__absolute_auth", "ticket");
-  return url.href;
+var parseRecord = (value, label, context, protector) => {
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "string")
+    throw new Error(`Expo Sync SQLite returned invalid ${label} JSON.`);
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && "__absoluteSyncProtected" in parsed) {
+      const envelope = parsed.__absoluteSyncProtected;
+      if (!context || !protector || protector.id !== envelope.protector)
+        throw new Error(`Expo Sync ${label} requires unavailable protection provider "${envelope.protector}".`);
+      return JSON.parse(protector.open(envelope.value, {
+        ...context,
+        name: envelope.name
+      }));
+    }
+    return parsed;
+  } catch (cause) {
+    throw new Error(`Expo Sync SQLite could not parse ${label} JSON.`, {
+      cause
+    });
+  }
 };
-var SOCKET_CHUNK_BYTES = 24 * 1024;
-var SOCKET_UPLOAD_TIMEOUT_MS = 1e4;
-var encodeBase64 = (value) => {
-  let binary = "";
-  for (const byte of value)
-    binary += String.fromCharCode(byte);
-  return btoa(binary);
+var serializeRecord = (value, context, protector) => protector ? JSON.stringify({
+  __absoluteSyncProtected: {
+    name: context.name,
+    protector: protector.id,
+    value: protector.seal(JSON.stringify(value), context)
+  }
+}) : JSON.stringify(value);
+var requireNamespace = (namespace) => {
+  if (namespace.length === 0)
+    throw new TypeError("Sync local-store namespace must not be empty.");
 };
-var decodeBase64 = (value) => {
-  if (value.length === 0 || value.length > Math.ceil(SOCKET_CHUNK_BYTES / 3) * 4 + 4 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(value))
-    throw new TypeError("Expo Sync socket chunk is invalid.");
-  return Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+var rowString = (row, field) => {
+  const value = row?.[field];
+  return typeof value === "string" ? value : undefined;
 };
-var createExpoSyncSocketBridgeHost = ({
-  allowedOrigin,
-  socketTicket,
-  emit,
-  webSocketImpl = globalThis.WebSocket,
-  maxSockets = 4,
-  maxFrameBytes = 4 * 1024 * 1024
-}) => {
-  const origin = new URL(allowedOrigin);
-  if (origin.protocol !== "https:" || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash)
-    throw new TypeError("Expo Sync socket allowedOrigin must be an HTTPS origin.");
-  if (!webSocketImpl)
-    throw new Error("Expo Sync socket bridge requires WebSocket support.");
-  if (!Number.isSafeInteger(maxSockets) || maxSockets < 1 || maxSockets > 16)
-    throw new TypeError("Expo Sync maxSockets must be between 1 and 16.");
-  if (!Number.isSafeInteger(maxFrameBytes) || maxFrameBytes < SOCKET_CHUNK_BYTES || maxFrameBytes > 16 * 1024 * 1024)
-    throw new TypeError("Expo Sync maxFrameBytes must be between 24 KiB and 16 MiB.");
-  const sockets = new Map;
-  const uploads = new Map;
-  let messageSequence = 0;
-  const socketId = (value) => {
-    const id = requireString(value, "socket id");
-    if (!/^[A-Za-z0-9._:-]{1,160}$/u.test(id))
-      throw new TypeError("Expo Sync bridge socket id is invalid.");
-    return id;
-  };
-  const close = (id, code, reason) => {
-    const socket = sockets.get(id);
-    if (!socket)
-      return;
-    sockets.delete(id);
-    for (const [key, upload] of uploads)
-      if (key.startsWith(`${id}:\x00`)) {
-        clearTimeout(upload.timer);
-        uploads.delete(key);
+var prepareSchema = async (database, storageSchema, protector) => {
+  let status;
+  await database.withExclusiveTransactionAsync(async (transaction) => {
+    const legacy = await transaction.getFirstAsync("SELECT logical_version FROM absolute_sync_schema WHERE singleton_id = 1 LIMIT 1");
+    const componentRows = await transaction.getAllAsync("SELECT component_id, logical_version FROM absolute_sync_schema_components ORDER BY component_id");
+    const storedVersions = {};
+    for (const row of componentRows) {
+      if (typeof row.component_id !== "string" || typeof row.logical_version !== "number")
+        throw new Error("Expo Sync SQLite returned an invalid schema component ledger.");
+      storedVersions[row.component_id] = row.logical_version;
+    }
+    if (storedVersions["@absolutejs/app"] === undefined && typeof legacy?.logical_version === "number")
+      storedVersions["@absolutejs/app"] = legacy.logical_version;
+    const resolved = resolveSyncLocalSchemaComponents(storedVersions, storageSchema);
+    const steps = resolved.components.flatMap((component) => component.steps);
+    if (steps.length > 0) {
+      const collections = await transaction.getAllAsync("SELECT namespace, collection_key, record_json FROM absolute_sync_collections ORDER BY namespace, collection_key");
+      for (const row of collections) {
+        const namespace = row.namespace;
+        const key = row.collection_key;
+        if (typeof namespace !== "string" || typeof key !== "string")
+          throw new Error("Expo Sync SQLite returned an invalid collection identity.");
+        const record = parseRecord(row.record_json, "collection", { kind: "collection", namespace }, protector);
+        if (!record)
+          throw new Error("Expo Sync SQLite returned a missing collection record.");
+        const migrated = migrateSyncLocalCollectionRecord(record, { key, namespace }, steps);
+        if (migrated === null)
+          await transaction.runAsync("DELETE FROM absolute_sync_collections WHERE namespace = ? AND collection_key = ?", [namespace, key]);
+        else
+          await transaction.runAsync("UPDATE absolute_sync_collections SET record_json = ? WHERE namespace = ? AND collection_key = ?", [
+            serializeRecord(migrated, {
+              kind: "collection",
+              name: migrated.collection ?? key,
+              namespace
+            }, protector),
+            namespace,
+            key
+          ]);
       }
-    socket.close(code, reason);
+      const mutations = await transaction.getAllAsync("SELECT namespace, operation_id, record_json FROM absolute_sync_mutations ORDER BY namespace, operation_id");
+      for (const row of mutations) {
+        const namespace = row.namespace;
+        const operationId = row.operation_id;
+        if (typeof namespace !== "string" || typeof operationId !== "string")
+          throw new Error("Expo Sync SQLite returned an invalid mutation identity.");
+        const record = parseRecord(row.record_json, "mutation", { kind: "mutation", namespace }, protector);
+        if (!record)
+          throw new Error("Expo Sync SQLite returned a missing mutation record.");
+        const migrated = migrateSyncLocalMutationRecord(record, { key: operationId, namespace }, steps);
+        if (migrated === null)
+          await transaction.runAsync("DELETE FROM absolute_sync_mutations WHERE namespace = ? AND operation_id = ?", [namespace, operationId]);
+        else
+          await transaction.runAsync("UPDATE absolute_sync_mutations SET created_at = ?, record_json = ? WHERE namespace = ? AND operation_id = ?", [
+            migrated.createdAt,
+            serializeRecord(migrated, {
+              kind: "mutation",
+              name: migrated.name,
+              namespace
+            }, protector),
+            namespace,
+            operationId
+          ]);
+      }
+    }
+    for (const component of resolved.components)
+      await transaction.runAsync("INSERT INTO absolute_sync_schema_components (component_id, logical_version) VALUES (?, ?) ON CONFLICT(component_id) DO UPDATE SET logical_version = excluded.logical_version", [component.id, component.targetVersion]);
+    const app = resolved.components.find((component) => component.id === "@absolutejs/app");
+    if (app)
+      await transaction.runAsync("INSERT INTO absolute_sync_schema (singleton_id, logical_version) VALUES (1, ?) ON CONFLICT(singleton_id) DO UPDATE SET logical_version = excluded.logical_version", [app.targetVersion]);
+    status = createSyncLocalSchemaStatus(resolved.components, resolved.orphanedComponents, "components" in storageSchema);
+  });
+  if (!status)
+    throw new Error("Expo Sync schema transaction did not run.");
+  return status;
+};
+var createExpoSyncLocalStore = ({
+  databaseName = "absolutejs-sync-local-v1.db",
+  database: createDatabase = () => defaultDatabase(databaseName),
+  storageSchema = { version: 1 },
+  protection,
+  now = Date.now
+} = {}) => {
+  if (!/^[A-Za-z0-9._-]{1,120}$/u.test(databaseName))
+    throw new TypeError("Expo Sync databaseName is invalid.");
+  const localData = resolveSyncLocalDataPolicy(storageSchema);
+  let protectorPromise;
+  const prepareProtector = () => protectorPromise ??= protection?.prepare();
+  let schemaStatus;
+  let databasePromise;
+  const database = () => {
+    databasePromise ??= Promise.all([
+      Promise.resolve(createDatabase()),
+      prepareProtector()
+    ]).then(async ([value, protector]) => {
+      await value.execAsync("PRAGMA journal_mode = WAL");
+      for (const statement of SCHEMA)
+        await value.execAsync(statement);
+      schemaStatus = await prepareSchema(value, storageSchema, protector);
+      return value;
+    });
+    return databasePromise;
   };
-  const emitMessage = (id, data) => {
-    const bytes = new TextEncoder().encode(data);
-    if (bytes.byteLength > maxFrameBytes) {
-      emit({ socketId: id, type: "error" });
-      close(id, 1009, "Sync frame is too large");
+  let tail = Promise.resolve();
+  const locked = async (run) => {
+    let release = () => {
       return;
+    };
+    const previous = tail;
+    tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await run();
+    } finally {
+      release();
     }
-    const total = Math.max(1, Math.ceil(bytes.byteLength / SOCKET_CHUNK_BYTES));
-    const messageId = `native_${(messageSequence += 1).toString(36)}`;
-    for (let index = 0;index < total; index += 1)
-      emit({
-        data: encodeBase64(bytes.slice(index * SOCKET_CHUNK_BYTES, Math.min(bytes.byteLength, (index + 1) * SOCKET_CHUNK_BYTES))),
-        index,
-        messageId,
-        socketId: id,
-        total,
-        type: "message-chunk"
-      });
   };
-  return {
-    close: () => {
-      for (const id of [...sockets.keys()])
-        close(id, 1000, "Host closed");
-    },
-    request: async (method, rawParams) => {
-      const params = requireRecord(rawParams, "socket params");
-      const id = socketId(params.socketId);
-      if (method === "sync.socket.open") {
-        if (sockets.has(id))
-          throw new Error("Expo Sync bridge socket id is already open.");
-        if (sockets.size >= maxSockets)
-          throw new Error("Expo Sync bridge socket limit exceeded.");
-        const url = new URL(requireString(params.url, "socket URL"));
-        if (url.protocol !== "wss:" || url.username || url.password || websocketOrigin(url) !== origin.origin)
-          throw new Error("Expo Sync socket must use WSS on the configured production origin.");
-        const socket = new webSocketImpl(ticketSocketUrl(url));
-        sockets.set(id, socket);
-        socket.onopen = () => {
-          socketTicket(origin.origin).then((ticket) => {
-            if (sockets.get(id) !== socket)
-              return;
-            socket.send(JSON.stringify({ ticket, type: "authenticate" }));
-            emit({ socketId: id, type: "open" });
-          }).catch(() => {
-            if (sockets.get(id) !== socket)
-              return;
-            emit({ socketId: id, type: "error" });
-            close(id, 1008, "Authentication failed");
-          });
+  const transaction = async (namespace, mode, run) => {
+    requireNamespace(namespace);
+    return locked(async () => {
+      const value = await database();
+      const protector = await prepareProtector();
+      let result;
+      let completed = false;
+      await value.withExclusiveTransactionAsync(async (sqlite) => {
+        const writable = () => {
+          if (mode !== "readwrite")
+            throw new Error("Cannot write in a readonly Sync local transaction");
         };
-        socket.onmessage = (event) => {
-          if (sockets.get(id) !== socket)
-            return;
-          if (typeof event.data !== "string") {
-            emit({ socketId: id, type: "error" });
-            close(id, 1003, "Binary frames are not supported");
-            return;
+        const raw = {
+          deleteCollection: async (key) => {
+            writable();
+            await sqlite.runAsync("DELETE FROM absolute_sync_collections WHERE namespace = ? AND collection_key = ?", [namespace, key]);
+          },
+          deleteMutation: async (operationId) => {
+            writable();
+            await sqlite.runAsync("DELETE FROM absolute_sync_mutations WHERE namespace = ? AND operation_id = ?", [namespace, operationId]);
+          },
+          getCollection: async (key) => {
+            const row = await sqlite.getFirstAsync("SELECT record_json FROM absolute_sync_collections WHERE namespace = ? AND collection_key = ? LIMIT 1", [namespace, key]);
+            return parseRecord(row?.record_json, "collection", { kind: "collection", namespace }, protector);
+          },
+          getInstallationId: async () => {
+            const row = await sqlite.getFirstAsync("SELECT installation_id FROM absolute_sync_metadata WHERE namespace = ? LIMIT 1", [namespace]);
+            return rowString(row, "installation_id");
+          },
+          getMutation: async (operationId) => {
+            const row = await sqlite.getFirstAsync("SELECT record_json FROM absolute_sync_mutations WHERE namespace = ? AND operation_id = ? LIMIT 1", [namespace, operationId]);
+            return parseRecord(row?.record_json, "mutation", { kind: "mutation", namespace }, protector);
+          },
+          listCollections: async () => {
+            const rows = await sqlite.getAllAsync("SELECT collection_key, record_json FROM absolute_sync_collections WHERE namespace = ? ORDER BY collection_key ASC", [namespace]);
+            return rows.map((row) => {
+              const key = row.collection_key;
+              const record = parseRecord(row.record_json, "collection", { kind: "collection", namespace }, protector);
+              return typeof key === "string" && record ? { key, record } : undefined;
+            }).filter((entry) => entry !== undefined);
+          },
+          listMutations: async () => {
+            const rows = await sqlite.getAllAsync("SELECT record_json FROM absolute_sync_mutations WHERE namespace = ? ORDER BY created_at ASC, operation_id ASC", [namespace]);
+            return rows.map((row) => parseRecord(row.record_json, "mutation", { kind: "mutation", namespace }, protector)).filter((record) => record !== undefined);
+          },
+          putCollection: async (key, record) => {
+            writable();
+            await sqlite.runAsync("INSERT INTO absolute_sync_collections (namespace, collection_key, record_json) VALUES (?, ?, ?) ON CONFLICT(namespace, collection_key) DO UPDATE SET record_json = excluded.record_json", [
+              namespace,
+              key,
+              serializeRecord(record, {
+                kind: "collection",
+                name: record.collection ?? key,
+                namespace
+              }, protector)
+            ]);
+          },
+          putMutation: async (record) => {
+            writable();
+            await sqlite.runAsync("INSERT INTO absolute_sync_mutations (namespace, operation_id, created_at, record_json) VALUES (?, ?, ?, ?) ON CONFLICT(namespace, operation_id) DO UPDATE SET created_at = excluded.created_at, record_json = excluded.record_json", [
+              namespace,
+              record.operationId,
+              record.createdAt,
+              serializeRecord(record, {
+                kind: "mutation",
+                name: record.name,
+                namespace
+              }, protector)
+            ]);
+          },
+          setInstallationId: async (installationId) => {
+            writable();
+            if (installationId.length === 0)
+              throw new TypeError("Sync installation id must not be empty.");
+            await sqlite.runAsync("INSERT INTO absolute_sync_metadata (namespace, installation_id) VALUES (?, ?) ON CONFLICT(namespace) DO UPDATE SET installation_id = excluded.installation_id", [namespace, installationId]);
           }
-          emitMessage(id, event.data);
-        };
-        socket.onerror = () => {
-          if (sockets.get(id) === socket)
-            emit({ socketId: id, type: "error" });
-        };
-        socket.onclose = (event) => {
-          if (sockets.get(id) === socket)
-            sockets.delete(id);
-          emit({
-            code: event.code,
-            reason: event.reason,
-            socketId: id,
-            type: "close"
-          });
         };
-        return null;
-      }
-      if (method === "sync.socket.sendChunk") {
-        const socket = sockets.get(id);
-        if (!socket || socket.readyState !== webSocketImpl.OPEN)
-          throw new Error("Expo Sync bridge socket is not open.");
-        const messageId = requireString(params.messageId, "message id");
-        const index = params.index;
-        const total = params.total;
-        if (typeof index !== "number" || !Number.isSafeInteger(index) || typeof total !== "number" || !Number.isSafeInteger(total) || index < 0 || total < 1 || index >= total || total > Math.ceil(maxFrameBytes / SOCKET_CHUNK_BYTES))
-          throw new TypeError("Expo Sync socket chunk position is invalid.");
-        if (typeof params.data !== "string")
-          throw new TypeError("Expo Sync socket chunk data is invalid.");
-        const key = `${id}:\x00${messageId}`;
-        let upload = uploads.get(key);
-        if (!upload) {
-          const timer = setTimeout(() => uploads.delete(key), SOCKET_UPLOAD_TIMEOUT_MS);
-          upload = { chunks: Array.from({ length: total }), timer };
-          uploads.set(key, upload);
-        }
-        if (upload.chunks.length !== total || upload.chunks[index])
-          throw new Error("Expo Sync socket chunk sequence is invalid.");
-        upload.chunks[index] = decodeBase64(params.data);
-        if (upload.chunks.every((chunk) => chunk !== undefined)) {
-          clearTimeout(upload.timer);
-          uploads.delete(key);
-          const size = upload.chunks.reduce((sum, chunk) => sum + (chunk?.byteLength ?? 0), 0);
-          if (size > maxFrameBytes)
-            throw new Error("Expo Sync socket frame exceeds its byte limit.");
-          const bytes = new Uint8Array(size);
-          let offset = 0;
-          for (const chunk of upload.chunks) {
-            bytes.set(chunk, offset);
-            offset += chunk.byteLength;
-          }
-          socket.send(new TextDecoder().decode(bytes));
-        }
-        return null;
-      }
-      if (method === "sync.socket.close") {
-        const code = params.code === undefined ? undefined : typeof params.code === "number" && Number.isSafeInteger(params.code) && params.code >= 1000 && params.code <= 4999 ? params.code : null;
-        if (code === null)
-          throw new TypeError("Expo Sync bridge close code is invalid.");
-        const reason = params.reason === undefined ? undefined : requireString(params.reason, "close reason");
-        close(id, code, reason);
-        return null;
-      }
-      throw new Error("Expo Sync socket bridge method is not allowed.");
-    }
+        result = await runSyncLocalPolicyTransaction({
+          mode,
+          now: now(),
+          policy: localData,
+          protected: protector !== undefined,
+          raw,
+          run
+        });
+        completed = true;
+      });
+      if (!completed)
+        throw new Error("Expo Sync transaction did not complete.");
+      return result;
+    });
+  };
+  return {
+    deleteNamespace: async (namespace) => {
+      requireNamespace(namespace);
+      await locked(async () => {
+        const value = await database();
+        await value.withExclusiveTransactionAsync(async (sqlite) => {
+          for (const table of [
+            "absolute_sync_metadata",
+            "absolute_sync_collections",
+            "absolute_sync_mutations"
+          ])
+            await sqlite.runAsync(`DELETE FROM ${table} WHERE namespace = ?`, [
+              namespace
+            ]);
+        });
+      });
+    },
+    getSchemaStatus: async () => {
+      await database();
+      if (!schemaStatus)
+        throw new Error("Expo Sync schema was not prepared.");
+      return { ...schemaStatus };
+    },
+    transaction
   };
 };
 
@@ -1388,5 +1389,5 @@ export {
   unregisterExpoSyncBackgroundTask
 };
 
-//# debugId=549E3E1847B4FE1C64756E2164756E21
+//# debugId=300EEDFDC3B21ACA64756E2164756E21
 //# sourceMappingURL=index.js.map