@drakkar.software/octovault-sdk 0.3.0

package/dist/index.js

@@ -0,0 +1,2108 @@
+import { mutePrefsConfig, readPrefsConfig, MAX_OBJECT_BLOB_BYTES, objectBlobPaths, kvRemove, kvSet, kvGet, getSyncBase, getSyncPrefix, getSyncNamespace, keyringPull, configureDKSpaces, configureKv as configureKv$1, isMuteActive, applyMute, getSharedSpacesNamespace, pairingClientConfig, attachmentKind, linkedDeviceScope, accountScope, profilePush, profilePull } from '@drakkar.software/dk-spaces-sdk';
+export { MAX_OBJECT_BLOB_BYTES, OBJECT_COLLECTIONS, attachmentKind, buildSignedEventsRequest, clearLiveSyncBus, clockTime, dispatchDocChange, emitSseStatus, fold, formatBytes, initialsFor, isMuteActive, isWordStart, keyringPull, keyringPush, matchTitle, objIndexPull, objIndexPush, objInvPull, objInvPush, objLogName, objPubPull, objPubPush, objectBlobName, objectDirName, onSseStatus, plural, previewInvite, rankResults, registerPull, relativeTime, relativeTimeShort, subscribeChanges, typesIndexName, typesIndexPull, typesIndexPush } from '@drakkar.software/dk-spaces-sdk';
+import { defaultSpaceLayout, createPrefsStore, readProfile as readProfile$1, readProfiles as readProfiles$1, writeProfile as writeProfile$1, buildEncryptor as buildEncryptor$1, configureSpaces, addObject, deriveSession as deriveSession$1, buildSession as buildSession$1, buildLinkedSession as buildLinkedSession$1, sessionFromPersisted as sessionFromPersisted$1, completeDevicePairing as completeDevicePairing$1, startDevicePairing as startDevicePairing$1, getSpaceAccessEntry, readSpaces as readSpaces$1, updateSpacesDoc, removeSpaceAccessEntry, unsealFromSelf, updateSpacesExtraField } from '@drakkar.software/starfish-spaces';
+export { SpaceAccessError, acceptSpaceInvite, activeAccountOf, addObject, ancestors, archiveObject, breadcrumbs, broadcastSpaceMeta, buildTree, capProviderFor, clearNodeAccessCache, clearSpaceAccessStore, createNode, createSpace, createSpaceInviteLink, fingerprintFromUserId, generateSeedWords, getNodeAccess, getNodeAccessEntry, getSpaceAccessEntry, getSpaceClient, hydrateSpaceAccessStore, inviteToNode, inviteToSpace, isValidSeed, joinNodeByLink, joinSpaceByLink, linkAccessFromStore, localSpaceAccessEntries, makeJoinRequest, memberCapsFromStore, nextOrder, onSpaceMeta, ownerEnsureKeyring, ownerTrustedAdders, parseObjectDirectoryDoc, patchObject, readObjectDirectory, readSpaceAccess, reconcileSpaceMeta, recoverSpaceAccess, removeSpaceAccessEntry, removeSpaceMember, reorderObjects, reorderSpaces, reparentObject, rootIdentityOf, saveNodeAccessEntry, saveSpaceAccessEntry, sealToRecipient, sealToSelf, subtreeIds, unsealFromRecipient, unsealFromSelf, updateSpacesDoc, writeSpaceAccess } from '@drakkar.software/starfish-spaces';
+import { signRequest, stableStringify, randomId } from '@drakkar.software/starfish-protocol';
+export { bytesToHex, randomId, slugify as roomSlug } from '@drakkar.software/starfish-protocol';
+import { createSealedBlobStore, createKvPullCache } from '@drakkar.software/starfish-client';
+export { FileTooLargeError } from '@drakkar.software/starfish-client';
+import { createTimeoutFetch } from '@drakkar.software/starfish-client/fetch';
+export { parseSseFrames } from '@drakkar.software/starfish-client/events';
+export { WalDocument } from '@drakkar.software/starfish-wal';
+export { createWalDocument, noopEncryptor } from '@drakkar.software/starfish-wal/client';
+
+// src/config/config.ts
+async function buildAuthHeaders(cap, devEdPrivHex, method, pathAndQuery) {
+  let host = "";
+  try {
+    host = new URL(getSyncBase()).host;
+  } catch {
+  }
+  const { sig, ts, nonce } = await signRequest(
+    { method, pathAndQuery, host },
+    devEdPrivHex
+  );
+  const capJson = stableStringify(cap);
+  const capB64 = typeof btoa === "function" ? btoa(capJson) : Buffer.from(capJson, "utf-8").toString("base64");
+  return {
+    Authorization: `Cap ${capB64}`,
+    "X-Starfish-Sig": sig,
+    "X-Starfish-Ts": String(ts),
+    "X-Starfish-Nonce": nonce
+  };
+}
+var _OCTOVAULT_LAYOUT = { ...defaultSpaceLayout, profilePull, profilePush, accountScope, linkedDeviceScope };
+function octoVaultLayout() {
+  return _OCTOVAULT_LAYOUT;
+}
+async function readProfile(userId) {
+  return readProfile$1(userId, { baseUrl: `${getSyncBase()}${getSyncPrefix()}`, layout: octoVaultLayout() });
+}
+async function readProfiles(ids) {
+  return readProfiles$1(ids, {
+    baseUrl: getSyncBase(),
+    namespace: getSyncNamespace() ?? "",
+    layout: octoVaultLayout()
+  });
+}
+async function writeProfile(client, userId, patch) {
+  return writeProfile$1(client, userId, octoVaultLayout(), patch);
+}
+async function buildEncryptor(client, keys, spaceId, trustedAdders) {
+  return buildEncryptor$1(client, keys, keyringPull(spaceId), trustedAdders);
+}
+var PULL_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var _cache = null;
+function pullCache() {
+  if (!_cache) {
+    _cache = createKvPullCache(
+      { getItem: kvGet, setItem: kvSet, removeItem: kvRemove },
+      { prefix: "octovault.pullcache.", maxAgeMs: PULL_CACHE_MAX_AGE_MS }
+    );
+  }
+  return _cache;
+}
+function resetPullCache() {
+  _cache = null;
+}
+
+// src/config/config.ts
+var _config = {
+  syncBase: "http://localhost:8787",
+  syncNamespace: void 0,
+  syncPrefix: "",
+  eventsUrl: "http://localhost:8787/events",
+  webBase: ""
+};
+function configureOctoVault(config) {
+  _config = { ..._config, ...config };
+  resetPullCache();
+  configureDKSpaces({
+    syncBase: _config.syncBase,
+    syncNamespace: _config.syncNamespace,
+    eventsUrl: _config.eventsUrl,
+    ..._config.sharedSpacesNamespace ? { sharedSpacesNamespace: _config.sharedSpacesNamespace } : {}
+  });
+  configureSpaces({ layout: octoVaultLayout() });
+}
+function getSyncBase2() {
+  return _config.syncBase;
+}
+function getSyncNamespace2() {
+  return _config.syncNamespace;
+}
+function getSyncPrefix2() {
+  return _config.syncPrefix;
+}
+function getEventsUrl() {
+  return _config.eventsUrl;
+}
+var _kv = {
+  async get() {
+    return null;
+  },
+  async set() {
+  },
+  async remove() {
+  }
+};
+function configureKv(adapter) {
+  _kv = adapter;
+  configureKv$1({ get: adapter.get, set: adapter.set, remove: adapter.remove });
+}
+async function kvGet2(key) {
+  return _kv.get(key);
+}
+async function kvSet2(key, value) {
+  return _kv.set(key, value);
+}
+async function kvRemove2(key) {
+  return _kv.remove(key);
+}
+
+// src/domain/types.ts
+var BUILTIN_OBJECT_TYPES = [
+  "folder",
+  "page",
+  "board",
+  "task",
+  "file",
+  "image",
+  "automation",
+  "note",
+  "calendar",
+  "form",
+  "feedback"
+];
+
+// src/domain/capabilities.ts
+var CAPABILITY_META = {
+  pages: { label: "Pages", description: "Rich-text pages with nested blocks", objectType: "page" },
+  boards: { label: "Boards", description: "Kanban boards with tasks", objectType: "board" },
+  notes: { label: "Notes", description: "Personal note-taking", objectType: "note" },
+  calendar: { label: "Calendar", description: "Event scheduling and agenda view", objectType: "calendar" },
+  forms: { label: "Forms", description: "Form builder and response collection", objectType: "form" },
+  feedback: { label: "Feedback", description: "Ranked feedback with voting", objectType: "feedback" }
+};
+
+// src/domain/object-types.ts
+var TASK_PROPS = [
+  {
+    key: "status",
+    label: "Status",
+    kind: "select",
+    options: [
+      { id: "todo", label: "To do" },
+      { id: "doing", label: "In progress" },
+      { id: "done", label: "Done" }
+    ]
+  },
+  { key: "columnId", label: "Column", kind: "text" },
+  { key: "order", label: "Order", kind: "number" }
+];
+var BLOB_PROPS = [
+  { key: "blobId", label: "Blob", kind: "text" },
+  { key: "mime", label: "MIME type", kind: "text" },
+  { key: "size", label: "Size", kind: "number" },
+  { key: "name", label: "Filename", kind: "text" }
+];
+var NOTE_PROPS = [
+  { key: "tags", label: "Tags", kind: "text" }
+];
+var BUILTIN_DESCRIPTORS = {
+  // OctoVault primary types
+  folder: { contentKind: "none", icon: "folder", label: "Folder", editor: "none", props: [], creatable: true, workTree: false, findable: false },
+  page: { contentKind: "append", icon: "file", label: "Page", editor: "page", props: [], creatable: true, workTree: true, findable: true, defaultTitle: "Untitled", capability: "pages" },
+  board: { contentKind: "append", icon: "work", label: "Board", editor: "board", props: [], creatable: true, workTree: true, findable: true, defaultTitle: "Untitled Board", capability: "boards", ownsScroll: true },
+  task: { contentKind: "append", icon: "check", label: "Task", editor: "page", props: TASK_PROPS, creatable: false, workTree: false, findable: false },
+  file: { contentKind: "none", icon: "file", label: "File", editor: "file", props: BLOB_PROPS, creatable: true, workTree: false, findable: false, defaultTitle: "Untitled File" },
+  image: { contentKind: "none", icon: "image", label: "Image", editor: "file", props: BLOB_PROPS, creatable: true, workTree: false, findable: false, defaultTitle: "Untitled Image" },
+  // Automation: stream-bot integration node; not yet creatable from the UI.
+  automation: { contentKind: "none", icon: "stream", label: "Automation", editor: "none", props: [], creatable: false, workTree: false, findable: false },
+  // Sub-app variant types
+  note: { contentKind: "append", icon: "file", label: "Note", editor: "page", props: NOTE_PROPS, creatable: false, workTree: false, findable: true, defaultTitle: "Untitled Note", capability: "notes" },
+  calendar: { contentKind: "append", icon: "clock", label: "Calendar", editor: "calendar", props: [], creatable: true, workTree: true, findable: true, defaultTitle: "Untitled Calendar", capability: "calendar", ownsScroll: true },
+  form: { contentKind: "append", icon: "layers", label: "Form", editor: "form", props: [], creatable: true, workTree: true, findable: true, defaultTitle: "Untitled Form", capability: "forms", ownsScroll: true },
+  feedback: { contentKind: "append", icon: "check", label: "Feedback", editor: "feedback", props: [], creatable: true, workTree: true, findable: true, defaultTitle: "Untitled Feedback", capability: "feedback", ownsScroll: true },
+  // Removed types — tombstones so legacy nodes in existing spaces stay hidden (workTree: false)
+  // rather than falling through to the generic descriptor (workTree: true). Not creatable.
+  room: { contentKind: "none", icon: "layers", label: "Channel", editor: "none", props: [], creatable: false, workTree: false, findable: false },
+  category: { contentKind: "none", icon: "folder", label: "Category", editor: "none", props: [], creatable: false, workTree: false, findable: false }
+};
+var GENERIC = { contentKind: "merge", icon: "layers", label: "Object", editor: "record", props: [], creatable: false, workTree: true, findable: true };
+function objectDescriptor(type) {
+  return BUILTIN_DESCRIPTORS[type] ?? GENERIC;
+}
+function iconForNode(node) {
+  return objectDescriptor(node.type).icon;
+}
+function isContainerType(type) {
+  return objectDescriptor(type).editor === "none";
+}
+function showsInWorkTree(node) {
+  return objectDescriptor(node.type).workTree;
+}
+function isOpenableObjectType(type) {
+  return objectDescriptor(type).editor !== "none";
+}
+function isFindableType(type) {
+  return objectDescriptor(type).findable;
+}
+function contentKindOf(node) {
+  return node.contentKind ?? objectDescriptor(node.type).contentKind;
+}
+function creatableTypes() {
+  return Object.entries(BUILTIN_DESCRIPTORS).filter(([, d]) => d.creatable).map(([type, d]) => ({ type, ...d }));
+}
+function defaultProps(_type) {
+  return {};
+}
+function typeDefToDescriptor(def) {
+  return {
+    contentKind: def.contentKind,
+    icon: def.icon || "layers",
+    label: def.label,
+    editor: def.editorKind,
+    props: def.fields.map((f) => ({
+      key: f.key,
+      label: f.label,
+      kind: f.kind,
+      options: f.options,
+      required: f.required
+    })),
+    creatable: def.creatable,
+    workTree: true,
+    findable: true,
+    color: def.color
+  };
+}
+function makeRegistry(customTypes) {
+  const customMap = /* @__PURE__ */ new Map();
+  for (const def of customTypes) {
+    if (!BUILTIN_DESCRIPTORS[def.id]) {
+      customMap.set(def.id, typeDefToDescriptor(def));
+    }
+  }
+  const descriptor = (type) => BUILTIN_DESCRIPTORS[type] ?? customMap.get(type) ?? GENERIC;
+  const creatableTypes2 = () => {
+    const builtins = Object.entries(BUILTIN_DESCRIPTORS).filter(([, d]) => d.creatable).map(([type, d]) => ({ type, ...d }));
+    const customs = [];
+    for (const [type, d] of customMap) {
+      if (d.creatable) customs.push({ type, ...d });
+    }
+    return [...builtins, ...customs];
+  };
+  return {
+    descriptor,
+    creatableTypes: creatableTypes2,
+    showsInWorkTree: (node) => descriptor(node.type).workTree,
+    iconForNode: (node) => descriptor(node.type).icon,
+    isFindableType: (type) => descriptor(type).findable,
+    isContainerType: (type) => descriptor(type).editor === "none",
+    isOpenableType: (type) => descriptor(type).editor !== "none",
+    allTypes: () => {
+      const builtins = Object.entries(BUILTIN_DESCRIPTORS).map(
+        ([type, d]) => ({ type, ...d, isCustom: false })
+      );
+      const customs = Array.from(customMap.entries()).map(([type, d]) => ({
+        type,
+        ...d,
+        isCustom: true
+      }));
+      return [...builtins, ...customs];
+    }
+  };
+}
+var BUILTIN_REGISTRY = makeRegistry([]);
+function routeForNode(_node) {
+  return "/work/object/[id]";
+}
+function objectLink(spaceId, node) {
+  const origin = globalThis.location?.origin;
+  if (!origin) return null;
+  return `${origin}${routeForNode().replace("[id]", node.id)}?spaceId=${encodeURIComponent(spaceId)}`;
+}
+
+// src/domain/errors.ts
+var GENERIC_FALLBACK = "Something went wrong. Please try again.";
+var NETWORK_RE = /failed to fetch|network request failed|networkerror|load failed|fetch failed|socket|ECONN|timeout/i;
+var INTERNAL_RE = /argon2|wasm|hkdf|kyber|kem\b|cbor|nacl|ciphertext|deserializ|undefined is not|cannot read|JSON parse|unexpected token/i;
+function looksHuman(message) {
+  if (!message) return false;
+  if (message.length > 160) return false;
+  if (INTERNAL_RE.test(message)) return false;
+  return true;
+}
+function humanizeError(e, fallback = GENERIC_FALLBACK) {
+  const err = e instanceof Error ? e : null;
+  const message = err?.message ?? (typeof e === "string" ? e : "");
+  const name = err?.name ?? "";
+  if (NETWORK_RE.test(message) || NETWORK_RE.test(name)) {
+    return "Can't reach the sync server. Check your connection and try again.";
+  }
+  if (name === "NotAllowedError") {
+    return "The passkey prompt was dismissed. Try again, or use your PIN.";
+  }
+  if (name === "AbortError") {
+    return "That took too long. Try again.";
+  }
+  const status = e?.status;
+  if (typeof status === "number") {
+    if (status === 401 || status === 403) return "You don't have access to that. Check the invite or ask its owner.";
+    if (status === 404) return fallback;
+    if (status === 429) return "Too many requests \u2014 wait a moment and try again.";
+    if (status >= 500) return "The sync server hit a problem. Try again in a moment.";
+    if (status >= 400) return fallback;
+  }
+  return looksHuman(message) ? message : fallback;
+}
+
+// src/format/emoji.ts
+var CATEGORY_TABLES = [
+  {
+    id: "smileys",
+    label: "Smileys & emotion",
+    table: {
+      smile: "\u{1F604}",
+      smiley: "\u{1F603}",
+      grin: "\u{1F601}",
+      laughing: "\u{1F606}",
+      joy: "\u{1F602}",
+      rofl: "\u{1F923}",
+      sweat_smile: "\u{1F605}",
+      wink: "\u{1F609}",
+      blush: "\u{1F60A}",
+      slight_smile: "\u{1F642}",
+      upside_down: "\u{1F643}",
+      heart_eyes: "\u{1F60D}",
+      kissing_heart: "\u{1F618}",
+      thinking: "\u{1F914}",
+      neutral_face: "\u{1F610}",
+      unamused: "\u{1F612}",
+      roll_eyes: "\u{1F644}",
+      smirk: "\u{1F60F}",
+      relieved: "\u{1F60C}",
+      pensive: "\u{1F614}",
+      confused: "\u{1F615}",
+      cry: "\u{1F622}",
+      sob: "\u{1F62D}",
+      fearful: "\u{1F628}",
+      weary: "\u{1F629}",
+      triumph: "\u{1F624}",
+      angry: "\u{1F620}",
+      rage: "\u{1F621}",
+      sleeping: "\u{1F634}",
+      sunglasses: "\u{1F60E}",
+      nerd: "\u{1F913}",
+      star_struck: "\u{1F929}",
+      partying_face: "\u{1F973}",
+      zany: "\u{1F92A}",
+      scream: "\u{1F631}",
+      exploding_head: "\u{1F92F}",
+      shushing: "\u{1F92B}"
+    }
+  },
+  {
+    id: "gestures",
+    label: "Gestures & body",
+    table: {
+      "+1": "\u{1F44D}",
+      thumbsup: "\u{1F44D}",
+      "-1": "\u{1F44E}",
+      thumbsdown: "\u{1F44E}",
+      ok_hand: "\u{1F44C}",
+      fist: "\u{1F44A}",
+      wave: "\u{1F44B}",
+      raised_hands: "\u{1F64C}",
+      clap: "\u{1F44F}",
+      pray: "\u{1F64F}",
+      muscle: "\u{1F4AA}",
+      v: "\u270C\uFE0F",
+      crossed_fingers: "\u{1F91E}",
+      handshake: "\u{1F91D}",
+      eyes: "\u{1F440}",
+      point_up: "\u261D\uFE0F"
+    }
+  },
+  {
+    id: "hearts",
+    label: "Hearts",
+    table: {
+      heart: "\u2764\uFE0F",
+      broken_heart: "\u{1F494}",
+      sparkling_heart: "\u{1F496}",
+      two_hearts: "\u{1F495}",
+      blue_heart: "\u{1F499}",
+      green_heart: "\u{1F49A}",
+      purple_heart: "\u{1F49C}",
+      yellow_heart: "\u{1F49B}",
+      orange_heart: "\u{1F9E1}",
+      black_heart: "\u{1F5A4}"
+    }
+  },
+  {
+    id: "symbols",
+    label: "Symbols & marks",
+    table: {
+      fire: "\u{1F525}",
+      sparkles: "\u2728",
+      star: "\u2B50",
+      star2: "\u{1F31F}",
+      zap: "\u26A1",
+      boom: "\u{1F4A5}",
+      "100": "\u{1F4AF}",
+      tada: "\u{1F389}",
+      confetti_ball: "\u{1F38A}",
+      balloon: "\u{1F388}",
+      gift: "\u{1F381}",
+      bell: "\u{1F514}",
+      warning: "\u26A0\uFE0F",
+      check: "\u2705",
+      white_check_mark: "\u2705",
+      heavy_check_mark: "\u2714\uFE0F",
+      x: "\u274C",
+      no_entry: "\u26D4",
+      question: "\u2753",
+      exclamation: "\u2757",
+      plus: "\u2795",
+      heavy_plus_sign: "\u2795",
+      minus: "\u2796",
+      heavy_minus_sign: "\u2796",
+      bulb: "\u{1F4A1}",
+      lock: "\u{1F512}",
+      key: "\u{1F511}",
+      mag: "\u{1F50D}",
+      hourglass: "\u23F3",
+      alarm_clock: "\u23F0",
+      calendar: "\u{1F4C5}",
+      pushpin: "\u{1F4CC}",
+      paperclip: "\u{1F4CE}",
+      memo: "\u{1F4DD}",
+      link: "\u{1F517}"
+    }
+  },
+  {
+    id: "objects",
+    label: "Objects",
+    table: {
+      rocket: "\u{1F680}",
+      computer: "\u{1F4BB}",
+      iphone: "\u{1F4F1}",
+      email: "\u2709\uFE0F",
+      package: "\u{1F4E6}",
+      bug: "\u{1F41B}",
+      robot: "\u{1F916}",
+      ghost: "\u{1F47B}",
+      alien: "\u{1F47D}",
+      poop: "\u{1F4A9}",
+      skull: "\u{1F480}",
+      clown: "\u{1F921}",
+      coffee: "\u2615",
+      beer: "\u{1F37A}",
+      pizza: "\u{1F355}",
+      cake: "\u{1F382}",
+      trophy: "\u{1F3C6}",
+      medal: "\u{1F3C5}",
+      moneybag: "\u{1F4B0}",
+      chart: "\u{1F4C8}",
+      hammer: "\u{1F528}",
+      wrench: "\u{1F527}",
+      gear: "\u2699\uFE0F"
+    }
+  },
+  {
+    id: "marine",
+    label: "Marine & animals",
+    table: {
+      octopus: "\u{1F419}",
+      whale: "\u{1F433}",
+      fish: "\u{1F41F}",
+      tropical_fish: "\u{1F420}",
+      dolphin: "\u{1F42C}",
+      shark: "\u{1F988}",
+      crab: "\u{1F980}",
+      shell: "\u{1F41A}",
+      ocean: "\u{1F30A}",
+      anchor: "\u2693",
+      ship: "\u{1F6A2}",
+      dog: "\u{1F436}",
+      cat: "\u{1F431}",
+      unicorn: "\u{1F984}",
+      turtle: "\u{1F422}",
+      penguin: "\u{1F427}",
+      owl: "\u{1F989}",
+      snail: "\u{1F40C}"
+    }
+  },
+  {
+    id: "nature",
+    label: "Nature & weather",
+    table: {
+      sunny: "\u2600\uFE0F",
+      cloud: "\u2601\uFE0F",
+      rainbow: "\u{1F308}",
+      snowflake: "\u2744\uFE0F",
+      droplet: "\u{1F4A7}"
+    }
+  }
+];
+var EMOJI = Object.assign(
+  {},
+  ...CATEGORY_TABLES.map((c) => c.table)
+);
+function dedupeByGlyph(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of entries) {
+    if (seen.has(e.glyph)) continue;
+    seen.add(e.glyph);
+    out.push(e);
+  }
+  return out;
+}
+var EMOJI_CATEGORIES = CATEGORY_TABLES.map((c) => ({
+  id: c.id,
+  label: c.label,
+  emoji: dedupeByGlyph(Object.entries(c.table).map(([code, glyph]) => ({ code, glyph })))
+}));
+var EMOJI_LIST = EMOJI_CATEGORIES.flatMap((c) => c.emoji);
+var LIST = Object.entries(EMOJI).map(([code, glyph]) => ({ code, glyph }));
+var TOKEN_RE = /(?:^|\s):([a-z0-9_+-]*)$/i;
+function activeEmojiQuery(textBeforeCaret) {
+  const m = TOKEN_RE.exec(textBeforeCaret);
+  if (!m) return null;
+  const query = m[1];
+  return { query, start: textBeforeCaret.length - query.length - 1 };
+}
+function matchEmoji(query, limit = 8) {
+  const q = query.toLowerCase();
+  if (!q) return [];
+  const prefix = [];
+  const substr = [];
+  for (const e of LIST) {
+    const i = e.code.indexOf(q);
+    if (i === 0) prefix.push(e);
+    else if (i > 0) substr.push(e);
+  }
+  return [...prefix, ...substr].slice(0, limit);
+}
+function searchEmoji(query, limit = 64) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  const prefix = [];
+  const substr = [];
+  for (const e of LIST) {
+    const i = e.code.indexOf(q);
+    if (i === 0) prefix.push(e);
+    else if (i > 0) substr.push(e);
+  }
+  return dedupeByGlyph([...prefix, ...substr]).slice(0, limit);
+}
+
+// src/legal.ts
+var privacy = {
+  title: "Privacy Policy",
+  subtitle: "How OctoVault handles your data \u2014 or rather, how it doesn't.",
+  updated: "June 2026",
+  sections: [
+    {
+      title: "Overview",
+      paragraphs: [
+        "OctoVault is an end-to-end encrypted knowledge management app. Every page, block, board, and document is sealed on your device before it is transmitted or stored. Neither Drakkar Software nor any server operator can read your documents, notes, or boards.",
+        "This policy describes what minimal information is associated with your use of OctoVault and how it is handled."
+      ]
+    },
+    {
+      title: "Your Identity and Keys",
+      paragraphs: [
+        "Your cryptographic identity (Ed25519 signing key, Kyber encryption key) is derived locally from a BIP-39 mnemonic seed phrase that you generate during onboarding. Your seed phrase never leaves your device and is never transmitted to any server.",
+        "Profile information such as your display name and workspace avatar is encrypted before storage. The server holds ciphertext; it has no way to associate a readable identity with your key material."
+      ]
+    },
+    {
+      title: "Document Content",
+      paragraphs: [
+        "All documents, pages, blocks, and boards are encrypted client-side using per-space symmetric keys before being sent to the server. The server stores and delivers opaque encrypted blobs. It cannot read, index, or analyse your content.",
+        "Attachments (images, files) are encrypted with the same per-space keys. File content is never accessible to the server."
+      ]
+    },
+    {
+      title: "Server Metadata",
+      paragraphs: [
+        "Basic connection metadata \u2014 document identifiers, timestamps, and the size of encrypted payloads \u2014 is necessarily visible to the server in order to route and deliver updates. This metadata does not include any document content.",
+        "OctoVault does not use analytics services, tracking pixels, advertising SDKs, or any third-party library that reports usage data to external parties."
+      ]
+    },
+    {
+      title: "Self-Hosted Deployments",
+      paragraphs: [
+        "OctoVault is designed to be self-hosted. When you run your own Starfish server, you control all infrastructure, logs, and data retention policies.",
+        "If you use a server operated by a third party (a team admin, an employer, etc.), their privacy practices govern the infrastructure they control \u2014 including metadata, access logs, and backup retention. They cannot read your encrypted document content, but they do control server-level metadata.",
+        "Drakkar Software has no visibility into, and no responsibility for, the data handling practices of third-party server operators."
+      ]
+    },
+    {
+      title: "Push Notifications",
+      paragraphs: [
+        'Push notifications, when enabled, are delivered through platform services (Apple APNs, Google FCM). By default OctoVault sends generic alerts ("New update") without decrypted content.',
+        "If you enable notification previews in Settings, a decrypted preview is generated on-device and passed to the platform notification service. Drakkar Software recommends leaving previews disabled on shared or untrusted devices."
+      ]
+    },
+    {
+      title: "Data Retention",
+      paragraphs: [
+        `OctoVault is a persistent, append-only system by design. Documents, pages, and server-side records are retained per the server operator's infrastructure policy. There is no "delete account" feature \u2014 this is intentional: the append-only model is fundamental to the security and auditability of the system.`,
+        "You may remove OctoVault from your device at any time, which discards your local keys. Because documents are end-to-end encrypted, your local keys are the only way to decrypt stored ciphertext. Removing them renders your document history permanently inaccessible on that device \u2014 without recovery, by design."
+      ]
+    },
+    {
+      title: "Children's Privacy",
+      paragraphs: [
+        "OctoVault is not directed at children under the age of 13. We do not knowingly process information relating to minors. If you believe a minor has created an account, please contact us at the address below."
+      ]
+    },
+    {
+      title: "Changes to This Policy",
+      paragraphs: [
+        "We may update this policy to reflect changes in the software or applicable law. Material changes will be communicated through the application release notes or the official OctoVault repository.",
+        "Continued use of OctoVault after a policy update constitutes acceptance of the revised terms."
+      ]
+    },
+    {
+      title: "Contact",
+      paragraphs: [
+        "Questions or concerns about this Privacy Policy? Reach us at privacy@drakkar.software or open an issue in the public OctoVault repository."
+      ]
+    }
+  ]
+};
+var terms = {
+  title: "Terms of Service",
+  subtitle: "What you can do with OctoVault, and what we ask of you.",
+  updated: "June 2026",
+  sections: [
+    {
+      title: "Acceptance",
+      paragraphs: [
+        "By installing, accessing, or using OctoVault you agree to be bound by these Terms of Service. If you do not agree with any part of these Terms, do not use the software.",
+        "These Terms apply to all users of OctoVault, whether connecting to the official hosted service, a self-hosted Starfish server, or running the software locally."
+      ]
+    },
+    {
+      title: "Open-Source License",
+      paragraphs: [
+        "OctoVault client code and the OctoVault SDK are released under the MIT License. You may freely use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software, subject to the license conditions.",
+        "The Starfish server software is licensed separately; refer to its repository for applicable terms. Third-party dependencies carry their own licenses."
+      ]
+    },
+    {
+      title: "Description of the Service",
+      paragraphs: [
+        "OctoVault provides end-to-end encrypted knowledge management software. Pages, boards, and documents are encrypted on your device; the server stores only ciphertext. You are solely responsible for the security of your seed phrase.",
+        "Lost or forgotten seed phrases cannot be recovered by Drakkar Software. There is no password reset, no backdoor, and no key escrow. Treat your seed phrase like a private key \u2014 back it up securely and never share it."
+      ]
+    },
+    {
+      title: "Self-Hosting Responsibility",
+      paragraphs: [
+        "If you operate a Starfish server for yourself or others, you bear full responsibility for its security, availability, and legal compliance. This includes data protection obligations in your jurisdiction, secure configuration, and timely security updates.",
+        "You must not use the software to host, store, or distribute content that is illegal in your jurisdiction or in the jurisdiction of your users."
+      ]
+    },
+    {
+      title: "Acceptable Use",
+      paragraphs: [
+        "You agree not to use OctoVault to: (a) violate any applicable local, national, or international law or regulation; (b) transmit or facilitate the transmission of malware, spam, or unsolicited communications; (c) harass, stalk, threaten, or harm any individual; (d) attempt to undermine the security or integrity of OctoVault or any Starfish server you do not operate; or (e) resell or white-label the service without prior written permission.",
+        "We reserve the right to terminate access to any officially operated service for users who violate these terms."
+      ]
+    },
+    {
+      title: "No Warranty",
+      paragraphs: [
+        'OctoVault is provided "as is" and "as available", without warranty of any kind, express or implied. We do not warrant uninterrupted or error-free operation, security against all attack vectors, fitness for a particular purpose, or the permanent preservation of any data.',
+        "Cryptographic security relies on correct implementation of published open standards (Ed25519, Kyber, AES-GCM). We make reasonable efforts to maintain correctness and to address security disclosures promptly, but no software is free of bugs."
+      ]
+    },
+    {
+      title: "Limitation of Liability",
+      paragraphs: [
+        "To the maximum extent permitted by applicable law, Drakkar Software and its contributors shall not be liable for any indirect, incidental, special, consequential, or punitive damages, including loss of data, arising from your use of or inability to use OctoVault.",
+        "Our aggregate liability for any claim arising from these Terms shall not exceed one hundred euros (\u20AC100)."
+      ]
+    },
+    {
+      title: "Governing Law and Disputes",
+      paragraphs: [
+        "These Terms are governed by the laws of France, without regard to conflict-of-law provisions. Any dispute arising under these Terms shall be submitted to the exclusive jurisdiction of the competent courts of Paris, France."
+      ]
+    },
+    {
+      title: "Changes to These Terms",
+      paragraphs: [
+        "We may revise these Terms from time to time. The most current version will always be available in the application and in the official OctoVault repository. Material changes will be flagged in the release notes.",
+        "Continued use of OctoVault after a revision becomes effective constitutes your acceptance of the updated Terms."
+      ]
+    },
+    {
+      title: "Contact",
+      paragraphs: [
+        "Legal questions? Contact us at legal@drakkar.software or open an issue in the public OctoVault repository at github.com/drakkar-software/octovault."
+      ]
+    }
+  ]
+};
+var _store = createPrefsStore({
+  ...mutePrefsConfig("octovault"),
+  client: (s) => s.accountClient
+});
+var getMutePrefs = () => _store.get();
+var isRoomMuted = (roomId) => isMuteActive(_store.get().nodes[roomId]);
+var isSpaceMuted = (spaceId) => isMuteActive(_store.get().spaces[spaceId]);
+var isMuted = (roomId, spaceId) => isRoomMuted(roomId) || isSpaceMuted(spaceId);
+var subscribeMutes = (listener) => _store.subscribe(listener);
+var hydrateMutes = (userId, serverPrefs) => _store.hydrate(userId, serverPrefs);
+var resetMutes = () => _store.reset();
+var loadMutesFromKv = (userId) => _store.loadFromKv(userId);
+var setRoomMute = (session, roomId, muted) => _store.mutate(session, (cur) => applyMute(cur, "nodes", roomId, muted));
+var setSpaceMute = (session, spaceId, muted) => _store.mutate(session, (cur) => applyMute(cur, "spaces", spaceId, muted));
+var _store2 = createPrefsStore({
+  ...readPrefsConfig("octovault"),
+  client: (s) => s.accountClient
+});
+var getReadPrefs = () => _store2.get();
+var getRoomReadAt = (roomId) => _store2.get().nodes[roomId];
+var subscribeReads = (listener) => _store2.subscribe(listener);
+var loadReadMarksFromKv = (userId) => _store2.loadFromKv(userId);
+var hydrateReads = (userId, serverPrefs) => _store2.hydrate(userId, serverPrefs);
+var resetReads = () => _store2.reset();
+var flushReadsNow = () => _store2.flushNow();
+var setRoomReadAt = (session, roomId, ts) => _store2.mutate(
+  session,
+  (cur) => ts > (cur.nodes[roomId] ?? 0) ? { nodes: { ...cur.nodes, [roomId]: ts } } : null
+);
+var updateQuickReactionsDoc = (session, mutator) => updateSpacesExtraField(session.spacesRegistryClient, session, "quickReactions", mutator);
+var QUICK_REACTION_COUNT = 6;
+var DEFAULT_QUICK_REACTIONS = ["\u{1F44D}", "\u{1F600}", "\u{1F602}", "\u2764\uFE0F", "\u{1F389}", "\u{1F419}"];
+var snapshot = DEFAULT_QUICK_REACTIONS;
+var listeners = /* @__PURE__ */ new Set();
+var pending = 0;
+function getQuickReactions() {
+  return snapshot;
+}
+function subscribeQuickReactions(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function setQuickReactions(next) {
+  snapshot = next;
+  for (const listener of listeners) listener();
+}
+function resetQuickReactions() {
+  setQuickReactions(DEFAULT_QUICK_REACTIONS);
+}
+function coerce(raw) {
+  if (!Array.isArray(raw)) return DEFAULT_QUICK_REACTIONS;
+  return DEFAULT_QUICK_REACTIONS.map((fallback, i) => {
+    const v = raw[i];
+    return typeof v === "string" && v.length > 0 ? v : fallback;
+  });
+}
+function arraysEqual(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function hydrateQuickReactions(serverPalette) {
+  if (pending > 0) return;
+  const next = coerce(serverPalette);
+  if (arraysEqual(snapshot, next)) return;
+  setQuickReactions(next);
+}
+async function saveQuickReactions(session, emojis) {
+  const next = coerce(emojis);
+  setQuickReactions(next);
+  pending++;
+  try {
+    await updateQuickReactionsDoc(session, () => next);
+  } catch (err) {
+    console.error("[OctoVault] quick reactions: failed to sync palette change", err);
+  } finally {
+    pending--;
+  }
+}
+
+// src/ai-settings.ts
+var DEFAULT_AI_SETTINGS = {
+  enabled: false
+};
+var settingsKey = (userId) => `octovault.ai.${userId}`;
+var snapshot2 = DEFAULT_AI_SETTINGS;
+var listeners2 = /* @__PURE__ */ new Set();
+function getAiSettings() {
+  return snapshot2;
+}
+function subscribeAiSettings(listener) {
+  listeners2.add(listener);
+  return () => {
+    listeners2.delete(listener);
+  };
+}
+function setAiSettings(next) {
+  snapshot2 = next;
+  for (const listener of listeners2) listener();
+}
+function resetAiSettings() {
+  setAiSettings(DEFAULT_AI_SETTINGS);
+}
+function coerce2(raw) {
+  if (!raw || typeof raw !== "object") return DEFAULT_AI_SETTINGS;
+  const r = raw;
+  return {
+    enabled: typeof r.enabled === "boolean" ? r.enabled : DEFAULT_AI_SETTINGS.enabled
+  };
+}
+async function loadAiSettings(userId) {
+  const raw = await kvGet2(settingsKey(userId));
+  if (!raw) return DEFAULT_AI_SETTINGS;
+  try {
+    return coerce2(JSON.parse(raw));
+  } catch {
+    return DEFAULT_AI_SETTINGS;
+  }
+}
+async function saveAiSettings(userId, patch) {
+  const next = { ...snapshot2, ...patch };
+  setAiSettings(next);
+  await kvSet2(settingsKey(userId), JSON.stringify(next));
+}
+
+// src/spaces-prime.ts
+var primed = null;
+function primeSpaces(userId, spaces) {
+  primed = { userId, spaces, at: Date.now() };
+}
+function consumePrimedSpaces(userId) {
+  if (!primed || primed.userId !== userId || Date.now() - primed.at > 1e4) return null;
+  const { spaces } = primed;
+  primed = null;
+  return spaces;
+}
+function clearPrimedSpaces() {
+  primed = null;
+}
+
+// src/blocks.ts
+var BLOCK_SECTIONS = [
+  { id: "basic", label: "Basic" },
+  { id: "list", label: "Lists" },
+  { id: "other", label: "More" }
+];
+var BLOCK_TYPES = [
+  { type: "paragraph", label: "Text", icon: "text", section: "basic", keywords: ["plain", "p"], variant: "body", mono: false, multiline: true, placeholder: "Type '/' for commands" },
+  { type: "page", label: "Page", icon: "page", section: "basic", keywords: ["sub", "child", "doc"], variant: "body", mono: false, multiline: false, placeholder: "Untitled" },
+  { type: "heading", label: "Heading 1", icon: "h1", section: "basic", keywords: ["h1", "title", "#"], variant: "title", mono: false, multiline: false, placeholder: "Heading 1", mdPrefixes: ["# "] },
+  { type: "subheading", label: "Heading 2", icon: "h2", section: "basic", keywords: ["h2", "h3", "sub", "##"], variant: "heading", mono: false, multiline: false, placeholder: "Heading 2", mdPrefixes: ["## ", "### "] },
+  { type: "todo", label: "To-do list", icon: "square", section: "list", keywords: ["check", "checkbox", "task", "[]"], variant: "body", mono: false, multiline: false, placeholder: "To-do", mdPrefixes: ["[] ", "[ ] "] },
+  { type: "bulleted", label: "Bulleted list", icon: "list-bullet", section: "list", keywords: ["ul", "bullet", "unordered", "-"], variant: "body", mono: false, multiline: false, placeholder: "List item", mdPrefixes: ["- ", "* "] },
+  { type: "numbered", label: "Numbered list", icon: "list-number", section: "list", keywords: ["ol", "ordered", "1."], variant: "body", mono: false, multiline: false, placeholder: "List item" },
+  { type: "toggle", label: "Toggle", icon: "toggle-chev", section: "list", keywords: ["collapse", "expand", "details"], variant: "body", mono: false, multiline: false, placeholder: "Toggle" },
+  { type: "quote", label: "Quote", icon: "quote-mark", section: "other", keywords: ["blockquote", "cite", ">"], variant: "body", mono: false, multiline: true, placeholder: "Quote", mdPrefixes: ["> "] },
+  { type: "code", label: "Code", icon: "code-block", section: "other", keywords: ["snippet", "mono", "```"], variant: "callout", mono: true, multiline: true, placeholder: "Code", mdPrefixes: ["``` ", "```"] },
+  { type: "divider", label: "Divider", icon: "minus", section: "other", keywords: ["rule", "hr", "separator", "---"], variant: "body", mono: false, multiline: false, placeholder: "", mdPrefixes: ["--- ", "---"] },
+  { type: "image", label: "Image", icon: "image", section: "other", keywords: ["picture", "photo", "img", "upload"], variant: "body", mono: false, multiline: false, placeholder: "" },
+  { type: "file", label: "File", icon: "paperclip", section: "other", keywords: ["attachment", "upload", "pdf", "doc", "attach"], variant: "body", mono: false, multiline: false, placeholder: "" },
+  { type: "bookmark", label: "Web bookmark", icon: "link", section: "other", keywords: ["url", "link", "bookmark", "embed", "web"], variant: "body", mono: false, multiline: false, placeholder: "Paste a link\u2026" },
+  { type: "table", label: "Table", icon: "table", section: "other", keywords: ["table", "grid", "database", "db", "rows", "columns"], variant: "body", mono: false, multiline: false, placeholder: "" }
+];
+var BY_TYPE = BLOCK_TYPES.reduce(
+  (acc, def) => {
+    acc[def.type] = def;
+    return acc;
+  },
+  {}
+);
+function blockDef(type) {
+  return BY_TYPE[type] ?? BY_TYPE.paragraph;
+}
+var labelFor = (type) => blockDef(type).label;
+var iconFor = (type) => blockDef(type).icon;
+var variantFor = (type) => blockDef(type).variant;
+var monoFor = (type) => blockDef(type).mono;
+var isMultiline = (type) => blockDef(type).multiline;
+var placeholderFor = (type) => blockDef(type).placeholder;
+var CONTINUES = /* @__PURE__ */ new Set(["todo", "bulleted", "numbered", "toggle"]);
+function continuationType(type) {
+  return CONTINUES.has(type) ? type : "paragraph";
+}
+function endsListOnEmptyEnter(type) {
+  return CONTINUES.has(type);
+}
+var MD_PREFIXES = [
+  ...BLOCK_TYPES.flatMap((def) => (def.mdPrefixes ?? []).map((prefix) => ({ prefix, type: def.type }))),
+  { prefix: "[x] ", type: "todo", checked: true },
+  { prefix: "[X] ", type: "todo", checked: true }
+].sort((a, b) => b.prefix.length - a.prefix.length);
+var NUMBERED_MD = /^\d+[.)] /;
+function mdShortcut(text) {
+  for (const m of MD_PREFIXES) {
+    if (text.startsWith(m.prefix)) return { type: m.type, rest: text.slice(m.prefix.length), checked: m.checked };
+  }
+  const num = NUMBERED_MD.exec(text);
+  if (num) return { type: "numbered", rest: text.slice(num[0].length) };
+  return void 0;
+}
+function filterBlockTypes(query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return BLOCK_TYPES;
+  return BLOCK_TYPES.filter(
+    (def) => def.label.toLowerCase().includes(q) || def.keywords.some((k) => k.toLowerCase().startsWith(q))
+  );
+}
+function listOrdinals(blocks) {
+  const ordinals = /* @__PURE__ */ new Map();
+  const counters = [];
+  for (const b of blocks) {
+    const ind = b.indent ?? 0;
+    if (b.type === "numbered") {
+      counters[ind] = (counters[ind] ?? 0) + 1;
+      ordinals.set(b.id, counters[ind]);
+      counters.length = ind + 1;
+    } else {
+      counters.length = ind;
+    }
+  }
+  return ordinals;
+}
+
+// src/object-content-model.ts
+var PAGE_SCHEMA = {
+  collections: [
+    {
+      listKey: "order",
+      fields: [
+        { key: "text", kind: "charRga" },
+        { key: "type", kind: "lww" },
+        { key: "checked", kind: "lww" },
+        { key: "indent", kind: "lww" },
+        { key: "collapsed", kind: "lww" },
+        { key: "ref", kind: "lww" }
+      ]
+    }
+  ]
+};
+var BOARD_SCHEMA = {
+  collections: [
+    {
+      listKey: "columns",
+      fields: [
+        { key: "coltitle", kind: "lww" },
+        { key: "coldone", kind: "lww" }
+      ]
+    },
+    {
+      listKey: "tasks",
+      fields: [
+        { key: "task", kind: "lww" }
+        // task:{id}:col / :order / :status / :title / :notes
+      ]
+    }
+  ]
+};
+var CALENDAR_SCHEMA = {
+  collections: [
+    {
+      listKey: "events",
+      fields: [
+        { key: "etitle", kind: "charRga" },
+        { key: "estart", kind: "lww" },
+        { key: "eend", kind: "lww" },
+        { key: "eallDay", kind: "lww" },
+        { key: "ecolor", kind: "lww" },
+        { key: "edesc", kind: "lww" }
+      ]
+    }
+  ]
+};
+var FORM_SCHEMA = {
+  collections: [
+    {
+      listKey: "fields",
+      fields: [
+        { key: "flabel", kind: "charRga" },
+        { key: "fkind", kind: "lww" },
+        { key: "frequired", kind: "lww" },
+        { key: "foptions", kind: "lww" }
+      ]
+    },
+    {
+      listKey: "responses",
+      fields: [
+        { key: "rsubmittedAt", kind: "lww" },
+        { key: "rsubmitter", kind: "lww" },
+        { key: "rdata", kind: "lww" }
+      ]
+    }
+  ]
+};
+var FEEDBACK_SCHEMA = {
+  collections: [
+    {
+      listKey: "items",
+      fields: [
+        { key: "ititle", kind: "charRga" },
+        { key: "istatus", kind: "lww" },
+        { key: "idesc", kind: "lww" },
+        // Per-voter LWW toggle registers: `ivote:{itemId}:{userId}` (boolean true).
+        // Cross-voter concurrent votes commute; same-voter vote vs unvote is LWW.
+        { key: "ivote", kind: "lww" }
+      ]
+    }
+  ]
+};
+function schemaFor(editorKind) {
+  switch (editorKind) {
+    case "page":
+      return PAGE_SCHEMA;
+    case "board":
+      return BOARD_SCHEMA;
+    case "calendar":
+      return CALENDAR_SCHEMA;
+    case "form":
+      return FORM_SCHEMA;
+    case "feedback":
+      return FEEDBACK_SCHEMA;
+    default:
+      return null;
+  }
+}
+
+// src/wal-helpers.ts
+function strArray(value) {
+  return Array.isArray(value) ? value.filter((x) => typeof x === "string") : [];
+}
+function rgaList(doc, key) {
+  return strArray(doc.materialize()[key]);
+}
+function dedupRgaList(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  if (Array.isArray(value)) {
+    for (const raw of value) {
+      if (typeof raw !== "string" || seen.has(raw)) continue;
+      seen.add(raw);
+      out.push(raw);
+    }
+  }
+  return out;
+}
+var asStr = (v) => typeof v === "string" ? v : "";
+var asNum = (v, fallback) => typeof v === "number" ? v : fallback;
+var asBool = (v) => typeof v === "boolean" ? v : void 0;
+var asStrOrNull = (v) => typeof v === "string" ? v : null;
+var asObj = (v) => v != null && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+function deleteFieldsByPrefix(doc, prefix) {
+  for (const key of Object.keys(doc.materialize())) {
+    if (key.startsWith(prefix)) doc.deleteField(key);
+  }
+}
+
+// src/page-content.ts
+var REF_BLOCK_TYPES = /* @__PURE__ */ new Set(["page", "image", "file"]);
+var ORDER = "order";
+var typeReg = (id) => `type:${id}`;
+var checkedReg = (id) => `checked:${id}`;
+var indentReg = (id) => `indent:${id}`;
+var collapsedReg = (id) => `collapsed:${id}`;
+var refReg = (id) => `ref:${id}`;
+var bookmarkReg = (id) => `bookmark:${id}`;
+var textList = (id) => `text:${id}`;
+function readBlocks(doc) {
+  const state = doc.materialize();
+  const blocks = [];
+  for (const raw of dedupRgaList(state[ORDER])) {
+    const type = state[typeReg(raw)] ?? "paragraph";
+    const indentVal = state[indentReg(raw)];
+    const refVal = state[refReg(raw)];
+    blocks.push({
+      id: raw,
+      type,
+      text: doc.text(textList(raw)),
+      checked: asBool(state[checkedReg(raw)]),
+      // Clamp a concurrent-merge artifact (negative indent) rather than render off-canvas.
+      indent: typeof indentVal === "number" && indentVal > 0 ? Math.floor(indentVal) : void 0,
+      collapsed: asBool(state[collapsedReg(raw)]),
+      ref: typeof refVal === "string" ? refVal : void 0,
+      bookmark: asObj(state[bookmarkReg(raw)])
+    });
+  }
+  return blocks;
+}
+function visibleBlocks(blocks) {
+  const out = [];
+  let hideDeeperThan = null;
+  for (const b of blocks) {
+    const ind = b.indent ?? 0;
+    if (hideDeeperThan !== null && ind > hideDeeperThan) continue;
+    hideDeeperThan = null;
+    out.push(b);
+    if (b.type === "toggle" && b.collapsed) hideDeeperThan = ind;
+  }
+  return out;
+}
+function insertBlock(doc, index, init = {}) {
+  const id = randomId();
+  doc.setField(typeReg(id), init.type ?? "paragraph");
+  if (init.text) doc.setText(textList(id), init.text);
+  if (init.checked !== void 0) doc.setField(checkedReg(id), init.checked);
+  if (init.indent) doc.setField(indentReg(id), init.indent);
+  if (init.ref) doc.setField(refReg(id), init.ref);
+  const order = rgaList(doc, ORDER);
+  const at = Math.max(0, Math.min(index, order.length));
+  doc.setList(ORDER, [...order.slice(0, at), id, ...order.slice(at)]);
+  return id;
+}
+function appendBlock(doc, init = {}) {
+  return insertBlock(doc, rgaList(doc, ORDER).length, init);
+}
+function setBlockText(doc, id, text) {
+  doc.setText(textList(id), text);
+}
+function setBlockType(doc, id, type) {
+  doc.setField(typeReg(id), type);
+}
+function setBlockChecked(doc, id, checked) {
+  doc.setField(checkedReg(id), checked);
+}
+function setBlockIndent(doc, id, indent) {
+  const v = Math.max(0, Math.floor(indent));
+  if (v === 0) doc.deleteField(indentReg(id));
+  else doc.setField(indentReg(id), v);
+}
+function setBlockCollapsed(doc, id, collapsed) {
+  doc.setField(collapsedReg(id), collapsed);
+}
+function setBlockRef(doc, id, ref) {
+  doc.setField(refReg(id), ref);
+}
+function removeBlock(doc, id) {
+  doc.setList(ORDER, rgaList(doc, ORDER).filter((x) => x !== id));
+  doc.setText(textList(id), "");
+  doc.deleteField(typeReg(id));
+  doc.deleteField(checkedReg(id));
+  doc.deleteField(indentReg(id));
+  doc.deleteField(collapsedReg(id));
+  doc.deleteField(refReg(id));
+  doc.deleteField(bookmarkReg(id));
+}
+function moveBlock(doc, id, toIndex) {
+  const order = rgaList(doc, ORDER).filter((x) => x !== id);
+  const at = Math.max(0, Math.min(toIndex, order.length));
+  order.splice(at, 0, id);
+  doc.setList(ORDER, order);
+}
+function splitBlock(doc, id, head, init = {}) {
+  const order = rgaList(doc, ORDER);
+  const at = order.indexOf(id);
+  if (at < 0) return null;
+  doc.setText(textList(id), head);
+  return insertBlock(doc, at + 1, init);
+}
+function mergeBlockIntoPrevious(doc, id, textOverride) {
+  const order = rgaList(doc, ORDER);
+  const at = order.indexOf(id);
+  if (at <= 0) return null;
+  const prevId = order[at - 1];
+  const prevText = doc.text(textList(prevId));
+  const tail = textOverride ?? doc.text(textList(id));
+  if (tail) doc.setText(textList(prevId), prevText + tail);
+  removeBlock(doc, id);
+  return { prevId, offset: prevText.length };
+}
+function duplicateBlock(doc, id) {
+  const order = rgaList(doc, ORDER);
+  const at = order.indexOf(id);
+  if (at < 0) return null;
+  const state = doc.materialize();
+  const checkedVal = state[checkedReg(id)];
+  const indentVal = state[indentReg(id)];
+  const refVal = state[refReg(id)];
+  const newId = insertBlock(doc, at + 1, {
+    type: state[typeReg(id)] ?? "paragraph",
+    text: doc.text(textList(id)),
+    checked: typeof checkedVal === "boolean" ? checkedVal : void 0,
+    indent: typeof indentVal === "number" ? indentVal : void 0,
+    ref: typeof refVal === "string" ? refVal : void 0
+  });
+  const bkVal = state[bookmarkReg(id)];
+  if (bkVal && typeof bkVal === "object" && !Array.isArray(bkVal)) {
+    doc.setField(bookmarkReg(newId), bkVal);
+  }
+  return newId;
+}
+function restoreBlock(doc, index, block) {
+  doc.setField(typeReg(block.id), block.type);
+  if (block.text) doc.setText(textList(block.id), block.text);
+  if (block.checked !== void 0) doc.setField(checkedReg(block.id), block.checked);
+  if (block.indent) doc.setField(indentReg(block.id), block.indent);
+  if (block.collapsed !== void 0) doc.setField(collapsedReg(block.id), block.collapsed);
+  if (block.ref) doc.setField(refReg(block.id), block.ref);
+  if (block.bookmark) doc.setField(bookmarkReg(block.id), block.bookmark);
+  const order = rgaList(doc, ORDER).filter((x) => x !== block.id);
+  const at = Math.max(0, Math.min(index, order.length));
+  doc.setList(ORDER, [...order.slice(0, at), block.id, ...order.slice(at)]);
+}
+function setBlockBookmark(doc, id, meta) {
+  doc.setField(bookmarkReg(id), meta);
+}
+
+// src/comments-content.ts
+var COMMENTS_PREFIX = "comments:";
+var REACT_PREFIX = "react:";
+var commentsList = (blockId) => `${COMMENTS_PREFIX}${blockId}`;
+var authorReg = (commentId) => `author:${commentId}`;
+var createdReg = (commentId) => `created:${commentId}`;
+var bodyList = (commentId) => `body:${commentId}`;
+var resolvedReg = (blockId) => `resolved:${blockId}`;
+var reactReg = (commentId, userId) => `${REACT_PREFIX}${commentId}:${userId}`;
+function commentIds(state, blockId) {
+  return dedupRgaList(state[commentsList(blockId)]);
+}
+function readReactions(state, commentId) {
+  const prefix = `${REACT_PREFIX}${commentId}:`;
+  const groups = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(state)) {
+    if (!key.startsWith(prefix)) continue;
+    const userId = key.slice(prefix.length);
+    for (const emoji of strArray(state[key])) {
+      const arr = groups.get(emoji) ?? [];
+      if (!arr.includes(userId)) arr.push(userId);
+      groups.set(emoji, arr);
+    }
+  }
+  const out = [];
+  for (const [emoji, userIds] of groups) {
+    if (userIds.length > 0) out.push({ emoji, userIds: userIds.sort() });
+  }
+  return out;
+}
+function readComment(doc, state, id) {
+  const createdVal = state[createdReg(id)];
+  const authorVal = state[authorReg(id)];
+  return {
+    id,
+    author: typeof authorVal === "string" ? authorVal : "",
+    createdAt: typeof createdVal === "number" ? createdVal : 0,
+    body: doc.text(bodyList(id)),
+    reactions: readReactions(state, id)
+  };
+}
+function readThread(doc, blockId) {
+  const state = doc.materialize();
+  return {
+    blockId,
+    resolved: state[resolvedReg(blockId)] === true,
+    comments: commentIds(state, blockId).map((id) => readComment(doc, state, id))
+  };
+}
+function readThreads(doc) {
+  const state = doc.materialize();
+  const threads = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(state)) {
+    if (!key.startsWith(COMMENTS_PREFIX)) continue;
+    const blockId = key.slice(COMMENTS_PREFIX.length);
+    const liveIds = commentIds(state, blockId);
+    if (liveIds.length === 0) continue;
+    threads.set(blockId, {
+      blockId,
+      resolved: state[resolvedReg(blockId)] === true,
+      comments: liveIds.map((id) => readComment(doc, state, id))
+    });
+  }
+  return threads;
+}
+function threadLastActivity(thread) {
+  return thread.comments.reduce((max, c) => c.createdAt > max ? c.createdAt : max, 0);
+}
+function addComment(doc, blockId, authorUserId, text, createdAt = Date.now()) {
+  const id = randomId();
+  doc.setField(authorReg(id), authorUserId);
+  doc.setField(createdReg(id), createdAt);
+  if (text) doc.setText(bodyList(id), text);
+  doc.push(commentsList(blockId), id);
+  return id;
+}
+function setCommentBody(doc, commentId, text) {
+  doc.setText(bodyList(commentId), text);
+}
+function removeComment(doc, blockId, commentId) {
+  const state = doc.materialize();
+  doc.setList(commentsList(blockId), commentIds(state, blockId).filter((x) => x !== commentId));
+  doc.setText(bodyList(commentId), "");
+  doc.deleteField(authorReg(commentId));
+  doc.deleteField(createdReg(commentId));
+  deleteFieldsByPrefix(doc, `${REACT_PREFIX}${commentId}:`);
+}
+function resolveThread(doc, blockId, resolved) {
+  if (resolved) doc.setField(resolvedReg(blockId), true);
+  else doc.deleteField(resolvedReg(blockId));
+}
+function toggleReaction(doc, commentId, userId, emoji) {
+  const current = strArray(doc.materialize()[reactReg(commentId, userId)]);
+  const next = current.includes(emoji) ? current.filter((e) => e !== emoji) : [...current, emoji];
+  if (next.length === 0) doc.deleteField(reactReg(commentId, userId));
+  else doc.setField(reactReg(commentId, userId), next);
+}
+
+// src/board-content.ts
+var COLS = "columns";
+var colTitle = (id) => `coltitle:${id}`;
+var colDone = (id) => `coldone:${id}`;
+function readColumns(doc) {
+  const state = doc.materialize();
+  const columns = [];
+  for (const raw of dedupRgaList(state[COLS])) {
+    columns.push({ id: raw, title: asStr(state[colTitle(raw)]), done: state[colDone(raw)] === true });
+  }
+  return columns;
+}
+function orderBetween(above, below) {
+  if (above !== void 0 && below !== void 0) return (above + below) / 2;
+  if (below !== void 0) return below - 1;
+  if (above !== void 0) return above + 1;
+  return 1;
+}
+function addColumn(doc, title) {
+  const id = randomId();
+  doc.setField(colTitle(id), title);
+  doc.push(COLS, id);
+  return id;
+}
+function renameColumn(doc, id, title) {
+  doc.setField(colTitle(id), title);
+}
+function setColumnDone(doc, id, done) {
+  doc.setField(colDone(id), done);
+}
+function moveColumn(doc, id, toIndex) {
+  const cur = rgaList(doc, COLS).filter((x, i, a) => a.indexOf(x) === i);
+  const from = cur.indexOf(id);
+  if (from === -1) return;
+  const next = cur.filter((x) => x !== id);
+  next.splice(Math.max(0, Math.min(toIndex, next.length)), 0, id);
+  doc.setList(COLS, next);
+}
+function deleteColumn(doc, id) {
+  doc.setList(COLS, rgaList(doc, COLS).filter((x) => x !== id));
+  doc.deleteField(colTitle(id));
+  doc.deleteField(colDone(id));
+}
+function seedDefaultColumns(doc) {
+  addColumn(doc, "To do");
+  addColumn(doc, "In progress");
+  setColumnDone(doc, addColumn(doc, "Done"), true);
+}
+
+// src/table-content.ts
+var tblCols = (T) => `tblcols:${T}`;
+var tblRows = (T) => `tblrows:${T}`;
+var tblSort = (T) => `tblsort:${T}`;
+var tblFilters = (T) => `tblfilters:${T}`;
+var tColTitle = (c) => `tcoltitle:${c}`;
+var tColType = (c) => `tcoltype:${c}`;
+var tColOpts = (c) => `tcolopts:${c}`;
+var tColWidth = (c) => `tcolwidth:${c}`;
+var tCell = (r, c) => `tcell:${r}:${c}`;
+var colIdsOf = (doc, T) => rgaList(doc, tblCols(T));
+var rowIdsOf = (doc, T) => rgaList(doc, tblRows(T));
+function readTable(doc, T) {
+  const state = doc.materialize();
+  const columns = [];
+  for (const raw of dedupRgaList(state[tblCols(T)])) {
+    const optsRaw = state[tColOpts(raw)];
+    const options = Array.isArray(optsRaw) ? optsRaw.filter((o) => typeof o === "object" && o !== null && !Array.isArray(o)).map((o) => ({
+      id: asStr(o["id"]),
+      label: asStr(o["label"]),
+      swatch: asStr(o["swatch"]) || "gray"
+    })) : void 0;
+    const widthRaw = state[tColWidth(raw)];
+    const typeRaw = state[tColType(raw)];
+    const colType = ["text", "number", "select", "checkbox"].includes(typeRaw) ? typeRaw : "text";
+    columns.push({
+      id: raw,
+      title: asStr(state[tColTitle(raw)]),
+      type: colType,
+      options: options?.length ? options : void 0,
+      width: typeof widthRaw === "number" ? widthRaw : void 0
+    });
+  }
+  const rowIds = dedupRgaList(state[tblRows(T)]);
+  const cells = {};
+  for (const r of rowIds) {
+    for (const col of columns) {
+      const v = state[tCell(r, col.id)];
+      if (v !== void 0 && v !== null) {
+        cells[`${r}:${col.id}`] = v;
+      }
+    }
+  }
+  const sortRaw = state[tblSort(T)];
+  const sort = sortRaw !== null && typeof sortRaw === "object" && !Array.isArray(sortRaw) && typeof sortRaw["colId"] === "string" && (sortRaw["dir"] === "asc" || sortRaw["dir"] === "desc") ? {
+    colId: sortRaw["colId"],
+    dir: sortRaw["dir"]
+  } : null;
+  const filtersRaw = state[tblFilters(T)];
+  const filters = filtersRaw !== null && typeof filtersRaw === "object" && !Array.isArray(filtersRaw) ? filtersRaw : {};
+  return { columns, rowIds, cells, sort, filters };
+}
+function visibleTableRowIds(model) {
+  const { columns, rowIds: ids, cells, sort, filters } = model;
+  const colMap = new Map(columns.map((c) => [c.id, c]));
+  let visible = ids;
+  for (const [colId, filter] of Object.entries(filters)) {
+    const col = colMap.get(colId);
+    if (!col) continue;
+    visible = visible.filter((r) => {
+      const v = cells[`${r}:${colId}`] ?? null;
+      switch (filter.kind) {
+        case "contains":
+          return String(v ?? "").toLowerCase().includes(filter.text.toLowerCase());
+        case "numRange": {
+          const n = typeof v === "number" ? v : parseFloat(String(v ?? ""));
+          if (isNaN(n)) return false;
+          if (filter.min !== void 0 && n < filter.min) return false;
+          if (filter.max !== void 0 && n > filter.max) return false;
+          return true;
+        }
+        case "isOption":
+          return filter.optionIds.length === 0 || filter.optionIds.includes(String(v ?? ""));
+        case "checked":
+          return (v === true || v === "true") === filter.value;
+      }
+    });
+  }
+  if (sort) {
+    const col = colMap.get(sort.colId);
+    if (col) {
+      const optOrder = new Map(
+        col.options ? col.options.map((o, i) => [o.id, i]) : []
+      );
+      visible = [...visible].sort((a, b) => {
+        const av = cells[`${a}:${sort.colId}`] ?? null;
+        const bv = cells[`${b}:${sort.colId}`] ?? null;
+        let cmp = 0;
+        switch (col.type) {
+          case "number": {
+            const an = typeof av === "number" ? av : parseFloat(String(av ?? ""));
+            const bn = typeof bv === "number" ? bv : parseFloat(String(bv ?? ""));
+            if (isNaN(an) && isNaN(bn)) {
+              cmp = 0;
+              break;
+            }
+            if (isNaN(an)) {
+              cmp = 1;
+              break;
+            }
+            if (isNaN(bn)) {
+              cmp = -1;
+              break;
+            }
+            cmp = an - bn;
+            break;
+          }
+          case "select": {
+            const ai = optOrder.get(String(av ?? "")) ?? Infinity;
+            const bi = optOrder.get(String(bv ?? "")) ?? Infinity;
+            cmp = ai - bi;
+            break;
+          }
+          case "checkbox": {
+            cmp = (av === true ? 1 : 0) - (bv === true ? 1 : 0);
+            break;
+          }
+          default:
+            cmp = String(av ?? "").localeCompare(String(bv ?? ""));
+        }
+        if (cmp !== 0) return sort.dir === "asc" ? cmp : -cmp;
+        return a < b ? -1 : a > b ? 1 : 0;
+      });
+    }
+  }
+  return visible;
+}
+function createTable(doc, T) {
+  const nameId = randomId();
+  const statusId = randomId();
+  const notesId = randomId();
+  const statusOpts = [
+    { id: randomId(), label: "Not started", swatch: "gray" },
+    { id: randomId(), label: "In progress", swatch: "blue" },
+    { id: randomId(), label: "Done", swatch: "green" }
+  ];
+  doc.setField(tColTitle(nameId), "Name");
+  doc.setField(tColType(nameId), "text");
+  doc.setField(tColTitle(statusId), "Status");
+  doc.setField(tColType(statusId), "select");
+  doc.setField(tColOpts(statusId), statusOpts);
+  doc.setField(tColTitle(notesId), "Notes");
+  doc.setField(tColType(notesId), "text");
+  doc.setList(tblCols(T), [nameId, statusId, notesId]);
+  const r1 = randomId();
+  const r2 = randomId();
+  doc.setList(tblRows(T), [r1, r2]);
+}
+function addTableColumn(doc, T, type, title) {
+  const id = randomId();
+  doc.setField(tColTitle(id), title);
+  doc.setField(tColType(id), type);
+  if (type === "select") {
+    doc.setField(tColOpts(id), [{ id: randomId(), label: "Option 1", swatch: "gray" }]);
+  }
+  doc.push(tblCols(T), id);
+  return id;
+}
+function renameTableColumn(doc, id, title) {
+  doc.setField(tColTitle(id), title);
+}
+function setTableColumnType(doc, id, type) {
+  doc.setField(tColType(id), type);
+  if (type === "select") {
+    const cur = doc.materialize()[tColOpts(id)];
+    if (!Array.isArray(cur) || cur.length === 0) {
+      doc.setField(tColOpts(id), [{ id: randomId(), label: "Option 1", swatch: "gray" }]);
+    }
+  }
+}
+function setTableColumnOptions(doc, id, options) {
+  doc.setField(tColOpts(id), options);
+}
+function addTableSelectOption(doc, colId, label, swatch = "gray") {
+  const state = doc.materialize();
+  const cur = Array.isArray(state[tColOpts(colId)]) ? state[tColOpts(colId)] : [];
+  doc.setField(tColOpts(colId), [...cur, { id: randomId(), label, swatch }]);
+}
+function removeTableSelectOption(doc, colId, optionId) {
+  const state = doc.materialize();
+  const cur = Array.isArray(state[tColOpts(colId)]) ? state[tColOpts(colId)] : [];
+  doc.setField(tColOpts(colId), cur.filter((o) => o.id !== optionId));
+}
+function setTableColumnWidth(doc, colId, width) {
+  doc.setField(tColWidth(colId), width);
+}
+function moveTableColumn(doc, T, id, toIndex) {
+  const cur = colIdsOf(doc, T).filter((x, i, a) => a.indexOf(x) === i);
+  if (!cur.includes(id)) return;
+  const next = cur.filter((x) => x !== id);
+  next.splice(Math.max(0, Math.min(toIndex, next.length)), 0, id);
+  doc.setList(tblCols(T), next);
+}
+function deleteTableColumn(doc, T, id) {
+  const curRowIds = rowIdsOf(doc, T);
+  doc.setList(tblCols(T), colIdsOf(doc, T).filter((x) => x !== id));
+  doc.deleteField(tColTitle(id));
+  doc.deleteField(tColType(id));
+  doc.deleteField(tColOpts(id));
+  doc.deleteField(tColWidth(id));
+  for (const r of curRowIds) doc.deleteField(tCell(r, id));
+}
+function addTableRow(doc, T, atIndex) {
+  const id = randomId();
+  const cur = rowIdsOf(doc, T);
+  if (atIndex !== void 0) {
+    const at = Math.max(0, Math.min(atIndex, cur.length));
+    doc.setList(tblRows(T), [...cur.slice(0, at), id, ...cur.slice(at)]);
+  } else {
+    doc.push(tblRows(T), id);
+  }
+  return id;
+}
+function moveTableRow(doc, T, id, toIndex) {
+  const cur = rowIdsOf(doc, T).filter((x, i, a) => a.indexOf(x) === i);
+  if (!cur.includes(id)) return;
+  const next = cur.filter((x) => x !== id);
+  next.splice(Math.max(0, Math.min(toIndex, next.length)), 0, id);
+  doc.setList(tblRows(T), next);
+}
+function duplicateTableRow(doc, T, id) {
+  const cur = rowIdsOf(doc, T);
+  const at = cur.indexOf(id);
+  const insertAt = at >= 0 ? at + 1 : cur.length;
+  const newId = randomId();
+  doc.setList(tblRows(T), [...cur.slice(0, insertAt), newId, ...cur.slice(insertAt)]);
+  const state = doc.materialize();
+  for (const c of colIdsOf(doc, T)) {
+    const v = state[tCell(id, c)];
+    if (v !== void 0 && v !== null) doc.setField(tCell(newId, c), v);
+  }
+  return newId;
+}
+function deleteTableRow(doc, T, id) {
+  const curColIds = colIdsOf(doc, T);
+  doc.setList(tblRows(T), rowIdsOf(doc, T).filter((x) => x !== id));
+  for (const c of curColIds) doc.deleteField(tCell(id, c));
+}
+function setTableCell(doc, r, c, value) {
+  if (value === null || value === void 0) {
+    doc.deleteField(tCell(r, c));
+  } else {
+    doc.setField(tCell(r, c), value);
+  }
+}
+function setTableSort(doc, T, colId, dir) {
+  doc.setField(tblSort(T), { colId, dir });
+}
+function clearTableSort(doc, T) {
+  doc.deleteField(tblSort(T));
+}
+function setTableFilter(doc, T, colId, filter) {
+  const state = doc.materialize();
+  const cur = state[tblFilters(T)] !== null && typeof state[tblFilters(T)] === "object" && !Array.isArray(state[tblFilters(T)]) ? { ...state[tblFilters(T)] } : {};
+  cur[colId] = filter;
+  doc.setField(tblFilters(T), cur);
+}
+function clearTableFilter(doc, T, colId) {
+  const state = doc.materialize();
+  const cur = state[tblFilters(T)] !== null && typeof state[tblFilters(T)] === "object" && !Array.isArray(state[tblFilters(T)]) ? { ...state[tblFilters(T)] } : {};
+  delete cur[colId];
+  if (Object.keys(cur).length === 0) {
+    doc.deleteField(tblFilters(T));
+  } else {
+    doc.setField(tblFilters(T), cur);
+  }
+}
+function clearAllTableFilters(doc, T) {
+  doc.deleteField(tblFilters(T));
+}
+function clearTable(doc, T) {
+  const curColIds = colIdsOf(doc, T);
+  const curRowIds = rowIdsOf(doc, T);
+  for (const c of curColIds) {
+    doc.deleteField(tColTitle(c));
+    doc.deleteField(tColType(c));
+    doc.deleteField(tColOpts(c));
+    doc.deleteField(tColWidth(c));
+    for (const r of curRowIds) doc.deleteField(tCell(r, c));
+  }
+  doc.setList(tblCols(T), []);
+  doc.setList(tblRows(T), []);
+  doc.deleteField(tblSort(T));
+  doc.deleteField(tblFilters(T));
+}
+function propsOf(node) {
+  const meta = node.meta;
+  if (!meta || typeof meta.props !== "object" || meta.props === null) return {};
+  return meta.props;
+}
+function automationOf(node) {
+  return node.meta?.automation ?? null;
+}
+function addVaultObject(nodes, input, now) {
+  const meta = { ...input.meta };
+  if (input.props && Object.keys(input.props).length > 0) meta.props = input.props;
+  if (input.automation) meta.automation = input.automation;
+  return addObject(nodes, {
+    type: input.type,
+    parentId: input.parentId,
+    title: input.title,
+    emoji: input.emoji,
+    id: input.id,
+    access: input.access,
+    enc: input.enc,
+    ...Object.keys(meta).length > 0 ? { meta } : {}
+  }, now);
+}
+function setProps(nodes, id, patch, now) {
+  return nodes.map((n) => {
+    if (n.id !== id) return n;
+    const existingProps = propsOf(n);
+    const newMeta = { ...n.meta ?? {}, props: { ...existingProps, ...patch } };
+    return { ...n, meta: newMeta, updatedAt: now };
+  });
+}
+function clearProp(nodes, id, key, now) {
+  return nodes.map((n) => {
+    if (n.id !== id) return n;
+    const existingProps = { ...propsOf(n) };
+    delete existingProps[key];
+    const newMeta = { ...n.meta ?? {}, props: existingProps };
+    return { ...n, meta: newMeta, updatedAt: now };
+  });
+}
+function patchAutomation(nodes, id, automation, now) {
+  return nodes.map((n) => {
+    if (n.id !== id) return n;
+    const newMeta = { ...n.meta ?? {} };
+    if (automation !== null) {
+      newMeta.automation = automation;
+    } else {
+      delete newMeta.automation;
+    }
+    return { ...n, meta: newMeta, updatedAt: now };
+  });
+}
+
+// src/task-model.ts
+function tasksForBoard(nodes, boardId, columns) {
+  const colSet = new Set(columns.map((c) => c.id));
+  const hasDoneCol = columns.some((c) => c.done);
+  const doneColIds = new Set(columns.filter((c) => c.done).map((c) => c.id));
+  const firstCol = columns[0]?.id ?? "";
+  const tasks = [];
+  for (const node of nodes) {
+    if (node.archived || node.type !== "task" || node.parentId !== boardId) continue;
+    const props = propsOf(node);
+    let columnId = props.columnId ?? "";
+    if (!colSet.has(columnId)) columnId = firstCol;
+    const statusRaw = props.status;
+    const status = statusRaw === "doing" || statusRaw === "done" ? statusRaw : "todo";
+    const order = typeof props.order === "number" ? props.order : 0;
+    const done = hasDoneCol ? doneColIds.has(columnId) : status === "done";
+    tasks.push({ id: node.id, columnId, title: node.title ?? "", status, order, done });
+  }
+  const tasksByColumn = {};
+  for (const col of columns) {
+    tasksByColumn[col.id] = tasks.filter((t) => t.columnId === col.id).sort((a, b) => a.order - b.order || (a.id < b.id ? -1 : 1));
+  }
+  const visible = tasks.filter((t) => !!t.columnId);
+  const doneCount = visible.filter((t) => t.done).length;
+  return { tasksByColumn, done: doneCount, total: visible.length };
+}
+
+// src/calendar-content.ts
+var EVENTS = "events";
+var startReg = (id) => `estart:${id}`;
+var endReg = (id) => `eend:${id}`;
+var allDayReg = (id) => `eallDay:${id}`;
+var colorReg = (id) => `ecolor:${id}`;
+var descReg = (id) => `edesc:${id}`;
+var titleList = (id) => `etitle:${id}`;
+function readEvents(doc) {
+  const state = doc.materialize();
+  const events = [];
+  for (const raw of dedupRgaList(state[EVENTS])) {
+    const start = asNum(state[startReg(raw)], 0);
+    const end = asNum(state[endReg(raw)], start);
+    events.push({
+      id: raw,
+      title: doc.text(titleList(raw)),
+      start,
+      end,
+      allDay: state[allDayReg(raw)] === true,
+      color: asStrOrNull(state[colorReg(raw)]),
+      desc: asStrOrNull(state[descReg(raw)])
+    });
+  }
+  return events.sort((a, b) => a.start - b.start);
+}
+function addEvent(doc, init) {
+  const id = randomId();
+  const order = rgaList(doc, EVENTS);
+  doc.setField(startReg(id), init.start);
+  doc.setField(endReg(id), init.end ?? init.start);
+  if (init.allDay) doc.setField(allDayReg(id), true);
+  if (init.color) doc.setField(colorReg(id), init.color);
+  if (init.desc) doc.setField(descReg(id), init.desc);
+  if (init.title) doc.setText(titleList(id), init.title);
+  doc.setList(EVENTS, [...order, id]);
+  return id;
+}
+function deleteEvent(doc, id) {
+  const order = rgaList(doc, EVENTS);
+  doc.setList(EVENTS, order.filter((x) => x !== id));
+  doc.setText(titleList(id), "");
+  doc.deleteField(startReg(id));
+  doc.deleteField(endReg(id));
+  doc.deleteField(allDayReg(id));
+  doc.deleteField(colorReg(id));
+  doc.deleteField(descReg(id));
+}
+function patchEvent(doc, id, patch) {
+  if (patch.start !== void 0) doc.setField(startReg(id), patch.start);
+  if (patch.end !== void 0) doc.setField(endReg(id), patch.end);
+  if (patch.allDay !== void 0) doc.setField(allDayReg(id), patch.allDay);
+  if (patch.color !== void 0) {
+    if (patch.color === null) doc.deleteField(colorReg(id));
+    else doc.setField(colorReg(id), patch.color);
+  }
+  if (patch.desc !== void 0) {
+    if (patch.desc === null) doc.deleteField(descReg(id));
+    else doc.setField(descReg(id), patch.desc);
+  }
+  if (patch.title !== void 0) doc.setText(titleList(id), patch.title);
+}
+
+// src/form-content.ts
+var FIELDS = "fields";
+var RESPONSES = "responses";
+var labelList = (id) => `flabel:${id}`;
+var kindReg = (id) => `fkind:${id}`;
+var requiredReg = (id) => `frequired:${id}`;
+var optionsReg = (id) => `foptions:${id}`;
+var submittedAtReg = (id) => `rsubmittedAt:${id}`;
+var submitterReg = (id) => `rsubmitter:${id}`;
+var dataReg = (id) => `rdata:${id}`;
+function safeParseJson(raw) {
+  if (typeof raw !== "string") return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readFields(doc) {
+  const state = doc.materialize();
+  const fields = [];
+  for (const raw of dedupRgaList(state[FIELDS])) {
+    fields.push({
+      id: raw,
+      label: doc.text(labelList(raw)),
+      kind: typeof state[kindReg(raw)] === "string" ? state[kindReg(raw)] : "text",
+      required: state[requiredReg(raw)] === true,
+      options: safeParseJson(state[optionsReg(raw)]) ?? []
+    });
+  }
+  return fields;
+}
+function readResponses(doc) {
+  const state = doc.materialize();
+  const responses = [];
+  for (const raw of dedupRgaList(state[RESPONSES])) {
+    responses.push({
+      id: raw,
+      submittedAt: asNum(state[submittedAtReg(raw)], 0),
+      submitter: asStr(state[submitterReg(raw)]),
+      data: safeParseJson(state[dataReg(raw)]) ?? {}
+    });
+  }
+  return responses;
+}
+function addField(doc, init = {}) {
+  const id = randomId();
+  const order = rgaList(doc, FIELDS);
+  doc.setField(kindReg(id), init.kind ?? "text");
+  if (init.required) doc.setField(requiredReg(id), true);
+  if (init.options?.length) doc.setField(optionsReg(id), JSON.stringify(init.options));
+  if (init.label) doc.setText(labelList(id), init.label);
+  doc.setList(FIELDS, [...order, id]);
+  return id;
+}
+function deleteField(doc, id) {
+  const order = rgaList(doc, FIELDS);
+  doc.setList(FIELDS, order.filter((x) => x !== id));
+  doc.setText(labelList(id), "");
+  doc.deleteField(kindReg(id));
+  doc.deleteField(requiredReg(id));
+  doc.deleteField(optionsReg(id));
+}
+function moveField(doc, id, toIndex) {
+  const order = rgaList(doc, FIELDS);
+  const without = order.filter((x) => x !== id);
+  const clamped = Math.max(0, Math.min(toIndex, without.length));
+  without.splice(clamped, 0, id);
+  doc.setList(FIELDS, without);
+}
+function patchField(doc, id, patch) {
+  if (patch.kind !== void 0) doc.setField(kindReg(id), patch.kind);
+  if (patch.required !== void 0) doc.setField(requiredReg(id), patch.required);
+  if (patch.options !== void 0) doc.setField(optionsReg(id), JSON.stringify(patch.options));
+  if (patch.label !== void 0) doc.setText(labelList(id), patch.label);
+}
+function addResponse(doc, submitter, data, now) {
+  const id = randomId();
+  const order = rgaList(doc, RESPONSES);
+  doc.setField(submittedAtReg(id), now);
+  doc.setField(submitterReg(id), submitter);
+  doc.setField(dataReg(id), JSON.stringify(data));
+  doc.setList(RESPONSES, [...order, id]);
+  return id;
+}
+
+// src/feedback-content.ts
+var ITEMS = "items";
+var titleList2 = (id) => `ititle:${id}`;
+var statusReg = (id) => `istatus:${id}`;
+var descReg2 = (id) => `idesc:${id}`;
+var voteKey = (itemId, userId) => `ivote:${itemId}:${userId}`;
+var votePrefix = (itemId) => `ivote:${itemId}:`;
+function readVoters(state, itemId) {
+  const prefix = votePrefix(itemId);
+  const voters = [];
+  for (const key of Object.keys(state)) {
+    if (key.startsWith(prefix) && state[key] === true) {
+      voters.push(key.slice(prefix.length));
+    }
+  }
+  return voters;
+}
+function readItems(doc) {
+  const state = doc.materialize();
+  const items = [];
+  for (const raw of dedupRgaList(state[ITEMS])) {
+    items.push({
+      id: raw,
+      title: doc.text(titleList2(raw)),
+      status: typeof state[statusReg(raw)] === "string" ? state[statusReg(raw)] : "open",
+      desc: asStrOrNull(state[descReg2(raw)]),
+      voters: readVoters(state, raw)
+    });
+  }
+  return items.sort((a, b) => b.voters.length - a.voters.length || (a.id < b.id ? -1 : 1));
+}
+function addItem(doc, title) {
+  const id = randomId();
+  const order = rgaList(doc, ITEMS);
+  doc.setText(titleList2(id), title);
+  doc.setField(statusReg(id), "open");
+  doc.setList(ITEMS, [...order, id]);
+  return id;
+}
+function deleteItem(doc, id) {
+  const order = rgaList(doc, ITEMS);
+  doc.setList(ITEMS, order.filter((x) => x !== id));
+  doc.setText(titleList2(id), "");
+  doc.deleteField(statusReg(id));
+  doc.deleteField(descReg2(id));
+  deleteFieldsByPrefix(doc, votePrefix(id));
+}
+function patchItem(doc, id, patch) {
+  if (patch.status !== void 0) doc.setField(statusReg(id), patch.status);
+  if (patch.desc !== void 0) {
+    if (patch.desc === null) doc.deleteField(descReg2(id));
+    else doc.setField(descReg2(id), patch.desc);
+  }
+  if (patch.title !== void 0) doc.setText(titleList2(id), patch.title);
+}
+function vote(doc, id, userId) {
+  doc.setField(voteKey(id, userId), true);
+}
+function unvote(doc, id, userId) {
+  doc.deleteField(voteKey(id, userId));
+}
+function clientOpts() {
+  return { baseUrl: getSyncBase(), namespace: getSyncNamespace() ?? "" };
+}
+async function deriveSession(seedWords, name) {
+  return deriveSession$1(seedWords, clientOpts(), { name, sharedNamespace: getSharedSpacesNamespace() ?? void 0 });
+}
+async function buildSession(opts, name) {
+  return buildSession$1({ ...opts, name, clientOpts: clientOpts(), sharedNamespace: getSharedSpacesNamespace() ?? void 0 });
+}
+async function buildLinkedSession(linked, name) {
+  return buildLinkedSession$1({
+    identity: linked,
+    name,
+    clientOpts: clientOpts(),
+    sharedNamespace: getSharedSpacesNamespace() ?? void 0
+  });
+}
+async function sessionFromPersisted(persisted) {
+  return sessionFromPersisted$1(persisted, clientOpts(), {
+    sharedNamespace: getSharedSpacesNamespace() ?? void 0
+  });
+}
+var PAIR_PREFIX = "octovault-pair:";
+async function completeDevicePairing(payload, pin) {
+  return completeDevicePairing$1(payload, pin, {
+    ...pairingClientConfig(),
+    confirmUnpinnedRoot: () => true
+  });
+}
+async function startDevicePairing(session, pin) {
+  return startDevicePairing$1(session, pin, { prefix: PAIR_PREFIX });
+}
+function getMemberCap(spaceId) {
+  const entry = getSpaceAccessEntry(spaceId);
+  return entry?.kind === "member" ? entry.cap : null;
+}
+var asRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+function coerceMutePrefs(v) {
+  const r = asRecord(v);
+  const nodes = {};
+  for (const [k, val] of Object.entries(asRecord(r.nodes))) {
+    if (typeof val === "number" || val === true) nodes[k] = val;
+  }
+  const spaces = {};
+  for (const [k, val] of Object.entries(asRecord(r.spaces))) {
+    if (typeof val === "number" || val === true) spaces[k] = val;
+  }
+  return { nodes, spaces };
+}
+function coerceReadPrefs(v) {
+  const r = asRecord(v);
+  const nodes = {};
+  for (const [k, val] of Object.entries(asRecord(r.nodes))) {
+    if (typeof val === "number") nodes[k] = val;
+  }
+  return { nodes };
+}
+async function readSpaces(client, session) {
+  const doc = await readSpaces$1(client, session);
+  const extra = doc.extra ?? {};
+  return {
+    ...doc,
+    mutes: coerceMutePrefs(extra.mutes),
+    reads: coerceReadPrefs(extra.reads)
+  };
+}
+async function leaveSpace(client, session, spaceId) {
+  await updateSpacesDoc(client, session, (cur) => {
+    if (!cur.spaces.some((s) => s.id === spaceId)) return cur;
+    const caps = { ...cur.caps };
+    delete caps[spaceId];
+    const pubAccess = { ...cur.pubAccess };
+    delete pubAccess[spaceId];
+    return { spaces: cur.spaces.filter((s) => s.id !== spaceId), caps, pubAccess };
+  });
+  removeSpaceAccessEntry(spaceId);
+}
+var CategoryError = class extends Error {
+};
+
+// src/starfish/object-types-store.ts
+var EMPTY_TYPES_DOC = { types: [] };
+function addType(doc, def) {
+  const id = randomId();
+  const type = { id, ...def };
+  return { doc: { ...doc, types: [...doc.types, type] }, id };
+}
+function patchType(doc, id, patch) {
+  return { ...doc, types: doc.types.map((t) => t.id === id ? { ...t, ...patch } : t) };
+}
+function addField2(doc, typeId, field) {
+  return {
+    ...doc,
+    types: doc.types.map(
+      (t) => t.id === typeId ? { ...t, fields: [...t.fields, field] } : t
+    )
+  };
+}
+function patchField2(doc, typeId, fieldKey, patch) {
+  return {
+    ...doc,
+    types: doc.types.map(
+      (t) => t.id === typeId ? { ...t, fields: t.fields.map((f) => f.key === fieldKey ? { ...f, ...patch } : f) } : t
+    )
+  };
+}
+function removeField(doc, typeId, fieldKey) {
+  return {
+    ...doc,
+    types: doc.types.map(
+      (t) => t.id === typeId ? { ...t, fields: t.fields.filter((f) => f.key !== fieldKey) } : t
+    )
+  };
+}
+function reorderFields(doc, typeId, keys) {
+  return {
+    ...doc,
+    types: doc.types.map((t) => {
+      if (t.id !== typeId) return t;
+      const byKey = new Map(t.fields.map((f) => [f.key, f]));
+      const ordered = keys.map((k) => byKey.get(k)).filter((f) => !!f);
+      const rest = t.fields.filter((f) => !keys.includes(f.key));
+      return { ...t, fields: [...ordered, ...rest] };
+    })
+  };
+}
+function archiveType(doc, id) {
+  return patchType(doc, id, { archived: true });
+}
+var _objStore = createSealedBlobStore({
+  paths: objectBlobPaths,
+  maxBytes: MAX_OBJECT_BLOB_BYTES
+});
+async function uploadObjectBlob(client, enc, spaceId, bytes, name, mime) {
+  const blobId = await _objStore.upload(client, enc, bytes, { spaceId });
+  return { blobId, name, mime, size: bytes.length };
+}
+async function loadObjectBlob(client, enc, spaceId, blobId) {
+  return _objStore.load(client, enc, blobId, { spaceId });
+}
+var _blobStore = createSealedBlobStore({
+  paths: objectBlobPaths,
+  maxBytes: MAX_OBJECT_BLOB_BYTES,
+  kvAdapter: { getItem: kvGet, setItem: kvSet, removeItem: kvRemove },
+  persistPrefix: "octovault.attach.blob.",
+  persistIndexKey: "octovault.attach.index"
+});
+async function uploadAttachment(client, enc, spaceId, bytes, name, mime) {
+  const blobId = await _blobStore.upload(client, enc, bytes, { spaceId });
+  return { blobId, name, mime, size: bytes.length, kind: attachmentKind(mime) };
+}
+async function loadAttachment(client, enc, spaceId, ref) {
+  return _blobStore.load(client, enc, ref.blobId, { spaceId });
+}
+function clearAttachmentCache() {
+  _blobStore.clearCache();
+}
+var CONNECT_TIMEOUT_MS = 12e3;
+function fetchWithTimeout(ms = CONNECT_TIMEOUT_MS) {
+  return createTimeoutFetch(ms);
+}
+
+// src/starfish/stream-bots.ts
+async function openStreamBotCredential(session, stored) {
+  if (typeof stored.token === "string") return stored;
+  return JSON.parse(await unsealFromSelf(session, stored));
+}
+
+export { BLOCK_SECTIONS, BLOCK_TYPES, BOARD_SCHEMA, BUILTIN_OBJECT_TYPES, BUILTIN_REGISTRY, CALENDAR_SCHEMA, CAPABILITY_META, CONNECT_TIMEOUT_MS, CategoryError, DEFAULT_AI_SETTINGS, DEFAULT_QUICK_REACTIONS, EMOJI, EMOJI_CATEGORIES, EMOJI_LIST, EMPTY_TYPES_DOC, FEEDBACK_SCHEMA, FORM_SCHEMA, PAGE_SCHEMA, PAIR_PREFIX, PULL_CACHE_MAX_AGE_MS, QUICK_REACTION_COUNT, REF_BLOCK_TYPES, activeEmojiQuery, addColumn, addComment, addEvent, addField2 as addField, addField as addFormField, addItem, addResponse, addTableColumn, addTableRow, addTableSelectOption, addType, addVaultObject, appendBlock, archiveType, automationOf, blockDef, buildAuthHeaders, buildEncryptor, buildLinkedSession, buildSession, clearAllTableFilters, clearAttachmentCache, clearPrimedSpaces, clearProp, clearTable, clearTableFilter, clearTableSort, completeDevicePairing, configureKv, configureOctoVault, consumePrimedSpaces, contentKindOf, continuationType, creatableTypes, createTable, defaultProps, deleteColumn, deleteEvent, deleteField as deleteFormField, deleteItem, deleteTableColumn, deleteTableRow, deriveSession, duplicateBlock, duplicateTableRow, endsListOnEmptyEnter, fetchWithTimeout, filterBlockTypes, flushReadsNow, getAiSettings, getEventsUrl, getMemberCap, getMutePrefs, getQuickReactions, getReadPrefs, getRoomReadAt, getSyncBase2 as getSyncBase, getSyncNamespace2 as getSyncNamespace, getSyncPrefix2 as getSyncPrefix, humanizeError, hydrateMutes, hydrateQuickReactions, hydrateReads, iconFor, iconForNode, insertBlock, isContainerType, isFindableType, isMultiline, isMuted, isOpenableObjectType, isRoomMuted, isSpaceMuted, kvGet2 as kvGet, kvRemove2 as kvRemove, kvSet2 as kvSet, labelFor, leaveSpace, listOrdinals, loadAiSettings, loadAttachment, loadMutesFromKv, loadObjectBlob, loadReadMarksFromKv, makeRegistry, matchEmoji, mdShortcut, mergeBlockIntoPrevious, monoFor, moveBlock, moveColumn, moveField as moveFormField, moveTableColumn, moveTableRow, objectDescriptor, objectLink, openStreamBotCredential, orderBetween, patchAutomation, patchEvent, patchField2 as patchField, patchField as patchFormField, patchItem, patchType, placeholderFor, primeSpaces, privacy, propsOf, pullCache, readBlocks, readColumns, readEvents, readFields, readItems, readProfile, readProfiles, readResponses, readSpaces, readTable, readThread, readThreads, removeBlock, removeComment, removeField, removeTableSelectOption, renameColumn, renameTableColumn, reorderFields, resetAiSettings, resetMutes, resetQuickReactions, resetReads, resolveThread, restoreBlock, routeForNode, saveAiSettings, saveQuickReactions, schemaFor, searchEmoji, seedDefaultColumns, sessionFromPersisted, setAiSettings, setBlockBookmark, setBlockChecked, setBlockCollapsed, setBlockIndent, setBlockRef, setBlockText, setBlockType, setColumnDone, setCommentBody, setProps, setQuickReactions, setRoomMute, setRoomReadAt, setSpaceMute, setTableCell, setTableColumnOptions, setTableColumnType, setTableColumnWidth, setTableFilter, setTableSort, showsInWorkTree, splitBlock, startDevicePairing, subscribeAiSettings, subscribeMutes, subscribeQuickReactions, subscribeReads, tasksForBoard, terms, threadLastActivity, toggleReaction, unvote, uploadAttachment, uploadObjectBlob, variantFor, visibleBlocks, visibleTableRowIds, vote, writeProfile };