@drakkar.software/octovault-sdk 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,1350 @@
+import { PresenceStatus, VerificationLevel, ObjectBlobRef } from '@drakkar.software/dk-spaces-sdk';
+export { InvitePreview, MAX_OBJECT_BLOB_BYTES, MatchRange, OBJECT_COLLECTIONS, ObjectBlobRef, PresenceStatus, RankedResult, ReadValue, SubscribeChangesOptions, TitleMatch, VerificationLevel, 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 * as _drakkar_software_starfish_spaces from '@drakkar.software/starfish-spaces';
+import { SealedBlob, Space as Space$1, ObjectContentKind, ObjectType, ObjectNode, MutePrefs, Session, ReadPrefs, LinkedIdentity, DeviceKeys, PersistedSession, PublicProfile, PairResult } from '@drakkar.software/starfish-spaces';
+export { CapMap, DerivedIdentity, ID, LinkedIdentity, MutePrefs, MuteValue, NewObjectInput, NodeAccess, NodeInviteLinkToken, ObjectContentKind, ObjectDirectoryEntry, ObjectNode, ObjectTreeNode, ObjectType, ObjectsIndex, PairResult, PasskeyEnrollment, PersistedSession, PubAccessMap, ObjectDirectoryEntry as PublicObjectDirEntry, ReadPrefs, SealedBlob, SeedLock, Session, SpaceAccessEntry, SpaceAccessError, SpaceAccessMap, SpaceInviteLinkToken, SpaceMeta, SpaceMetaUpdate, UnlockMethod, Vault, VaultLoad, 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';
+export { bytesToHex, randomId, slugify as roomSlug } from '@drakkar.software/starfish-protocol';
+import { WalDocument } from '@drakkar.software/starfish-wal';
+export { WalDocument } from '@drakkar.software/starfish-wal';
+import * as _drakkar_software_starfish_client from '@drakkar.software/starfish-client';
+import { StarfishClient, Encryptor, ByteSealer } from '@drakkar.software/starfish-client';
+export { ByteSealer, FileTooLargeError } from '@drakkar.software/starfish-client';
+export { parseSseFrames } from '@drakkar.software/starfish-client/events';
+export { createWalDocument, noopEncryptor } from '@drakkar.software/starfish-wal/client';
+
+interface OctoVaultConfig {
+    syncBase: string;
+    syncNamespace: string | undefined;
+    syncPrefix: string;
+    eventsUrl: string;
+    webBase: string;
+    /** Separate namespace for `user/{userId}/_spaces` reads/writes, enabling a
+     *  shared joined-space list across OctoVault and OctoChat. When set, both apps
+     *  must agree on the same value. Absent → uses `syncNamespace` (per-app silo). */
+    sharedSpacesNamespace?: string;
+}
+/**
+ * Configure the SDK with the sync server's coordinates. Call once at app boot
+ * (before any other SDK function), passing the env-derived values.
+ *
+ * Also configures the shared octospaces-sdk so all re-exported modules work
+ * without requiring a separate `configureOctoSpaces` call at the app level,
+ * then installs the OctoVault SpaceLayout via `configureSpaces`.
+ */
+declare function configureOctoVault(config: Partial<OctoVaultConfig>): void;
+/** Base URL of the Starfish sync server, e.g. `https://sync.example.com`. */
+declare function getSyncBase(): string;
+/** Starfish namespace name (undefined for a root-mounted local dev server). */
+declare function getSyncNamespace(): string | undefined;
+/**
+ * Namespaced path prefix (`/v1/<namespace>`, or '') for raw requests that live
+ * outside the StarfishClient (SSE `GET /events`, raw profile GET).
+ */
+declare function getSyncPrefix(): string;
+/** SSE event endpoint URL. */
+declare function getEventsUrl(): string;
+
+interface KvAdapter {
+    get: (key: string) => Promise<string | null>;
+    set: (key: string, value: string) => Promise<void>;
+    remove: (key: string) => Promise<void>;
+}
+/**
+ * Configure the KV store. Call at app boot before any SDK function that reads
+ * or writes persisted state (member caps, mutes, reads, AI settings, etc.).
+ *
+ * Also wires the shared dk-spaces-sdk so its pull-cache, profile-cache, and
+ * space-access-store all use the same platform adapter.
+ */
+declare function configureKv(adapter: KvAdapter): void;
+declare function kvGet(key: string): Promise<string | null>;
+declare function kvSet(key: string, value: string): Promise<void>;
+declare function kvRemove(key: string): Promise<void>;
+
+/**
+ * OctoVault curated icon name set — the single source of truth for the `IconName`
+ * union. App components import this from the SDK and derive their runtime mapping
+ * from it; nothing in the SDK renders icons, but several domain tables (blocks,
+ * object-types) carry icon names as data so they need the type.
+ */
+type IconName = 'hash' | 'stream' | 'lock' | 'unlock' | 'plus' | 'plus-circle' | 'search' | 'send' | 'paperclip' | 'smile' | 'reply' | 'thread' | 'dm' | 'pin' | 'mic' | 'image' | 'video' | 'file' | 'link' | 'qr' | 'qr-scan' | 'check' | 'check-circle' | 'chev' | 'chevron-down' | 'chevron-up' | 'gear' | 'bell' | 'volume' | 'volume-off' | 'menu' | 'x' | 'arrow-l' | 'arrow-r' | 'shield' | 'people' | 'user' | 'dots' | 'dots-v' | 'camera' | 'key' | 'devices' | 'copy' | 'eye' | 'eye-off' | 'alert' | 'info' | 'edit' | 'trash' | 'logout' | 'at' | 'clock' | 'refresh' | 'zap' | 'globe' | 'folder' | 'share' | 'chat' | 'agents' | 'work' | 'book' | 'target' | 'layers' | 'text' | 'heading' | 'subheading' | 'list' | 'list-numbered' | 'todo' | 'quote' | 'code' | 'minus' | 'callout' | 'palette' | 'grip' | 'expand' | 'h1' | 'h2' | 'quote-mark' | 'code-block' | 'list-bullet' | 'list-number' | 'toggle-chev' | 'page' | 'square' | 'square-check' | 'drag' | 'duplicate' | 'move-to' | 'restore' | 'sidebar' | 'external' | 'emoji' | 'chev-down' | 'chev-right' | 'arrow-up' | 'arrow-down' | 'enter' | 'command' | 'table' | 'filter';
+
+/**
+ * Text size-scale variant names — mirrors the keys of the `type` const in
+ * `apps/mobile/src/theme.ts`. Defined here so non-UI SDK modules (blocks,
+ * page-model) can carry the variant as data without importing @/theme.
+ */
+type TextVariant = 'pageTitle' | 'display' | 'title' | 'heading' | 'subhead' | 'body' | 'callout' | 'footnote' | 'caption' | 'micro';
+
+/**
+ * Domain model for OctoVault.
+ *
+ * Re-exports the shared octospaces-sdk types (Space, ObjectNode, NodeAccess, …)
+ * and adds vault-specific types (User, Profile, AutomationMeta, PropValue, etc.).
+ *
+ * ObjectNode.access / ObjectNode.enc (from octospaces) replace the old Space.type
+ * ('private'|'public') model. Space is now a neutral container (no `type`, `ownerId`,
+ * or `write` field). The per-node access:'public' model replaces public spaces.
+ *
+ * ObjectNode.automation and ObjectNode.props moved into ObjectNode.meta:
+ *   node.meta?.automation  →  automationOf(node)  (from objects-ext.ts)
+ *   node.meta?.props       →  propsOf(node)       (from objects-ext.ts)
+ */
+
+interface Space extends Space$1 {
+    /** Two-letter monogram shown in compact rail tiles. Populated by onSpaceMeta. */
+    short?: string;
+    /** Avatar data-URI (same contract as profile avatars). Populated by onSpaceMeta. */
+    image?: string;
+    /** Live unread count, overlaid by `useSpaces` from the read-marks store. */
+    unread?: number;
+}
+
+/** A vault user display record (enriched from the public profile). */
+interface User {
+    id: string;
+    name: string;
+    handle: string;
+    initials: string;
+    presence?: PresenceStatus;
+    /** Uploaded avatar as a data URI; absent → render the monogram initials. */
+    avatar?: string;
+}
+interface SecurityItem {
+    id: string;
+    icon: 'shield' | 'devices' | 'key';
+    title: string;
+    detail: string;
+    level: VerificationLevel;
+    mono?: boolean;
+}
+interface Profile {
+    user: User;
+    pronouns: string;
+    description: string;
+    status: string;
+    fingerprint: string;
+    security: SecurityItem[];
+}
+/** Scalar value that can be stored in an ObjectNode's `meta.props` map. */
+type PropValue = string | number | boolean | null;
+/** Stored, synced config of an automation node (`type:'automation'`), kept in
+ *  `node.meta.automation`. Use {@link automationOf} / `objects-ext.ts` to access. */
+interface AutomationMeta {
+    /** FK into the built-in provider catalog (e.g. 'rss' / 'http'). */
+    providerId: string;
+    /** Non-secret provider params (URLs, locations, etc.). */
+    params: Record<string, unknown>;
+    /** Scheduled-fetch cadence in minutes; `0` = commands-only (no scheduled run). */
+    intervalMin: number;
+    /** When set, the automation fires on every room open / background check,
+     *  bypassing the `intervalMin` time gate. */
+    onOpen?: boolean;
+    /** Off → ticker skips and `onCommand` ignores; the room itself still renders. */
+    enabled: boolean;
+    /** Bot write credential SEALED to the minting account key. */
+    credential: SealedBlob;
+    /** The deterministic id of the device elected to run this automation. */
+    runOnDeviceId: string | null;
+    /** Last successful tick (epoch ms). */
+    lastRunAt: number | null;
+    /** Hash of the last text a scheduled fetch posted. */
+    lastFetchHash?: string | null;
+    /** Last error message — set on throw, cleared on success. */
+    lastError: string | null;
+}
+/** The builtin object types shipped with OctoVault renderers. A custom type is
+ *  any `string` beyond these (the ObjectType union is open-ended). */
+type BuiltinObjectType = 'folder' | 'page' | 'board' | 'task' | 'file' | 'image' | 'automation' | 'note' | 'calendar' | 'form' | 'feedback';
+/** Runtime set of builtin type strings — use to branch "do we ship a renderer?". */
+declare const BUILTIN_OBJECT_TYPES: readonly BuiltinObjectType[];
+
+type Capability = 'pages' | 'boards' | 'notes' | 'calendar' | 'forms' | 'feedback';
+interface CapabilityMeta {
+    label: string;
+    description: string;
+    objectType?: string;
+}
+declare const CAPABILITY_META: Record<Capability, CapabilityMeta>;
+
+type PropKind$1 = 'text' | 'number' | 'select' | 'date' | 'checkbox' | 'url' | 'relation';
+type EditorKind$1 = 'page' | 'board' | 'file' | 'record' | 'calendar' | 'form' | 'feedback' | 'none';
+type ContentKind = 'append' | 'merge' | 'none';
+interface SelectOption {
+    id: string;
+    label: string;
+}
+interface FieldDef {
+    key: string;
+    label: string;
+    kind: PropKind$1;
+    required?: boolean;
+    options?: SelectOption[];
+    /** For `kind: 'relation'` — the target ObjectType id. */
+    targetType?: string;
+}
+interface TypeDef {
+    id: string;
+    label: string;
+    icon: string;
+    color?: string;
+    editorKind: EditorKind$1;
+    contentKind: ContentKind;
+    fields: FieldDef[];
+    creatable: boolean;
+    archived: boolean;
+}
+interface TypesDoc {
+    types: TypeDef[];
+}
+declare const EMPTY_TYPES_DOC: TypesDoc;
+declare function addType(doc: TypesDoc, def: Omit<TypeDef, 'id'>): {
+    doc: TypesDoc;
+    id: string;
+};
+declare function patchType(doc: TypesDoc, id: string, patch: Partial<Omit<TypeDef, 'id' | 'fields'>>): TypesDoc;
+declare function addField$1(doc: TypesDoc, typeId: string, field: FieldDef): TypesDoc;
+declare function patchField$1(doc: TypesDoc, typeId: string, fieldKey: string, patch: Partial<FieldDef>): TypesDoc;
+declare function removeField(doc: TypesDoc, typeId: string, fieldKey: string): TypesDoc;
+declare function reorderFields(doc: TypesDoc, typeId: string, keys: string[]): TypesDoc;
+declare function archiveType(doc: TypesDoc, id: string): TypesDoc;
+
+/**
+ * Object type registry — the single place that maps an {@link ObjectType} (builtin OR
+ * user-defined) to how the app treats it: which content sync model it uses, which icon
+ * renders it, which editor opens it, and what structured props it supports. Keeping this
+ * open-ended is what lets a custom type drop in without a renderer rewrite — unknown types
+ * resolve to a generic descriptor (a merge-doc with a neutral glyph) instead of being
+ * special-cased away.
+ *
+ * Pure data/logic (no React) so any layer — hooks picking a collection, the tree
+ * picking a glyph — reads the same descriptors.
+ */
+
+/** The fixed renderer a type reuses — a closed set of editors the app ships.
+ *  Data can declare new types but cannot ship new renderers without a code change. */
+type EditorKind = 'page' | 'board' | 'file' | 'record' | 'calendar' | 'form' | 'feedback' | 'none';
+type PropKind = 'text' | 'number' | 'select' | 'date' | 'checkbox' | 'url' | 'relation';
+interface PropOption {
+    id: string;
+    label: string;
+    color?: string;
+}
+interface PropField {
+    key: string;
+    label: string;
+    kind: PropKind;
+    options?: PropOption[];
+    required?: boolean;
+}
+interface TypeDescriptor {
+    /** Default content sync model for this type (a node's own `contentKind` overrides). */
+    contentKind: ObjectContentKind;
+    icon: IconName;
+    label: string;
+    /** The fixed renderer this type opens in. */
+    editor: EditorKind;
+    /** Declared structured property fields. */
+    props: PropField[];
+    /** Whether this type appears in the "create new" menus. */
+    creatable: boolean;
+    /** Whether this type appears in the workspace sidebar tree. Unknown types default to true. */
+    workTree: boolean;
+    /** Whether this type is searchable in quick-find / command palette. Unknown types default to true. */
+    findable: boolean;
+    /** Placeholder title for a newly created object. */
+    defaultTitle?: string;
+    /** Theme color swatch for the type pill (undefined = default accent). */
+    color?: string;
+    /** Which app capability this type belongs to. */
+    capability?: Capability;
+    /** Whether the editor owns its own internal ScrollView (outer StackScreen must not add one). */
+    ownsScroll?: boolean;
+}
+/** @deprecated Use {@link TypeDescriptor} — kept for legacy call sites reading only icon/label/contentKind. */
+type ObjectDescriptor = TypeDescriptor;
+/** Resolve a type's descriptor — a builtin, or the generic fallback for a custom type. */
+declare function objectDescriptor(type: ObjectType): TypeDescriptor;
+/** Resolve the display icon for a node from its type descriptor. */
+declare function iconForNode(node: Pick<ObjectNode, 'type'>): IconName;
+/** A container type holds children but has no content of its own (folder/category) —
+ *  in the tree it toggles open/closed instead of opening a content route. */
+declare function isContainerType(type: ObjectType): boolean;
+/** Whether a node appears in the workspace sidebar tree. Unknown custom types default to shown. */
+declare function showsInWorkTree(node: Pick<ObjectNode, 'type'>): boolean;
+/** Whether a type can be opened in an editor (clicking navigates rather than toggling). */
+declare function isOpenableObjectType(type: ObjectType): boolean;
+/** Whether a type is surfaced in quick-find and search. Unknown custom types default to findable. */
+declare function isFindableType(type: ObjectType): boolean;
+/** The effective content sync model for a node: its explicit `contentKind` wins (a
+ *  custom type declares its own), else the type descriptor's default. */
+declare function contentKindOf(node: Pick<ObjectNode, 'type' | 'contentKind'>): ObjectContentKind;
+interface CreatableTypeEntry extends TypeDescriptor {
+    type: ObjectType;
+}
+/** Types the user can explicitly create from the "new object" menus. */
+declare function creatableTypes(): CreatableTypeEntry[];
+/** Default `props` map for a newly created object of this type (all fields absent = empty map). */
+declare function defaultProps(_type: ObjectType): Record<string, PropValue>;
+interface TypeRegistry {
+    descriptor: (type: string) => TypeDescriptor;
+    creatableTypes: () => CreatableTypeEntry[];
+    showsInWorkTree: (node: Pick<ObjectNode, 'type'>) => boolean;
+    iconForNode: (node: Pick<ObjectNode, 'type'>) => IconName;
+    isFindableType: (type: string) => boolean;
+    isContainerType: (type: string) => boolean;
+    isOpenableType: (type: string) => boolean;
+    /** All types — built-in + custom (non-archived). */
+    allTypes: () => Array<CreatableTypeEntry & {
+        isCustom: boolean;
+    }>;
+}
+/** Build a merged TypeRegistry from built-ins + custom TypeDefs.
+ *  Custom types with the same id as a built-in are IGNORED (built-ins win). */
+declare function makeRegistry(customTypes: TypeDef[]): TypeRegistry;
+/** A static registry containing only built-in types (no React context needed).
+ *  Use this at non-React call sites; React components should use `useTypeRegistry()`. */
+declare const BUILTIN_REGISTRY: TypeRegistry;
+/** The detail route an object opens into — collapses to a single generic route now that
+ *  every object type (page, board, task, file, image, custom) is handled by one screen. */
+declare function routeForNode(_node: Pick<ObjectNode, 'type'>): '/work/object/[id]';
+/**
+ * Absolute shareable URL for an object — the "Copy link" target. Web-only by
+ * construction (it needs a routable origin; a native deep-link scheme would not
+ * open for a collaborator), so it returns `null` off web and callers hide the
+ * affordance.
+ */
+declare function objectLink(spaceId: string, node: Pick<ObjectNode, 'id' | 'type'>): string | null;
+
+/**
+ * Friendly error mapping for user-facing failure surfaces (onboarding, accounts,
+ * pairing, joining spaces). The sync/crypto stack throws developer-grade messages
+ * ("Failed to fetch", WebAuthn DOMExceptions, Argon2/WASM internals) that erode
+ * trust exactly where it matters most — the identity ceremony. Every screen that
+ * renders an error to a human routes it through {@link humanizeError} first.
+ *
+ * The mapping is deliberately heuristic, not a taxonomy: we only special-case the
+ * failure shapes users actually hit (network down, dismissed passkey prompt,
+ * permission/server errors) and otherwise pass through messages that already read
+ * like sentences — much of `src/lib/starfish/*` throws carefully-worded strings
+ * ("That is not a valid space invite.") that SHOULD reach the user verbatim.
+ */
+/**
+ * Map an unknown thrown value to a human string. Pass a `fallback` to tailor the
+ * generic case to the action ("Couldn't create your identity.").
+ */
+declare function humanizeError(e: unknown, fallback?: string): string;
+
+/**
+ * Curated emoji shortcode table (GitHub/Slack style). Powers the composer's
+ * `:shortcode:` autocomplete (type `:` + a name to insert the glyph) and the
+ * visual icon picker (`components/ui/EmojiPicker`), which renders the same
+ * table grouped by category.
+ *
+ * Deliberately a small, hand-picked set (no data dependency) — common smileys,
+ * gestures, hearts, symbols and a few marine/theme picks. Several codes may map
+ * to the same glyph as aliases (`+1`/`thumbsup`, `plus`/`heavy_plus_sign`), so
+ * familiar names from either ecosystem resolve; the picker collapses aliases
+ * into one cell while search still matches every name.
+ */
+/** A shortcode paired with the glyph it inserts. */
+interface EmojiMatch {
+    /** The shortcode without surrounding colons (e.g. `octopus`). */
+    code: string;
+    /** The emoji glyph it expands to. */
+    glyph: string;
+}
+/** A named group of glyphs — section data for the picker grid. */
+interface EmojiCategory {
+    id: string;
+    /** Section heading shown above the group in the picker. */
+    label: string;
+    /** Glyphs in curated order, aliases already collapsed (one cell per glyph). */
+    emoji: EmojiMatch[];
+}
+/** Flat shortcode → glyph lookup (every alias present) — the autocomplete table. */
+declare const EMOJI: Record<string, string>;
+/** Picker sections: curated categories with aliases collapsed. */
+declare const EMOJI_CATEGORIES: EmojiCategory[];
+/** Every distinct glyph in curated order — the picker's "all" grid. */
+declare const EMOJI_LIST: EmojiMatch[];
+/**
+ * Detect the active emoji shortcode token at the end of `textBeforeCaret`.
+ * Returns the partial `query` (no leading colon) and `start`, the index of the
+ * opening colon in the original text, or `null` when the caret isn't in a token.
+ */
+declare function activeEmojiQuery(textBeforeCaret: string): {
+    query: string;
+    start: number;
+} | null;
+/**
+ * Up to `limit` shortcodes matching `query` (case-insensitive). Prefix matches
+ * rank above interior substring matches; ties keep table order. An empty query
+ * yields nothing — we only suggest once the user commits to a name character.
+ */
+declare function matchEmoji(query: string, limit?: number): EmojiMatch[];
+/**
+ * Glyph search for the picker grid: ranks like {@link matchEmoji} (prefix over
+ * interior substring, ties in table order) across EVERY alias, then collapses
+ * aliases so each glyph appears once. Empty query yields nothing — the picker
+ * shows the category sections instead.
+ */
+declare function searchEmoji(query: string, limit?: number): EmojiMatch[];
+
+interface LegalSection {
+    title: string;
+    paragraphs: string[];
+}
+interface LegalDoc {
+    title: string;
+    subtitle: string;
+    updated: string;
+    sections: LegalSection[];
+}
+declare const privacy: LegalDoc;
+declare const terms: LegalDoc;
+
+/**
+ * dk-spaces-sdk 0.31 stopped wrapping the mute store — `createMutesStore` is gone.
+ * Build the generic `createPrefsStore` directly with dk-spaces-sdk's mute config
+ * preset, and re-derive the old room/space-specific method names this module used
+ * to expose (the generic store only has `get`/`mutate`/`subscribe`/etc.).
+ */
+
+declare const getMutePrefs: () => MutePrefs;
+declare const isRoomMuted: (roomId: string) => boolean;
+declare const isSpaceMuted: (spaceId: string) => boolean;
+declare const isMuted: (roomId: string, spaceId: string) => boolean;
+declare const subscribeMutes: (listener: () => void) => () => void;
+declare const hydrateMutes: (userId: string, serverPrefs: MutePrefs) => Promise<void>;
+declare const resetMutes: () => void;
+declare const loadMutesFromKv: (userId: string) => Promise<MutePrefs>;
+declare const setRoomMute: (session: Session, roomId: string, muted: boolean) => Promise<void>;
+declare const setSpaceMute: (session: Session, spaceId: string, muted: boolean) => Promise<void>;
+
+/**
+ * dk-spaces-sdk 0.31 stopped wrapping the read-marks store — `createReadsStore` is
+ * gone. Build the generic `createPrefsStore` directly with dk-spaces-sdk's read
+ * config preset, and re-derive the old room-specific method names this module used
+ * to expose (the generic store only has `get`/`mutate`/`subscribe`/etc.).
+ */
+
+declare const getReadPrefs: () => ReadPrefs;
+declare const getRoomReadAt: (roomId: string) => number;
+declare const subscribeReads: (listener: () => void) => () => void;
+declare const loadReadMarksFromKv: (userId: string) => Promise<ReadPrefs>;
+declare const hydrateReads: (userId: string, serverPrefs: ReadPrefs) => Promise<void>;
+declare const resetReads: () => void;
+declare const flushReadsNow: () => Promise<void>;
+declare const setRoomReadAt: (session: Session, roomId: string, ts: number) => Promise<void>;
+
+/**
+ * Identity bootstrap — thin wrappers that keep the old 2-arg call ergonomics
+ * (`buildSession({userId,keys}, name?)`, `deriveSession(seedWords, name?)`,
+ * `buildLinkedSession(linked, name?)`, `sessionFromPersisted(persisted)`) while
+ * injecting the per-call `clientOpts` required by starfish-spaces.
+ *
+ * dk-spaces-sdk 0.31 dropped its `sessionFromPersisted` proxy — clients now call
+ * starfish-spaces directly and must pass `clientOpts` themselves (2nd positional
+ * arg). `activeAccountOf` / `rootIdentityOf` take no `clientOpts` and are
+ * re-exported unchanged.
+ */
+
+/** Derive a session from a BIP-39 seed phrase. Preserves old `(seedWords, name?)` signature. */
+declare function deriveSession(seedWords: string[], name?: string): Promise<Session>;
+/** Build a session from a pre-derived root identity. Preserves old `({userId,keys}, name?)` signature. */
+declare function buildSession(opts: {
+    userId: string;
+    keys: DeviceKeys;
+}, name?: string): Promise<Session>;
+/** Build a session from a QR-paired linked identity. Preserves old `(linked, name?)` signature. */
+declare function buildLinkedSession(linked: LinkedIdentity, name?: string): Promise<Session>;
+/** Restore a session from a persisted account. Preserves old `(persisted)` signature. */
+declare function sessionFromPersisted(persisted: PersistedSession): Promise<Session>;
+
+/**
+ * Per-identity quick-reaction palette — the six emojis offered in the inline
+ * message reaction picker ({@link MessageActions}). Synced server-side: the durable
+ * source of truth is the user's own `_spaces` doc (a `quickReactions` key alongside
+ * `mutes`/`reads`, see `registry.ts`), which a fresh device re-hydrates from its seed
+ * so an edit on one device propagates cross-device. Held as a module-level snapshot —
+ * like `mutes.ts` / `notification-settings.ts` — so a non-React caller can read it
+ * synchronously; React consumers subscribe via {@link QuickReactionsProvider}.
+ *
+ * The snapshot seeds with the curated defaults so a picker opened before the session
+ * hydrates still shows something sane; the synced palette overwrites it on load. There
+ * is no local-kv cache (unlike `mutes`, which warms one for the headless push task) —
+ * the palette has no background consumer, so an offline cold-start shows the defaults
+ * until the next successful pull heals it.
+ */
+
+/** How many emojis the quick-reaction palette holds — a fixed six slots. */
+declare const QUICK_REACTION_COUNT = 6;
+/** The default palette, kept identical to the original hardcoded set. */
+declare const DEFAULT_QUICK_REACTIONS: string[];
+/** The live palette — synchronous read for any non-React caller. */
+declare function getQuickReactions(): string[];
+/** Subscribe to snapshot changes (drives `useSyncExternalStore`). */
+declare function subscribeQuickReactions(listener: () => void): () => void;
+/** Replace the live snapshot and notify React consumers. */
+declare function setQuickReactions(next: string[]): void;
+/** Reset to defaults on sign-out so a fresh session never inherits the prior one's.
+ *  Wired into `resetAccountScopedState` (the twin of `resetMutes`). */
+declare function resetQuickReactions(): void;
+/**
+ * Load the active account's palette into the snapshot. `serverPalette` comes from the
+ * SAME `_spaces` read that hydrates caps/mutes (session-context), so the doc isn't
+ * pulled twice. SERVER-AUTHORITATIVE wholesale replace — that is what lets an edit on
+ * another device propagate here. A `pending` local write is left untouched (its own emit
+ * already reflects the change). The strict {@link coerce} runs here so a doc that
+ * predates the feature (reads back `[]`) hydrates to the defaults.
+ */
+declare function hydrateQuickReactions(serverPalette: string[]): void;
+/** Optimistically update the snapshot and sync the palette to the durable `_spaces`
+ *  doc. `pending` brackets the round-trip so a navigation re-hydrate can't revert the
+ *  optimistic emit before the server reflects it (twin of `setMute`). */
+declare function saveQuickReactions(session: Session, emojis: string[]): Promise<void>;
+
+interface AiSettings {
+    /** Master switch for AI agents & suggestions. Off by default until the user
+     *  explicitly opts in — respects that on-device model availability is unknown
+     *  at first launch. */
+    enabled: boolean;
+}
+declare const DEFAULT_AI_SETTINGS: AiSettings;
+/** The live settings — synchronous read. */
+declare function getAiSettings(): AiSettings;
+/** Subscribe to snapshot changes (drives `useSyncExternalStore`). */
+declare function subscribeAiSettings(listener: () => void): () => void;
+/** Replace the live snapshot and notify React consumers. */
+declare function setAiSettings(next: AiSettings): void;
+/** Reset to defaults on sign-out so a fresh session never inherits the prior one's. */
+declare function resetAiSettings(): void;
+/** Read this identity's persisted settings (does NOT mutate the snapshot). */
+declare function loadAiSettings(userId: string): Promise<AiSettings>;
+/** Merge a patch into the live snapshot and persist it for the identity. */
+declare function saveAiSettings(userId: string, patch: Partial<AiSettings>): Promise<void>;
+
+/**
+ * One-shot handoff of the `_spaces` doc from session setup to {@link SpacesProvider}.
+ *
+ * Session establishment already reads the user's `_spaces` doc once (it carries the
+ * durable member caps — see session-context `hydrateCapsFor`). That doc ALSO holds
+ * the space list, so we stash it here for SpacesProvider to adopt instead of pulling
+ * the very same doc again on first paint. Lives in its own tiny module so neither
+ * `session-context` nor `spaces-context` has to import the other (they already form
+ * a one-way edge via `useSession`).
+ */
+
+/** Stash the space list read during session setup, keyed by identity. */
+declare function primeSpaces(userId: string, spaces: Space[]): void;
+/**
+ * Adopt the primed spaces for `userId`, if a fresh stash exists (set in the last few
+ * seconds, for this identity). Returns null — so the caller reads the doc itself —
+ * when absent, stale, or for a different account. Consuming clears the stash.
+ */
+declare function consumePrimedSpaces(userId: string): Space[] | null;
+/** Drop any stash (account switch / sign-out). */
+declare function clearPrimedSpaces(): void;
+
+/**
+ * Page-as-blocks model on a {@link WalDocument} (the Notion-style core).
+ *
+ * One page = one WAL document holding:
+ *  - an RGA list **`order`** of block ids (ordering + insert/delete; reorder via
+ *    the reconcile `setList`, which keeps unchanged ids and only diffs the move);
+ *  - per block, a char-RGA text list **`text:{id}`** so two people editing the
+ *    same block converge per character (`setText`);
+ *  - per block, LWW registers **`type:{id}`** and **`checked:{id}`** for the
+ *    block kind and the to-do state, plus the structure registers
+ *    **`indent:{id}`** (nesting depth under lists/toggles), **`collapsed:{id}`**
+ *    (a toggle's disclosure state) and **`ref:{id}`** (the child Object id a
+ *    `page` block links to). All follow the same `name:{id}` register pattern so
+ *    a future register costs one line here and nothing in the transport.
+ *
+ * Pure functions over a WalDocument: no React, no network — unit-testable with a
+ * fake transport. The `use-page` hook owns commit/pull; these only build ops.
+ */
+
+type BlockType = 'paragraph' | 'heading' | 'subheading' | 'todo' | 'bulleted' | 'numbered' | 'toggle' | 'quote' | 'code' | 'divider' | 'page' | 'image' | 'file' | 'bookmark' | 'table';
+/** Block types that reference a child Object by id (no inline text; clicking navigates). */
+declare const REF_BLOCK_TYPES: ReadonlySet<BlockType>;
+/** Cached OG metadata for a `bookmark` block (stored as a JSON LWW register). */
+interface BookmarkMeta {
+    title: string;
+    description?: string;
+    image?: string;
+    favicon?: string;
+    /** The URL the metadata was fetched for — used to invalidate when `text` changes. */
+    fetchedFor: string;
+}
+interface Block {
+    id: string;
+    type: BlockType;
+    text: string;
+    /** Only meaningful for `type === 'todo'`. */
+    checked?: boolean;
+    /** Nesting depth (0 = root). Drives the per-level indent and which toggle governs visibility. */
+    indent?: number;
+    /** Only meaningful for `type === 'toggle'` — whether its deeper-indented run is hidden. */
+    collapsed?: boolean;
+    /** Only meaningful for `type === 'page'|'image'|'file'` — the linked child Object's index id. */
+    ref?: string;
+    /** Only meaningful for `type === 'bookmark'` — cached OG metadata from the unfurl server. */
+    bookmark?: BookmarkMeta;
+}
+interface NewBlock {
+    type?: BlockType;
+    text?: string;
+    checked?: boolean;
+    indent?: number;
+    ref?: string;
+}
+/** Project the WAL document into an ordered, de-duplicated list of blocks. */
+declare function readBlocks(doc: WalDocument): Block[];
+/**
+ * The render-visible subset: blocks governed by a COLLAPSED toggle are hidden.
+ * A block is "governed" by the nearest preceding block with a SHALLOWER indent;
+ * walking the list once with a hide-threshold covers arbitrarily nested toggles
+ * (a visible block at/above the threshold ends the hidden run; if it is itself a
+ * collapsed toggle it starts a new one). Pure — unit-tested without a renderer.
+ */
+declare function visibleBlocks(blocks: Block[]): Block[];
+/** Insert a new block at `index` (clamped). Returns the new block id. */
+declare function insertBlock(doc: WalDocument, index: number, init?: NewBlock): string;
+/** Append a block to the end. Returns the new block id. */
+declare function appendBlock(doc: WalDocument, init?: NewBlock): string;
+/** Replace a block's body text (character-level CRDT merge). */
+declare function setBlockText(doc: WalDocument, id: string, text: string): void;
+declare function setBlockType(doc: WalDocument, id: string, type: BlockType): void;
+declare function setBlockChecked(doc: WalDocument, id: string, checked: boolean): void;
+/** Set a block's nesting depth (clamped to ≥ 0; 0 clears the register). */
+declare function setBlockIndent(doc: WalDocument, id: string, indent: number): void;
+declare function setBlockCollapsed(doc: WalDocument, id: string, collapsed: boolean): void;
+/** Point a `page` block at the child Object it links to. */
+declare function setBlockRef(doc: WalDocument, id: string, ref: string): void;
+/** Remove a block: drop it from `order`, clear its text, tombstone its props. */
+declare function removeBlock(doc: WalDocument, id: string): void;
+/** Move a block to `toIndex` via a minimal reconcile of the order list. */
+declare function moveBlock(doc: WalDocument, id: string, toIndex: number): void;
+/**
+ * Enter-to-split: rewrite `id`'s text to `head` and insert a sibling holding the
+ * tail DIRECTLY after it, as ONE op batch (the hook's single `touch()` commits
+ * them together, so a concurrent fold never sees a half-split). The caller picks
+ * the tail's type (list continuation) and indent. Returns the new block id, or
+ * null when `id` is no longer in the order (concurrently removed).
+ */
+declare function splitBlock(doc: WalDocument, id: string, head: string, init?: NewBlock): string | null;
+/**
+ * Backspace-at-start: append `id`'s text to the PREVIOUS block and remove `id`.
+ * `textOverride` lets the editor pass its live (not-yet-committed) field value so
+ * the merge never resurrects stale committed text. Returns the surviving block id
+ * and the seam offset (where the caret should land), or null at the top of the doc.
+ */
+declare function mergeBlockIntoPrevious(doc: WalDocument, id: string, textOverride?: string): {
+    prevId: string;
+    offset: number;
+} | null;
+/** Insert a copy of `id` (type/text/checked/indent/ref/bookmark) directly below it. */
+declare function duplicateBlock(doc: WalDocument, id: string): string | null;
+/**
+ * Undo for a structural delete: re-insert a previously {@link removeBlock}-ed
+ * block at `index` with its ORIGINAL id (so a concurrent device that still holds
+ * ops for it converges onto the same block). Re-setting the LWW registers and
+ * re-typing the text revives the tombstoned state.
+ */
+declare function restoreBlock(doc: WalDocument, index: number, block: Block): void;
+/** Store (or update) the fetched OG metadata for a `bookmark` block. */
+declare function setBlockBookmark(doc: WalDocument, id: string, meta: BookmarkMeta): void;
+
+/**
+ * Block-type presentation table — the single source of truth for how each
+ * {@link BlockType} renders, reads and is reached in the page editor (see
+ * {@link PageView}).
+ *
+ * Keeps the editor component declarative: instead of inline `switch`/`if` on the
+ * type for the label, slash-menu section, icon, text variant, mono-ness,
+ * multiline-ness and placeholder, components look these up here. Also carries
+ * the Markdown shortcut prefixes and the slash-menu search keywords, plus the
+ * pure typing-behaviour helpers (Enter continuation, slash filtering, numbered
+ * run counting) so the editor's "feel" logic is unit-testable without React.
+ */
+
+/** Slash/insert menu grouping (Notion-style sections, micro mono headers). */
+type BlockSection = 'basic' | 'list' | 'other';
+declare const BLOCK_SECTIONS: {
+    id: BlockSection;
+    label: string;
+}[];
+/** A {@link BlockType}'s presentation: how it reads and which editor it uses. */
+interface BlockTypeDef {
+    type: BlockType;
+    /** Menu label. */
+    label: string;
+    /** Glyph in the block-type / slash menu and (where shown) the gutter. */
+    icon: IconName;
+    /** Slash/insert menu section. */
+    section: BlockSection;
+    /** Extra slash-filter aliases beyond the label ("/h1", "/ul", "/check"…). */
+    keywords: string[];
+    /** Type-scale step the block's text renders at (also the editor's `textVariant`). */
+    variant: TextVariant;
+    /** Render the text in JetBrains Mono (code blocks). */
+    mono: boolean;
+    /** Editor allows in-block newlines (web Shift+Enter; plain Enter still splits). */
+    multiline: boolean;
+    /** Placeholder shown ONLY in the focused empty editor (unfocused empties are blank). */
+    placeholder: string;
+    /** Start-of-line Markdown shortcuts that convert a block to this type. */
+    mdPrefixes?: string[];
+}
+/**
+ * Every block type, in the order they appear in the block-type / slash menu.
+ * `divider` renders as a rule (no text editor); `page` renders as a child-page
+ * link row (its content lives in the linked Object, not in this doc).
+ */
+declare const BLOCK_TYPES: BlockTypeDef[];
+/** The full presentation def for a block type. */
+declare function blockDef(type: BlockType): BlockTypeDef;
+declare const labelFor: (type: BlockType) => string;
+declare const iconFor: (type: BlockType) => IconName;
+declare const variantFor: (type: BlockType) => TextVariant;
+declare const monoFor: (type: BlockType) => boolean;
+declare const isMultiline: (type: BlockType) => boolean;
+declare const placeholderFor: (type: BlockType) => string;
+/**
+ * What Enter at the end of a `type` block creates next: lists/todos/toggles
+ * continue themselves; everything else (headings, quotes, paragraphs…) yields a
+ * fresh paragraph — the Notion continuation rule.
+ */
+declare function continuationType(type: BlockType): BlockType;
+/** Whether Enter on an EMPTY block of this type should demote it to a paragraph
+ *  (ending the list) instead of stacking another empty item. */
+declare function endsListOnEmptyEnter(type: BlockType): boolean;
+interface MdShortcutMatch {
+    type: BlockType;
+    /** Whatever the user typed after the prefix — kept as the block's text. */
+    rest: string;
+    /** `[x] ` starts a CHECKED to-do. */
+    checked?: boolean;
+}
+/**
+ * Resolve a start-of-line Markdown shortcut: if `text` STARTS WITH a known
+ * prefix (e.g. `"# "`, `"- "`, `"[x] "`, `"--- "`), return the {@link BlockType}
+ * it converts to plus the remainder to keep as the block's text — so pasting
+ * `"# Title"` converts AND keeps "Title". Prefix-based (not exact-match) so the
+ * shortcut also fires when typed before existing text.
+ */
+declare function mdShortcut(text: string): MdShortcutMatch | undefined;
+/**
+ * Filter the slash menu by the text typed after "/" — case-insensitive substring
+ * over the label plus prefix match over the keyword aliases, preserving the
+ * canonical menu order (Notion keeps its sections stable rather than re-ranking).
+ */
+declare function filterBlockTypes(query: string): BlockTypeDef[];
+/**
+ * Per-run numbering for `numbered` blocks: a run restarts after any
+ * non-numbered block at the SAME indent, while deeper-indented content nested
+ * under an item does NOT break its parent's run (each indent level keeps its
+ * own counter, reset when the level is interrupted). Render-side only — the
+ * model stores no ordinals, so concurrent inserts renumber for free.
+ */
+declare function listOrdinals(blocks: Pick<Block, 'id' | 'type' | 'indent'>[]): Map<string, number>;
+
+/**
+ * Generic schema-driven content model — the shared vocabulary between
+ * `page-content.ts`, `board-content.ts`, and the future WAL/merge content
+ * engines for custom types.
+ *
+ * A `ContentSchema` describes the WAL key layout for an object type:
+ *  - `collections`: the named id-lists (RGAs) that hold item ids
+ *  - For each item field: whether it is char-RGA text or a LWW register
+ *
+ * `PAGE_SCHEMA` and `BOARD_SCHEMA` express the existing page/board layouts as
+ * data. Consumers that need to open a generic WAL doc (e.g. a future record
+ * editor) read the schema instead of hard-coding key names.
+ */
+/** How a field's value is stored in the WAL doc. */
+type FieldKind = 'charRga' | 'lww';
+interface ContentField {
+    key: string;
+    kind: FieldKind;
+}
+/** One named id-list (RGA) in the WAL doc, plus the per-item fields. */
+interface ContentCollection {
+    /** The WAL key for the id-list (e.g. `'order'`, `'columns'`, `'tasks'`). */
+    listKey: string;
+    /** Per-item field descriptors; keys are the base name (actual key = `${base}:${id}`). */
+    fields: ContentField[];
+}
+/** Full schema for an object type's WAL content doc. */
+interface ContentSchema {
+    collections: ContentCollection[];
+}
+/** Page content schema: one `order` collection whose items have char-RGA text
+ *  plus LWW registers for type/checked/indent/collapsed/ref. */
+declare const PAGE_SCHEMA: ContentSchema;
+/** Board content schema: `columns` collection (title/done per column) plus
+ *  `tasks` collection (col/order/status/title/notes per task).
+ *  NOTE: In Phase F, tasks will become first-class ObjectNodes and the `tasks`
+ *  collection will be removed from this schema. */
+declare const BOARD_SCHEMA: ContentSchema;
+declare const CALENDAR_SCHEMA: ContentSchema;
+declare const FORM_SCHEMA: ContentSchema;
+declare const FEEDBACK_SCHEMA: ContentSchema;
+/** Resolve the schema for an object's content kind.
+ *  Returns null for `'none'` (no content doc). */
+declare function schemaFor(editorKind: string): ContentSchema | null;
+
+/**
+ * Per-block discussions on a {@link WalDocument} — the Notion-style "floating
+ * comment" core. Lives in a page's **sibling** comments WAL doc (one per page,
+ * keyed `…__comments`), separate from the page content doc so the page snapshot
+ * stays lean and comments load in parallel.
+ *
+ * A **discussion** is the thread anchored to one block (by its stable block id):
+ *  - a per-block RGA list **`comments:{blockId}`** of comment ids (append order);
+ *  - per comment, the author **`author:{commentId}`** (LWW, the account userId —
+ *    the device key only *signs* the op), the timestamp **`created:{commentId}`**
+ *    (LWW) and a char-RGA body **`body:{commentId}`** so two people editing the
+ *    same comment converge per character;
+ *  - per block, a thread-level **`resolved:{blockId}`** flag (LWW);
+ *  - per (comment, reactor), an emoji set **`react:{commentId}:{userId}`** (LWW
+ *    JSON array). A **per-reactor** register — not one shared map — so two members
+ *    reacting at once never clobber each other; the projection folds the
+ *    `react:{commentId}:*` registers into `{ emoji → userIds[] }`.
+ *
+ * All registers follow the same `name:{id}` pattern as {@link page-content}, so a
+ * future field costs one line here and nothing in the transport. Pure functions
+ * over a WalDocument (no React, no network) — the `use-comments` hook owns
+ * commit/pull; these only build ops.
+ */
+
+/** One emoji and the members who reacted with it. */
+interface CommentReaction {
+    emoji: string;
+    userIds: string[];
+}
+/** A single comment in a block's discussion. */
+interface Comment {
+    id: string;
+    /** Account userId of the author (resolved to a name/avatar at the UI layer). */
+    author: string;
+    /** Creation timestamp (ms since epoch). */
+    createdAt: number;
+    /** Char-RGA body text. */
+    body: string;
+    /** Aggregated emoji reactions (empty when none). */
+    reactions: CommentReaction[];
+}
+/** The discussion anchored to one block. */
+interface DiscussionThread {
+    blockId: string;
+    resolved: boolean;
+    comments: Comment[];
+}
+/** Project the discussion for a single block (empty thread when none exist). */
+declare function readThread(doc: WalDocument, blockId: string): DiscussionThread;
+/** Project every block's discussion that holds at least one comment, keyed by
+ *  block id. The page editor reads this once and indexes per block. */
+declare function readThreads(doc: WalDocument): Map<string, DiscussionThread>;
+/** Most-recent comment timestamp in a thread (0 when empty) — the unread sort key. */
+declare function threadLastActivity(thread: DiscussionThread): number;
+/** Add a comment to a block's discussion. Returns the new comment id. */
+declare function addComment(doc: WalDocument, blockId: string, authorUserId: string, text: string, createdAt?: number): string;
+/** Replace a comment's body text (character-level CRDT merge). */
+declare function setCommentBody(doc: WalDocument, commentId: string, text: string): void;
+/** Remove a comment: drop it from the block's list, clear its body, and tombstone
+ *  its author/timestamp registers plus every reactor's register for it. */
+declare function removeComment(doc: WalDocument, blockId: string, commentId: string): void;
+/** Mark a block's discussion resolved (or reopen it). Clears the register when
+ *  reopening so a resolved-then-reopened thread leaves no snapshot residue. */
+declare function resolveThread(doc: WalDocument, blockId: string, resolved: boolean): void;
+/** Toggle one member's emoji reaction on a comment. Updates only that member's
+ *  own `react:{commentId}:{userId}` register, so concurrent reactors never
+ *  clobber each other; the register is cleared when their last emoji is removed. */
+declare function toggleReaction(doc: WalDocument, commentId: string, userId: string, emoji: string): void;
+
+/**
+ * Kanban-board view definition on a {@link WalDocument} (the `board` object type).
+ *
+ * One board WAL doc holds ONLY the **column list** (title + done-flag). Tasks are
+ * now first-class {@link ObjectNode}s (`type === 'task'`, `parentId === boardId`);
+ * see {@link task-model} for the projection from nodes → board view.
+ *
+ * Every mutation is an idempotent CRDT op. Pure over a WalDocument (no React/network).
+ */
+
+interface Column {
+    id: string;
+    title: string;
+    /** This column is the board's "Done" group: tasks in it render checked/struck. */
+    done: boolean;
+}
+/** Project the WAL document into the board's column list. */
+declare function readColumns(doc: WalDocument): Column[];
+/**
+ * Sort key for a card landing between two siblings — fractional indexing over
+ * the plain-number `order` register, so ANY drop position is a single LWW write.
+ */
+declare function orderBetween(above: number | undefined, below: number | undefined): number;
+declare function addColumn(doc: WalDocument, title: string): string;
+declare function renameColumn(doc: WalDocument, id: string, title: string): void;
+declare function setColumnDone(doc: WalDocument, id: string, done: boolean): void;
+declare function moveColumn(doc: WalDocument, id: string, toIndex: number): void;
+declare function deleteColumn(doc: WalDocument, id: string): void;
+declare function seedDefaultColumns(doc: WalDocument): void;
+
+/**
+ * Inline table block model on a {@link WalDocument} — a page's WAL doc can hold
+ * one or more table blocks among its other blocks, each keyed by its block id `T`.
+ *
+ * CRDT design decisions
+ *  - Columns: RGA list `tblcols:{T}` of column ids + per-column LWW registers.
+ *    Mirrors board-content's column list exactly (`coltitle:{c}` pattern).
+ *  - Rows: RGA list `tblrows:{T}` of row ids. Like page-content's `order`.
+ *  - Cells: `tcell:{r}:{c}` — whole-value LWW scalar registers. Deliberate trade-off:
+ *    concurrent edits to the SAME cell are last-writer-wins (simpler, no char-RGA).
+ *    Concurrent edits to DIFFERENT cells / rows / columns converge freely.
+ *  - Sort + filters: `tblsort:{T}` / `tblfilters:{T}` — LWW JSON objects shared
+ *    across all collaborators. Sort/filter are render-time derivations: the stored
+ *    `tblrows` order is NEVER mutated by sort.
+ *
+ * Pure functions over a WalDocument: no React, no network — unit-testable.
+ */
+
+/**
+ * Swatch names available for `TableSelectOption` colors.
+ * Mirrors `SwatchName` from `theme.ts` (SDK copy avoids an app-layer dependency).
+ */
+type TableSwatchName = 'gray' | 'red' | 'orange' | 'yellow' | 'green' | 'blue' | 'purple' | 'pink';
+type TableColType = 'text' | 'number' | 'select' | 'checkbox';
+/** One option in a `select` column — id + display label + categorical swatch. */
+interface TableSelectOption {
+    id: string;
+    label: string;
+    swatch: TableSwatchName;
+}
+interface TableColumn {
+    id: string;
+    title: string;
+    type: TableColType;
+    /** Options for `type === 'select'` columns. */
+    options?: TableSelectOption[];
+    /** Column width override in pixels; undefined uses the layout default. */
+    width?: number;
+}
+type CellValue = string | number | boolean | null;
+type SortDir = 'asc' | 'desc';
+interface TableSort {
+    colId: string;
+    dir: SortDir;
+}
+type TableFilter = {
+    kind: 'contains';
+    text: string;
+} | {
+    kind: 'numRange';
+    min?: number;
+    max?: number;
+} | {
+    kind: 'isOption';
+    optionIds: string[];
+} | {
+    kind: 'checked';
+    value: boolean;
+};
+interface TableModel {
+    columns: TableColumn[];
+    /** Stored (insertion-ordered) row ids — NOT sorted/filtered. */
+    rowIds: string[];
+    /** Cell values keyed `${rowId}:${colId}`. Missing key = null / empty. */
+    cells: Record<string, CellValue>;
+    sort: TableSort | null;
+    filters: Record<string, TableFilter>;
+}
+/** Project the WAL document into the full {@link TableModel} for block `T`. */
+declare function readTable(doc: WalDocument, T: string): TableModel;
+/**
+ * Derive the visible (post-filter, post-sort) row id list from a {@link TableModel}.
+ * Pure — no WAL writes. The stored `rowIds` order is NEVER mutated by sort.
+ */
+declare function visibleTableRowIds(model: TableModel): string[];
+/**
+ * Seed a newly-inserted table block: 3 columns (Name · Status · Notes) + 2 empty rows.
+ * Called from the page editor immediately after the block is created.
+ */
+declare function createTable(doc: WalDocument, T: string): void;
+/** Add a new column and return its id. */
+declare function addTableColumn(doc: WalDocument, T: string, type: TableColType, title: string): string;
+declare function renameTableColumn(doc: WalDocument, id: string, title: string): void;
+declare function setTableColumnType(doc: WalDocument, id: string, type: TableColType): void;
+declare function setTableColumnOptions(doc: WalDocument, id: string, options: TableSelectOption[]): void;
+declare function addTableSelectOption(doc: WalDocument, colId: string, label: string, swatch?: TableSwatchName): void;
+declare function removeTableSelectOption(doc: WalDocument, colId: string, optionId: string): void;
+declare function setTableColumnWidth(doc: WalDocument, colId: string, width: number): void;
+declare function moveTableColumn(doc: WalDocument, T: string, id: string, toIndex: number): void;
+/**
+ * Delete a column: remove it from the column list, tombstone its registers, and
+ * clear all cells in that column.
+ */
+declare function deleteTableColumn(doc: WalDocument, T: string, id: string): void;
+/** Add a new row at `atIndex` (appends if omitted). Returns the new row id. */
+declare function addTableRow(doc: WalDocument, T: string, atIndex?: number): string;
+declare function moveTableRow(doc: WalDocument, T: string, id: string, toIndex: number): void;
+/** Duplicate a row, placing the copy directly below the original. Returns the new row id. */
+declare function duplicateTableRow(doc: WalDocument, T: string, id: string): string;
+/**
+ * Delete a row: remove from the row list and tombstone all its cells.
+ */
+declare function deleteTableRow(doc: WalDocument, T: string, id: string): void;
+/** Set or clear a single cell value (LWW). */
+declare function setTableCell(doc: WalDocument, r: string, c: string, value: CellValue): void;
+declare function setTableSort(doc: WalDocument, T: string, colId: string, dir: SortDir): void;
+declare function clearTableSort(doc: WalDocument, T: string): void;
+/** Set the filter for one column. Merges into the existing filters record (LWW on the whole record). */
+declare function setTableFilter(doc: WalDocument, T: string, colId: string, filter: TableFilter): void;
+declare function clearTableFilter(doc: WalDocument, T: string, colId: string): void;
+declare function clearAllTableFilters(doc: WalDocument, T: string): void;
+/**
+ * Tombstone all WAL keys owned by table block `T` (call when the block is
+ * permanently deleted and undo has expired). Reads current col/row ids
+ * internally so the caller does not need to pass them.
+ */
+declare function clearTable(doc: WalDocument, T: string): void;
+
+/**
+ * Pure projection of task {@link ObjectNode}s into the kanban view.
+ *
+ * A task is an ObjectNode with `type === 'task'` and `parentId === boardId`.
+ * Its positional state lives in `meta.props` (via `propsOf`): `columnId`,
+ * `order` (fractional number), and the legacy `status` register (kept for boards
+ * without a Done column).
+ */
+
+type TaskStatus = 'todo' | 'doing' | 'done';
+interface Task {
+    id: string;
+    columnId: string;
+    title: string;
+    status: TaskStatus;
+    order: number;
+    /** Derived completion — column membership when the board has a Done column,
+     *  else the legacy `status` prop. Render from THIS, never from `status`. */
+    done: boolean;
+}
+/**
+ * Project task ObjectNodes into the board's view model.
+ *
+ * Orphaned tasks (unknown columnId) are re-homed to the first column.
+ */
+declare function tasksForBoard(nodes: ObjectNode[], boardId: string, columns: Column[]): {
+    tasksByColumn: Record<string, Task[]>;
+    done: number;
+    total: number;
+};
+
+interface CalendarEvent {
+    id: string;
+    title: string;
+    start: number;
+    end: number;
+    allDay: boolean;
+    color: string | null;
+    desc: string | null;
+}
+declare function readEvents(doc: WalDocument): CalendarEvent[];
+declare function addEvent(doc: WalDocument, init: {
+    start: number;
+    end?: number;
+    title?: string;
+    allDay?: boolean;
+    color?: string;
+    desc?: string;
+}): string;
+declare function deleteEvent(doc: WalDocument, id: string): void;
+declare function patchEvent(doc: WalDocument, id: string, patch: Partial<Omit<CalendarEvent, 'id'>>): void;
+
+type FormFieldKind = 'text' | 'email' | 'number' | 'select' | 'checkbox';
+interface FormFieldOption {
+    id: string;
+    label: string;
+}
+interface FormField {
+    id: string;
+    label: string;
+    kind: FormFieldKind;
+    required: boolean;
+    options: FormFieldOption[];
+}
+interface FormResponse {
+    id: string;
+    submittedAt: number;
+    submitter: string;
+    data: Record<string, unknown>;
+}
+declare function readFields(doc: WalDocument): FormField[];
+declare function readResponses(doc: WalDocument): FormResponse[];
+declare function addField(doc: WalDocument, init?: Partial<FormField>): string;
+declare function deleteField(doc: WalDocument, id: string): void;
+declare function moveField(doc: WalDocument, id: string, toIndex: number): void;
+declare function patchField(doc: WalDocument, id: string, patch: Partial<Omit<FormField, 'id'>>): void;
+declare function addResponse(doc: WalDocument, submitter: string, data: Record<string, unknown>, now: number): string;
+
+type FeedbackStatus = 'open' | 'planned' | 'in-progress' | 'done';
+interface FeedbackItem {
+    id: string;
+    title: string;
+    status: FeedbackStatus;
+    desc: string | null;
+    voters: string[];
+}
+declare function readItems(doc: WalDocument): FeedbackItem[];
+declare function addItem(doc: WalDocument, title: string): string;
+declare function deleteItem(doc: WalDocument, id: string): void;
+declare function patchItem(doc: WalDocument, id: string, patch: Partial<Omit<FeedbackItem, 'id' | 'voters'>>): void;
+declare function vote(doc: WalDocument, id: string, userId: string): void;
+declare function unvote(doc: WalDocument, id: string, userId: string): void;
+
+/**
+ * Starfish client construction + space keyring / encryptor / profile helpers.
+ *
+ * Profile read/write functions are thin wrappers that inject the global
+ * connection config (baseUrl, namespace via the octospaces-sdk residual
+ * `getSyncBase()` / `getSyncNamespace()`) into the starfish-spaces API,
+ * preserving the old single-argument call signature used throughout the app.
+ *
+ * openEncryptor / buildEncryptor are OctoVault-flavored wrappers: they take a
+ * `spaceId` string and construct the keyring pull path internally.
+ *
+ * makeClient is re-exported as an alias for the renamed makeSpaceClient.
+ */
+
+/**
+ * Build cap-cert auth headers for a raw `fetch` outside the StarfishClient (e.g. `GET /events`).
+ * Signing host is derived from `getSyncBase()` so the server-side verifier agrees — same pin as
+ * the client's own REST requests (StarfishClient.signingHost).
+ *
+ * starfish-spaces re-exports its own `buildAuthHeaders` that hardcodes `host: ""`, which causes
+ * `verifyRequestSignature` to fail on deployed servers that bind host. This local override
+ * restores correct behavior: sign the REAL host.
+ */
+declare function buildAuthHeaders(cap: unknown, devEdPrivHex: string, method: string, pathAndQuery: string): Promise<Record<string, string>>;
+/**
+ * Read a user's public profile (pseudo, avatar, public keys). Injects globals.
+ *
+ * Unlike readProfiles (routed through a namespace-aware client), starfish-spaces'
+ * readProfile does a raw `${baseUrl}${pullPath}` concat with no namespace option —
+ * so baseUrl must already carry the `/v1/{ns}` prefix (getSyncPrefix()).
+ */
+declare function readProfile(userId: string): Promise<PublicProfile>;
+/** Read multiple users' profiles in batched round-trips. Injects globals. */
+declare function readProfiles(ids: string[]): Promise<Map<string, PublicProfile>>;
+/** Merge a patch into the caller's own profile doc. Injects the layout. */
+declare function writeProfile(client: StarfishClient, userId: string, patch: {
+    pseudo?: string;
+    avatar?: string | null;
+    edPub?: string;
+    kemPub?: string;
+    kemSig?: string;
+}): Promise<void>;
+/** Soft variant of {@link openEncryptor}: returns null instead of throwing. */
+declare function buildEncryptor(client: StarfishClient, keys: DeviceKeys, spaceId: string, trustedAdders: string[]): Promise<Encryptor | null>;
+
+/**
+ * Device pairing (one-way, PIN-sealed). The existing device provisions a new
+ * device's keypair + cap bundle, seals it with the PIN (Argon2id → AES-GCM), and
+ * drops it on the public `_pairing/<nonce>` rendezvous. The QR carries only the
+ * nonce; the new device fetches the sealed blob, opens it with the PIN, and
+ * validates the cap bundle. This proves the cryptographic handshake end-to-end.
+ *
+ * `startDevicePairing` / `completeDevicePairing` come directly from
+ * starfish-spaces — dk-spaces-sdk 0.30 stopped wrapping device pairing.
+ *
+ * starfish alpha.63 made root-trust MANDATORY on pairing completion: the receiving
+ * device must pass `expectedRootEdPub` (a pinned root key) or `confirmUnpinnedRoot`
+ * (a callback), else `completeDevicePairing` throws. OctoVault has no prior-pinned
+ * root to check against here (the new device is bootstrapping FROM this scan), so
+ * `confirmUnpinnedRoot` always trusts — the actual security boundary is the
+ * PIN-sealed bundle + physical QR proximity, same as before this change.
+ */
+
+declare const PAIR_PREFIX = "octovault-pair:";
+
+/** New device: open the sealed bundle at the rendezvous nonce and install it. */
+declare function completeDevicePairing(payload: string, pin: string): Promise<PairResult>;
+/** Existing device: provision + PIN-seal a new device, publish to rendezvous, return the QR payload. */
+declare function startDevicePairing(session: Session, pin: string): Promise<string>;
+
+/**
+ * Member-cap shims — thin compatibility layer over the starfish-spaces
+ * space-access store. Exposes `getMemberCap` (vault convenience helper) and
+ * the store operations that the vault actively consumes.
+ */
+
+/** Returns the raw cap string for member-kind entries; null otherwise. */
+declare function getMemberCap(spaceId: string): string | null;
+
+/**
+ * Wraps starfish-spaces `readSpaces` to re-flatten OctoVault-specific extra fields:
+ * - `mutes: MutePrefs` — from `doc.extra.mutes`
+ * - `reads: ReadPrefs` — from `doc.extra.reads`
+ *
+ * Call-sites that destructure `{ spaces, caps, mutes, reads }` work without change.
+ */
+declare function readSpaces(client: StarfishClient, session: Session): Promise<{
+    mutes: MutePrefs;
+    reads: ReadPrefs;
+    spaces: _drakkar_software_starfish_spaces.Space[];
+    caps: _drakkar_software_starfish_spaces.CapMap;
+    pubAccess: _drakkar_software_starfish_spaces.PubAccessMap;
+    extra: Record<string, unknown>;
+    hash: string | null;
+}>;
+/**
+ * Member-side: leave a space — drop it from this identity's own `_spaces` doc (the
+ * `spaces` list AND its `caps`/`pubAccess` entry) through the conflict-retrying
+ * `updateSpacesDoc` funnel, then forget its member cap from the local store.
+ *
+ * This is a LOCAL leave (the user stops syncing/seeing the space) — it does NOT
+ * remove the user from the owner's roster or rotate the keyring; that is the owner's
+ * `removeSpaceMember`, and a true keyring revoke is out of scope.
+ */
+declare function leaveSpace(client: StarfishClient, session: Session, spaceId: string): Promise<void>;
+/** A user-facing category/space validation failure (empty/duplicate name).
+ *  The hook layer surfaces `message` verbatim, unlike an opaque network/HTTP error. */
+declare class CategoryError extends Error {
+}
+
+/**
+ * OctoVault-specific object-tree extensions.
+ *
+ * These helpers bridge the vault's `props`/`automation` concept (which used to be
+ * top-level ObjectNode fields) onto the octospaces-sdk `node.meta` bag.
+ *
+ * Migration:
+ *   OLD: node.props?.[key]         → NEW: propsOf(node)[key]
+ *   OLD: node.automation            → NEW: automationOf(node)
+ *   OLD: addObject(nodes, { type, title, props, automation }, now)
+ *        → addVaultObject(nodes, { type, title, props, automation }, now)
+ *   OLD: setProps(nodes, id, patch, now)  → same, from here
+ *   OLD: clearProp(nodes, id, key, now)   → same, from here
+ */
+
+/** Read the `props` map from a node's `meta` bag (typed for vault usage). */
+declare function propsOf(node: ObjectNode): Record<string, PropValue>;
+/** Read the `automation` config from a node's `meta` bag. Returns `null` when absent. */
+declare function automationOf(node: ObjectNode): AutomationMeta | null;
+/** Vault-specific new-node input (adds `props` and `automation` fields). */
+interface VaultNewObjectInput {
+    type: string;
+    parentId?: string | null;
+    title: string;
+    emoji?: string;
+    id?: string;
+    access?: ObjectNode['access'];
+    enc?: boolean;
+    /** Structured property values (stored under `meta.props`). */
+    props?: Record<string, PropValue>;
+    /** Automation config (stored under `meta.automation`). */
+    automation?: AutomationMeta;
+    /** Any additional meta fields (merged with props/automation). */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Create a new vault object node, mapping vault-specific `props`/`automation`
+ * into `meta.props`/`meta.automation` as required by the octospaces model.
+ */
+declare function addVaultObject(nodes: ObjectNode[], input: VaultNewObjectInput, now: number): {
+    nodes: ObjectNode[];
+    node: ObjectNode;
+};
+/** Merge a props patch into a node's `meta.props` (node-level LWW write; bumps `updatedAt`). */
+declare function setProps(nodes: ObjectNode[], id: string, patch: Record<string, PropValue>, now: number): ObjectNode[];
+/** Remove a single key from a node's `meta.props` (LWW write; bumps `updatedAt`). */
+declare function clearProp(nodes: ObjectNode[], id: string, key: string, now: number): ObjectNode[];
+/** Patch a node's `automation` field (stored as `meta.automation`), bumping `updatedAt`. */
+declare function patchAutomation(nodes: ObjectNode[], id: string, automation: AutomationMeta | null, now: number): ObjectNode[];
+
+/**
+ * Default object-blob store — a second, independent `createSealedBlobStore`
+ * singleton, in-memory cache only (no KV persistence — matches the old
+ * octospaces-sdk default singleton this replaces), previously exposed as bare
+ * `uploadObjectBlob`/`loadObjectBlob` functions. Used directly by file/image
+ * ObjectNode attachments (see apps/mobile's use-object-files.ts /
+ * use-object-blob.ts) — kept separate from ./attachments' custom-prefixed,
+ * KV-persisted store so neither store's cache behavior shifts.
+ */
+
+declare function uploadObjectBlob(client: StarfishClient, enc: ByteSealer | null, spaceId: string, bytes: Uint8Array, name: string, mime: string): Promise<ObjectBlobRef>;
+declare function loadObjectBlob(client: StarfishClient, enc: ByteSealer | null, spaceId: string, blobId: string): Promise<Uint8Array>;
+
+/**
+ * OctoVault attachment layer, backed by the `objblob` collection
+ * (`spaces/{spaceId}/objects/blobs/{blobId}`) via starfish-client's
+ * `createSealedBlobStore`, fed dk-spaces-sdk's `objectBlobPaths` path/AAD
+ * strategy. Blobs are keyed by SPACE, sealed client-side before upload, and
+ * cached in memory + KV for offline reads.
+ *
+ * Public API is kept stable (same names/types as the legacy attachment store)
+ * so callers need no changes to imports. dk-spaces-sdk 0.30 stopped wrapping
+ * the blob store — this module now builds it directly and re-attaches the
+ * `name`/`mime`/`kind` metadata the new generic store no longer tracks (its
+ * `upload`/`load` only take raw bytes + id).
+ */
+
+interface AttachmentRef extends ObjectBlobRef {
+    kind: 'image' | 'file';
+}
+declare function uploadAttachment(client: StarfishClient, enc: ByteSealer | null, spaceId: string, bytes: Uint8Array, name: string, mime: string): Promise<AttachmentRef>;
+declare function loadAttachment(client: StarfishClient, enc: ByteSealer | null, spaceId: string, ref: AttachmentRef): Promise<Uint8Array>;
+declare function clearAttachmentCache(): void;
+
+/** OctoVault's connection timeout: 12 s (octospaces used 12 s; starfish default is 10 s). */
+declare const CONNECT_TIMEOUT_MS = 12000;
+/**
+ * Returns a timeout-wrapped `fetch` function that aborts after `ms` milliseconds.
+ * Drop-in for the global `fetch` — pass to StarfishClient, useSyncInit, etc.
+ * Default timeout preserves OctoVault's historic 12 s.
+ */
+declare function fetchWithTimeout(ms?: number): typeof globalThis.fetch;
+
+/** 30 days — mirrors the default from the old octospaces pullCache. */
+declare const PULL_CACHE_MAX_AGE_MS: number;
+/**
+ * Returns the shared KV-backed pull-cache singleton. Pass it as `cache:` in every
+ * `useSyncInit` / `useSharedSyncStore` / `useMergeDoc` call-site.
+ */
+declare function pullCache(): _drakkar_software_starfish_client.PullCache;
+
+/**
+ * Bot / integration write credentials for automation stream rooms.
+ *
+ * `openStreamBotCredential` opens a stored (sealed) bot credential from an
+ * automation node's `meta.automation.credential` field.
+ *
+ * NOTE: `createStreamBotCredential` relied on the removed pubstream/public-link
+ * model. New automation bots are enrolled as node members via `inviteToNode` and
+ * receive a standard member cap; this module only provides the credential-open
+ * helper needed at runtime.
+ */
+
+interface StreamBotCredential {
+    /** The public-link fragment (an audience cap) — the bot's `parsePublicLink` input.
+     *  Carries no private key; the bot signs with its own generated key. */
+    token: string;
+    /** Full append endpoint the bot POSTs to (already namespace-prefixed). */
+    endpoint: string;
+    /** The path+query the bot must sign (what `redeemPublicLink` binds the signature to). */
+    signPath: string;
+    /** Absolute expiry (unix seconds) of the credential, if a TTL was set. */
+    expiresAt?: number;
+}
+/** Open a stored automation bot credential. Current rooms store it SEALED to the owner
+ *  key (`mintSealedCredential`) — unseal with the seed. A LEGACY room (created before
+ *  the seal) stored the credential in the clear; detect that by its `token` and return
+ *  it as-is so the automation keeps working until the owner rotates (which re-seals).
+ *  No new exposure: a legacy credential was already plaintext in the synced doc. */
+declare function openStreamBotCredential(session: Session, stored: SealedBlob | StreamBotCredential): Promise<StreamBotCredential>;
+
+export { type AiSettings, type AttachmentRef, type AutomationMeta, BLOCK_SECTIONS, BLOCK_TYPES, BOARD_SCHEMA, BUILTIN_OBJECT_TYPES, BUILTIN_REGISTRY, type Block, type BlockSection, type BlockType, type BlockTypeDef, type BookmarkMeta, type BuiltinObjectType, CALENDAR_SCHEMA, CAPABILITY_META, CONNECT_TIMEOUT_MS, type CalendarEvent, type Capability, type CapabilityMeta, CategoryError, type CellValue, type Column, type Comment, type CommentReaction, type ContentCollection, type ContentField, type ContentKind, type ContentSchema, type CreatableTypeEntry, DEFAULT_AI_SETTINGS, DEFAULT_QUICK_REACTIONS, type DiscussionThread, EMOJI, EMOJI_CATEGORIES, EMOJI_LIST, EMPTY_TYPES_DOC, type EditorKind, type EmojiCategory, type EmojiMatch, FEEDBACK_SCHEMA, FORM_SCHEMA, type FeedbackItem, type FeedbackStatus, type FieldDef, type FieldKind, type FormField, type FormFieldKind, type FormFieldOption, type FormResponse, type IconName, type LegalDoc, type LegalSection, type MdShortcutMatch, type NewBlock, type ObjectDescriptor, PAGE_SCHEMA, PAIR_PREFIX, PULL_CACHE_MAX_AGE_MS, type Profile, type PropField, type PropKind, type PropOption, type PropValue, QUICK_REACTION_COUNT, REF_BLOCK_TYPES, type SecurityItem, type SelectOption, type SortDir, type Space, type EditorKind$1 as StoresEditorKind, type PropKind$1 as StoresPropKind, type StreamBotCredential, type TableColType, type TableColumn, type TableFilter, type TableModel, type TableSelectOption, type TableSort, type TableSwatchName, type Task, type TaskStatus, type TextVariant, type TypeDef, type TypeDescriptor, type TypeRegistry, type TypesDoc, type User, activeEmojiQuery, addColumn, addComment, addEvent, addField$1 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, getSyncBase, getSyncNamespace, getSyncPrefix, humanizeError, hydrateMutes, hydrateQuickReactions, hydrateReads, iconFor, iconForNode, insertBlock, isContainerType, isFindableType, isMultiline, isMuted, isOpenableObjectType, isRoomMuted, isSpaceMuted, kvGet, kvRemove, 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, patchField$1 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 };