@exponential_app/engine 0.0.0-stage → 0.1.1

package/dist/web/index.js

@@ -0,0 +1,791 @@
+import {
+  LocalRecordStore2
+} from "../chunks/index-s3xjr701.js";
+
+// packages/eengine/src/web/mcp.ts
+var ok = (structuredContent) => ({
+  content: [{ type: `text`, text: JSON.stringify(structuredContent) }],
+  structuredContent
+});
+var fail = (reason) => ({
+  content: [{ type: `text`, text: reason }],
+  isError: true
+});
+var notFound = () => fail(`notFound`);
+var unavailable = () => fail(`unavailable`);
+var failed = (message) => fail(`failed: ${message}`);
+var errorMessage = (error) => {
+  const text = error instanceof Error ? error.message || error.name : String(error);
+  const line = text.replace(/\s+/g, ` `).trim();
+  return line.length > 200 ? `${line.slice(0, 199)}…` : line || `error`;
+};
+var isAbort = (error) => typeof error === `object` && error !== null && error.name === `AbortError`;
+var ALPHABET = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+var DECODE = new Int16Array(128).fill(-1);
+for (let i = 0;i < ALPHABET.length; i++)
+  DECODE[ALPHABET.charCodeAt(i)] = i;
+var encodeBase64 = (bytes) => {
+  let out = ``;
+  let i = 0;
+  for (;i + 2 < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out += ALPHABET[n >> 18] + ALPHABET[n >> 12 & 63] + ALPHABET[n >> 6 & 63] + ALPHABET[n & 63];
+  }
+  const rest = bytes.length - i;
+  if (rest === 1) {
+    const n = bytes[i] << 16;
+    out += `${ALPHABET[n >> 18]}${ALPHABET[n >> 12 & 63]}==`;
+  } else if (rest === 2) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8;
+    out += `${ALPHABET[n >> 18]}${ALPHABET[n >> 12 & 63]}${ALPHABET[n >> 6 & 63]}=`;
+  }
+  return out;
+};
+var decodeBase64 = (text) => {
+  if (text.length % 4 !== 0)
+    return null;
+  const pad = text.endsWith(`==`) ? 2 : text.endsWith(`=`) ? 1 : 0;
+  const out = new Uint8Array(text.length / 4 * 3 - pad);
+  let o = 0;
+  for (let i = 0;i < text.length; i += 4) {
+    const last = i + 4 === text.length;
+    const v = [0, 0, 0, 0];
+    for (let j = 0;j < 4; j++) {
+      const c = text.charCodeAt(i + j);
+      if (c === 61 && last && j >= 4 - pad)
+        continue;
+      const d = c < 128 ? DECODE[c] : -1;
+      if (d < 0)
+        return null;
+      v[j] = d;
+    }
+    const n = v[0] << 18 | v[1] << 12 | v[2] << 6 | v[3];
+    out[o++] = n >> 16;
+    if (o < out.length)
+      out[o++] = n >> 8 & 255;
+    if (o < out.length)
+      out[o++] = n & 255;
+    if (last && pad === 2 && (v[1] & 15) !== 0)
+      return null;
+    if (last && pad === 1 && (v[2] & 3) !== 0)
+      return null;
+  }
+  return out;
+};
+
+// packages/eengine/src/web/platform.ts
+var BLOB_URL_TTL_MS = 60000;
+var browserPlatform = () => {
+  const w = globalThis;
+  const nav = w.navigator;
+  const platform = {
+    pickWithInput: ({ accept, multiple }) => new Promise((resolve, reject) => {
+      const activation = nav?.userActivation;
+      if (activation && !activation.isActive) {
+        reject(new Error(`the picker needs a user gesture`));
+        return;
+      }
+      const input = w.document.createElement(`input`);
+      input.type = `file`;
+      input.multiple = multiple;
+      if (accept)
+        input.accept = accept;
+      input.style.display = `none`;
+      const done = (files) => {
+        input.remove();
+        resolve(files);
+      };
+      input.addEventListener(`change`, () => done(Array.from(input.files ?? [])), { once: true });
+      input.addEventListener(`cancel`, () => done([]), { once: true });
+      w.document.body.append(input);
+      input.click();
+    }),
+    download: (name, blob) => {
+      const url = URL.createObjectURL(blob);
+      const a = w.document.createElement(`a`);
+      a.href = url;
+      a.download = name;
+      a.style.display = `none`;
+      w.document.body.append(a);
+      a.click();
+      a.remove();
+      w.setTimeout(() => URL.revokeObjectURL(url), BLOB_URL_TTL_MS);
+    },
+    print: (blob) => new Promise((resolve, reject) => {
+      const url = URL.createObjectURL(blob);
+      const frame = w.document.createElement(`iframe`);
+      frame.style.cssText = `position:fixed;width:0;height:0;border:0;opacity:0;pointer-events:none`;
+      let removed = false;
+      const remove = () => {
+        if (removed)
+          return;
+        removed = true;
+        frame.remove();
+        URL.revokeObjectURL(url);
+      };
+      frame.addEventListener(`load`, () => {
+        const win = frame.contentWindow;
+        if (!win) {
+          remove();
+          reject(new Error(`no print frame`));
+          return;
+        }
+        win.addEventListener(`afterprint`, () => w.setTimeout(remove, 0), { once: true });
+        w.setTimeout(remove, BLOB_URL_TTL_MS);
+        try {
+          win.focus();
+          win.print();
+          resolve();
+        } catch (error) {
+          remove();
+          reject(error);
+        }
+      }, { once: true });
+      frame.src = url;
+      w.document.body.append(frame);
+    }),
+    now: () => Date.now(),
+    setTimeout: (fn, ms) => w.setTimeout(fn, ms),
+    clearTimeout: (handle) => w.clearTimeout(handle),
+    focus: () => w.focus()
+  };
+  if (typeof w.showOpenFilePicker === `function`) {
+    const pick = w.showOpenFilePicker.bind(w);
+    platform.showOpenFilePicker = (options) => pick(options);
+  }
+  if (typeof w.showSaveFilePicker === `function`) {
+    const pick = w.showSaveFilePicker.bind(w);
+    platform.showSaveFilePicker = (options) => pick(options);
+  }
+  if (nav && typeof nav.share === `function`) {
+    platform.share = (data) => nav.share(data);
+    platform.canShare = (data) => typeof nav.canShare === `function` ? nav.canShare(data) : false;
+  }
+  if (nav?.storage && typeof nav.storage.getDirectory === `function`) {
+    platform.storageDirectory = () => nav.storage.getDirectory();
+  }
+  const N = w.Notification;
+  if (typeof N === `function`) {
+    platform.notifications = {
+      permission: () => N.permission,
+      requestPermission: () => N.requestPermission(),
+      show: (title, options) => new N(title, options)
+    };
+  }
+  return platform;
+};
+// packages/eengine/src/web/stores.ts
+var SQLITE_SCHEMA = [
+  `CREATE TABLE IF NOT EXISTS app_records (app_id TEXT NOT NULL, id TEXT NOT NULL, kind TEXT NOT NULL, data TEXT NOT NULL, created_by TEXT, author_id TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, PRIMARY KEY (app_id, id))`,
+  `CREATE INDEX IF NOT EXISTS app_records_kind ON app_records (app_id, kind)`,
+  `CREATE TABLE IF NOT EXISTS app_record_events (seq INTEGER PRIMARY KEY AUTOINCREMENT, app_id TEXT NOT NULL, record_id TEXT NOT NULL, op TEXT NOT NULL, actor TEXT, write_id TEXT NOT NULL, patch TEXT NOT NULL, before TEXT NOT NULL, at TEXT NOT NULL)`,
+  `CREATE INDEX IF NOT EXISTS app_record_events_record ON app_record_events (app_id, record_id)`,
+  `CREATE TABLE IF NOT EXISTS app_record_writes (app_id TEXT NOT NULL, write_id TEXT NOT NULL, ids TEXT NOT NULL, PRIMARY KEY (app_id, write_id))`
+];
+function answerSql(db, request) {
+  try {
+    if (request.op === `query`)
+      return { id: request.id, rows: db.query(request.sql, request.bind) };
+    db.run(`BEGIN IMMEDIATE`, []);
+    try {
+      for (const s of request.statements)
+        db.run(s.sql, s.bind ?? []);
+      db.run(`COMMIT`, []);
+    } catch (error) {
+      db.run(`ROLLBACK`, []);
+      throw error;
+    }
+    return { id: request.id };
+  } catch (error) {
+    return { id: request.id, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function serveSql(db, port) {
+  for (const s of SQLITE_SCHEMA)
+    db.run(s, []);
+  port.addEventListener(`message`, (event) => port.postMessage(answerSql(db, event.data)));
+}
+function sqlClient(port) {
+  let next = 0;
+  const pending = new Map;
+  port.addEventListener(`message`, (event) => {
+    const r = event.data;
+    pending.get(r.id)?.resolve(r);
+    pending.delete(r.id);
+  });
+  const send = (request) => new Promise((resolve, reject) => {
+    pending.set(request.id, {
+      resolve: (r) => r.error === undefined ? resolve(r) : reject(new Error(r.error))
+    });
+    port.postMessage(request);
+  });
+  return {
+    query: async (sql, bind = []) => (await send({ id: ++next, op: `query`, sql, bind })).rows ?? [],
+    transaction: async (statements) => void await send({ id: ++next, op: `transaction`, statements })
+  };
+}
+var json = (v) => JSON.stringify(v ?? null);
+var parsed = (v) => {
+  try {
+    return typeof v === `string` ? JSON.parse(v) : null;
+  } catch {
+    return null;
+  }
+};
+var text = (v) => typeof v === `string` ? v : null;
+
+class SqlitePersistence {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async load(app) {
+    const rows = await this.db.query(`SELECT id, kind, data, created_by, author_id, created_at, updated_at FROM app_records WHERE app_id = ? ORDER BY created_at, id`, [app]);
+    return rows.map((r) => ({
+      id: String(r.id),
+      kind: String(r.kind),
+      data: parsed(r.data) ?? {},
+      createdBy: text(r.created_by),
+      authorId: text(r.author_id),
+      createdAt: String(r.created_at),
+      updatedAt: String(r.updated_at)
+    }));
+  }
+  async ack(app, writeId) {
+    const [row] = await this.db.query(`SELECT ids FROM app_record_writes WHERE app_id = ? AND write_id = ?`, [app, writeId]);
+    return row ? parsed(row.ids) ?? [] : null;
+  }
+  async commit(app, c) {
+    const statements = [];
+    for (const id of c.deletes)
+      statements.push({ sql: `DELETE FROM app_records WHERE app_id = ? AND id = ?`, bind: [app, id] });
+    for (const r of c.upserts)
+      statements.push({
+        sql: `INSERT INTO app_records (app_id, id, kind, data, created_by, author_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT (app_id, id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`,
+        bind: [app, r.id, r.kind, json(r.data), r.createdBy, r.authorId ?? null, r.createdAt, r.updatedAt]
+      });
+    for (const e of c.events)
+      statements.push({
+        sql: `INSERT INTO app_record_events (app_id, record_id, op, actor, write_id, patch, before, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        bind: [app, e.recordId, e.op, e.actor, e.writeId, json(e.patch), json(e.before), e.at]
+      });
+    statements.push({ sql: `INSERT INTO app_record_writes (app_id, write_id, ids) VALUES (?, ?, ?)`, bind: [app, c.writeId, json(c.ids)] });
+    await this.db.transaction(statements);
+  }
+  async history(app, id) {
+    const rows = await this.db.query(`SELECT record_id, op, actor, write_id, patch, before, at FROM app_record_events WHERE app_id = ? AND record_id = ? ORDER BY seq`, [app, id]);
+    return rows.map((r) => ({ recordId: String(r.record_id), op: r.op, actor: text(r.actor), writeId: String(r.write_id), patch: parsed(r.patch), before: parsed(r.before), at: String(r.at) }));
+  }
+}
+var RECORDS = `records`;
+var WRITES = `writes`;
+var EVENTS = `events`;
+var VAULT = `vault`;
+var done = (request) => new Promise((resolve, reject) => {
+  request.onsuccess = () => resolve(request.result);
+  request.onerror = () => reject(request.error);
+});
+var committed = (tx) => new Promise((resolve, reject) => {
+  tx.oncomplete = () => resolve();
+  tx.onerror = () => reject(tx.error);
+  tx.onabort = () => reject(tx.error ?? new Error(`aborted`));
+});
+function openRunnerIdb(factory, name) {
+  const request = factory.open(name, 1);
+  request.onupgradeneeded = () => {
+    const db = request.result;
+    db.createObjectStore(RECORDS, { keyPath: [`appId`, `id`] }).createIndex(`app`, `appId`);
+    db.createObjectStore(WRITES, { keyPath: [`appId`, `writeId`] });
+    db.createObjectStore(EVENTS, { autoIncrement: true }).createIndex(`record`, [`appId`, `recordId`]);
+    db.createObjectStore(VAULT);
+  };
+  return done(request);
+}
+
+class IndexedDbPersistence {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async load(app) {
+    const all = await done(this.db.transaction(RECORDS).objectStore(RECORDS).index(`app`).getAll(app));
+    return all.map(({ appId: _, ...row }) => row).sort((a, b) => a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : a.id < b.id ? -1 : 1);
+  }
+  async ack(app, writeId) {
+    const row = await done(this.db.transaction(WRITES).objectStore(WRITES).get([app, writeId]));
+    return row ? row.ids : null;
+  }
+  async commit(app, c) {
+    const tx = this.db.transaction([RECORDS, WRITES, EVENTS], `readwrite`);
+    const records = tx.objectStore(RECORDS);
+    for (const id of c.deletes)
+      records.delete([app, id]);
+    for (const r of c.upserts)
+      records.put({ ...r, appId: app });
+    for (const e of c.events)
+      tx.objectStore(EVENTS).add({ ...e, appId: app });
+    tx.objectStore(WRITES).put({ appId: app, writeId: c.writeId, ids: c.ids });
+    await committed(tx);
+  }
+  async history(app, id) {
+    const all = await done(this.db.transaction(EVENTS).objectStore(EVENTS).index(`record`).getAll([app, id]));
+    return all.map(({ appId: _, ...e }) => e);
+  }
+}
+
+class IndexedDbVault {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async read(key) {
+    const v = await done(this.db.transaction(VAULT).objectStore(VAULT).get(key));
+    return typeof v === `string` ? v : null;
+  }
+  async write(key, value) {
+    const tx = this.db.transaction(VAULT, `readwrite`);
+    tx.objectStore(VAULT).put(value, key);
+    await committed(tx);
+  }
+  async delete(key) {
+    const tx = this.db.transaction(VAULT, `readwrite`);
+    tx.objectStore(VAULT).delete(key);
+    await committed(tx);
+  }
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var notFound2 = (e) => e instanceof Error && (e.name === `NotFoundError` || e.name === `TypeMismatchError`);
+
+class OpfsBlobStore {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  async dir(app, create) {
+    if (!app || /[/\\]/.test(app) || app.startsWith(`.`))
+      throw new Error(`not an app id`);
+    return (await this.root()).getDirectoryHandle(app, { create });
+  }
+  async writeFile(dir, name, data) {
+    const writable = await (await dir.getFileHandle(name, { create: true })).createWritable();
+    await writable.write(data);
+    await writable.close();
+  }
+  async put(app, name, mimeType, bytes) {
+    const dir = await this.dir(app, true);
+    const id = crypto.randomUUID();
+    await this.writeFile(dir, id, bytes);
+    await this.writeFile(dir, `${id}.json`, JSON.stringify({ name, mime: mimeType }));
+    return id;
+  }
+  async get(app, id) {
+    if (!UUID.test(id))
+      return null;
+    try {
+      const file = await (await (await this.dir(app, false)).getFileHandle(id)).getFile();
+      return new Uint8Array(await file.arrayBuffer());
+    } catch (e) {
+      if (notFound2(e))
+        return null;
+      throw e;
+    }
+  }
+  async delete(app, id) {
+    if (!UUID.test(id))
+      return;
+    let dir;
+    try {
+      dir = await this.dir(app, false);
+    } catch (e) {
+      if (notFound2(e))
+        return;
+      throw e;
+    }
+    for (const name of [id, `${id}.json`])
+      await dir.removeEntry(name).catch((e) => notFound2(e) ? undefined : Promise.reject(e));
+  }
+}
+async function openWebStorage(options) {
+  const idb = await openRunnerIdb(options.indexedDB, options.idbName);
+  const vault = new IndexedDbVault(idb);
+  const blobs = new OpfsBlobStore(options.files);
+  if (options.openSqlite) {
+    try {
+      const db = await options.openSqlite();
+      return { records: new LocalRecordStore2(new SqlitePersistence(db)), backend: `sqlite`, vault, blobs };
+    } catch {}
+  }
+  return { records: new LocalRecordStore2(new IndexedDbPersistence(idb)), backend: `indexeddb`, vault, blobs };
+}
+
+// packages/eengine/src/web/index.ts
+var PHOTOS_DIR = `photos`;
+var MIME_BY_EXTENSION = {
+  avif: `image/avif`,
+  bmp: `image/bmp`,
+  csv: `text/csv`,
+  gif: `image/gif`,
+  heic: `image/heic`,
+  heif: `image/heif`,
+  html: `text/html`,
+  jpeg: `image/jpeg`,
+  jpg: `image/jpeg`,
+  json: `application/json`,
+  md: `text/markdown`,
+  pdf: `application/pdf`,
+  png: `image/png`,
+  svg: `image/svg+xml`,
+  tif: `image/tiff`,
+  tiff: `image/tiff`,
+  txt: `text/plain`,
+  webp: `image/webp`,
+  zip: `application/zip`
+};
+var OCTET = `application/octet-stream`;
+var MAX_DELAY_MS = 2147483647;
+var extensionMime = (name) => {
+  const dot = name.lastIndexOf(`.`);
+  return dot < 0 ? undefined : MIME_BY_EXTENSION[name.slice(dot + 1).toLowerCase()];
+};
+var codePoints = (text, max) => {
+  const chars = Array.from(text);
+  return chars.length > max ? chars.slice(0, max).join(``) : text;
+};
+var fileName = (name) => codePoints(name || `file`, 255);
+var fileMime = (file) => {
+  const type = file.type && file.type.length <= 100 ? file.type : undefined;
+  return type ?? extensionMime(file.name) ?? OCTET;
+};
+var str = (args, key) => typeof args[key] === `string` ? args[key] : undefined;
+var bytesOf = async (file) => new Uint8Array(await file.arrayBuffer());
+var blobOf = (bytes, type) => new Blob([bytes], { type });
+var pickerTypes = (accept) => {
+  const map = {};
+  for (const raw of accept) {
+    const entry = raw.trim();
+    if (entry.includes(`/`)) {
+      map[entry] ??= [];
+    } else {
+      const ext = entry.startsWith(`.`) ? entry : `.${entry}`;
+      const mime = extensionMime(ext) ?? OCTET;
+      (map[mime] ??= []).push(ext);
+    }
+  }
+  return [{ description: `Files`, accept: map }];
+};
+var pickFiles = async (platform2, accept, multiple) => {
+  if (platform2.showOpenFilePicker) {
+    const options = { multiple };
+    if (accept.length > 0) {
+      options.types = pickerTypes(accept);
+      options.excludeAcceptAllOption = true;
+    }
+    try {
+      const handles = await platform2.showOpenFilePicker(options);
+      return await Promise.all(handles.map((h) => h.getFile()));
+    } catch (error) {
+      if (isAbort(error))
+        return [];
+      if (!(error instanceof TypeError))
+        throw error;
+    }
+  }
+  return platform2.pickWithInput({ accept: accept.join(`,`), multiple });
+};
+var guard = (tools) => async (tool, args) => {
+  const run = Object.hasOwn(tools, tool) ? tools[tool] : undefined;
+  if (!run)
+    return unavailable();
+  try {
+    return await run(args ?? {});
+  } catch (error) {
+    return failed(errorMessage(error));
+  }
+};
+var filesCapability = (platform2) => ({
+  name: `files`,
+  call: guard({
+    open: async (args) => {
+      const accept = Array.isArray(args.accept) ? args.accept : [];
+      const files = await pickFiles(platform2, accept, args.multiple === true);
+      const picked = (args.multiple === true ? files : files.slice(0, 1)).slice(0, 100);
+      return ok({
+        files: await Promise.all(picked.map(async (f) => ({ name: fileName(f.name), mimeType: fileMime(f), data: encodeBase64(await bytesOf(f)) })))
+      });
+    },
+    save: async (args) => {
+      const name = str(args, `name`) ?? `file`;
+      const bytes = decodeBase64(str(args, `data`) ?? ``);
+      if (!bytes)
+        return failed(`bad base64`);
+      const blob = blobOf(bytes, str(args, `mimeType`) ?? OCTET);
+      if (platform2.showSaveFilePicker) {
+        let handle;
+        try {
+          handle = await platform2.showSaveFilePicker({ suggestedName: name });
+        } catch (error) {
+          if (isAbort(error))
+            return ok({ saved: false });
+          if (!(error instanceof TypeError))
+            throw error;
+        }
+        if (handle) {
+          const writable = await handle.createWritable();
+          await writable.write(blob);
+          await writable.close();
+          return ok({ saved: true });
+        }
+      }
+      platform2.download(name, blob);
+      return ok({ saved: true });
+    }
+  })
+});
+var parsePhotoId = (id) => {
+  const m = /^(\d{1,15})-(.+)$/.exec(id);
+  if (!m)
+    return null;
+  return { id, name: m[2], takenMs: Number(m[1]) };
+};
+var takenAt = (ms) => ms > 0 && ms <= 8640000000000000 ? new Date(ms).toISOString() : null;
+var photoMeta = (entry, mime) => ({
+  id: entry.id,
+  name: fileName(entry.name),
+  mimeType: mime ?? extensionMime(entry.name) ?? OCTET,
+  takenAt: takenAt(entry.takenMs)
+});
+var safeName = (name) => {
+  const cleaned = codePoints(name.replace(/[/\\\u0000]/g, `_`), 200);
+  return cleaned === `` || cleaned === `.` || cleaned === `..` ? `photo` : cleaned;
+};
+var photosCapability = (platform2) => {
+  const library = async () => {
+    if (!platform2.storageDirectory)
+      return null;
+    const root = await platform2.storageDirectory();
+    return root.getDirectoryHandle(PHOTOS_DIR, { create: true });
+  };
+  const entries = async (dir) => {
+    const out = [];
+    for await (const handle of dir.values()) {
+      if (handle.kind !== `file`)
+        continue;
+      const entry = parsePhotoId(handle.name);
+      if (entry)
+        out.push(entry);
+    }
+    return out.sort((a, b) => b.takenMs - a.takenMs || (a.id < b.id ? 1 : a.id > b.id ? -1 : 0));
+  };
+  return {
+    name: `photos`,
+    call: guard({
+      pick: async (args) => {
+        const limit = typeof args.limit === `number` ? Math.max(1, Math.min(50, Math.floor(args.limit))) : 1;
+        const files = (await pickFiles(platform2, [`image/*`], limit > 1)).slice(0, limit);
+        const dir = files.length > 0 ? await library().catch(() => null) : null;
+        const photos = [];
+        for (const file of files) {
+          const bytes = await bytesOf(file);
+          const ms = Number.isSafeInteger(file.lastModified) && file.lastModified > 0 ? file.lastModified : 0;
+          const id = `${ms}-${safeName(file.name)}`;
+          if (dir) {
+            try {
+              const writable = await (await dir.getFileHandle(id, { create: true })).createWritable();
+              await writable.write(bytes);
+              await writable.close();
+            } catch {}
+          }
+          const meta = photoMeta({ id, name: safeName(file.name), takenMs: ms }, fileMime(file));
+          photos.push({ ...meta, data: encodeBase64(bytes) });
+        }
+        return ok({ photos });
+      },
+      list: async (args) => {
+        const limit = typeof args.limit === `number` ? Math.max(1, Math.min(100, Math.floor(args.limit))) : 50;
+        const cursor = str(args, `cursor`);
+        if (cursor !== undefined && !/^\d{1,9}$/.test(cursor))
+          return failed(`bad cursor`);
+        const dir = await library().catch(() => null);
+        if (!dir)
+          return ok({ photos: [], cursor: null });
+        const all = await entries(dir);
+        const offset = cursor === undefined ? 0 : Number(cursor);
+        const page = all.slice(offset, offset + limit);
+        const next = offset + limit < all.length ? String(offset + limit) : null;
+        return ok({ photos: page.map((e) => photoMeta(e)), cursor: next });
+      },
+      get: async (args) => {
+        const entry = parsePhotoId(str(args, `id`) ?? ``);
+        if (!entry)
+          return notFound();
+        const dir = await library().catch(() => null);
+        if (!dir)
+          return notFound();
+        let file;
+        try {
+          file = await (await dir.getFileHandle(entry.id)).getFile();
+        } catch {
+          return notFound();
+        }
+        return ok({ photo: { ...photoMeta(entry), data: encodeBase64(await bytesOf(file)) } });
+      }
+    })
+  };
+};
+var shareCapability = (platform2) => ({
+  name: `share`,
+  call: guard({
+    send: async (args) => {
+      if (!platform2.share)
+        return unavailable();
+      const data = {};
+      for (const key of [`title`, `text`, `url`]) {
+        const value = str(args, key);
+        if (value !== undefined)
+          data[key] = value;
+      }
+      const file = args.file;
+      if (file && typeof file === `object`) {
+        const bytes = decodeBase64(file.data ?? ``);
+        if (!bytes)
+          return failed(`bad base64`);
+        const shared = new File([bytes], file.name ?? `file`, { type: file.mimeType ?? OCTET });
+        if (platform2.canShare?.({ files: [shared] }))
+          data.files = [shared];
+        else if (data.text === undefined && data.url === undefined)
+          return failed(`this browser cannot share files`);
+      }
+      try {
+        await platform2.share(data);
+      } catch (error) {
+        if (isAbort(error))
+          return ok({ shared: false });
+        throw error;
+      }
+      return ok({ shared: true });
+    }
+  })
+});
+var printCapability = (platform2) => ({
+  name: `print`,
+  call: guard({
+    print: async (args) => {
+      const bytes = decodeBase64(str(args, `data`) ?? ``);
+      if (!bytes)
+        return failed(`bad base64`);
+      await platform2.print(blobOf(bytes, str(args, `mimeType`) ?? `application/pdf`));
+      return ok({ printed: true });
+    }
+  })
+});
+var notificationsCapability = (platform2, opts) => {
+  const api = platform2.notifications;
+  const posted = new Map;
+  const withdraw = (id) => {
+    const entry = posted.get(id);
+    if (!entry)
+      return false;
+    posted.delete(id);
+    if (entry.timer !== undefined)
+      platform2.clearTimeout(entry.timer);
+    if (entry.shown) {
+      entry.shown.onclose = null;
+      entry.shown.close();
+    }
+    return true;
+  };
+  const show = (id, entry, title, body, tap) => {
+    entry.timer = undefined;
+    const n = api.show(title, body === null ? { tag: id } : { body, tag: id });
+    entry.shown = n;
+    n.onclick = () => {
+      platform2.focus();
+      if (tap !== null && tap !== undefined)
+        opts.onTap?.(tap);
+      withdraw(id);
+    };
+    n.onclose = () => {
+      if (posted.get(id) === entry)
+        posted.delete(id);
+    };
+  };
+  const schedule = (id, entry, atMs, fire) => {
+    const delay = atMs - platform2.now();
+    if (delay <= 0)
+      return fire();
+    entry.timer = platform2.setTimeout(() => {
+      if (posted.get(id) === entry)
+        schedule(id, entry, atMs, fire);
+    }, Math.min(delay, MAX_DELAY_MS));
+  };
+  return {
+    name: `notifications`,
+    call: guard({
+      post: async (args) => {
+        const id = str(args, `id`) ?? ``;
+        const title = str(args, `title`) ?? ``;
+        const body = str(args, `body`) ?? null;
+        const at = str(args, `at`);
+        const atMs = at === undefined ? Number.NaN : Date.parse(at);
+        if (at !== undefined && Number.isNaN(atMs))
+          return failed(`bad at`);
+        let permission = api.permission();
+        if (permission === `default`)
+          permission = await api.requestPermission();
+        if (permission !== `granted`)
+          return failed(`notifications blocked`);
+        withdraw(id);
+        const entry = {};
+        posted.set(id, entry);
+        const tap = args.tap ?? null;
+        const fire = () => {
+          if (posted.get(id) === entry)
+            show(id, entry, title, body, tap);
+        };
+        if (Number.isNaN(atMs))
+          fire();
+        else
+          schedule(id, entry, atMs, fire);
+        return ok({});
+      },
+      cancel: async (args) => ok({ cancelled: withdraw(str(args, `id`) ?? ``) })
+    })
+  };
+};
+var webCapabilities = (platform2 = browserPlatform(), opts = {}) => {
+  const out = [photosCapability(platform2), filesCapability(platform2)];
+  if (platform2.share)
+    out.push(shareCapability(platform2));
+  out.push(printCapability(platform2));
+  if (platform2.notifications)
+    out.push(notificationsCapability(platform2, opts));
+  return out;
+};
+export {
+  IndexedDbPersistence,
+  IndexedDbVault,
+  OpfsBlobStore,
+  PHOTOS_DIR,
+  SQLITE_SCHEMA,
+  SqlitePersistence,
+  answerSql,
+  browserPlatform,
+  decodeBase64,
+  encodeBase64,
+  errorMessage,
+  fail,
+  failed,
+  isAbort,
+  notFound,
+  ok,
+  openRunnerIdb,
+  openWebStorage,
+  pickerTypes,
+  serveSql,
+  sqlClient,
+  unavailable,
+  webCapabilities
+};
+
+//# debugId=597992B2AF6EE6B164756E2164756E21
+//# sourceMappingURL=index.js.map