@hostr/upload 0.1.0

package/dist/react-native.js

@@ -0,0 +1,896 @@
+// src/core/events.ts
+var Emitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(ev, cb) {
+    let set = this.listeners.get(ev);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(ev, set);
+    }
+    const wrapped = cb;
+    set.add(wrapped);
+    return () => {
+      set.delete(wrapped);
+    };
+  }
+  emit(ev, v) {
+    const set = this.listeners.get(ev);
+    if (!set) return;
+    for (const cb of set) {
+      try {
+        cb(v);
+      } catch {
+      }
+    }
+  }
+};
+function computeProgress(i) {
+  const elapsedSec = (i.nowMs - i.startedAtMs) / 1e3;
+  const confirmedThisRun = i.confirmed - i.confirmedAtStart;
+  const throughputBps = elapsedSec >= 1 && confirmedThisRun > 0 ? confirmedThisRun / elapsedSec : null;
+  const bytesSent = Math.min(i.confirmed + i.inflight, i.total);
+  const etaSec = throughputBps === null ? null : (i.total - bytesSent) / throughputBps;
+  const progress = {
+    bytesSent,
+    bytesConfirmed: i.confirmed,
+    totalBytes: i.total,
+    throughputBps,
+    etaSec,
+    partsDone: i.partsDone,
+    partsTotal: i.partsTotal
+  };
+  if (i.partStates !== void 0) progress.partStates = i.partStates;
+  return progress;
+}
+
+// src/core/session.ts
+var storageKey = (fileId) => `hostr.upload.v1:${fileId}`;
+async function loadSession(store, fileId) {
+  try {
+    const raw = await store.get(storageKey(fileId));
+    if (raw == null) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed?.v !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveSession(store, s) {
+  await store.set(storageKey(s.fileId), JSON.stringify(s));
+}
+async function clearSession(store, fileId) {
+  await store.delete(storageKey(fileId));
+}
+function partSizeOf(s, n) {
+  if (n === s.expectedParts) {
+    return s.declaredSize - (s.expectedParts - 1) * s.partSize;
+  }
+  return s.partSize;
+}
+
+// src/api/client.ts
+var ApiError = class extends Error {
+  status;
+  code;
+  constructor(status, code) {
+    super(code ? `hostr api error ${status}: ${code}` : `hostr api error ${status}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message = "network error") {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var trimEndpoint = (endpoint) => endpoint.replace(/\/$/, "");
+async function req(fetchFn, endpoint, bearer, path, init = {}) {
+  const url = `${trimEndpoint(endpoint)}${path}`;
+  const headers = { authorization: `Bearer ${bearer}` };
+  let body;
+  if (init.body !== void 0) {
+    headers["content-type"] = "application/json";
+    body = JSON.stringify(init.body);
+  }
+  let res;
+  try {
+    res = await fetchFn(url, { method: init.method ?? "GET", headers, body });
+  } catch {
+    throw new NetworkError();
+  }
+  const text = await res.text();
+  const data = text ? JSON.parse(text) : {};
+  if (!res.ok) {
+    const code = data && typeof data === "object" && typeof data.error === "string" ? data.error : void 0;
+    throw new ApiError(res.status, code);
+  }
+  return data;
+}
+var HostrApi = class {
+  #endpoint;
+  #bearer;
+  #fetch;
+  constructor(endpoint, bearer, fetchFn = fetch) {
+    this.#endpoint = endpoint;
+    this.#bearer = bearer;
+    this.#fetch = fetchFn;
+  }
+  setBearer(bearer) {
+    this.#bearer = bearer;
+  }
+  getUpload(assetId) {
+    return req(this.#fetch, this.#endpoint, this.#bearer, `/v1/uploads/${assetId}`);
+  }
+  presignParts(assetId, partNumbers, expiresIn) {
+    return req(this.#fetch, this.#endpoint, this.#bearer, `/v1/uploads/${assetId}/parts`, {
+      method: "POST",
+      body: expiresIn === void 0 ? { partNumbers } : { partNumbers, expiresIn }
+    });
+  }
+  complete(assetId, body) {
+    return req(this.#fetch, this.#endpoint, this.#bearer, `/v1/uploads/${assetId}/complete`, {
+      method: "POST",
+      body
+    });
+  }
+  async abort(assetId) {
+    await req(this.#fetch, this.#endpoint, this.#bearer, `/v1/uploads/${assetId}`, { method: "DELETE" });
+  }
+};
+
+// src/hash/hex.ts
+var HEX = "0123456789abcdef";
+function bytesToHex(b) {
+  let s = "";
+  for (let i = 0; i < b.length; i++) s += HEX[b[i] >> 4] + HEX[b[i] & 15];
+  return s;
+}
+function hexToBytes(s) {
+  const out = new Uint8Array(s.length >> 1);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+
+// src/hash/md5.ts
+var K = new Int32Array(64);
+for (let i = 0; i < 64; i++) K[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32) | 0;
+var S = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21];
+var rotl = (x, n) => x << n | x >>> 32 - n;
+var Md5 = class _Md5 {
+  h = new Int32Array([1732584193, 4023233417 | 0, 2562383102 | 0, 271733878]);
+  buf = new Uint8Array(64);
+  bufLen = 0;
+  len = 0;
+  // total bytes; Number is exact to 2^53
+  update(data) {
+    this.len += data.length;
+    let off = 0;
+    if (this.bufLen > 0) {
+      const take = Math.min(64 - this.bufLen, data.length);
+      this.buf.set(data.subarray(0, take), this.bufLen);
+      this.bufLen += take;
+      off = take;
+      if (this.bufLen === 64) {
+        this.compress(this.buf, 0);
+        this.bufLen = 0;
+      }
+    }
+    for (; off + 64 <= data.length; off += 64) this.compress(data, off);
+    if (off < data.length) {
+      this.buf.set(data.subarray(off));
+      this.bufLen = data.length - off;
+    }
+  }
+  compress(p, off) {
+    const m = new Int32Array(16);
+    for (let i = 0; i < 16; i++)
+      m[i] = p[off + 4 * i] | p[off + 4 * i + 1] << 8 | p[off + 4 * i + 2] << 16 | p[off + 4 * i + 3] << 24;
+    let a = this.h[0], b = this.h[1], c = this.h[2], d = this.h[3];
+    for (let i = 0; i < 64; i++) {
+      let f, g;
+      if (i < 16) {
+        f = b & c | ~b & d;
+        g = i;
+      } else if (i < 32) {
+        f = d & b | ~d & c;
+        g = (5 * i + 1) % 16;
+      } else if (i < 48) {
+        f = b ^ c ^ d;
+        g = (3 * i + 5) % 16;
+      } else {
+        f = c ^ (b | ~d);
+        g = 7 * i % 16;
+      }
+      const t = d;
+      d = c;
+      c = b;
+      b = b + rotl(a + f + K[i] + m[g] | 0, S[(i >> 4) * 4 + (i & 3)]) | 0;
+      a = t;
+    }
+    this.h[0] = this.h[0] + a | 0;
+    this.h[1] = this.h[1] + b | 0;
+    this.h[2] = this.h[2] + c | 0;
+    this.h[3] = this.h[3] + d | 0;
+  }
+  /**
+   * Finalize on a clone so the hash can keep accepting updates.
+   *
+   * Padding: capture the message length in bits BEFORE touching the clone,
+   * then build the entire 0x80 + zero-padding + 64-bit length tail as one
+   * buffer sized so the clone's running byte count lands on a block
+   * boundary, and hand it to update() in a single call. update()'s own
+   * `len` bookkeeping on the clone is irrelevant after this point (the
+   * clone is discarded), so there is no need to keep it meaningful.
+   */
+  digestBytes() {
+    const c = this.clone();
+    const bitLen = c.len * 8;
+    const zeroCount = (56 - (c.len + 1) % 64 + 64) % 64;
+    const pad = new Uint8Array(1 + zeroCount + 8);
+    pad[0] = 128;
+    const lo = bitLen >>> 0, hi = Math.floor(bitLen / 2 ** 32);
+    const tailOff = 1 + zeroCount;
+    for (let i = 0; i < 4; i++) {
+      pad[tailOff + i] = lo >>> 8 * i & 255;
+      pad[tailOff + 4 + i] = hi >>> 8 * i & 255;
+    }
+    c.update(pad);
+    const out = new Uint8Array(16);
+    for (let i = 0; i < 4; i++)
+      for (let j = 0; j < 4; j++) out[4 * i + j] = c.h[i] >>> 8 * j & 255;
+    return out;
+  }
+  digestHex() {
+    return bytesToHex(this.digestBytes());
+  }
+  exportState() {
+    return JSON.stringify({ h: [...this.h], buf: bytesToHex(this.buf.subarray(0, this.bufLen)), len: this.len });
+  }
+  importState(state) {
+    const s = JSON.parse(state);
+    this.h = new Int32Array(s.h);
+    this.buf.fill(0);
+    this.bufLen = s.buf.length / 2;
+    this.len = s.len;
+    for (let i = 0; i < this.bufLen; i++) this.buf[i] = parseInt(s.buf.slice(i * 2, i * 2 + 2), 16);
+  }
+  clone() {
+    const c = new _Md5();
+    c.h = new Int32Array(this.h);
+    c.buf = new Uint8Array(this.buf);
+    c.bufLen = this.bufLen;
+    c.len = this.len;
+    return c;
+  }
+};
+
+// src/hash/composite.ts
+function compositeEtag(md5Hexes) {
+  const h = new Md5();
+  for (const hex of md5Hexes) h.update(hexToBytes(hex));
+  return `${h.digestHex()}-${md5Hexes.length}`;
+}
+
+// src/core/engine.ts
+var IntegrityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IntegrityError";
+  }
+};
+
+// src/react-native/background-plan.ts
+function planBackgroundWork(i) {
+  const { session, remote, staged, currentEpoch } = i;
+  const remoteByPart = new Map(remote.map((p) => [p.partNumber, p]));
+  const stagedByPart = new Map(staged.map((s) => [s.partNumber, s]));
+  const toStage = [];
+  const toCleanup = [];
+  const adopt = {};
+  for (let n = 1; n <= session.expectedParts; n++) {
+    if (session.done[n]) continue;
+    const r = remoteByPart.get(n);
+    const s = stagedByPart.get(n);
+    if (r) {
+      if (s && s.md5 === r.etag) {
+        adopt[n] = s.md5;
+        toCleanup.push(s.fileUri);
+      } else {
+        toStage.push(n);
+      }
+    } else if (!s || s.launchEpoch !== currentEpoch) {
+      toStage.push(n);
+    }
+  }
+  for (const s of staged)
+    if (session.done[s.partNumber]) toCleanup.push(s.fileUri);
+  return { toStage, toCleanup, adopt };
+}
+
+// src/react-native/fs.ts
+async function loadFileSystem() {
+  return await import("expo-file-system");
+}
+
+// src/react-native/background.ts
+var LAUNCH_EPOCH = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+var stripQuotes = (s) => s.replace(/^"|"$/g, "");
+function findHeader(headers, name) {
+  if (!headers) return null;
+  const lower = name.toLowerCase();
+  for (const k of Object.keys(headers)) if (k.toLowerCase() === lower) return headers[k];
+  return null;
+}
+var fileIdOf = (f) => `${f.uri}:${f.size}:${f.modificationTime ?? 0}`;
+var stagedKey = (assetId) => `hostr.upload.v1.staged:${assetId}`;
+var filePtrKey = (fileId) => `hostr.upload.v1.background.file:${fileId}`;
+var activeKey = "hostr.upload.v1.background:active";
+async function loadJson(store, key, fallback) {
+  const raw = await store.get(key);
+  if (!raw) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+async function loadStaged(store, assetId) {
+  return loadJson(store, stagedKey(assetId), []);
+}
+async function saveStaged(store, assetId, parts) {
+  if (parts.length === 0) await store.delete(stagedKey(assetId));
+  else await store.set(stagedKey(assetId), JSON.stringify(parts));
+}
+async function loadActive(store) {
+  return loadJson(store, activeKey, []);
+}
+async function saveFilePtr(store, fileId, file) {
+  await store.set(filePtrKey(fileId), JSON.stringify(file));
+}
+async function loadFilePtr(store, fileId) {
+  return loadJson(store, filePtrKey(fileId), null);
+}
+async function clearFilePtr(store, fileId) {
+  await store.delete(filePtrKey(fileId));
+}
+var chains = /* @__PURE__ */ new Map();
+function serialize(key, fn) {
+  const prev = chains.get(key) ?? Promise.resolve();
+  const run = prev.catch(() => {
+  }).then(fn);
+  chains.set(key, run.catch(() => {
+  }));
+  return run;
+}
+function mutateStaged(store, assetId, mutate) {
+  return serialize(stagedKey(assetId), async () => {
+    const current = await loadStaged(store, assetId);
+    const next = mutate(current);
+    await saveStaged(store, assetId, next);
+    return next;
+  });
+}
+function mutateActive(store, mutate) {
+  return serialize(activeKey, async () => {
+    const current = await loadActive(store);
+    const next = mutate(current);
+    if (next.length === 0) await store.delete(activeKey);
+    else await store.set(activeKey, JSON.stringify(next));
+    return next;
+  });
+}
+async function markActive(store, fileId) {
+  await mutateActive(store, (ids) => ids.includes(fileId) ? ids : [...ids, fileId]);
+}
+async function unmarkActive(store, fileId) {
+  await mutateActive(store, (ids) => ids.filter((x) => x !== fileId));
+}
+async function windowed(items, limit, fn) {
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const item = items[next++];
+      await fn(item);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+var liveTasks = /* @__PURE__ */ new Map();
+function trackTask(assetId, task) {
+  let set = liveTasks.get(assetId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    liveTasks.set(assetId, set);
+  }
+  set.add(task);
+  return () => {
+    set.delete(task);
+    if (set.size === 0) liveTasks.delete(assetId);
+  };
+}
+function cancelBackgroundTasks(assetId) {
+  const set = liveTasks.get(assetId);
+  if (!set) return 0;
+  const n = set.size;
+  for (const task of set) {
+    try {
+      task.cancel();
+    } catch {
+    }
+  }
+  return n;
+}
+var stagingDirReady = null;
+async function ensureStagingDir(FS) {
+  if (!stagingDirReady) {
+    stagingDirReady = (async () => {
+      const dir = new FS.Directory(FS.Paths.cache, "hostr");
+      dir.create({ intermediates: true, idempotent: true });
+      return dir;
+    })().catch((e) => {
+      stagingDirReady = null;
+      throw e;
+    });
+  }
+  return stagingDirReady;
+}
+async function stagePart(opts) {
+  const FS = await loadFileSystem();
+  const handle = new FS.File(opts.file.uri).open();
+  let bytes;
+  try {
+    handle.offset = opts.offset;
+    bytes = handle.readBytes(opts.length);
+  } finally {
+    handle.close();
+  }
+  if (bytes.length !== opts.length)
+    throw new Error(
+      `part ${opts.partNumber}: source file changed size mid-upload (expected ${opts.length} bytes, read ${bytes.length}) \u2014 the file was modified or truncated after the upload started`
+    );
+  const dir = await ensureStagingDir(FS);
+  const staged = new FS.File(dir, `${opts.session.assetId}.${opts.partNumber}.part`);
+  staged.create({ overwrite: true });
+  staged.write(bytes);
+  const stagedUri = staged.uri;
+  const md5 = staged.md5?.toLowerCase();
+  if (!md5)
+    throw new Error(`part ${opts.partNumber}: staged file at ${stagedUri} is unreadable (md5 unavailable)`);
+  await mutateStaged(opts.store, opts.session.assetId, (current) => {
+    const next = current.filter((s) => s.partNumber !== opts.partNumber);
+    next.push({ partNumber: opts.partNumber, fileUri: stagedUri, md5, launchEpoch: LAUNCH_EPOCH });
+    return next;
+  });
+  const task = staged.createUploadTask(opts.url, {
+    httpMethod: "PUT",
+    uploadType: FS.UploadType.BINARY_CONTENT,
+    sessionType: "background",
+    onProgress: (d) => opts.observer?.onPartProgress?.(opts.partNumber, d.bytesSent)
+  });
+  const untrack = trackTask(opts.session.assetId, task);
+  const forgetStaged = async () => {
+    try {
+      staged.delete();
+    } catch {
+    }
+    await mutateStaged(opts.store, opts.session.assetId, (current) => current.filter((s) => s.partNumber !== opts.partNumber));
+  };
+  task.uploadAsync().then(async (result) => {
+    untrack();
+    const ok = !!result && result.status >= 200 && result.status < 300;
+    const rawEtag = ok ? findHeader(result.headers, "etag") : null;
+    const etag = rawEtag ? stripQuotes(rawEtag) : null;
+    if (etag === md5) {
+      if (opts.session.status !== "running") {
+        await forgetStaged();
+        return;
+      }
+      opts.session.done[opts.partNumber] = md5;
+      await saveSession(opts.store, opts.session);
+      await forgetStaged();
+      opts.observer?.onPartLanded?.(opts.partNumber);
+      if (opts.onAllLanded && Object.keys(opts.session.done).length >= opts.session.expectedParts)
+        opts.onAllLanded();
+      return;
+    }
+    await forgetStaged();
+    opts.observer?.onPartFailed?.(opts.partNumber);
+  }).catch(async () => {
+    untrack();
+    await forgetStaged();
+    opts.observer?.onPartFailed?.(opts.partNumber);
+  });
+}
+async function safeStagePart(opts) {
+  try {
+    await stagePart(opts);
+  } catch (e) {
+    console.warn(
+      `hostr background: failed to stage part ${opts.partNumber} for ${opts.session.assetId}: ${e instanceof Error ? e.message : String(e)} \u2014 will retry on the next reconcile`
+    );
+  }
+}
+async function apiCall(ctx, fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (e instanceof ApiError && e.status === 401 && ctx.onTokenExpired) {
+      const t = await ctx.onTokenExpired(ctx.session.assetId);
+      ctx.session.uploadToken = t;
+      ctx.api.setBearer(t);
+      await saveSession(ctx.store, ctx.session);
+      return await fn();
+    }
+    throw e;
+  }
+}
+async function loadOrCreateSession(opts) {
+  const api = new HostrApi(opts.endpoint, opts.uploadToken);
+  const fileId = fileIdOf(opts.file);
+  let session = await loadSession(opts.store, fileId);
+  if (session) {
+    session.uploadToken = opts.uploadToken;
+    await saveSession(opts.store, session);
+  } else {
+    const remote = await api.getUpload(opts.assetId);
+    session = {
+      v: 1,
+      assetId: opts.assetId,
+      endpoint: opts.endpoint,
+      uploadToken: opts.uploadToken,
+      key: remote.key,
+      partSize: remote.partSize,
+      expectedParts: remote.expectedParts,
+      declaredSize: opts.file.size,
+      fileId,
+      done: {},
+      status: "running",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await saveSession(opts.store, session);
+  }
+  return { session, api };
+}
+function runReconcile(opts) {
+  return serialize(`reconcile:${opts.session.assetId}`, () => runReconcilePass(opts));
+}
+async function runReconcilePass(opts) {
+  const { store, session, api, file } = opts;
+  if (session.status === "complete") return "complete";
+  if (session.status === "aborted") return "in-progress";
+  const ctx = { api, session, store, onTokenExpired: opts.onTokenExpired };
+  const remote = (await apiCall(ctx, () => api.getUpload(session.assetId))).parts;
+  const staged = await loadStaged(store, session.assetId);
+  const plan = planBackgroundWork({ session, remote, staged, currentEpoch: LAUNCH_EPOCH });
+  for (const [nStr, md5] of Object.entries(plan.adopt)) session.done[Number(nStr)] = md5;
+  if (Object.keys(plan.adopt).length > 0) await saveSession(store, session);
+  if (plan.toCleanup.length > 0) {
+    const FS = await loadFileSystem();
+    for (const uri of plan.toCleanup) {
+      try {
+        new FS.File(uri).delete();
+      } catch {
+      }
+    }
+    await mutateStaged(store, session.assetId, (current) => current.filter((s) => !plan.toCleanup.includes(s.fileUri)));
+  }
+  if (plan.toStage.length > 0) {
+    if (!file) {
+      console.warn(
+        `hostr background: cannot stage ${plan.toStage.length} part(s) for ${session.assetId} \u2014 no file pointer available; left for the next reconcile`
+      );
+      return "in-progress";
+    }
+    const { urls } = await apiCall(ctx, () => api.presignParts(session.assetId, plan.toStage, 43200));
+    const urlByPart = new Map(urls.map((u) => [u.partNumber, u.url]));
+    const onAllLanded = () => {
+      void runReconcile(opts).then((result) => opts.onAutoReconcile?.(result)).catch(() => {
+      });
+    };
+    await windowed(plan.toStage, 4, async (n) => {
+      const url = urlByPart.get(n);
+      if (!url) return;
+      const offset = (n - 1) * session.partSize;
+      const length = partSizeOf(session, n);
+      await safeStagePart({
+        store,
+        session,
+        file,
+        partNumber: n,
+        offset,
+        length,
+        url,
+        onAllLanded,
+        observer: opts.observer
+      });
+    });
+    return "in-progress";
+  }
+  if (Object.keys(session.done).length < session.expectedParts) return "in-progress";
+  session.status = "completing";
+  await saveSession(store, session);
+  const res = await apiCall(ctx, () => api.complete(session.assetId, session.sha256 ? { sha256: session.sha256 } : {}));
+  const md5s = [];
+  for (let n = 1; n <= session.expectedParts; n++) md5s.push(session.done[n]);
+  const expected = compositeEtag(md5s);
+  if (res.etag && res.etag !== expected)
+    throw new IntegrityError(`R2 assembled ${res.etag}; client computed ${expected}`);
+  await clearSession(store, session.fileId);
+  await unmarkActive(store, session.fileId);
+  await clearFilePtr(store, session.fileId);
+  session.status = "complete";
+  opts.observer?.onComplete?.({
+    assetId: session.assetId,
+    etag: res.etag ?? expected,
+    bytes: session.declaredSize
+  });
+  return "complete";
+}
+async function startBackgroundUpload(opts) {
+  const { session, api } = await loadOrCreateSession(opts);
+  await markActive(opts.store, session.fileId);
+  await saveFilePtr(opts.store, session.fileId, opts.file);
+  const reconcile = () => runReconcile({
+    store: opts.store,
+    session,
+    api,
+    file: opts.file,
+    onTokenExpired: opts.onTokenExpired,
+    onAutoReconcile: opts.onAutoReconcile,
+    observer: opts.observer
+  });
+  await reconcile();
+  return {
+    reconcile,
+    pause: () => cancelBackgroundTasks(session.assetId),
+    abort: async () => {
+      session.status = "aborted";
+      cancelBackgroundTasks(session.assetId);
+      await api.abort(session.assetId).catch(() => {
+      });
+      const staged = await loadStaged(opts.store, session.assetId);
+      if (staged.length > 0) {
+        const FS = await loadFileSystem();
+        for (const s of staged) {
+          try {
+            new FS.File(s.fileUri).delete();
+          } catch {
+          }
+        }
+        await mutateStaged(opts.store, session.assetId, () => []);
+      }
+      await clearSession(opts.store, session.fileId);
+      await unmarkActive(opts.store, session.fileId);
+      await clearFilePtr(opts.store, session.fileId);
+    },
+    assetId: session.assetId,
+    partSize: session.partSize,
+    expectedParts: session.expectedParts,
+    declaredSize: session.declaredSize,
+    donePartNumbers: () => Object.keys(session.done).map(Number)
+  };
+}
+async function reconcileOnLaunch(store, opts) {
+  const ids = await loadActive(store);
+  for (const fileId of ids) {
+    const session = await loadSession(store, fileId);
+    if (!session) {
+      await unmarkActive(store, fileId);
+      continue;
+    }
+    const file = await loadFilePtr(store, fileId);
+    const api = new HostrApi(opts.endpoint, session.uploadToken);
+    try {
+      await runReconcile({ store, session, api, file });
+    } catch {
+    }
+  }
+}
+
+// src/react-native/native-upload.ts
+var RETRY_DELAY_MS = 15e3;
+var PROGRESS_THROTTLE_MS = 250;
+var NativeUpload = class {
+  done;
+  resolveDone;
+  rejectDone;
+  emitter = new Emitter();
+  handle = null;
+  status = "idle";
+  doneParts = /* @__PURE__ */ new Set();
+  inflight = /* @__PURE__ */ new Map();
+  // partNumber -> bytesSent
+  confirmedBytes = 0;
+  confirmedAtStart = 0;
+  startedAtMs = 0;
+  lastProgressEmit = 0;
+  retryTimer = null;
+  // Not a TS parameter property — Node 24's strip-only TS can't run those,
+  // and this package's tests execute the source directly.
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.done = new Promise((res, rej) => {
+      this.resolveDone = res;
+      this.rejectDone = rej;
+    });
+    this.done.catch(() => {
+    });
+  }
+  get state() {
+    return this.status;
+  }
+  on(ev, cb) {
+    return this.emitter.on(ev, cb);
+  }
+  /** Kicks the upload off. Synchronous by signature (matching the engine);
+   *  the launch itself is async and reports failures via the 'error' event
+   *  and the `done` promise. Calling it twice is a no-op. */
+  start() {
+    if (this.status !== "idle") return;
+    this.setStatus("running");
+    void this.launch();
+  }
+  pause() {
+    if (this.status !== "running") return;
+    this.setStatus("paused");
+    this.clearRetry();
+    this.handle?.pause();
+    this.inflight.clear();
+    this.emitProgress(true);
+  }
+  resume() {
+    if (this.status !== "paused") return;
+    this.setStatus("running");
+    void this.reconcileQuietly();
+  }
+  abort() {
+    if (this.status === "complete" || this.status === "aborted") return;
+    this.setStatus("aborted");
+    this.clearRetry();
+    const h = this.handle;
+    this.handle = null;
+    void (async () => {
+      try {
+        await h?.abort();
+      } catch {
+      }
+      this.rejectDone(new Error("upload aborted"));
+    })();
+  }
+  // --- internals ------------------------------------------------------------
+  async launch() {
+    try {
+      const observer = {
+        onPartProgress: (n, bytesSent) => {
+          if (this.status !== "running") return;
+          this.inflight.set(n, bytesSent);
+          this.emitProgress(false);
+        },
+        onPartLanded: (n) => {
+          if (this.doneParts.has(n)) return;
+          this.doneParts.add(n);
+          this.inflight.delete(n);
+          this.confirmedBytes += this.partSizeOf(n);
+          this.emitProgress(true);
+        },
+        onPartFailed: (n) => {
+          this.inflight.delete(n);
+          if (this.status !== "running") return;
+          this.scheduleRetry();
+        },
+        onComplete: (info) => {
+          this.clearRetry();
+          this.inflight.clear();
+          this.emitProgress(true);
+          this.setStatus("complete");
+          this.resolveDone({ ...info, sha256: void 0 });
+        }
+      };
+      const handle = await startBackgroundUpload({ ...this.opts, observer });
+      if (this.status === "aborted") {
+        await handle.abort().catch(() => {
+        });
+        return;
+      }
+      this.handle = handle;
+      if (this.status === "paused") handle.pause();
+      for (const n of handle.donePartNumbers()) {
+        if (!this.doneParts.has(n)) {
+          this.doneParts.add(n);
+          this.confirmedBytes += this.partSizeOf(n);
+        }
+      }
+      this.confirmedAtStart = this.confirmedBytes;
+      this.startedAtMs = Date.now();
+      this.emitProgress(true);
+      if (this.doneParts.size >= handle.expectedParts) void this.reconcileQuietly();
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      this.setStatus("failed");
+      this.emitter.emit("error", err);
+      this.rejectDone(err);
+    }
+  }
+  /** A reconcile whose failure must not kill the upload: log-free retry via
+   *  the timer, because reconcile failures here are transient by
+   *  construction (offline, a token mid-refresh) and the store still holds
+   *  everything needed to finish later. */
+  async reconcileQuietly() {
+    if (!this.handle || this.status !== "running") return;
+    try {
+      await this.handle.reconcile();
+    } catch {
+      this.scheduleRetry();
+    }
+  }
+  scheduleRetry() {
+    if (this.retryTimer || this.status !== "running") return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.reconcileQuietly();
+    }, RETRY_DELAY_MS);
+  }
+  clearRetry() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  partSizeOf(n) {
+    const h = this.handle;
+    if (!h) return 0;
+    return n < h.expectedParts ? h.partSize : h.declaredSize - (h.expectedParts - 1) * h.partSize;
+  }
+  setStatus(s) {
+    if (this.status === s) return;
+    this.status = s;
+    this.emitter.emit("statechange", s);
+  }
+  emitProgress(force) {
+    const now = Date.now();
+    if (!force && now - this.lastProgressEmit < PROGRESS_THROTTLE_MS) return;
+    this.lastProgressEmit = now;
+    const h = this.handle;
+    const total = h?.declaredSize ?? this.opts.file.size;
+    const partsTotal = h?.expectedParts ?? 0;
+    let inflightBytes = 0;
+    for (const b of this.inflight.values()) inflightBytes += b;
+    this.emitter.emit("progress", computeProgress({
+      confirmed: this.confirmedBytes,
+      inflight: inflightBytes,
+      total,
+      partsDone: this.doneParts.size,
+      partsTotal,
+      startedAtMs: this.startedAtMs || now,
+      nowMs: now,
+      confirmedAtStart: this.confirmedAtStart
+    }));
+  }
+};
+
+// src/react-native/index.ts
+function asyncStorageStore(as) {
+  return {
+    get: (key) => as.getItem(key),
+    set: (key, value) => as.setItem(key, value),
+    delete: (key) => as.removeItem(key)
+  };
+}
+async function createUpload(opts) {
+  return new NativeUpload(opts);
+}
+export {
+  ApiError,
+  IntegrityError,
+  NativeUpload,
+  NetworkError,
+  asyncStorageStore,
+  cancelBackgroundTasks,
+  createUpload,
+  reconcileOnLaunch,
+  startBackgroundUpload
+};