@absolutejs/sync-expo 0.0.1

package/dist/index.js

@@ -0,0 +1,1392 @@
+// 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);
+  }
+}
+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 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;
+};
+
+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;
+        }
+      }
+    }
+    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;
+    }
+  }
+  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];
+    }
+  }
+  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();
+    }
+    const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
+    return { xk, authKey, counter, tagMask };
+  }
+  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;
+    },
+    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");
+      }
+      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 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 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 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;
+    }
+    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 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;
+  };
+  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 {
+    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
+  };
+};
+// 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 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;
+    }
+    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 (method === "sync.tx.deleteCollection") {
+      await transaction.deleteCollection(requireString(params.key, "collection key"));
+      return null;
+    }
+    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;
+    }
+    if (method === "sync.tx.deleteMutation") {
+      await transaction.deleteMutation(requireString(params.operationId, "operation id"));
+      return null;
+    }
+    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.");
+    }
+  };
+};
+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 {
+    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");
+          });
+        };
+        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;
+      }
+      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
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+var base64 = (value) => {
+  let binary = "";
+  for (const byte of value)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var unbase64 = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+var normalizeStoragePrefix = (value = "absolutejs.sync") => {
+  if (!/^[A-Za-z0-9._-]{1,80}$/u.test(value))
+    throw new TypeError("Expo Sync storagePrefix must use 1-80 letters, numbers, dots, underscores, or hyphens.");
+  return value;
+};
+var lockTails = new Map;
+var withProcessLock = async (key, run) => {
+  const previous = lockTails.get(key) ?? Promise.resolve();
+  let release = () => {
+    return;
+  };
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current);
+  lockTails.set(key, tail);
+  await previous;
+  try {
+    return await run();
+  } finally {
+    release();
+    if (lockTails.get(key) === tail)
+      lockTails.delete(key);
+  }
+};
+var createExpoSyncProtection = (options = {}) => {
+  const storage = options.secureStore ?? SecureStore;
+  const prefix = normalizeStoragePrefix(options.storagePrefix);
+  const keyName = `${prefix}.data-key.v1`;
+  const secureStoreOptions = {
+    keychainAccessible: storage.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY
+  };
+  return {
+    prepare: async () => {
+      if (!await storage.isAvailableAsync())
+        throw new Error("Expo Sync data protection requires persistent SecureStore storage.");
+      const key = await withProcessLock(keyName, async () => {
+        const existing = await storage.getItemAsync(keyName, secureStoreOptions);
+        if (existing)
+          return unbase64(existing);
+        const created = randomBytes(32);
+        await storage.setItemAsync(keyName, base64(created), secureStoreOptions);
+        const persisted = await storage.getItemAsync(keyName, secureStoreOptions);
+        if (!persisted)
+          throw new Error("Expo Sync data-protection key was not persisted.");
+        return unbase64(persisted);
+      });
+      if (key.byteLength !== 32)
+        throw new Error("Expo Sync data-protection key is invalid.");
+      const additionalData = (context) => textEncoder.encode(`absolute-sync-v1\x00${context.kind}\x00${context.namespace}\x00${context.name}`);
+      return {
+        id: "aes-256-gcm-v1",
+        open: (value, context) => {
+          const bytes = unbase64(value);
+          if (bytes.byteLength < 13)
+            throw new Error("Expo Sync protected record is malformed.");
+          const nonce = bytes.slice(0, 12);
+          return textDecoder.decode(gcm(key, nonce, additionalData(context)).decrypt(bytes.slice(12)));
+        },
+        seal: (value, context) => {
+          const nonce = randomBytes(12);
+          const encrypted = gcm(key, nonce, additionalData(context)).encrypt(textEncoder.encode(value));
+          const output = new Uint8Array(nonce.length + encrypted.length);
+          output.set(nonce);
+          output.set(encrypted, nonce.length);
+          return base64(output);
+        }
+      };
+    }
+  };
+};
+var installExpoSyncLifecycle = ({
+  client,
+  flushTimeoutMs = 1e4,
+  onError,
+  dependencies = { appState: AppState, network: Network }
+}) => {
+  if (!Number.isFinite(flushTimeoutMs) || flushTimeoutMs < 0)
+    throw new TypeError("Expo Sync flushTimeoutMs must be a non-negative number.");
+  const wake = () => {
+    client.reconnect();
+    client.flush?.({ timeoutMs: flushTimeoutMs }).catch((error) => onError?.(error));
+  };
+  let previous = dependencies.appState.currentState ?? undefined;
+  const appState = dependencies.appState.addEventListener("change", (state) => {
+    if (state === "active" && previous !== "active")
+      wake();
+    previous = state;
+  });
+  const network = dependencies.network.addNetworkStateListener((state) => {
+    if (state.isConnected && state.isInternetReachable !== false)
+      wake();
+  });
+  let active = true;
+  return () => {
+    if (!active)
+      return;
+    active = false;
+    appState.remove();
+    network.remove();
+  };
+};
+var backgroundDependencies = () => ({
+  backgroundTask: {
+    Failed: BackgroundTask.BackgroundTaskResult.Failed,
+    Success: BackgroundTask.BackgroundTaskResult.Success,
+    getStatusAsync: () => BackgroundTask.getStatusAsync(),
+    registerTaskAsync: (taskName, options) => BackgroundTask.registerTaskAsync(taskName, options),
+    unregisterTaskAsync: (taskName) => BackgroundTask.unregisterTaskAsync(taskName)
+  },
+  taskManager: TaskManager
+});
+var requireTaskName = (taskName) => {
+  if (!/^[A-Za-z0-9._-]{1,120}$/u.test(taskName))
+    throw new TypeError("Expo Sync background task name is invalid.");
+};
+var defineExpoSyncBackgroundTask = (taskName, run, dependencies = backgroundDependencies()) => {
+  requireTaskName(taskName);
+  if (dependencies.taskManager.isTaskDefined(taskName))
+    return;
+  dependencies.taskManager.defineTask(taskName, async () => {
+    try {
+      await run();
+      return dependencies.backgroundTask.Success;
+    } catch {
+      return dependencies.backgroundTask.Failed;
+    }
+  });
+};
+var registerExpoSyncBackgroundTask = async (taskName, options = {}, dependencies = backgroundDependencies()) => {
+  requireTaskName(taskName);
+  if (options.minimumInterval !== undefined && (!Number.isFinite(options.minimumInterval) || options.minimumInterval < 15))
+    throw new TypeError("Expo Sync background minimumInterval must be at least 15 minutes.");
+  const available = await dependencies.taskManager.isAvailableAsync();
+  const status = await dependencies.backgroundTask.getStatusAsync();
+  if (!available)
+    return {
+      available: false,
+      registered: false,
+      status
+    };
+  if (!dependencies.taskManager.isTaskDefined(taskName))
+    throw new Error("Expo Sync background task must be defined at module scope before registration.");
+  if (!await dependencies.taskManager.isTaskRegisteredAsync(taskName))
+    await dependencies.backgroundTask.registerTaskAsync(taskName, options);
+  return {
+    available: true,
+    registered: true,
+    status
+  };
+};
+var unregisterExpoSyncBackgroundTask = async (taskName, dependencies = backgroundDependencies()) => {
+  requireTaskName(taskName);
+  if (await dependencies.taskManager.isTaskRegisteredAsync(taskName))
+    await dependencies.backgroundTask.unregisterTaskAsync(taskName);
+};
+export {
+  createExpoSyncBridgeHost,
+  createExpoSyncLocalStore,
+  createExpoSyncProtection,
+  createExpoSyncSocketBridgeHost,
+  defineExpoSyncBackgroundTask,
+  installExpoSyncLifecycle,
+  registerExpoSyncBackgroundTask,
+  unregisterExpoSyncBackgroundTask
+};
+
+//# debugId=549E3E1847B4FE1C64756E2164756E21
+//# sourceMappingURL=index.js.map