@xnetjs/react 0.0.2 → 0.1.0

package/dist/chunk-7OQXRHEQ.js

@@ -0,0 +1,4649 @@
+import {
+  useMutate,
+  useQuery
+} from "./chunk-6VOICQZ3.js";
+import {
+  XNetContext,
+  downloadBackup,
+  uploadBackup,
+  useNodeStore,
+  useSecurityContext,
+  useXNet
+} from "./chunk-IHTMVTTE.js";
+
+// src/hooks/useTaskProjectionSync.ts
+import { ExternalReferenceSchema, TaskSchema, isCompletedTaskStatus } from "@xnetjs/data";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var DEFAULT_DEBOUNCE_MS = 250;
+function arraysEqual(a, b) {
+  if (!Array.isArray(a)) return b.length === 0;
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index += 1) {
+    if (a[index] !== b[index]) return false;
+  }
+  return true;
+}
+function stableHash(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function computeExternalReferenceId(taskId, reference) {
+  const identity = [
+    taskId,
+    reference.provider ?? "generic",
+    reference.kind ?? "link",
+    reference.refId ?? "",
+    reference.url
+  ].join("|");
+  return `external_reference_${stableHash(identity)}`;
+}
+function getNextStatus(currentStatus, completed) {
+  if (completed) return "done";
+  if (!currentStatus || isCompletedTaskStatus(currentStatus)) return "todo";
+  return currentStatus;
+}
+function isDid(value) {
+  return /^did:[a-z]+:[a-zA-Z0-9._:-]+$/.test(value);
+}
+function normalizeAssignees(assignees) {
+  return Array.from(new Set(assignees)).filter(isDid);
+}
+function toDateTimestamp(date) {
+  if (!date || !/^\d{4}-\d{2}-\d{2}$/.test(date)) return void 0;
+  const [year, month, day] = date.split("-").map(Number);
+  const timestamp = Date.UTC(year, month - 1, day);
+  if (Number.isNaN(timestamp)) return void 0;
+  const normalized = new Date(timestamp);
+  if (normalized.getUTCFullYear() !== year || normalized.getUTCMonth() !== month - 1 || normalized.getUTCDate() !== day) {
+    return void 0;
+  }
+  return timestamp;
+}
+function normalizeProvider(provider) {
+  switch (provider) {
+    case "github":
+    case "figma":
+    case "youtube":
+    case "loom":
+    case "vimeo":
+    case "codesandbox":
+    case "spotify":
+    case "twitter":
+    case "instagram":
+    case "tiktok":
+      return provider;
+    default:
+      return "generic";
+  }
+}
+function normalizeKind(kind) {
+  switch (kind) {
+    case "issue":
+    case "pull-request":
+    case "design":
+    case "video":
+    case "sandbox":
+    case "social":
+    case "audio":
+      return kind;
+    default:
+      return "link";
+  }
+}
+function useTaskProjectionSync({
+  host,
+  hostId,
+  debounceMs = DEFAULT_DEBOUNCE_MS
+}) {
+  const { create, update, remove, restore } = useMutate();
+  const disabledHostId = `__${host}_task_sync_disabled__`;
+  const { data: existingTasks } = useQuery(TaskSchema, {
+    where: host === "page" ? { page: hostId ?? disabledHostId } : { canvas: hostId ?? disabledHostId },
+    includeDeleted: true
+  });
+  const taskSnapshotsRef = useRef([]);
+  const syncRunIdRef = useRef(0);
+  const [revision, setRevision] = useState(0);
+  const [syncing, setSyncing] = useState(false);
+  const [error, setError] = useState(null);
+  const existingTaskMap = useMemo(() => {
+    return new Map(existingTasks.map((task) => [task.id, task]));
+  }, [existingTasks]);
+  const handleTasksChange = useCallback((tasks) => {
+    taskSnapshotsRef.current = tasks;
+    setRevision((value) => value + 1);
+  }, []);
+  useEffect(() => {
+    if (!hostId) return;
+    let cancelled = false;
+    const timer = setTimeout(() => {
+      const run = async () => {
+        const runId = syncRunIdRef.current + 1;
+        syncRunIdRef.current = runId;
+        const currentTasks = taskSnapshotsRef.current;
+        const nextTaskIds = new Set(currentTasks.map((task) => task.taskId));
+        const tasksToClaimOrCreate = [];
+        const tasksToRestore = [];
+        const taskUpdates = [];
+        const taskDeletes = [];
+        const referenceUpserts = [];
+        const hostFields = host === "page" ? { page: hostId, source: "page" } : { canvas: hostId, source: "canvas" };
+        for (const task of currentTasks) {
+          const existingTask = existingTaskMap.get(task.taskId);
+          const assignees = normalizeAssignees(task.assignees);
+          const dueDate = toDateTimestamp(task.dueDate);
+          const primaryAssignee = assignees[0];
+          const nextReferenceUpserts = [];
+          const referenceIds = task.references.map((reference) => {
+            const id = computeExternalReferenceId(task.taskId, reference);
+            nextReferenceUpserts.push({
+              id,
+              data: {
+                url: reference.url,
+                provider: normalizeProvider(reference.provider),
+                kind: normalizeKind(reference.kind),
+                ...reference.refId ? { refId: reference.refId } : {},
+                title: reference.title ?? reference.refId ?? reference.url,
+                ...reference.subtitle ? { subtitle: reference.subtitle } : {},
+                ...reference.icon ? { icon: reference.icon } : {},
+                ...reference.embedUrl ? { embedUrl: reference.embedUrl } : {},
+                metadata: reference.metadata
+              }
+            });
+            return id;
+          });
+          if (!existingTask) {
+            tasksToClaimOrCreate.push({
+              id: task.taskId,
+              data: {
+                title: task.title,
+                completed: task.completed,
+                status: getNextStatus(void 0, task.completed),
+                parent: task.parentTaskId ?? void 0,
+                ...hostFields,
+                anchorBlockId: task.blockId,
+                sortKey: task.sortKey,
+                assignee: primaryAssignee,
+                assignees,
+                dueDate,
+                references: referenceIds
+              }
+            });
+            referenceUpserts.push(...nextReferenceUpserts);
+            continue;
+          }
+          if (existingTask.deleted) {
+            tasksToRestore.push(task.taskId);
+          }
+          const nextStatus = getNextStatus(
+            typeof existingTask.status === "string" ? existingTask.status : void 0,
+            task.completed
+          );
+          const updateData = {};
+          const nextDueDate = dueDate;
+          const nextPrimaryAssignee = primaryAssignee;
+          if (existingTask.title !== task.title) updateData.title = task.title;
+          if (existingTask.completed !== task.completed) updateData.completed = task.completed;
+          if (existingTask.status !== nextStatus) updateData.status = nextStatus;
+          if ((existingTask.parent ?? null) !== task.parentTaskId) {
+            updateData.parent = task.parentTaskId ?? void 0;
+          }
+          if (host === "page" && existingTask.page !== hostId) updateData.page = hostId;
+          if (host === "canvas" && existingTask.canvas !== hostId) updateData.canvas = hostId;
+          if (existingTask.anchorBlockId !== task.blockId) updateData.anchorBlockId = task.blockId;
+          if (existingTask.sortKey !== task.sortKey) updateData.sortKey = task.sortKey;
+          if (existingTask.source !== host) updateData.source = host;
+          if (!arraysEqual(existingTask.assignees, assignees)) {
+            updateData.assignees = assignees;
+          }
+          if ((existingTask.assignee ?? void 0) !== nextPrimaryAssignee) {
+            updateData.assignee = nextPrimaryAssignee;
+          }
+          if ((existingTask.dueDate ?? void 0) !== nextDueDate) {
+            updateData.dueDate = nextDueDate;
+          }
+          if (!arraysEqual(existingTask.references, referenceIds)) {
+            updateData.references = referenceIds;
+            referenceUpserts.push(...nextReferenceUpserts);
+          }
+          if (Object.keys(updateData).length > 0) {
+            taskUpdates.push({
+              id: task.taskId,
+              data: updateData
+            });
+          }
+        }
+        for (const existingTask of existingTasks) {
+          if (existingTask.deleted) continue;
+          if (nextTaskIds.has(existingTask.id)) continue;
+          taskDeletes.push(existingTask.id);
+        }
+        if (tasksToClaimOrCreate.length === 0 && tasksToRestore.length === 0 && taskUpdates.length === 0 && taskDeletes.length === 0 && referenceUpserts.length === 0) {
+          if (!cancelled) {
+            setSyncing(false);
+            setError(null);
+          }
+          return;
+        }
+        if (!cancelled) {
+          setSyncing(true);
+          setError(null);
+        }
+        try {
+          for (const reference of referenceUpserts) {
+            if (cancelled || runId !== syncRunIdRef.current) return;
+            try {
+              await update(ExternalReferenceSchema, reference.id, reference.data);
+            } catch {
+              await create(ExternalReferenceSchema, reference.data, reference.id);
+            }
+          }
+          for (const taskId of tasksToRestore) {
+            if (cancelled || runId !== syncRunIdRef.current) return;
+            await restore(taskId);
+          }
+          for (const task of tasksToClaimOrCreate) {
+            if (cancelled || runId !== syncRunIdRef.current) return;
+            let claimed = false;
+            try {
+              await restore(task.id);
+              claimed = true;
+            } catch {
+              claimed = false;
+            }
+            if (cancelled || runId !== syncRunIdRef.current) return;
+            if (claimed) {
+              await update(TaskSchema, task.id, task.data);
+            } else {
+              await create(TaskSchema, task.data, task.id);
+            }
+          }
+          for (const task of taskUpdates) {
+            if (cancelled || runId !== syncRunIdRef.current) return;
+            await update(TaskSchema, task.id, task.data);
+          }
+          for (const taskId of taskDeletes) {
+            if (cancelled || runId !== syncRunIdRef.current) return;
+            await remove(taskId);
+          }
+          if (!cancelled) {
+            setSyncing(false);
+          }
+        } catch (err) {
+          if (!cancelled) {
+            setSyncing(false);
+            setError(err instanceof Error ? err : new Error(String(err)));
+          }
+        }
+      };
+      void run();
+    }, debounceMs);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [
+    create,
+    debounceMs,
+    existingTaskMap,
+    existingTasks,
+    host,
+    hostId,
+    remove,
+    restore,
+    revision,
+    update
+  ]);
+  return {
+    handleTasksChange,
+    syncing,
+    error
+  };
+}
+
+// src/hooks/usePageTaskSync.ts
+function usePageTaskSync({
+  pageId,
+  debounceMs
+}) {
+  return useTaskProjectionSync({
+    host: "page",
+    hostId: pageId,
+    ...debounceMs !== void 0 ? { debounceMs } : {}
+  });
+}
+
+// src/hooks/useFind.ts
+import { evaluateQueryASTPlannerGate, executeQueryASTLoadedAggregates } from "@xnetjs/data";
+import { useMemo as useMemo2 } from "react";
+var EMPTY_FIND_OPTIONS = {};
+function addBlocker(blockers, blocker) {
+  if (!blockers.includes(blocker)) {
+    blockers.push(blocker);
+  }
+}
+function schemaIdsFor(schema) {
+  return [...new Set([schema._schemaId, schema.schema["@id"]].filter(Boolean))];
+}
+function compilePredicate(predicate) {
+  const where = {};
+  const blockers = [];
+  const visit = (next) => {
+    if (next.kind === "and") {
+      next.predicates.forEach(visit);
+      return;
+    }
+    if (next.kind !== "comparison" || next.op !== "eq") {
+      addBlocker(blockers, "usefind-predicate-not-lowerable");
+      return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(next, "value")) {
+      addBlocker(blockers, "usefind-eq-value-required");
+      return;
+    }
+    if (Object.prototype.hasOwnProperty.call(where, next.field) && where[next.field] !== next.value) {
+      addBlocker(blockers, "usefind-conflicting-field-equality");
+      return;
+    }
+    where[next.field] = next.value;
+  };
+  if (predicate) {
+    visit(predicate);
+  }
+  return { where, blockers };
+}
+function compilePage(page, filter, blockers) {
+  if (!page) return;
+  if ((page.after || page.count) && page.first === void 0) {
+    addBlocker(blockers, "usefind-cursor-page-first-required");
+  }
+  if (page.after && page.offset !== void 0) {
+    addBlocker(blockers, "usefind-cursor-and-offset-pagination-not-supported");
+  }
+  if (page.first !== void 0) {
+    filter.page = {
+      first: page.first,
+      ...page.after ? { after: page.after } : {},
+      ...page.count ? { count: page.count } : {}
+    };
+  }
+  if (page.offset !== void 0) {
+    filter.offset = page.offset;
+  }
+}
+function compileNodeQuery(schema, ast, options) {
+  const blockers = [];
+  if (!schemaIdsFor(schema).includes(ast.schemaId)) {
+    addBlocker(blockers, "usefind-schema-mismatch");
+  }
+  if (ast.include && Object.keys(ast.include).length > 0) {
+    addBlocker(blockers, "usefind-relation-includes-not-executable");
+  }
+  const compiledPredicate = compilePredicate(ast.predicate);
+  compiledPredicate.blockers.forEach((blocker) => addBlocker(blockers, blocker));
+  const filter = {
+    ...options,
+    ...Object.keys(compiledPredicate.where).length > 0 ? { where: compiledPredicate.where } : {},
+    ...ast.orderBy && ast.orderBy.length > 0 ? {
+      orderBy: Object.fromEntries(
+        ast.orderBy.map((entry) => [entry.field, entry.direction])
+      )
+    } : {}
+  };
+  compilePage(ast.page, filter, blockers);
+  return { filter, blockers };
+}
+function compileFindQuery(schema, ast, options) {
+  if (ast.kind !== "node") {
+    return {
+      filter: {},
+      blockers: ["usefind-query-sets-not-executable"]
+    };
+  }
+  return compileNodeQuery(schema, ast, options);
+}
+function plannerError(blockers) {
+  return new Error(`useFind planner blocked query execution: ${blockers.join(", ")}`);
+}
+function useFind(schema, ast, options) {
+  const resolvedOptions = options ?? EMPTY_FIND_OPTIONS;
+  const plannerGate = useMemo2(() => evaluateQueryASTPlannerGate(ast), [ast]);
+  const compiled = useMemo2(
+    () => compileFindQuery(schema, ast, resolvedOptions),
+    [schema, ast, resolvedOptions]
+  );
+  const blockers = useMemo2(
+    () => [.../* @__PURE__ */ new Set([...plannerGate.blockers, ...compiled.blockers])],
+    [compiled.blockers, plannerGate.blockers]
+  );
+  const canExecute = plannerGate.validation.valid && blockers.length === 0;
+  const result = useQuery(schema, canExecute ? compiled.filter : { enabled: false });
+  const error = useMemo2(
+    () => canExecute ? result.error : plannerError(blockers),
+    [blockers, canExecute, result.error]
+  );
+  const aggregates = useMemo2(
+    () => canExecute && ast.kind === "node" && ast.aggregates && ast.aggregates.length > 0 ? executeQueryASTLoadedAggregates(ast, result.data) : null,
+    [ast, canExecute, result.data]
+  );
+  return {
+    ...result,
+    status: error ? "error" : result.status,
+    loading: canExecute ? result.loading : false,
+    isLoading: canExecute ? result.isLoading : false,
+    isFetching: canExecute ? result.isFetching : false,
+    error,
+    plannerGate,
+    blockers,
+    canExecute,
+    aggregates
+  };
+}
+
+// src/hooks/useTasks.ts
+import { TaskSchema as TaskSchema2 } from "@xnetjs/data";
+import { useMemo as useMemo3 } from "react";
+function compareOptionalNumbers(a, b) {
+  if (a == null && b == null) return 0;
+  if (a == null) return 1;
+  if (b == null) return -1;
+  return a - b;
+}
+function sortTasks(tasks, pageScoped) {
+  return [...tasks].sort((a, b) => {
+    if (pageScoped) {
+      const aKey2 = typeof a.sortKey === "string" ? a.sortKey : "";
+      const bKey2 = typeof b.sortKey === "string" ? b.sortKey : "";
+      return aKey2.localeCompare(bKey2) || a.id.localeCompare(b.id);
+    }
+    if (a.completed !== b.completed) {
+      return Number(a.completed) - Number(b.completed);
+    }
+    const dueDateComparison = compareOptionalNumbers(
+      typeof a.dueDate === "number" ? a.dueDate : void 0,
+      typeof b.dueDate === "number" ? b.dueDate : void 0
+    );
+    if (dueDateComparison !== 0) return dueDateComparison;
+    const updatedAtComparison = b.updatedAt - a.updatedAt;
+    if (updatedAtComparison !== 0) return updatedAtComparison;
+    const aKey = typeof a.sortKey === "string" ? a.sortKey : "";
+    const bKey = typeof b.sortKey === "string" ? b.sortKey : "";
+    const aTitle = a.title ?? "";
+    const bTitle = b.title ?? "";
+    return aKey.localeCompare(bKey) || aTitle.localeCompare(bTitle) || a.id.localeCompare(b.id);
+  });
+}
+function matchesAssignee(task, assigneeDid) {
+  if (!assigneeDid) return true;
+  if (typeof task.assignee === "string" && task.assignee === assigneeDid) return true;
+  return Array.isArray(task.assignees) && task.assignees.map(String).includes(assigneeDid);
+}
+function matchesStatus(task, statuses) {
+  if (!statuses || statuses.length === 0) return true;
+  return typeof task.status === "string" && statuses.includes(task.status);
+}
+function matchesParent(task, parentTaskId) {
+  if (parentTaskId === void 0) return true;
+  return (task.parent ?? null) === parentTaskId;
+}
+function getStartOfUtcDay(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+function matchesDueDate(task, dueDateFilter) {
+  if (!dueDateFilter || dueDateFilter === "any") return true;
+  const dueDate = typeof task.dueDate === "number" ? task.dueDate : void 0;
+  if (dueDateFilter === "none") return dueDate == null;
+  if (dueDate == null) return false;
+  const todayStart = getStartOfUtcDay(Date.now());
+  const dueDay = getStartOfUtcDay(dueDate);
+  switch (dueDateFilter) {
+    case "overdue":
+      return dueDay < todayStart;
+    case "today":
+      return dueDay === todayStart;
+    case "next-7-days":
+      return dueDay >= todayStart && dueDay <= todayStart + 6 * 24 * 60 * 60 * 1e3;
+    default:
+      return true;
+  }
+}
+function buildTaskTree(tasks) {
+  const treeById = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const task of tasks) {
+    treeById.set(task.id, {
+      task,
+      depth: 0,
+      children: []
+    });
+  }
+  for (const task of tasks) {
+    const current = treeById.get(task.id);
+    if (!current) continue;
+    const parentId = task.parent ?? null;
+    const parent = parentId ? treeById.get(parentId) : void 0;
+    if (!parent) {
+      roots.push(current);
+      continue;
+    }
+    parent.children.push(current);
+  }
+  const setDepth = (node, depth) => {
+    node.depth = depth;
+    for (const child of node.children) {
+      setDepth(child, depth + 1);
+    }
+  };
+  for (const root of roots) {
+    setDepth(root, 0);
+  }
+  return roots;
+}
+function useTasks({
+  pageId,
+  assigneeDid,
+  includeCompleted = true,
+  statuses,
+  parentTaskId,
+  dueDateFilter = "any"
+} = {}) {
+  const query = useQuery(
+    TaskSchema2,
+    pageId ? {
+      where: { page: pageId }
+    } : {}
+  );
+  const tasks = useMemo3(() => {
+    const filtered = query.data.filter((task) => {
+      if (!includeCompleted && task.completed) return false;
+      if (!matchesAssignee(task, assigneeDid)) return false;
+      if (!matchesStatus(task, statuses)) return false;
+      if (!matchesParent(task, parentTaskId)) return false;
+      if (!matchesDueDate(task, dueDateFilter)) return false;
+      return true;
+    });
+    return sortTasks(filtered, Boolean(pageId));
+  }, [assigneeDid, dueDateFilter, includeCompleted, pageId, parentTaskId, query.data, statuses]);
+  const tree = useMemo3(() => buildTaskTree(tasks), [tasks]);
+  return {
+    data: tasks,
+    tree,
+    loading: query.loading,
+    error: query.error,
+    reload: query.reload
+  };
+}
+
+// src/hooks/useComments.ts
+import { CommentSchema, getMentionedUsers, normalizeMentions } from "@xnetjs/data";
+import { useState as useState2, useEffect as useEffect2, useMemo as useMemo4, useCallback as useCallback2, useRef as useRef2 } from "react";
+function useComments({ nodeId, anchorType }) {
+  const { store, isReady } = useNodeStore();
+  const [comments, setComments] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const queryRef = useRef2({ nodeId, anchorType });
+  queryRef.current = { nodeId, anchorType };
+  const loadComments = useCallback2(async () => {
+    if (!store || !isReady) return;
+    try {
+      setLoading(true);
+      setError(null);
+      const nodes = await store.list({
+        schemaId: CommentSchema._schemaId
+      });
+      const filtered = nodes.filter((n) => {
+        if (n.properties.target !== queryRef.current.nodeId) return false;
+        if (queryRef.current.anchorType && n.properties.anchorType !== queryRef.current.anchorType && !n.properties.inReplyTo) {
+          return false;
+        }
+        return true;
+      });
+      const commentNodes = filtered.map((n) => nodeToComment(n));
+      setComments(commentNodes);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [store, isReady]);
+  useEffect2(() => {
+    loadComments();
+  }, [loadComments]);
+  useEffect2(() => {
+    if (!store || !isReady) return;
+    const handleChange = (event) => {
+      if (event.node?.schemaId === CommentSchema._schemaId) {
+        if (event.node.properties.target === nodeId) {
+          loadComments();
+        }
+      } else if (event.change?.payload?.schemaId === CommentSchema._schemaId) {
+        loadComments();
+      }
+    };
+    const unsubscribe = store.subscribe(handleChange);
+    return () => unsubscribe();
+  }, [store, isReady, loadComments, nodeId]);
+  const threads = useMemo4(() => {
+    const threadMap = /* @__PURE__ */ new Map();
+    for (const comment of comments) {
+      if (!comment.properties.inReplyTo) {
+        threadMap.set(comment.id, { root: comment, replies: [] });
+      }
+    }
+    for (const comment of comments) {
+      const rootId = comment.properties.inReplyTo;
+      if (rootId) {
+        const thread = threadMap.get(rootId);
+        if (thread) {
+          thread.replies.push(comment);
+        }
+      }
+    }
+    for (const thread of threadMap.values()) {
+      thread.replies.sort((a, b) => a.lamportTime - b.lamportTime);
+    }
+    return Array.from(threadMap.values());
+  }, [comments]);
+  const unresolvedCount = useMemo4(() => {
+    return threads.filter((t) => !t.root.properties.resolved).length;
+  }, [threads]);
+  const addComment = useCallback2(
+    async (options) => {
+      if (!store || !isReady) return null;
+      try {
+        const node = await store.create({
+          schemaId: CommentSchema._schemaId,
+          properties: {
+            target: nodeId,
+            targetSchema: options.targetSchema,
+            anchorType: options.anchorType,
+            anchorData: options.anchorData,
+            content: options.content,
+            // Composer-declared structured mentions (0168): DID-form
+            // @mentions in the markdown become a queryable field.
+            mentions: normalizeMentions({ dids: getMentionedUsers(options.content) }),
+            resolved: false,
+            edited: false
+          }
+        });
+        return node.id;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, isReady, nodeId]
+  );
+  const replyTo = useCallback2(
+    async (rootCommentId, content, context) => {
+      if (!store || !isReady) return null;
+      const root = threads.find((t) => t.root.id === rootCommentId)?.root;
+      if (!root) {
+        setError(new Error("Thread root not found"));
+        return null;
+      }
+      try {
+        const node = await store.create({
+          schemaId: CommentSchema._schemaId,
+          properties: {
+            target: nodeId,
+            targetSchema: root.properties.targetSchema,
+            inReplyTo: rootCommentId,
+            // Always points to root (flat threading)
+            anchorType: "node",
+            // Replies don't need positional anchors
+            anchorData: "{}",
+            content,
+            mentions: normalizeMentions({ dids: getMentionedUsers(content) }),
+            replyToUser: context?.replyToUser,
+            replyToCommentId: context?.replyToCommentId,
+            resolved: false,
+            edited: false
+          }
+        });
+        return node.id;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, isReady, nodeId, threads]
+  );
+  const resolveThread = useCallback2(
+    async (rootCommentId) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(rootCommentId, {
+          properties: {
+            resolved: true,
+            resolvedAt: Date.now()
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  const reopenThread = useCallback2(
+    async (rootCommentId) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(rootCommentId, {
+          properties: {
+            resolved: false,
+            resolvedBy: null,
+            resolvedAt: null
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  const deleteComment = useCallback2(
+    async (commentId) => {
+      if (!store || !isReady) return;
+      try {
+        const thread = threads.find((t) => t.root.id === commentId);
+        const isRoot = thread !== void 0;
+        if (isRoot) {
+          if (thread.replies.length > 0) {
+            await store.update(commentId, {
+              properties: { content: "[deleted]" }
+            });
+          } else {
+            await store.delete(commentId);
+          }
+        } else {
+          await store.delete(commentId);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady, threads]
+  );
+  const deleteThread = useCallback2(
+    async (rootCommentId) => {
+      if (!store || !isReady) return;
+      const thread = threads.find((t) => t.root.id === rootCommentId);
+      if (!thread) return;
+      try {
+        for (const reply of thread.replies) {
+          await store.delete(reply.id);
+        }
+        await store.delete(rootCommentId);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady, threads]
+  );
+  const editComment = useCallback2(
+    async (commentId, content) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(commentId, {
+          properties: {
+            content,
+            edited: true,
+            editedAt: Date.now()
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  return {
+    comments,
+    threads,
+    count: comments.length,
+    unresolvedCount,
+    loading,
+    error,
+    addComment,
+    replyTo,
+    resolveThread,
+    reopenThread,
+    deleteComment,
+    deleteThread,
+    editComment,
+    reload: loadComments
+  };
+}
+function nodeToComment(node) {
+  const firstTimestamp = Object.values(node.timestamps)[0];
+  const lamportTime = firstTimestamp?.lamport ?? 0;
+  const wallTime = firstTimestamp?.wallTime ?? node.createdAt;
+  return {
+    id: node.id,
+    schemaId: node.schemaId,
+    createdAt: node.createdAt,
+    lamportTime,
+    wallTime,
+    properties: {
+      target: node.properties.target,
+      targetSchema: node.properties.targetSchema,
+      inReplyTo: node.properties.inReplyTo,
+      anchorType: node.properties.anchorType,
+      anchorData: node.properties.anchorData,
+      content: node.properties.content,
+      attachments: node.properties.attachments,
+      replyToUser: node.properties.replyToUser,
+      replyToCommentId: node.properties.replyToCommentId,
+      resolved: node.properties.resolved ?? false,
+      resolvedBy: node.properties.resolvedBy,
+      resolvedAt: node.properties.resolvedAt,
+      edited: node.properties.edited ?? false,
+      editedAt: node.properties.editedAt,
+      createdBy: node.createdBy
+    }
+  };
+}
+
+// src/hooks/useModeratedComments.ts
+import { ModerationLabelSchema, PublicInteractionPolicySchema } from "@xnetjs/data";
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo5, useState as useState3 } from "react";
+var DEFAULT_HIDDEN_COMMENT_LABELS = [
+  "spam",
+  "scam",
+  "malware",
+  "impersonation",
+  "harassment"
+];
+var DEFAULT_COLLAPSED_COMMENT_LABELS = [
+  "slop",
+  "inaccurate",
+  "unsupported",
+  "stale",
+  "synthetic"
+];
+var DEFAULT_HIDE_CONFIDENCE = 0.85;
+var DEFAULT_COLLAPSE_CONFIDENCE = 0.65;
+var DEFAULT_PUBLIC_INTERACTION_MODES = {
+  comment: "authenticated",
+  reply: "authenticated",
+  reaction: "authenticated",
+  quote: "trusted",
+  mention: "trusted",
+  communityNote: "reviewed",
+  message: "authenticated",
+  crawl: "closed",
+  index: "reviewed"
+};
+function summarizeModerationLabel(node, now = Date.now()) {
+  const target = asString(node.properties.target);
+  const value = asString(node.properties.value);
+  const confidence = asNumber(node.properties.confidence);
+  const sourceWeight = asNumber(node.properties.sourceWeight) ?? 1;
+  const expiresAt = asNumber(node.properties.expiresAt);
+  if (!target || !value || confidence === void 0) return null;
+  if (expiresAt !== void 0 && expiresAt <= now) return null;
+  return {
+    id: node.id,
+    target,
+    value,
+    confidence,
+    sourceWeight,
+    sourceType: asString(node.properties.sourceType),
+    sourceDID: asString(node.properties.sourceDID),
+    evidenceRefs: asString(node.properties.evidenceRefs),
+    expiresAt,
+    negates: asString(node.properties.negates),
+    createdAt: node.createdAt
+  };
+}
+function summarizePublicInteractionPolicy(node) {
+  const target = asString(node.properties.target);
+  if (!target) return null;
+  const updatedAt = asNumber(node.properties.updatedAt) ?? node.updatedAt ?? node.createdAt;
+  return {
+    id: node.id,
+    target,
+    targetSchema: asString(node.properties.targetSchema),
+    scope: asString(node.properties.scope),
+    commentMode: asInteractionMode(node.properties.commentMode, "authenticated"),
+    replyMode: asInteractionMode(node.properties.replyMode, "authenticated"),
+    reactionMode: asInteractionMode(node.properties.reactionMode, "authenticated"),
+    quoteMode: asInteractionMode(node.properties.quoteMode, "trusted"),
+    mentionMode: asInteractionMode(node.properties.mentionMode, "trusted"),
+    communityNoteMode: asInteractionMode(node.properties.communityNoteMode, "reviewed"),
+    messageMode: asInteractionMode(node.properties.messageMode, "authenticated"),
+    crawlMode: asInteractionMode(node.properties.crawlMode, "closed"),
+    indexMode: asInteractionMode(node.properties.indexMode, "reviewed"),
+    defaultVisibility: asVisibility(node.properties.defaultVisibility, "visible"),
+    firstContactMode: asFirstContactMode(node.properties.firstContactMode, "slow-mode"),
+    moderationMode: asModerationMode(node.properties.moderationMode, "post-review"),
+    slowModeSeconds: asNumber(node.properties.slowModeSeconds),
+    maxRootCommentsPerHour: asNumber(node.properties.maxRootCommentsPerHour),
+    maxRepliesPerHour: asNumber(node.properties.maxRepliesPerHour),
+    maxReactionsPerHour: asNumber(node.properties.maxReactionsPerHour),
+    maxMentionsPerComment: asNumber(node.properties.maxMentionsPerComment),
+    minimumAccountAgeHours: asNumber(node.properties.minimumAccountAgeHours),
+    minimumReputation: asNumber(node.properties.minimumReputation),
+    trustThreshold: asNumber(node.properties.trustThreshold),
+    quarantineConfidenceThreshold: asNumber(node.properties.quarantineConfidenceThreshold),
+    hideConfidenceThreshold: asNumber(node.properties.hideConfidenceThreshold),
+    requiresVerifiedIdentity: asBoolean(node.properties.requiresVerifiedIdentity, false),
+    acceptsPolicySubscriptions: asBoolean(node.properties.acceptsPolicySubscriptions, true),
+    policyLists: asStringArray(node.properties.policyLists),
+    activeLabels: asStringArray(node.properties.activeLabels),
+    maintainers: asStringArray(node.properties.maintainers),
+    moderators: asStringArray(node.properties.moderators),
+    policyPublishers: asStringArray(node.properties.policyPublishers),
+    trustedDIDs: asStringArray(node.properties.trustedDIDs),
+    mutedDIDs: asStringArray(node.properties.mutedDIDs),
+    blockedDIDs: asStringArray(node.properties.blockedDIDs),
+    updatedAt,
+    createdAt: node.createdAt
+  };
+}
+function selectActiveInteractionPolicy(policies) {
+  return [...policies].sort((left, right) => {
+    const updatedDelta = right.updatedAt - left.updatedAt;
+    return updatedDelta !== 0 ? updatedDelta : right.createdAt - left.createdAt;
+  })[0] ?? null;
+}
+function selectPublicInteractionMode(policy, surface) {
+  if (!policy) return DEFAULT_PUBLIC_INTERACTION_MODES[surface];
+  if (surface === "comment") return policy.commentMode;
+  if (surface === "reply") return policy.replyMode;
+  if (surface === "reaction") return policy.reactionMode;
+  if (surface === "quote") return policy.quoteMode;
+  if (surface === "mention") return policy.mentionMode;
+  if (surface === "communityNote") return policy.communityNoteMode;
+  if (surface === "message") return policy.messageMode;
+  if (surface === "crawl") return policy.crawlMode;
+  return policy.indexMode;
+}
+function createModerationLabelIndex(labels) {
+  return labels.reduce((index, label) => {
+    const existing = index.get(label.target) ?? [];
+    index.set(label.target, [...existing, label]);
+    return index;
+  }, /* @__PURE__ */ new Map());
+}
+function evaluateInteractionPermission(mode, policy, options = {}) {
+  const reasons = [];
+  const viewerDID = options.viewerDID;
+  const authenticated = options.isAuthenticated ?? Boolean(viewerDID);
+  const trusted = viewerDID !== void 0 && policy?.trustedDIDs.includes(viewerDID);
+  const privileged = viewerDID !== void 0 && (policy?.maintainers.includes(viewerDID) || policy?.moderators.includes(viewerDID) || policy?.policyPublishers.includes(viewerDID));
+  if (viewerDID !== void 0 && policy?.blockedDIDs.includes(viewerDID)) {
+    return { allowed: false, requiresReview: false, mode, reasons: ["viewer-blocked"] };
+  }
+  if (viewerDID !== void 0 && policy?.mutedDIDs.includes(viewerDID)) {
+    return { allowed: false, requiresReview: false, mode, reasons: ["viewer-muted"] };
+  }
+  if (policy?.requiresVerifiedIdentity && !options.isVerified && !privileged) {
+    reasons.push("verified-identity-required");
+  }
+  if (mode === "closed") reasons.push("interaction-closed");
+  if (mode === "authenticated" && !authenticated) reasons.push("authentication-required");
+  if (mode === "trusted" && !trusted && !privileged) reasons.push("trusted-viewer-required");
+  if (mode === "reviewed" && !authenticated && !privileged) {
+    reasons.push("authentication-required");
+  }
+  return {
+    allowed: reasons.length === 0,
+    requiresReview: mode === "reviewed",
+    mode,
+    reasons
+  };
+}
+function evaluateCommentModeration(comment, options = {}) {
+  const policy = options.policy ?? null;
+  const labels = filterActiveLabels(options.labels ?? [], policy, options.minimumLabelConfidence);
+  const reasons = [];
+  if (policy?.moderationMode === "off") {
+    return {
+      comment,
+      visibility: "visible",
+      labels,
+      reasons,
+      visible: true
+    };
+  }
+  const safeConfidence = maxConfidence(labels, "safe");
+  const hiddenLabels = new Set(options.hiddenLabels ?? DEFAULT_HIDDEN_COMMENT_LABELS);
+  const collapsedLabels = new Set(options.collapsedLabels ?? DEFAULT_COLLAPSED_COMMENT_LABELS);
+  const hideThreshold = policy?.hideConfidenceThreshold ?? DEFAULT_HIDE_CONFIDENCE;
+  const collapseThreshold = policy?.quarantineConfidenceThreshold ?? DEFAULT_COLLAPSE_CONFIDENCE;
+  const hideLabel = labels.find(
+    (label) => hiddenLabels.has(label.value) && label.confidence >= hideThreshold && label.confidence > safeConfidence
+  );
+  if (hideLabel) {
+    reasons.push(`label:${hideLabel.value}`);
+    return {
+      comment,
+      visibility: "hidden",
+      labels,
+      reasons,
+      visible: isVisibilityIncluded("hidden", options)
+    };
+  }
+  const collapseLabel = labels.find(
+    (label) => collapsedLabels.has(label.value) && label.confidence >= collapseThreshold && label.confidence > safeConfidence
+  );
+  if (collapseLabel) {
+    reasons.push(`label:${collapseLabel.value}`);
+    const visibility = policy?.defaultVisibility === "quarantined" ? "quarantined" : "collapsed";
+    return {
+      comment,
+      visibility,
+      labels,
+      reasons,
+      visible: isVisibilityIncluded(visibility, options)
+    };
+  }
+  const defaultVisibility = policy?.defaultVisibility ?? "visible";
+  return {
+    comment,
+    visibility: defaultVisibility,
+    labels,
+    reasons,
+    visible: isVisibilityIncluded(defaultVisibility, options)
+  };
+}
+function moderateThread(thread, options = {}) {
+  const labelIndex = options.labelIndex ?? /* @__PURE__ */ new Map();
+  const root = evaluateCommentModeration(thread.root, {
+    ...options,
+    labels: labelIndex.get(thread.root.id)
+  });
+  const replies = thread.replies.map(
+    (reply) => evaluateCommentModeration(reply, {
+      ...options,
+      labels: labelIndex.get(reply.id)
+    })
+  );
+  const visibleReplies = replies.filter((reply) => reply.visible);
+  return {
+    root,
+    replies,
+    visibleReplies,
+    visible: root.visible,
+    hiddenReplyCount: countByVisibility(replies, "hidden"),
+    collapsedReplyCount: countByVisibility(replies, "collapsed"),
+    quarantinedReplyCount: countByVisibility(replies, "quarantined")
+  };
+}
+function useModeratedThread({
+  thread,
+  labelIndex,
+  policy,
+  hiddenLabels,
+  collapsedLabels,
+  includeCollapsed,
+  includeQuarantined,
+  includeHidden,
+  minimumLabelConfidence
+}) {
+  return useMemo5(() => {
+    if (!thread) return null;
+    return moderateThread(thread, {
+      labelIndex,
+      policy,
+      hiddenLabels,
+      collapsedLabels,
+      includeCollapsed,
+      includeQuarantined,
+      includeHidden,
+      minimumLabelConfidence
+    });
+  }, [
+    thread,
+    labelIndex,
+    policy,
+    hiddenLabels,
+    collapsedLabels,
+    includeCollapsed,
+    includeQuarantined,
+    includeHidden,
+    minimumLabelConfidence
+  ]);
+}
+function useVisibleComments(options) {
+  const {
+    viewerDID,
+    isAuthenticated,
+    isVerified,
+    policy: providedPolicy,
+    hiddenLabels,
+    collapsedLabels,
+    includeCollapsed,
+    includeQuarantined,
+    includeHidden,
+    minimumLabelConfidence,
+    ...commentOptions
+  } = options;
+  const base = useComments(commentOptions);
+  const { store, isReady } = useNodeStore();
+  const [moderationLabels, setModerationLabels] = useState3([]);
+  const [loadedPolicy, setLoadedPolicy] = useState3(null);
+  const [policyLoading, setPolicyLoading] = useState3(true);
+  const [policyError, setPolicyError] = useState3(null);
+  const commentIds = useMemo5(
+    () => new Set(base.comments.map((comment) => comment.id)),
+    [base.comments]
+  );
+  const loadModerationState = useCallback3(async () => {
+    if (!store || !isReady) {
+      setPolicyLoading(false);
+      return;
+    }
+    try {
+      setPolicyLoading(true);
+      setPolicyError(null);
+      const [labelNodes, policyNodes] = await Promise.all([
+        store.list({ schemaId: ModerationLabelSchema._schemaId }),
+        store.list({ schemaId: PublicInteractionPolicySchema._schemaId })
+      ]);
+      const labels = labelNodes.map((node) => summarizeModerationLabel(node)).filter((label) => {
+        return label !== null && commentIds.has(label.target);
+      });
+      const policies = policyNodes.map((node) => summarizePublicInteractionPolicy(node)).filter((policy2) => {
+        return policy2 !== null && policy2.target === commentOptions.nodeId;
+      });
+      setModerationLabels(labels);
+      setLoadedPolicy(selectActiveInteractionPolicy(policies));
+    } catch (err) {
+      setPolicyError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setPolicyLoading(false);
+    }
+  }, [store, isReady, commentIds, commentOptions.nodeId]);
+  useEffect3(() => {
+    loadModerationState();
+  }, [loadModerationState]);
+  useEffect3(() => {
+    if (!store || !isReady) return;
+    const handleChange = (event) => {
+      const schemaId = event.node?.schemaId ?? event.change?.payload?.schemaId;
+      if (schemaId === ModerationLabelSchema._schemaId || schemaId === PublicInteractionPolicySchema._schemaId) {
+        loadModerationState();
+      }
+    };
+    const unsubscribe = store.subscribe(handleChange);
+    return () => unsubscribe();
+  }, [store, isReady, loadModerationState]);
+  const policy = providedPolicy === void 0 ? loadedPolicy : providedPolicy;
+  const labelIndex = useMemo5(() => createModerationLabelIndex(moderationLabels), [moderationLabels]);
+  const filterOptions = useMemo5(
+    () => ({
+      hiddenLabels,
+      collapsedLabels,
+      includeCollapsed,
+      includeQuarantined,
+      includeHidden,
+      minimumLabelConfidence
+    }),
+    [
+      hiddenLabels,
+      collapsedLabels,
+      includeCollapsed,
+      includeQuarantined,
+      includeHidden,
+      minimumLabelConfidence
+    ]
+  );
+  const moderatedThreads = useMemo5(
+    () => base.threads.map(
+      (thread) => moderateThread(thread, {
+        ...filterOptions,
+        labelIndex,
+        policy
+      })
+    ),
+    [base.threads, filterOptions, labelIndex, policy]
+  );
+  const moderationByCommentId = useMemo5(() => {
+    return moderatedThreads.reduce((index, thread) => {
+      index.set(thread.root.comment.id, thread.root);
+      for (const reply of thread.replies) {
+        index.set(reply.comment.id, reply);
+      }
+      return index;
+    }, /* @__PURE__ */ new Map());
+  }, [moderatedThreads]);
+  const threads = useMemo5(
+    () => moderatedThreads.filter((thread) => thread.visible).map((thread) => ({
+      root: thread.root.comment,
+      replies: thread.visibleReplies.map((reply) => reply.comment)
+    })),
+    [moderatedThreads]
+  );
+  const comments = useMemo5(
+    () => threads.flatMap((thread) => [thread.root, ...thread.replies]),
+    [threads]
+  );
+  const canAddRootComment = useMemo5(
+    () => evaluateInteractionPermission(selectPublicInteractionMode(policy, "comment"), policy, {
+      viewerDID,
+      isAuthenticated,
+      isVerified
+    }),
+    [policy, viewerDID, isAuthenticated, isVerified]
+  );
+  const canReply = useMemo5(
+    () => evaluateInteractionPermission(selectPublicInteractionMode(policy, "reply"), policy, {
+      viewerDID,
+      isAuthenticated,
+      isVerified
+    }),
+    [policy, viewerDID, isAuthenticated, isVerified]
+  );
+  const addComment = useCallback3(
+    async (addOptions) => {
+      if (!canAddRootComment.allowed) {
+        setPolicyError(new Error(canAddRootComment.reasons.join(", ") || "Commenting is closed"));
+        return null;
+      }
+      return base.addComment(addOptions);
+    },
+    [base, canAddRootComment]
+  );
+  const replyTo = useCallback3(
+    async (rootCommentId, content, context) => {
+      if (!canReply.allowed) {
+        setPolicyError(new Error(canReply.reasons.join(", ") || "Replies are closed"));
+        return null;
+      }
+      return base.replyTo(rootCommentId, content, context);
+    },
+    [base, canReply]
+  );
+  return {
+    ...base,
+    comments,
+    threads,
+    allComments: base.comments,
+    allThreads: base.threads,
+    moderatedThreads,
+    moderationByCommentId,
+    moderationLabels,
+    policy,
+    policyLoading,
+    policyError,
+    count: comments.length,
+    unresolvedCount: threads.filter((thread) => !thread.root.properties.resolved).length,
+    hiddenCount: countModeratedComments(moderatedThreads, "hidden"),
+    collapsedCount: countModeratedComments(moderatedThreads, "collapsed"),
+    quarantinedCount: countModeratedComments(moderatedThreads, "quarantined"),
+    loading: base.loading || policyLoading,
+    error: base.error ?? policyError,
+    canAddRootComment,
+    canReply,
+    addComment,
+    replyTo
+  };
+}
+function filterActiveLabels(labels, policy, minimumLabelConfidence) {
+  const activeLabels = new Set(policy?.activeLabels ?? []);
+  const minimumConfidence = minimumLabelConfidence ?? 0;
+  const negatedLabelIds = new Set(
+    labels.flatMap((label) => label.negates !== void 0 ? [label.negates] : [])
+  );
+  return labels.filter((label) => {
+    if (negatedLabelIds.has(label.id)) return false;
+    if (label.confidence < minimumConfidence) return false;
+    return activeLabels.size === 0 || activeLabels.has(label.value);
+  });
+}
+function maxConfidence(labels, value) {
+  return labels.filter((label) => label.value === value).reduce((confidence, label) => Math.max(confidence, label.confidence), 0);
+}
+function countByVisibility(comments, visibility) {
+  return comments.filter((comment) => comment.visibility === visibility).length;
+}
+function countModeratedComments(threads, visibility) {
+  return threads.reduce((count, thread) => {
+    const rootCount = thread.root.visibility === visibility ? 1 : 0;
+    return count + rootCount + countByVisibility(thread.replies, visibility);
+  }, 0);
+}
+function isVisibilityIncluded(visibility, options) {
+  if (visibility === "visible") return true;
+  if (visibility === "collapsed") return options.includeCollapsed ?? true;
+  if (visibility === "quarantined") return options.includeQuarantined ?? false;
+  return options.includeHidden ?? false;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asInteractionMode(value, fallback) {
+  return isOneOf(value, ["open", "authenticated", "trusted", "reviewed", "closed"]) ? value : fallback;
+}
+function asFirstContactMode(value, fallback) {
+  return isOneOf(value, ["allow", "slow-mode", "quarantine", "review", "block"]) ? value : fallback;
+}
+function asModerationMode(value, fallback) {
+  return isOneOf(value, ["off", "label-only", "post-review", "pre-filter", "pre-review"]) ? value : fallback;
+}
+function asVisibility(value, fallback) {
+  return isOneOf(value, ["visible", "collapsed", "quarantined", "hidden"]) ? value : fallback;
+}
+function isOneOf(value, options) {
+  return typeof value === "string" && options.includes(value);
+}
+
+// src/hooks/useReactionCounters.ts
+import { ModerationLabelSchema as ModerationLabelSchema2, ReactionSchema } from "@xnetjs/data";
+import { useCallback as useCallback4, useEffect as useEffect4, useMemo as useMemo6, useState as useState4 } from "react";
+var DEFAULT_HIDDEN_REACTION_LABELS = [
+  "spam",
+  "scam",
+  "malware",
+  "impersonation",
+  "harassment"
+];
+function summarizeReactionNode(node) {
+  const target = asString2(node.properties.target);
+  const reactionType = asReactionType(node.properties.reactionType);
+  const reactor = asString2(node.properties.reactor);
+  if (!target || !reactionType || !reactor) return null;
+  return {
+    id: node.id,
+    target,
+    targetSchema: asString2(node.properties.targetSchema),
+    reactionType,
+    reactor,
+    emoji: asString2(node.properties.emoji),
+    annotation: asString2(node.properties.annotation),
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+function isReactionVisible(reaction, labels, policy, options = {}) {
+  if (policy?.blockedDIDs.includes(reaction.reactor)) return false;
+  if (policy?.mutedDIDs.includes(reaction.reactor)) return false;
+  if (policy?.moderationMode === "off") return true;
+  if (policy?.defaultVisibility === "hidden" && !(options.includeHidden ?? false)) return false;
+  if (policy?.defaultVisibility === "quarantined" && !(options.includeQuarantined ?? false)) {
+    return false;
+  }
+  const activeLabels = new Set(policy?.activeLabels ?? []);
+  const hiddenLabels = new Set(options.hiddenLabels ?? DEFAULT_HIDDEN_REACTION_LABELS);
+  const hideThreshold = policy?.hideConfidenceThreshold ?? 0.85;
+  const safeConfidence = labels.filter((label) => label.value === "safe").reduce((confidence, label) => Math.max(confidence, label.confidence), 0);
+  return !labels.some((label) => {
+    if (activeLabels.size > 0 && !activeLabels.has(label.value)) return false;
+    if (!hiddenLabels.has(label.value)) return false;
+    return label.confidence >= hideThreshold && label.confidence > safeConfidence;
+  });
+}
+function dedupeReactions(reactions) {
+  const byActorAndType = reactions.reduce((index, reaction) => {
+    const key = [reaction.reactionType, reaction.reactor, reaction.emoji ?? ""].join(":");
+    const existing = index.get(key);
+    if (!existing || reaction.createdAt >= existing.createdAt) {
+      index.set(key, reaction);
+    }
+    return index;
+  }, /* @__PURE__ */ new Map());
+  return Array.from(byActorAndType.values());
+}
+function createReactionCounterSnapshot(reactions, replies) {
+  const unique = dedupeReactions(reactions);
+  const countType = (reactionType) => {
+    return unique.filter((reaction) => reaction.reactionType === reactionType).length;
+  };
+  const totalReactions = unique.length;
+  return {
+    likes: countType("like"),
+    reposts: countType("repost"),
+    bookmarks: countType("bookmark"),
+    emoji: countType("emoji"),
+    replies,
+    totalReactions,
+    total: totalReactions + replies
+  };
+}
+function usePolicyFilteredReactionCounters({
+  nodeId,
+  targetSchema,
+  viewerDID,
+  isAuthenticated,
+  isVerified,
+  policy: providedPolicy,
+  hiddenLabels,
+  collapsedLabels,
+  includeCollapsed,
+  includeQuarantined,
+  includeHidden,
+  minimumLabelConfidence
+}) {
+  const { store, isReady } = useNodeStore();
+  const visibleComments = useVisibleComments({
+    nodeId,
+    viewerDID,
+    isAuthenticated,
+    isVerified,
+    policy: providedPolicy,
+    hiddenLabels,
+    collapsedLabels,
+    includeCollapsed,
+    includeQuarantined,
+    includeHidden,
+    minimumLabelConfidence
+  });
+  const [reactions, setReactions] = useState4([]);
+  const [labels, setLabels] = useState4([]);
+  const [loading, setLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const policy = providedPolicy === void 0 ? visibleComments.policy : providedPolicy;
+  const loadReactions = useCallback4(async () => {
+    if (!store || !isReady) {
+      setLoading(false);
+      return;
+    }
+    try {
+      setLoading(true);
+      setError(null);
+      const [reactionNodes, labelNodes] = await Promise.all([
+        store.list({ schemaId: ReactionSchema._schemaId }),
+        store.list({ schemaId: ModerationLabelSchema2._schemaId })
+      ]);
+      const nextReactions = reactionNodes.map((node) => summarizeReactionNode(node)).filter((reaction) => {
+        return reaction !== null && reaction.target === nodeId;
+      });
+      const reactionIds = new Set(nextReactions.map((reaction) => reaction.id));
+      const nextLabels = labelNodes.map((node) => summarizeModerationLabel(node)).filter((label) => {
+        return label !== null && reactionIds.has(label.target);
+      });
+      setReactions(nextReactions);
+      setLabels(nextLabels);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [store, isReady, nodeId]);
+  useEffect4(() => {
+    loadReactions();
+  }, [loadReactions]);
+  useEffect4(() => {
+    if (!store || !isReady) return;
+    const handleChange = (event) => {
+      const schemaId = event.node?.schemaId ?? event.change?.payload?.schemaId;
+      if (schemaId === ReactionSchema._schemaId || schemaId === ModerationLabelSchema2._schemaId) {
+        loadReactions();
+      }
+    };
+    const unsubscribe = store.subscribe(handleChange);
+    return () => unsubscribe();
+  }, [store, isReady, loadReactions]);
+  const labelIndex = useMemo6(() => createModerationLabelIndex(labels), [labels]);
+  const filterOptions = useMemo6(
+    () => ({
+      hiddenLabels,
+      collapsedLabels,
+      includeCollapsed,
+      includeQuarantined,
+      includeHidden,
+      minimumLabelConfidence
+    }),
+    [
+      hiddenLabels,
+      collapsedLabels,
+      includeCollapsed,
+      includeQuarantined,
+      includeHidden,
+      minimumLabelConfidence
+    ]
+  );
+  const visibleReactions = useMemo6(() => {
+    return reactions.filter(
+      (reaction) => isReactionVisible(reaction, labelIndex.get(reaction.id) ?? [], policy, filterOptions)
+    );
+  }, [reactions, labelIndex, policy, filterOptions]);
+  const canReact = useMemo6(
+    () => evaluateInteractionPermission(selectPublicInteractionMode(policy, "reaction"), policy, {
+      viewerDID,
+      isAuthenticated,
+      isVerified
+    }),
+    [policy, viewerDID, isAuthenticated, isVerified]
+  );
+  const canRepost = useMemo6(
+    () => evaluateInteractionPermission(selectPublicInteractionMode(policy, "quote"), policy, {
+      viewerDID,
+      isAuthenticated,
+      isVerified
+    }),
+    [policy, viewerDID, isAuthenticated, isVerified]
+  );
+  const counts = useMemo6(
+    () => createReactionCounterSnapshot(visibleReactions, visibleComments.count),
+    [visibleReactions, visibleComments.count]
+  );
+  const rawCounts = useMemo6(
+    () => createReactionCounterSnapshot(reactions, visibleComments.allComments.length),
+    [reactions, visibleComments.allComments.length]
+  );
+  const addReaction = useCallback4(
+    async (options) => {
+      if (!store || !isReady || !viewerDID) return null;
+      const permission = options.reactionType === "repost" ? canRepost : canReact;
+      if (!permission.allowed) {
+        setError(new Error(permission.reasons.join(", ") || "Reactions are closed"));
+        return null;
+      }
+      try {
+        const node = await store.create({
+          schemaId: ReactionSchema._schemaId,
+          properties: {
+            target: nodeId,
+            targetSchema,
+            reactionType: options.reactionType,
+            reactor: viewerDID,
+            emoji: options.emoji,
+            annotation: options.annotation
+          }
+        });
+        return node.id;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, isReady, viewerDID, canRepost, canReact, nodeId, targetSchema]
+  );
+  const removeReaction = useCallback4(
+    async (reactionId) => {
+      if (!store || !isReady) return;
+      try {
+        await store.delete(reactionId);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  const toggleReaction = useCallback4(
+    async (options) => {
+      const existing = reactions.find((reaction) => {
+        return reaction.reactor === viewerDID && reaction.reactionType === options.reactionType && (reaction.emoji ?? "") === (options.emoji ?? "");
+      });
+      if (existing) {
+        await removeReaction(existing.id);
+        return null;
+      }
+      return addReaction(options);
+    },
+    [reactions, viewerDID, removeReaction, addReaction]
+  );
+  return {
+    reactions,
+    visibleReactions,
+    counts,
+    rawCounts,
+    hiddenReactionCount: reactions.length - visibleReactions.length,
+    loading: loading || visibleComments.loading,
+    error: error ?? visibleComments.error,
+    policy,
+    canReact,
+    canRepost,
+    addReaction,
+    removeReaction,
+    toggleReaction,
+    reload: loadReactions
+  };
+}
+function asString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asReactionType(value) {
+  return isOneOf2(value, ["like", "repost", "bookmark", "emoji"]) ? value : void 0;
+}
+function isOneOf2(value, options) {
+  return typeof value === "string" && options.includes(value);
+}
+
+// src/hooks/useMessageRequests.ts
+import { MessageRequestSchema } from "@xnetjs/data";
+import { useCallback as useCallback5, useEffect as useEffect5, useMemo as useMemo7, useState as useState5 } from "react";
+var REQUEST_STATUSES = [
+  "pending",
+  "accepted",
+  "declined",
+  "quarantined",
+  "blocked",
+  "expired"
+];
+var ADMISSIONS = [
+  "allow",
+  "message-request",
+  "quarantine",
+  "review",
+  "block"
+];
+var ACTIVE_REQUEST_STATUSES = ["pending", "quarantined"];
+function createConversationKey(senderDID, recipientDID) {
+  return [senderDID, recipientDID].sort().join("::");
+}
+function summarizeMessageRequest(node, now = Date.now()) {
+  const conversationKey = asString3(node.properties.conversationKey);
+  const sender = asString3(node.properties.sender);
+  const recipient = asString3(node.properties.recipient);
+  if (!conversationKey || !sender || !recipient) return null;
+  const expiresAt = asNumber2(node.properties.expiresAt);
+  const rawStatus = asRequestStatus(node.properties.status) ?? "pending";
+  const status = expiresAt !== void 0 && expiresAt <= now && ACTIVE_REQUEST_STATUSES.includes(rawStatus) ? "expired" : rawStatus;
+  return {
+    id: node.id,
+    conversationKey,
+    sender,
+    recipient,
+    target: asString3(node.properties.target),
+    targetSchema: asString3(node.properties.targetSchema),
+    firstMessageRef: asString3(node.properties.firstMessageRef),
+    firstMessagePreview: asString3(node.properties.firstMessagePreview),
+    status,
+    admission: asAdmission(node.properties.admission) ?? "message-request",
+    reasonCodes: asStringArray2(node.properties.reasonCodes),
+    confidence: asNumber2(node.properties.confidence),
+    policy: asString3(node.properties.policy),
+    policyMode: asFirstContactMode2(node.properties.policyMode),
+    quarantineUntil: asNumber2(node.properties.quarantineUntil),
+    expiresAt,
+    respondedAt: asNumber2(node.properties.respondedAt),
+    respondedBy: asString3(node.properties.respondedBy),
+    reviewers: asStringArray2(node.properties.reviewers),
+    notes: asString3(node.properties.notes),
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+function findLatestMessageRequest(requests, senderDID, recipientDID) {
+  const conversationKey = createConversationKey(senderDID, recipientDID);
+  return requests.filter((request) => request.conversationKey === conversationKey).sort((a, b) => b.createdAt - a.createdAt)[0] ?? null;
+}
+function hasAcceptedContact(requests, senderDID, recipientDID) {
+  return findLatestMessageRequest(requests, senderDID, recipientDID)?.status === "accepted";
+}
+function evaluateFirstContactDecision({
+  senderDID,
+  recipientDID,
+  policy,
+  existingRequests = [],
+  isAuthenticated,
+  isVerified = false,
+  now = Date.now()
+}) {
+  if (!senderDID || !recipientDID) {
+    return createFirstContactDecision("block", ["missing-participants"], 1);
+  }
+  if (senderDID === recipientDID) {
+    return createFirstContactDecision("allow", ["self-message"], 1);
+  }
+  const latest = findLatestMessageRequest(existingRequests, senderDID, recipientDID);
+  if (latest?.status === "accepted") {
+    return createFirstContactDecision("allow", ["known-contact"], 1);
+  }
+  if (policy?.blockedDIDs.includes(senderDID) || latest?.status === "blocked") {
+    return createFirstContactDecision("block", ["sender-blocked"], 1);
+  }
+  if (policy?.mutedDIDs.includes(senderDID)) {
+    return createFirstContactDecision("quarantine", ["sender-muted"], 0.9);
+  }
+  if ((policy?.requiresVerifiedIdentity ?? false) && (!isAuthenticated || !isVerified)) {
+    return createFirstContactDecision("review", ["verified-identity-required"], 0.8);
+  }
+  const messagePermission = evaluateInteractionPermission(
+    selectPublicInteractionMode(policy ?? null, "message"),
+    policy ?? null,
+    {
+      viewerDID: senderDID,
+      isAuthenticated: isAuthenticated ?? Boolean(senderDID),
+      isVerified
+    }
+  );
+  if (!messagePermission.allowed) {
+    return createFirstContactDecision(
+      "block",
+      ["message-policy-denied", ...messagePermission.reasons],
+      0.95
+    );
+  }
+  if (messagePermission.requiresReview) {
+    return createFirstContactDecision("review", ["message-review-required"], 0.75);
+  }
+  if (policy?.trustedDIDs.includes(senderDID)) {
+    return createFirstContactDecision("allow", ["trusted-sender"], 0.95);
+  }
+  const mode = policy?.firstContactMode ?? "slow-mode";
+  const reasons = ["first-contact", `policy-${mode}`];
+  if (mode === "allow") return createFirstContactDecision("allow", reasons, 0.8);
+  if (mode === "block") return createFirstContactDecision("block", reasons, 0.95);
+  if (mode === "review") return createFirstContactDecision("review", reasons, 0.75);
+  if (mode === "quarantine") return createFirstContactDecision("quarantine", reasons, 0.85);
+  return createFirstContactDecision("message-request", reasons, 0.6, {
+    quarantineUntil: policy?.slowModeSeconds !== void 0 ? now + policy.slowModeSeconds * 1e3 : void 0
+  });
+}
+function createMessageRequestProperties(options, decision, policy) {
+  return {
+    conversationKey: createConversationKey(options.senderDID, options.recipientDID),
+    sender: options.senderDID,
+    recipient: options.recipientDID,
+    target: options.target,
+    targetSchema: options.targetSchema,
+    firstMessageRef: options.firstMessageRef,
+    firstMessagePreview: truncatePreview(options.firstMessagePreview),
+    status: decision.status,
+    admission: decision.admission,
+    reasonCodes: decision.reasonCodes,
+    confidence: decision.confidence,
+    policy: policy?.id,
+    policyMode: policy?.firstContactMode,
+    quarantineUntil: decision.quarantineUntil,
+    expiresAt: options.expiresAt,
+    reviewers: [...options.reviewers ?? []],
+    notes: options.notes
+  };
+}
+function useMessageRequests({
+  recipientDID,
+  senderDID,
+  policy,
+  isAuthenticated,
+  isVerified,
+  includeResolved = false
+} = {}) {
+  const { store, isReady } = useNodeStore();
+  const [requests, setRequests] = useState5([]);
+  const [loading, setLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const loadRequests = useCallback5(async () => {
+    if (!store || !isReady) {
+      setLoading(false);
+      return;
+    }
+    try {
+      setLoading(true);
+      setError(null);
+      const nodes = await store.list({ schemaId: MessageRequestSchema._schemaId });
+      const nextRequests = nodes.map((node) => summarizeMessageRequest(node)).filter((request) => {
+        if (request === null) return false;
+        if (recipientDID && request.recipient !== recipientDID) return false;
+        if (senderDID && request.sender !== senderDID) return false;
+        if (!includeResolved && !ACTIVE_REQUEST_STATUSES.includes(request.status)) return false;
+        return true;
+      }).sort((a, b) => b.createdAt - a.createdAt);
+      setRequests(nextRequests);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [store, isReady, recipientDID, senderDID, includeResolved]);
+  useEffect5(() => {
+    loadRequests();
+  }, [loadRequests]);
+  useEffect5(() => {
+    if (!store || !isReady) return;
+    const handleChange = (event) => {
+      const schemaId = event.node?.schemaId ?? event.change?.payload?.schemaId;
+      if (schemaId === MessageRequestSchema._schemaId) {
+        loadRequests();
+      }
+    };
+    const unsubscribe = store.subscribe(handleChange);
+    return () => unsubscribe();
+  }, [store, isReady, loadRequests]);
+  const evaluateFirstContact = useCallback5(
+    (input) => evaluateFirstContactDecision({
+      policy,
+      existingRequests: requests,
+      isAuthenticated,
+      isVerified,
+      ...input
+    }),
+    [policy, requests, isAuthenticated, isVerified]
+  );
+  const createMessageRequest = useCallback5(
+    async (options) => {
+      if (!store || !isReady) return null;
+      const decision = evaluateFirstContact({
+        senderDID: options.senderDID,
+        recipientDID: options.recipientDID
+      });
+      if (!decision.shouldCreateRequest) return null;
+      try {
+        const node = await store.create({
+          schemaId: MessageRequestSchema._schemaId,
+          properties: createMessageRequestProperties(options, decision, policy)
+        });
+        return node.id;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, isReady, evaluateFirstContact, policy]
+  );
+  const setRequestStatus = useCallback5(
+    async (requestId, status, responderDID) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(requestId, {
+          properties: {
+            status,
+            respondedAt: Date.now(),
+            respondedBy: responderDID
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  const pendingRequests = useMemo7(
+    () => requests.filter((request) => request.status === "pending"),
+    [requests]
+  );
+  const quarantinedRequests = useMemo7(
+    () => requests.filter((request) => request.status === "quarantined"),
+    [requests]
+  );
+  const acceptedRequests = useMemo7(
+    () => requests.filter((request) => request.status === "accepted"),
+    [requests]
+  );
+  const blockedRequests = useMemo7(
+    () => requests.filter((request) => request.status === "blocked"),
+    [requests]
+  );
+  return {
+    requests,
+    pendingRequests,
+    quarantinedRequests,
+    acceptedRequests,
+    blockedRequests,
+    loading,
+    error,
+    evaluateFirstContact,
+    createMessageRequest,
+    acceptRequest: (requestId, responderDID) => setRequestStatus(requestId, "accepted", responderDID),
+    declineRequest: (requestId, responderDID) => setRequestStatus(requestId, "declined", responderDID),
+    quarantineRequest: (requestId, responderDID) => setRequestStatus(requestId, "quarantined", responderDID),
+    blockRequest: (requestId, responderDID) => setRequestStatus(requestId, "blocked", responderDID),
+    reload: loadRequests
+  };
+}
+function createFirstContactDecision(admission, reasons, confidence, options = {}) {
+  return {
+    admission,
+    status: statusForAdmission(admission),
+    visibility: visibilityForAdmission(admission),
+    notifyRecipient: admission === "message-request" || admission === "review",
+    requiresReview: admission === "review" || admission === "quarantine",
+    shouldCreateRequest: admission === "message-request" || admission === "review" || admission === "quarantine",
+    reasons: [...reasons],
+    reasonCodes: normalizeReasonCodes(reasons),
+    confidence,
+    quarantineUntil: options.quarantineUntil
+  };
+}
+function statusForAdmission(admission) {
+  if (admission === "allow") return "accepted";
+  if (admission === "block") return "blocked";
+  if (admission === "quarantine") return "quarantined";
+  return "pending";
+}
+function visibilityForAdmission(admission) {
+  if (admission === "allow") return "inbox";
+  if (admission === "message-request" || admission === "review") return "requests";
+  if (admission === "quarantine") return "quarantine";
+  return "hidden";
+}
+function normalizeReasonCodes(reasons) {
+  return reasons.map((reason) => {
+    if (reason === "policy-slow-mode") return "policy-slow-mode";
+    if (reason.startsWith("policy-")) return reason;
+    return reason;
+  });
+}
+function truncatePreview(preview) {
+  if (preview === void 0) return void 0;
+  return preview.length > 1e3 ? preview.slice(0, 1e3) : preview;
+}
+function asString3(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asStringArray2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function asRequestStatus(value) {
+  return isOneOf3(value, REQUEST_STATUSES) ? value : void 0;
+}
+function asAdmission(value) {
+  return isOneOf3(value, ADMISSIONS) ? value : void 0;
+}
+function asFirstContactMode2(value) {
+  return isOneOf3(value, ["allow", "slow-mode", "quarantine", "review", "block"]) ? value : void 0;
+}
+function isOneOf3(value, options) {
+  return typeof value === "string" && options.includes(value);
+}
+
+// src/hooks/useCommentCount.ts
+import { useMemo as useMemo8 } from "react";
+function useCommentCount(nodeId) {
+  const { unresolvedCount } = useComments({ nodeId });
+  return unresolvedCount;
+}
+function useCommentCounts(nodeId) {
+  const { threads } = useComments({ nodeId });
+  return useMemo8(() => {
+    const resolved = threads.filter((t) => t.root.properties.resolved).length;
+    const unresolved = threads.length - resolved;
+    return {
+      total: threads.length,
+      unresolved,
+      resolved
+    };
+  }, [threads]);
+}
+
+// src/hooks/useHistory.ts
+import {
+  HistoryEngine,
+  SnapshotCache,
+  MemorySnapshotStorage
+} from "@xnetjs/history";
+import { useState as useState6, useEffect as useEffect6, useCallback as useCallback6, useRef as useRef3 } from "react";
+function useHistory(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [timeline, setTimeline] = useState6([]);
+  const [loading, setLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const engineRef = useRef3(null);
+  const getEngine = useCallback6(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      const snapshotStorage = new MemorySnapshotStorage();
+      const snapshots = new SnapshotCache(snapshotStorage, { interval: 50 });
+      engineRef.current = { engine: new HistoryEngine(storage, snapshots), storage };
+    }
+    return engineRef.current.engine;
+  }, [store]);
+  const loadTimeline = useCallback6(async () => {
+    if (!nodeId || !isReady) return;
+    const engine = getEngine();
+    if (!engine) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const entries = await engine.getTimeline(nodeId);
+      setTimeline(entries);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [nodeId, isReady, getEngine]);
+  useEffect6(() => {
+    loadTimeline();
+  }, [loadTimeline]);
+  useEffect6(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        loadTimeline();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, loadTimeline]);
+  const materializeAt = useCallback6(
+    async (target) => {
+      if (!nodeId) return null;
+      const engine = getEngine();
+      if (!engine) return null;
+      try {
+        return await engine.materializeAt(nodeId, target);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const diff = useCallback6(
+    async (from, to) => {
+      if (!nodeId) return [];
+      const engine = getEngine();
+      if (!engine) return [];
+      try {
+        return await engine.diff(nodeId, from, to);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return [];
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const createRevertPayload = useCallback6(
+    async (target) => {
+      if (!nodeId || !store) return null;
+      const engine = getEngine();
+      if (!engine) return null;
+      try {
+        const current = await store.get(nodeId);
+        if (!current) return null;
+        return await engine.createRevertPayload(nodeId, target, current);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [nodeId, store, getEngine]
+  );
+  return {
+    timeline,
+    changeCount: timeline.length,
+    materializeAt,
+    diff,
+    createRevertPayload,
+    loading,
+    error,
+    reload: loadTimeline
+  };
+}
+
+// src/hooks/useUndo.ts
+import { UndoManager } from "@xnetjs/history";
+import { useState as useState7, useEffect as useEffect7, useCallback as useCallback7, useMemo as useMemo9, useRef as useRef4 } from "react";
+function useUndo(nodeId, opts) {
+  const { store } = useNodeStore();
+  const [undoCount, setUndoCount] = useState7(0);
+  const [redoCount, setRedoCount] = useState7(0);
+  const hasOptions = opts.options !== void 0;
+  const optionLocalOnly = opts.options?.localOnly;
+  const optionMaxStackSize = opts.options?.maxStackSize;
+  const optionMergeInterval = opts.options?.mergeInterval;
+  const managerRef = useRef4(null);
+  const normalizedOptions = useMemo9(
+    () => hasOptions ? {
+      localOnly: optionLocalOnly,
+      maxStackSize: optionMaxStackSize,
+      mergeInterval: optionMergeInterval
+    } : void 0,
+    [hasOptions, optionLocalOnly, optionMaxStackSize, optionMergeInterval]
+  );
+  useEffect7(() => {
+    if (!store || !opts.localDID) {
+      managerRef.current = null;
+      setUndoCount(0);
+      setRedoCount(0);
+      return;
+    }
+    const manager = new UndoManager(store, opts.localDID, normalizedOptions);
+    manager.start();
+    managerRef.current = manager;
+    return () => {
+      manager.stop();
+      managerRef.current = null;
+    };
+  }, [store, opts.localDID, normalizedOptions]);
+  const syncCounts = useCallback7(() => {
+    if (!managerRef.current || !nodeId) {
+      setUndoCount(0);
+      setRedoCount(0);
+      return;
+    }
+    setUndoCount(managerRef.current.getUndoCount(nodeId));
+    setRedoCount(managerRef.current.getRedoCount(nodeId));
+  }, [nodeId]);
+  useEffect7(() => {
+    syncCounts();
+  }, [syncCounts]);
+  useEffect7(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        syncCounts();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, syncCounts]);
+  const undo = useCallback7(async () => {
+    if (!managerRef.current || !nodeId) return false;
+    const result = await managerRef.current.undo(nodeId);
+    syncCounts();
+    return result;
+  }, [nodeId, syncCounts]);
+  const redo = useCallback7(async () => {
+    if (!managerRef.current || !nodeId) return false;
+    const result = await managerRef.current.redo(nodeId);
+    syncCounts();
+    return result;
+  }, [nodeId, syncCounts]);
+  const undoBatch = useCallback7(
+    async (batchId) => {
+      if (!managerRef.current) return false;
+      const result = await managerRef.current.undoBatch(batchId);
+      syncCounts();
+      return result;
+    },
+    [syncCounts]
+  );
+  const clear = useCallback7(() => {
+    if (!managerRef.current || !nodeId) return;
+    managerRef.current.clear(nodeId);
+    syncCounts();
+  }, [nodeId, syncCounts]);
+  return {
+    undo,
+    redo,
+    undoBatch,
+    canUndo: undoCount > 0,
+    canRedo: redoCount > 0,
+    undoCount,
+    redoCount,
+    clear
+  };
+}
+
+// src/hooks/useAudit.ts
+import { AuditIndex } from "@xnetjs/history";
+import { useState as useState8, useEffect as useEffect8, useCallback as useCallback8, useRef as useRef5 } from "react";
+function useAudit(nodeId, options) {
+  const { store, isReady } = useNodeStore();
+  const [entries, setEntries] = useState8([]);
+  const [activity, setActivity] = useState8(null);
+  const [loading, setLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const auditRef = useRef5(null);
+  const getAudit = useCallback8(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!auditRef.current || auditRef.current.storage !== storage) {
+      auditRef.current = { audit: new AuditIndex(storage), storage };
+    }
+    return auditRef.current.audit;
+  }, [store]);
+  const load = useCallback8(async () => {
+    if (!nodeId || !isReady) return;
+    const audit = getAudit();
+    if (!audit) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const query = {
+        nodeId,
+        order: options?.order ?? "desc",
+        limit: options?.limit ?? 200
+      };
+      if (options?.operations) query.operations = options.operations;
+      if (options?.author) query.author = options.author;
+      if (options?.timeRange) {
+        query.fromWallTime = options.timeRange[0];
+        query.toWallTime = options.timeRange[1];
+      }
+      const [auditEntries, activitySummary] = await Promise.all([
+        audit.query(query),
+        audit.getNodeActivity(nodeId)
+      ]);
+      setEntries(auditEntries);
+      setActivity(activitySummary);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    nodeId,
+    isReady,
+    getAudit,
+    options?.operations,
+    options?.author,
+    options?.timeRange,
+    options?.limit,
+    options?.order
+  ]);
+  useEffect8(() => {
+    load();
+  }, [load]);
+  useEffect8(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        load();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, load]);
+  return { entries, activity, loading, error, reload: load };
+}
+
+// src/hooks/useDiff.ts
+import {
+  HistoryEngine as HistoryEngine2,
+  SnapshotCache as SnapshotCache2,
+  MemorySnapshotStorage as MemorySnapshotStorage2,
+  DiffEngine
+} from "@xnetjs/history";
+import { useState as useState9, useCallback as useCallback9, useRef as useRef6 } from "react";
+function useDiff(nodeId) {
+  const { store } = useNodeStore();
+  const [result, setResult] = useState9(null);
+  const [loading, setLoading] = useState9(false);
+  const [error, setError] = useState9(null);
+  const engineRef = useRef6(null);
+  const getEngine = useCallback9(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      const snapshotStorage = new MemorySnapshotStorage2();
+      const snapshots = new SnapshotCache2(snapshotStorage, { interval: 50 });
+      const history = new HistoryEngine2(storage, snapshots);
+      engineRef.current = { diff: new DiffEngine(history), storage };
+    }
+    return engineRef.current.diff;
+  }, [store]);
+  const diff = useCallback9(
+    async (from, to) => {
+      if (!nodeId) return;
+      const engine = getEngine();
+      if (!engine) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const diffResult = await engine.diffNode(nodeId, from, to);
+        setResult(diffResult);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const diffFromCurrent = useCallback9(
+    async (changesAgo) => {
+      if (!nodeId) return;
+      const engine = getEngine();
+      if (!engine) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const diffResult = await engine.diffFromCurrent(nodeId, changesAgo);
+        setResult(diffResult);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [nodeId, getEngine]
+  );
+  return { diff, diffFromCurrent, result, loading, error };
+}
+
+// src/hooks/useBlame.ts
+import { BlameEngine } from "@xnetjs/history";
+import { useState as useState10, useEffect as useEffect9, useCallback as useCallback10, useRef as useRef7 } from "react";
+function useBlame(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [blame, setBlame] = useState10([]);
+  const [loading, setLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const engineRef = useRef7(null);
+  const getEngine = useCallback10(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      engineRef.current = { engine: new BlameEngine(storage), storage };
+    }
+    return engineRef.current.engine;
+  }, [store]);
+  const load = useCallback10(async () => {
+    if (!nodeId || !isReady) return;
+    const engine = getEngine();
+    if (!engine) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const info = await engine.getBlame(nodeId);
+      setBlame(info);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [nodeId, isReady, getEngine]);
+  useEffect9(() => {
+    load();
+  }, [load]);
+  useEffect9(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        load();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, load]);
+  return { blame, loading, error, reload: load };
+}
+
+// src/hooks/useVerification.ts
+import {
+  VerificationEngine
+} from "@xnetjs/history";
+import { useState as useState11, useCallback as useCallback11, useRef as useRef8 } from "react";
+function useVerification(nodeId) {
+  const { store } = useNodeStore();
+  const [result, setResult] = useState11(null);
+  const [loading, setLoading] = useState11(false);
+  const [progress, setProgress] = useState11(0);
+  const [error, setError] = useState11(null);
+  const engineRef = useRef8(null);
+  const getEngine = useCallback11(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      engineRef.current = { engine: new VerificationEngine(storage), storage };
+    }
+    return engineRef.current.engine;
+  }, [store]);
+  const verify = useCallback11(
+    async (options) => {
+      if (!nodeId) return;
+      const engine = getEngine();
+      if (!engine) return;
+      setLoading(true);
+      setProgress(0);
+      setError(null);
+      try {
+        const verifyResult = await engine.verifyNodeHistory(nodeId, {
+          ...options,
+          onProgress: (p) => {
+            setProgress(p);
+            options?.onProgress?.(p);
+          }
+        });
+        setResult(verifyResult);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+        setProgress(1);
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const quickCheck = useCallback11(async () => {
+    if (!nodeId) return null;
+    const engine = getEngine();
+    if (!engine) return null;
+    try {
+      return await engine.quickCheck(nodeId);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    }
+  }, [nodeId, getEngine]);
+  return { verify, quickCheck, result, loading, progress, error };
+}
+
+// src/hooks/useHubStatus.ts
+import { useContext } from "react";
+function useHubStatus() {
+  const context = useContext(XNetContext);
+  return context?.hubStatus ?? "disconnected";
+}
+
+// src/hooks/useCan.ts
+import { useEffect as useEffect10, useRef as useRef9, useState as useState12 } from "react";
+var GRANT_SCHEMA_ID = "xnet://xnet.fyi/Grant";
+var INITIAL_STATE = {
+  canRead: false,
+  canWrite: false,
+  canDelete: false,
+  canShare: false,
+  loading: true,
+  error: null,
+  isFresh: false,
+  evaluatedAt: 0
+};
+function useCan(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [state, setState] = useState12(INITIAL_STATE);
+  const requestRef = useRef9(0);
+  useEffect10(() => {
+    if (!store || !isReady) {
+      setState((prev) => ({ ...prev, loading: true }));
+      return;
+    }
+    if (!store.auth) {
+      setState({
+        ...INITIAL_STATE,
+        loading: false,
+        error: new Error("Authorization API is not configured on this NodeStore")
+      });
+      return;
+    }
+    const run = async () => {
+      const requestId = ++requestRef.current;
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const [read, write, del, share] = await Promise.all([
+          store.auth.can({ action: "read", nodeId }),
+          store.auth.can({ action: "write", nodeId }),
+          store.auth.can({ action: "delete", nodeId }),
+          store.auth.can({ action: "share", nodeId })
+        ]);
+        if (requestRef.current !== requestId) return;
+        setState({
+          canRead: read.allowed,
+          canWrite: write.allowed,
+          canDelete: del.allowed,
+          canShare: share.allowed,
+          loading: false,
+          error: null,
+          isFresh: !read.cached,
+          evaluatedAt: read.evaluatedAt
+        });
+      } catch (error) {
+        if (requestRef.current !== requestId) return;
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        setState((prev) => ({ ...prev, loading: false, error: normalized }));
+      }
+    };
+    void run();
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const eventNodeId = typedEvent.change?.payload?.nodeId;
+      if (eventNodeId === nodeId) {
+        void run();
+        return;
+      }
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID;
+      const grantResource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && grantResource === nodeId) {
+        void run();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [isReady, nodeId, store]);
+  return state;
+}
+
+// src/hooks/useCanEdit.ts
+import { useEffect as useEffect11, useRef as useRef10, useState as useState13 } from "react";
+var GRANT_SCHEMA_ID2 = "xnet://xnet.fyi/Grant";
+var INITIAL_STATE2 = {
+  canEdit: false,
+  canView: false,
+  loading: true,
+  error: null,
+  roles: []
+};
+function useCanEdit(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [state, setState] = useState13(INITIAL_STATE2);
+  const requestRef = useRef10(0);
+  useEffect11(() => {
+    if (!store || !isReady) {
+      setState((prev) => ({ ...prev, loading: true }));
+      return;
+    }
+    if (!store.auth) {
+      setState({
+        ...INITIAL_STATE2,
+        loading: false,
+        error: new Error("Authorization API is not configured on this NodeStore")
+      });
+      return;
+    }
+    const run = async () => {
+      const requestId = ++requestRef.current;
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const [read, write] = await Promise.all([
+          store.auth.can({ action: "read", nodeId }),
+          store.auth.can({ action: "write", nodeId })
+        ]);
+        if (requestRef.current !== requestId) return;
+        const roleSet = /* @__PURE__ */ new Set([...read.roles, ...write.roles]);
+        setState({
+          canEdit: write.allowed,
+          canView: read.allowed && !write.allowed,
+          loading: false,
+          error: null,
+          roles: Array.from(roleSet)
+        });
+      } catch (error) {
+        if (requestRef.current !== requestId) return;
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        setState((prev) => ({ ...prev, loading: false, error: normalized }));
+      }
+    };
+    void run();
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const eventNodeId = typedEvent.change?.payload?.nodeId;
+      if (eventNodeId === nodeId) {
+        void run();
+        return;
+      }
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID2;
+      const grantResource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && grantResource === nodeId) {
+        void run();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [isReady, nodeId, store]);
+  return state;
+}
+
+// src/hooks/useGrants.ts
+import { useCallback as useCallback12, useEffect as useEffect12, useState as useState14 } from "react";
+var GRANT_SCHEMA_ID3 = "xnet://xnet.fyi/Grant";
+var DEFAULT_GRANT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function describeGrantConsent(input, defaultResource, now = Date.now()) {
+  const resource = input.resource ?? defaultResource;
+  const expiresAt = computeGrantExpiration(input.expiresIn, now);
+  const actions = [...input.actions];
+  return {
+    grantee: input.to,
+    resource,
+    actions,
+    expiresAt,
+    what: actions.join(", "),
+    where: resource,
+    howLong: formatGrantExpiration(expiresAt, now)
+  };
+}
+function useGrants(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [grants, setGrants] = useState14([]);
+  const [loading, setLoading] = useState14(true);
+  const [error, setError] = useState14(null);
+  const load = useCallback12(async () => {
+    if (!store || !store.auth || !isReady) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const next = await store.auth.listGrants({ nodeId });
+      setGrants(next);
+      setLoading(false);
+    } catch (err) {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      setLoading(false);
+    }
+  }, [isReady, nodeId, store]);
+  useEffect12(() => {
+    if (!store || !isReady) {
+      setLoading(true);
+      return;
+    }
+    if (!store.auth) {
+      setLoading(false);
+      setError(new Error("Authorization API is not configured on this NodeStore"));
+      return;
+    }
+    void load();
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID3;
+      const resource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && resource === nodeId) {
+        void load();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [isReady, load, nodeId, store]);
+  const grant = useCallback12(
+    async (input) => {
+      if (!store?.auth) {
+        throw new Error("Authorization API is not configured on this NodeStore");
+      }
+      const created = await store.auth.grant({ ...input, resource: input.resource ?? nodeId });
+      await load();
+      return created;
+    },
+    [load, nodeId, store]
+  );
+  const revoke = useCallback12(
+    async (grantId) => {
+      if (!store?.auth) {
+        throw new Error("Authorization API is not configured on this NodeStore");
+      }
+      await store.auth.revoke({ grantId });
+      await load();
+    },
+    [load, store]
+  );
+  return { grants, loading, error, grant, revoke };
+}
+function computeGrantExpiration(expiresIn, now) {
+  if (typeof expiresIn === "number") {
+    return expiresIn;
+  }
+  if (typeof expiresIn === "string") {
+    const parsed = parseDuration(expiresIn);
+    if (parsed !== null) {
+      return now + parsed;
+    }
+  }
+  return now + DEFAULT_GRANT_TTL_MS;
+}
+function formatGrantExpiration(expiresAt, now) {
+  const durationMs = Math.max(0, expiresAt - now);
+  const roundedDays = Math.round(durationMs / (24 * 60 * 60 * 1e3));
+  const roundedHours = Math.round(durationMs / (60 * 60 * 1e3));
+  const roundedMinutes = Math.round(durationMs / (60 * 1e3));
+  if (roundedDays >= 1) {
+    return `${roundedDays}d`;
+  }
+  if (roundedHours >= 1) {
+    return `${roundedHours}h`;
+  }
+  if (roundedMinutes >= 1) {
+    return `${roundedMinutes}m`;
+  }
+  return `${Math.round(durationMs / 1e3)}s`;
+}
+function parseDuration(value) {
+  const match = value.match(/^(\d+)([smhdw])$/);
+  if (!match) {
+    return null;
+  }
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return null;
+  }
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return amount * 1e3;
+    case "m":
+      return amount * 60 * 1e3;
+    case "h":
+      return amount * 60 * 60 * 1e3;
+    case "d":
+      return amount * 24 * 60 * 60 * 1e3;
+    case "w":
+      return amount * 7 * 24 * 60 * 60 * 1e3;
+    default:
+      return null;
+  }
+}
+
+// src/hooks/useAuthTrace.ts
+import { useCallback as useCallback13, useEffect as useEffect13, useRef as useRef11, useState as useState15 } from "react";
+var GRANT_SCHEMA_ID4 = "xnet://xnet.fyi/Grant";
+function summarizeAuthTrace(trace) {
+  return {
+    allowed: trace.allowed,
+    action: trace.action,
+    resource: trace.resource,
+    roles: trace.roles,
+    grants: trace.grants,
+    reasons: trace.reasons,
+    evaluatedAt: trace.evaluatedAt,
+    duration: trace.duration,
+    steps: trace.steps
+  };
+}
+function useAuthTrace({
+  nodeId,
+  action,
+  enabled = true
+}) {
+  const { store, isReady } = useNodeStore();
+  const [trace, setTrace] = useState15(null);
+  const [summary, setSummary] = useState15(null);
+  const [loading, setLoading] = useState15(enabled);
+  const [error, setError] = useState15(null);
+  const requestRef = useRef11(0);
+  const refresh = useCallback13(async () => {
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    if (!store || !isReady) {
+      setLoading(true);
+      return;
+    }
+    if (!store.auth) {
+      setTrace(null);
+      setSummary(null);
+      setLoading(false);
+      setError(new Error("Authorization API is not configured on this NodeStore"));
+      return;
+    }
+    const requestId = ++requestRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const nextTrace = await store.auth.explain({ action, nodeId });
+      if (requestRef.current !== requestId) return;
+      setTrace(nextTrace);
+      setSummary(summarizeAuthTrace(nextTrace));
+      setLoading(false);
+    } catch (err) {
+      if (requestRef.current !== requestId) return;
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setTrace(null);
+      setSummary(null);
+      setLoading(false);
+      setError(normalized);
+    }
+  }, [action, enabled, isReady, nodeId, store]);
+  useEffect13(() => {
+    void refresh();
+    if (!store || !isReady || !enabled) {
+      return;
+    }
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const eventNodeId = typedEvent.change?.payload?.nodeId;
+      if (eventNodeId === nodeId) {
+        void refresh();
+        return;
+      }
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID4;
+      const grantResource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && grantResource === nodeId) {
+        void refresh();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [enabled, isReady, nodeId, refresh, store]);
+  return {
+    trace,
+    summary,
+    loading,
+    error,
+    refresh
+  };
+}
+
+// src/hooks/useBackup.ts
+import { useCallback as useCallback14, useContext as useContext2, useMemo as useMemo10, useState as useState16 } from "react";
+function useBackup() {
+  const context = useContext2(XNetContext);
+  const [uploading, setUploading] = useState16(false);
+  const backupConfig = useMemo10(() => {
+    if (!context) return null;
+    if (!context.hubUrl || !context.encryptionKey) return null;
+    return {
+      hubUrl: context.hubUrl,
+      encryptionKey: context.encryptionKey,
+      getAuthToken: context.getHubAuthToken
+    };
+  }, [context]);
+  const upload = useCallback14(
+    async (docId, plaintext) => {
+      if (!backupConfig) {
+        throw new Error("Hub backup is not configured");
+      }
+      setUploading(true);
+      try {
+        await uploadBackup(backupConfig, docId, plaintext);
+      } finally {
+        setUploading(false);
+      }
+    },
+    [backupConfig]
+  );
+  const download = useCallback14(
+    async (docId) => {
+      if (!backupConfig) return null;
+      return downloadBackup(backupConfig, docId);
+    },
+    [backupConfig]
+  );
+  return {
+    upload,
+    download,
+    uploading
+  };
+}
+
+// src/hooks/useFileUpload.ts
+import { hashHex } from "@xnetjs/crypto";
+import { useCallback as useCallback15, useContext as useContext3, useState as useState17 } from "react";
+var toHttpUrl = (hubUrl) => {
+  try {
+    const url = new URL(hubUrl);
+    if (url.protocol === "ws:") url.protocol = "http:";
+    if (url.protocol === "wss:") url.protocol = "https:";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return hubUrl;
+  }
+};
+function useFileUpload() {
+  const context = useContext3(XNetContext);
+  const [uploading, setUploading] = useState17(false);
+  const [progress, setProgress] = useState17(0);
+  const upload = useCallback15(
+    async (file) => {
+      if (!context?.hubUrl) throw new Error("Hub URL not configured");
+      setUploading(true);
+      setProgress(0);
+      try {
+        const buffer = new Uint8Array(await file.arrayBuffer());
+        setProgress(0.3);
+        const cid = `cid:blake3:${hashHex(buffer)}`;
+        setProgress(0.5);
+        const token = context.getHubAuthToken ? await context.getHubAuthToken() : "";
+        const httpUrl = toHttpUrl(context.hubUrl);
+        const res = await fetch(`${httpUrl}/files/${cid}`, {
+          method: "PUT",
+          headers: {
+            ...token ? { Authorization: `Bearer ${token}` } : {},
+            "Content-Type": file.type || "application/octet-stream",
+            "X-File-Name": file.name
+          },
+          body: buffer
+        });
+        setProgress(0.9);
+        if (!res.ok) {
+          let message = `Upload failed: ${res.status}`;
+          try {
+            const err = await res.json();
+            if (err?.error) message = err.error;
+          } catch {
+          }
+          throw new Error(message);
+        }
+        setProgress(1);
+        return {
+          cid,
+          name: file.name,
+          mimeType: file.type || "application/octet-stream",
+          size: file.size
+        };
+      } finally {
+        setUploading(false);
+      }
+    },
+    [context]
+  );
+  return { upload, uploading, progress };
+}
+
+// src/hooks/useHubSearch.ts
+import { useCallback as useCallback16, useContext as useContext4, useEffect as useEffect14, useMemo as useMemo11, useRef as useRef12, useState as useState18 } from "react";
+var createRequestId = () => {
+  const cryptoObj = globalThis.crypto;
+  if (cryptoObj && "randomUUID" in cryptoObj) {
+    return cryptoObj.randomUUID();
+  }
+  return Math.random().toString(36).slice(2);
+};
+function useHubSearch() {
+  const context = useContext4(XNetContext);
+  const connection = context?.hubConnection ?? context?.syncManager?.connection ?? null;
+  const [results, setResults] = useState18([]);
+  const [loading, setLoading] = useState18(false);
+  const [error, setError] = useState18(null);
+  const pendingRef = useRef12(/* @__PURE__ */ new Map());
+  useEffect14(() => {
+    if (!connection) return;
+    const unsubscribe = connection.onMessage((message) => {
+      const msg = message;
+      if (!msg.type || !msg.id) return;
+      if (msg.type === "query-response") {
+        const pending = pendingRef.current.get(msg.id);
+        if (pending) {
+          pendingRef.current.delete(msg.id);
+          clearTimeout(pending.timeoutId);
+          pending.resolve(msg.results ?? []);
+        }
+      }
+      if (msg.type === "query-error") {
+        const pending = pendingRef.current.get(msg.id);
+        if (pending) {
+          pendingRef.current.delete(msg.id);
+          clearTimeout(pending.timeoutId);
+          pending.reject(new Error(msg.error ?? "Query failed"));
+        }
+      }
+    });
+    return () => {
+      unsubscribe();
+      for (const pending of pendingRef.current.values()) {
+        clearTimeout(pending.timeoutId);
+        pending.reject(new Error("Query cancelled"));
+      }
+      pendingRef.current.clear();
+    };
+  }, [connection]);
+  const search = useCallback16(
+    async (query, options) => {
+      if (!connection || connection.status !== "connected") {
+        setError(new Error("Hub connection not available"));
+        setResults([]);
+        return [];
+      }
+      setLoading(true);
+      setError(null);
+      const id = createRequestId();
+      const promise = new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          pendingRef.current.delete(id);
+          reject(new Error("Query timeout"));
+        }, 5e3);
+        pendingRef.current.set(id, { resolve, reject, timeoutId });
+      });
+      connection.sendRaw({
+        type: "query-request",
+        id,
+        query,
+        filters: options?.schemaIri ? { schemaIri: options.schemaIri } : void 0,
+        limit: options?.limit,
+        offset: options?.offset
+      });
+      try {
+        const response = await promise;
+        setResults(response);
+        return response;
+      } catch (err) {
+        const errorValue = err instanceof Error ? err : new Error("Search failed");
+        setError(errorValue);
+        setResults([]);
+        return [];
+      } finally {
+        setLoading(false);
+      }
+    },
+    [connection]
+  );
+  return useMemo11(
+    () => ({
+      search,
+      results,
+      loading,
+      error
+    }),
+    [search, results, loading, error]
+  );
+}
+
+// src/hooks/useRemoteSchema.ts
+import { useContext as useContext5, useEffect as useEffect15, useMemo as useMemo12, useState as useState19 } from "react";
+var toHubHttpUrl = (hubUrl) => {
+  if (hubUrl.startsWith("http://") || hubUrl.startsWith("https://")) return hubUrl;
+  return hubUrl.replace("wss://", "https://").replace("ws://", "http://");
+};
+var useRemoteSchema = (iri) => {
+  const context = useContext5(XNetContext);
+  const hubUrl = context?.hubUrl ?? null;
+  const getHubAuthToken = context?.getHubAuthToken;
+  const [schema, setSchema] = useState19(null);
+  const [loading, setLoading] = useState19(false);
+  const [error, setError] = useState19(null);
+  useEffect15(() => {
+    if (!iri || !hubUrl) {
+      setSchema(null);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const controller = new AbortController();
+    const fetchSchema = async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        const hubHttpUrl = toHubHttpUrl(hubUrl);
+        const encodedIri = encodeURIComponent(iri);
+        const token = getHubAuthToken ? await getHubAuthToken() : "";
+        const headers = token ? { Authorization: `Bearer ${token}` } : void 0;
+        const response = await fetch(`${hubHttpUrl}/schemas/resolve/${encodedIri}`, {
+          headers,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            if (!cancelled) setSchema(null);
+            return;
+          }
+          throw new Error(`Failed to resolve schema: ${response.status}`);
+        }
+        const data = await response.json();
+        if (!cancelled) setSchema(data);
+      } catch (err) {
+        if (cancelled) return;
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        const errorValue = err instanceof Error ? err : new Error("Schema lookup failed");
+        setError(errorValue);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    };
+    void fetchSchema();
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [getHubAuthToken, hubUrl, iri]);
+  return useMemo12(
+    () => ({
+      schema,
+      loading,
+      error
+    }),
+    [schema, loading, error]
+  );
+};
+
+// src/hooks/usePeerDiscovery.ts
+import { useCallback as useCallback17, useContext as useContext6, useMemo as useMemo13, useState as useState20 } from "react";
+var toHubHttpUrl2 = (hubUrl) => hubUrl.replace("wss://", "https://").replace("ws://", "http://");
+var usePeerDiscovery = () => {
+  const context = useContext6(XNetContext);
+  const hubUrl = context?.hubUrl ?? null;
+  const [peers, setPeers] = useState20([]);
+  const [loading, setLoading] = useState20(false);
+  const refresh = useCallback17(async () => {
+    if (!hubUrl) return;
+    setLoading(true);
+    try {
+      const hubHttpUrl = toHubHttpUrl2(hubUrl);
+      const res = await fetch(`${hubHttpUrl}/dids?limit=50`);
+      if (!res.ok) return;
+      const { peers: records } = await res.json();
+      const now = Date.now();
+      setPeers(
+        records.map((record) => ({
+          did: record.did,
+          displayName: record.displayName,
+          endpoints: record.endpoints,
+          lastSeen: record.lastSeen,
+          isOnline: now - record.lastSeen < 5 * 60 * 1e3
+        }))
+      );
+    } finally {
+      setLoading(false);
+    }
+  }, [hubUrl]);
+  const resolve = useCallback17(
+    async (did) => {
+      if (!hubUrl) return null;
+      const hubHttpUrl = toHubHttpUrl2(hubUrl);
+      const res = await fetch(`${hubHttpUrl}/dids/${encodeURIComponent(did)}`);
+      if (!res.ok) return null;
+      const record = await res.json();
+      return {
+        did: record.did,
+        displayName: record.displayName,
+        endpoints: record.endpoints,
+        lastSeen: record.lastSeen,
+        isOnline: Date.now() - record.lastSeen < 5 * 60 * 1e3
+      };
+    },
+    [hubUrl]
+  );
+  return useMemo13(
+    () => ({
+      peers,
+      resolve,
+      refresh,
+      loading
+    }),
+    [peers, resolve, refresh, loading]
+  );
+};
+
+// src/components/HubStatusIndicator.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var STATUS_CONFIG = {
+  disconnected: { color: "var(--muted)", label: "Offline" },
+  connecting: { color: "var(--warning)", label: "Connecting..." },
+  connected: { color: "var(--success)", label: "Synced to hub" },
+  error: { color: "var(--destructive)", label: "Connection error" }
+};
+function HubStatusIndicator() {
+  const status = useHubStatus();
+  const config = STATUS_CONFIG[status];
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: { display: "flex", alignItems: "center", gap: "6px", fontSize: "12px" },
+      title: config.label,
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            style: {
+              width: "8px",
+              height: "8px",
+              borderRadius: "50%",
+              backgroundColor: config.color,
+              display: "inline-block",
+              animation: status === "connecting" ? "pulse 1.5s infinite" : void 0
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { style: { color: "var(--muted-foreground)" }, children: config.label })
+      ]
+    }
+  );
+}
+
+// src/components/Skeleton.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var stylesInjected = false;
+function ensureStyles() {
+  if (stylesInjected || typeof document === "undefined") return;
+  const id = "xnet-skeleton-styles";
+  if (document.getElementById(id)) {
+    stylesInjected = true;
+    return;
+  }
+  const el = document.createElement("style");
+  el.id = id;
+  el.textContent = `
+    @keyframes xnet-skeleton-pulse {
+      0% { background-position: 200% 0; }
+      100% { background-position: -200% 0; }
+    }
+  `;
+  document.head.appendChild(el);
+  stylesInjected = true;
+}
+function Skeleton({
+  width = "100%",
+  height = "1em",
+  borderRadius = "4px",
+  style,
+  lines = 1,
+  gap = "0.5rem"
+}) {
+  ensureStyles();
+  const baseStyle = {
+    display: "block",
+    width,
+    height,
+    borderRadius,
+    background: "linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%)",
+    backgroundSize: "200% 100%",
+    animation: "xnet-skeleton-pulse 1.5s ease-in-out infinite",
+    ...style
+  };
+  if (lines <= 1) {
+    return /* @__PURE__ */ jsx2("span", { "aria-hidden": "true", style: baseStyle });
+  }
+  return /* @__PURE__ */ jsx2("div", { "aria-hidden": "true", style: { display: "flex", flexDirection: "column", gap }, children: Array.from({ length: lines }, (_, i) => /* @__PURE__ */ jsx2(
+    "span",
+    {
+      style: {
+        ...baseStyle,
+        // Last line is shorter for visual realism
+        width: i === lines - 1 ? "60%" : width
+      }
+    },
+    i
+  )) });
+}
+function injectSkeletonStyles() {
+  if (typeof document === "undefined") return;
+  const id = "xnet-skeleton-styles";
+  if (document.getElementById(id)) return;
+  const style = document.createElement("style");
+  style.id = id;
+  style.textContent = `
+    @keyframes xnet-skeleton-pulse {
+      0% { background-position: 200% 0; }
+      100% { background-position: -200% 0; }
+    }
+  `;
+  document.head.appendChild(style);
+}
+
+// src/components/DemoBanner.tsx
+import { useState as useState21 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var STORAGE_KEY = "xnet:demo-banner-dismissed";
+function DemoBanner({ evictionHours, onDismiss }) {
+  const [dismissed, setDismissed] = useState21(() => {
+    if (typeof window === "undefined") return false;
+    return localStorage.getItem(STORAGE_KEY) === "true";
+  });
+  if (dismissed) return null;
+  const handleDismiss = () => {
+    localStorage.setItem(STORAGE_KEY, "true");
+    setDismissed(true);
+    onDismiss?.();
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "fixed top-0 left-0 right-0 z-50 flex items-center justify-between px-4 py-2 bg-amber-100 dark:bg-amber-900/50 border-b border-amber-300 dark:border-amber-700 text-amber-900 dark:text-amber-100 text-sm", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsxs2("span", { children: [
+        "Demo mode \u2014 data is saved locally; encrypted backups expire after ",
+        evictionHours,
+        "h of inactivity."
+      ] }),
+      /* @__PURE__ */ jsx3(
+        "a",
+        {
+          href: "https://xnet.fyi/download",
+          className: "ml-2 px-2 py-0.5 bg-amber-500 hover:bg-amber-600 text-white rounded text-xs font-medium transition-colors",
+          children: "Download desktop app"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx3(
+      "button",
+      {
+        onClick: handleDismiss,
+        className: "p-1 hover:bg-amber-200 dark:hover:bg-amber-800 rounded transition-colors",
+        "aria-label": "Dismiss banner",
+        children: /* @__PURE__ */ jsx3("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx3(
+          "path",
+          {
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 2,
+            d: "M6 18L18 6M6 6l12 12"
+          }
+        ) })
+      }
+    )
+  ] });
+}
+
+// src/components/DemoQuotaIndicator.tsx
+import { formatBytes } from "@xnetjs/core";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function DemoQuotaIndicator({ usedBytes, limitBytes }) {
+  const percentage = Math.round(usedBytes / limitBytes * 100);
+  const isWarning = percentage >= 80;
+  const isCritical = percentage >= 95;
+  return /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-2 text-xs text-muted-foreground", children: [
+    /* @__PURE__ */ jsx4("div", { className: "w-16 h-1.5 bg-border rounded-full overflow-hidden", children: /* @__PURE__ */ jsx4(
+      "div",
+      {
+        className: `h-full transition-all ${isCritical ? "bg-red-500" : isWarning ? "bg-amber-500" : "bg-primary"}`,
+        style: { width: `${Math.min(percentage, 100)}%` }
+      }
+    ) }),
+    /* @__PURE__ */ jsxs3("span", { className: isCritical ? "text-red-500" : isWarning ? "text-amber-500" : "", children: [
+      formatBytes(usedBytes),
+      " / ",
+      formatBytes(limitBytes)
+    ] })
+  ] });
+}
+
+// src/components/DemoDataExpiredScreen.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function DemoDataExpiredScreen() {
+  return /* @__PURE__ */ jsxs4("div", { className: "flex flex-col items-center justify-center min-h-screen p-6 text-center bg-background", children: [
+    /* @__PURE__ */ jsx5("div", { className: "text-6xl mb-6", children: "\u{1F550}" }),
+    /* @__PURE__ */ jsx5("h1", { className: "text-2xl font-bold mb-3 text-foreground", children: "Your demo data has expired" }),
+    /* @__PURE__ */ jsx5("p", { className: "text-muted-foreground max-w-md mb-6", children: "Your local data is still saved in this browser, but encrypted hub backups are removed after 24 hours of inactivity. Cross-device sync requires an active hub connection." }),
+    /* @__PURE__ */ jsxs4("div", { className: "flex gap-3", children: [
+      /* @__PURE__ */ jsx5(
+        "button",
+        {
+          onClick: () => window.location.reload(),
+          className: "px-4 py-2 bg-primary text-primary-foreground rounded-md hover:bg-primary/90 transition-colors",
+          children: "Start Fresh"
+        }
+      ),
+      /* @__PURE__ */ jsx5(
+        "a",
+        {
+          href: "https://xnet.fyi/download",
+          className: "px-4 py-2 border border-border rounded-md hover:bg-accent transition-colors text-foreground no-underline",
+          children: "Download Desktop App"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx5("p", { className: "mt-8 text-sm text-muted-foreground", children: "The desktop app stores data permanently on your device." })
+  ] });
+}
+
+// src/hooks/useDemoMode.ts
+import { useState as useState22, useEffect as useEffect16 } from "react";
+function useDemoMode() {
+  const { syncManager } = useXNet();
+  const [state, setState] = useState22({ isDemo: false });
+  useEffect16(() => {
+    if (!syncManager?.connection) return;
+    const connection = syncManager.connection;
+    const unsubscribe = connection.onMessage((message) => {
+      if (message.type !== "handshake") return;
+      const isDemo = message.isDemo === true;
+      if (!isDemo) {
+        setState({ isDemo: false });
+        return;
+      }
+      const demoLimits = message.demoLimits;
+      setState({
+        isDemo: true,
+        limits: demoLimits ? {
+          quotaBytes: demoLimits.quotaBytes,
+          maxDocs: demoLimits.maxDocs,
+          evictionHours: Math.round(demoLimits.evictionTtlMs / 36e5)
+        } : void 0
+      });
+    });
+    return unsubscribe;
+  }, [syncManager]);
+  return state;
+}
+
+// src/onboarding/machine.ts
+var TRANSITIONS = {
+  welcome: {
+    AUTHENTICATE: "authenticating",
+    CREATE_NEW: "authenticating",
+    CREATE_RECOVERABLE: "creating-recoverable",
+    IMPORT_EXISTING: "import-identity",
+    BROWSER_UNSUPPORTED: "unsupported-browser"
+  },
+  "creating-recoverable": {
+    RECOVERABLE_CREATED: "show-recovery-phrase",
+    PASSKEY_FAILED: "auth-error",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "show-recovery-phrase": {
+    PHRASE_SAVED: "connecting-hub"
+  },
+  authenticating: {
+    PASSKEY_SUCCESS: "connecting-hub",
+    PASSKEY_FAILED: "auth-error"
+  },
+  "auth-error": {
+    RETRY_AUTH: "authenticating",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "import-identity": {
+    SCAN_QR: "qr-scan",
+    ENTER_PHRASE: "recovery-phrase",
+    ENTER_GUARDIAN_SHARES: "guardian-recovery",
+    USE_SYNCED_PASSKEY: "authenticating",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "guardian-recovery": {
+    IDENTITY_IMPORTED: "connecting-hub",
+    IMPORT_FAILED: "guardian-recovery",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "qr-scan": {
+    IDENTITY_IMPORTED: "connecting-hub",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "recovery-phrase": {
+    IDENTITY_IMPORTED: "connecting-hub",
+    IMPORT_FAILED: "recovery-phrase",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "connecting-hub": {
+    HUB_CONNECTED: "ready",
+    HUB_FAILED: "ready"
+    // Continue anyway — hub is optional
+  },
+  ready: {
+    CREATE_FIRST_PAGE: "complete"
+  }
+  // 'unsupported-browser' and 'complete' have no transitions (terminal)
+};
+function onboardingReducer(current, event) {
+  const transitions = TRANSITIONS[current.state];
+  const nextState = transitions?.[event.type];
+  if (!nextState) {
+    return current;
+  }
+  const nextContext = { ...current.context };
+  switch (event.type) {
+    case "PASSKEY_SUCCESS":
+      nextContext.identity = event.identity;
+      nextContext.keyBundle = event.keyBundle;
+      nextContext.error = null;
+      break;
+    case "PASSKEY_FAILED":
+      nextContext.error = event.error;
+      break;
+    case "IDENTITY_IMPORTED":
+      nextContext.identity = event.identity;
+      nextContext.keyBundle = event.keyBundle;
+      nextContext.error = null;
+      break;
+    case "RECOVERABLE_CREATED":
+      nextContext.identity = event.identity;
+      nextContext.keyBundle = event.keyBundle;
+      nextContext.recoveryPhrase = event.phrase;
+      nextContext.error = null;
+      break;
+    case "IMPORT_FAILED":
+      nextContext.error = event.error;
+      break;
+    case "CREATE_RECOVERABLE":
+      nextContext.error = null;
+      break;
+    case "HUB_FAILED":
+      nextContext.error = event.error;
+      break;
+    case "HUB_CONNECTED":
+      nextContext.error = null;
+      break;
+    case "RETRY_AUTH":
+    case "AUTHENTICATE":
+    case "CREATE_NEW":
+      nextContext.error = null;
+      break;
+  }
+  return { state: nextState, context: nextContext };
+}
+function createInitialState(hubUrl) {
+  return {
+    state: "welcome",
+    context: {
+      identity: null,
+      keyBundle: null,
+      hubUrl: hubUrl ?? null,
+      error: null,
+      isDemo: false,
+      recoveryPhrase: null
+    }
+  };
+}
+
+// src/onboarding/OnboardingProvider.tsx
+import {
+  detectPasskeySupport,
+  createIdentityManager,
+  isTestBypassEnabled,
+  parseShare
+} from "@xnetjs/identity";
+import {
+  createContext,
+  useContext as useContext7,
+  useReducer,
+  useCallback as useCallback18,
+  useEffect as useEffect17,
+  useRef as useRef13,
+  useMemo as useMemo14
+} from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var OnboardingCtx = createContext(null);
+function OnboardingProvider({
+  children,
+  defaultHubUrl = "wss://hub.xnet.fyi",
+  onComplete
+}) {
+  const [{ state, context }, dispatch] = useReducer(
+    onboardingReducer,
+    createInitialState(defaultHubUrl)
+  );
+  const manager = useMemo14(() => createIdentityManager(), []);
+  useEffect17(() => {
+    let cancelled = false;
+    manager.preflight().catch(() => {
+    });
+    detectPasskeySupport().then((support) => {
+      if (isTestBypassEnabled()) {
+        return;
+      }
+      if (!cancelled && (!support.webauthn || !support.platform)) {
+        dispatch({ type: "BROWSER_UNSUPPORTED" });
+      }
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [manager]);
+  useEffect17(() => {
+    if (state === "complete" && context.identity && context.keyBundle && onComplete) {
+      onComplete(context.identity, context.keyBundle);
+    }
+  }, [state, context.identity, context.keyBundle, onComplete]);
+  const authInFlight = useRef13(false);
+  const send = useCallback18(
+    (event) => {
+      if ((event.type === "AUTHENTICATE" || event.type === "CREATE_NEW") && state === "welcome" || event.type === "RETRY_AUTH" && state === "auth-error") {
+        if (authInFlight.current) return;
+        authInFlight.current = true;
+        manager.create().then((keyBundle) => {
+          dispatch({
+            type: "PASSKEY_SUCCESS",
+            identity: keyBundle.identity,
+            keyBundle
+          });
+        }).catch((err) => {
+          dispatch({
+            type: "PASSKEY_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }).finally(() => {
+          authInFlight.current = false;
+        });
+      }
+      if (event.type === "CREATE_RECOVERABLE" && state === "welcome") {
+        if (authInFlight.current) return;
+        authInFlight.current = true;
+        manager.createRecoverable().then(({ keyBundle, phrase }) => {
+          dispatch({
+            type: "RECOVERABLE_CREATED",
+            identity: keyBundle.identity,
+            keyBundle,
+            phrase
+          });
+        }).catch((err) => {
+          dispatch({
+            type: "PASSKEY_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }).finally(() => {
+          authInFlight.current = false;
+        });
+      }
+      if (event.type === "USE_SYNCED_PASSKEY" && state === "import-identity") {
+        if (authInFlight.current) return;
+        authInFlight.current = true;
+        manager.recoverViaSyncedPasskey().then((keyBundle) => {
+          if (keyBundle) {
+            dispatch({ type: "PASSKEY_SUCCESS", identity: keyBundle.identity, keyBundle });
+          } else {
+            dispatch({
+              type: "PASSKEY_FAILED",
+              error: new Error("No synced passkey found on this device")
+            });
+          }
+        }).catch((err) => {
+          dispatch({
+            type: "PASSKEY_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }).finally(() => {
+          authInFlight.current = false;
+        });
+      }
+      if (event.type === "SUBMIT_GUARDIAN_SHARES" && state === "guardian-recovery") {
+        if (authInFlight.current) return;
+        authInFlight.current = true;
+        Promise.resolve().then(() => {
+          const shares = event.codes.map((code) => parseShare(code));
+          return manager.recoverFromGuardianShares(shares);
+        }).then(({ keyBundle }) => {
+          dispatch({ type: "IDENTITY_IMPORTED", identity: keyBundle.identity, keyBundle });
+        }).catch((err) => {
+          dispatch({
+            type: "IMPORT_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }).finally(() => {
+          authInFlight.current = false;
+        });
+      }
+      if (event.type === "SUBMIT_PHRASE" && state === "recovery-phrase") {
+        if (authInFlight.current) return;
+        authInFlight.current = true;
+        manager.importRecoveryPhrase(event.phrase).then(({ keyBundle }) => {
+          dispatch({
+            type: "IDENTITY_IMPORTED",
+            identity: keyBundle.identity,
+            keyBundle
+          });
+        }).catch((err) => {
+          dispatch({
+            type: "IMPORT_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }).finally(() => {
+          authInFlight.current = false;
+        });
+      }
+      dispatch(event);
+    },
+    [state, manager]
+  );
+  return /* @__PURE__ */ jsx6(OnboardingCtx.Provider, { value: { state, context, send }, children });
+}
+function useOnboarding() {
+  const ctx = useContext7(OnboardingCtx);
+  if (!ctx) {
+    throw new Error("useOnboarding must be used within <OnboardingProvider>");
+  }
+  return ctx;
+}
+
+// src/onboarding/helpers.ts
+function getPlatformAuthName() {
+  if (typeof navigator === "undefined") return "Biometric authentication";
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.includes("mac") || ua.includes("iphone") || ua.includes("ipad")) {
+    return "Touch ID";
+  }
+  if (ua.includes("windows")) {
+    return "Windows Hello";
+  }
+  if (ua.includes("android")) {
+    return "Fingerprint";
+  }
+  return "Biometric authentication";
+}
+function truncateDid(did, headLen = 16, tailLen = 4) {
+  if (did.length <= headLen + tailLen + 3) return did;
+  return `${did.slice(0, headLen)}...${did.slice(-tailLen)}`;
+}
+async function copyToClipboard(text) {
+  if (typeof navigator === "undefined" || !navigator.clipboard) {
+    return false;
+  }
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/onboarding/screens/AuthenticatingScreen.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function AuthenticatingScreen() {
+  return /* @__PURE__ */ jsxs5("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx7("div", { className: "w-12 h-12 mb-6 border-4 border-primary border-t-transparent rounded-full animate-spin" }),
+    /* @__PURE__ */ jsxs5("h1", { className: "text-2xl font-semibold mb-2", children: [
+      "Waiting for ",
+      getPlatformAuthName()
+    ] }),
+    /* @__PURE__ */ jsx7("p", { className: "text-muted-foreground text-center", children: "Complete the biometric prompt to continue..." })
+  ] });
+}
+
+// src/onboarding/screens/AuthErrorScreen.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function AuthErrorScreen() {
+  const { send, context } = useOnboarding();
+  return /* @__PURE__ */ jsxs6("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx8("div", { className: "text-5xl mb-4", children: "!" }),
+    /* @__PURE__ */ jsx8("h1", { className: "text-2xl font-semibold mb-2", children: "Authentication failed" }),
+    /* @__PURE__ */ jsxs6("p", { className: "text-muted-foreground mb-2", children: [
+      "Could not set up ",
+      getPlatformAuthName(),
+      "."
+    ] }),
+    context.error && /* @__PURE__ */ jsx8("p", { className: "text-destructive text-sm mb-4 max-w-md text-center", children: context.error.message }),
+    /* @__PURE__ */ jsx8(
+      "button",
+      {
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors mb-3",
+        onClick: () => send({ type: "RETRY_AUTH" }),
+        children: "Try again"
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors mb-6",
+        onClick: () => send({ type: "BACK_TO_WELCOME" }),
+        children: "Back to welcome"
+      }
+    ),
+    /* @__PURE__ */ jsx8("p", { className: "text-xs text-muted-foreground max-w-sm text-center", children: "Make sure your browser supports passkeys (Chrome 116+, Safari 18+, Edge 116+)." })
+  ] });
+}
+
+// src/onboarding/screens/HubConnectScreen.tsx
+import { useEffect as useEffect18 } from "react";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function HubConnectScreen({ connectToHub }) {
+  const { send, context } = useOnboarding();
+  useEffect18(() => {
+    let cancelled = false;
+    if (connectToHub) {
+      connectToHub().then(() => {
+        if (!cancelled) send({ type: "HUB_CONNECTED" });
+      }).catch((err) => {
+        if (!cancelled) {
+          send({
+            type: "HUB_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }
+      });
+    } else {
+      send({ type: "HUB_CONNECTED" });
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs7("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx9("div", { className: "w-12 h-12 mb-6 border-4 border-primary border-t-transparent rounded-full animate-spin" }),
+    /* @__PURE__ */ jsx9("h1", { className: "text-2xl font-semibold mb-2", children: "Connecting to sync server" }),
+    /* @__PURE__ */ jsx9("p", { className: "text-muted-foreground mb-4", children: "Setting up secure connection..." }),
+    context.hubUrl && /* @__PURE__ */ jsx9("p", { className: "text-xs text-muted-foreground font-mono", children: context.hubUrl })
+  ] });
+}
+
+// src/onboarding/screens/ImportIdentityScreen.tsx
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function ImportIdentityScreen() {
+  const { send } = useOnboarding();
+  return /* @__PURE__ */ jsxs8("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx10("h1", { className: "text-2xl font-semibold mb-2", children: "Import your identity" }),
+    /* @__PURE__ */ jsx10("p", { className: "text-muted-foreground text-center mb-8 max-w-md", children: "Bring your existing xNet identity to this device." }),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors mb-3 w-64",
+        onClick: () => send({ type: "USE_SYNCED_PASSKEY" }),
+        children: "Use a synced passkey"
+      }
+    ),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors mb-2",
+        onClick: () => send({ type: "SCAN_QR" }),
+        children: "Scan from another device"
+      }
+    ),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors mb-2",
+        onClick: () => send({ type: "ENTER_PHRASE" }),
+        children: "Enter recovery phrase"
+      }
+    ),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors mb-6",
+        onClick: () => send({ type: "ENTER_GUARDIAN_SHARES" }),
+        children: "Recover with guardian shares"
+      }
+    ),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors",
+        onClick: () => send({ type: "BACK_TO_WELCOME" }),
+        children: "Back"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/ReadyScreen.tsx
+import { useState as useState23, useEffect as useEffect19, useRef as useRef14 } from "react";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function ReadyScreen() {
+  const { send, context } = useOnboarding();
+  const [copied, setCopied] = useState23(false);
+  const timerRef = useRef14(null);
+  useEffect19(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, []);
+  const handleCopy = async () => {
+    if (context.identity?.did) {
+      const ok = await copyToClipboard(context.identity.did);
+      if (ok) {
+        setCopied(true);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => setCopied(false), 2e3);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs9("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx11("div", { className: "text-5xl mb-4", children: "\u2713" }),
+    /* @__PURE__ */ jsx11("h1", { className: "text-2xl font-semibold mb-6", children: "You're all set!" }),
+    context.identity && /* @__PURE__ */ jsxs9("div", { className: "flex flex-col items-center mb-4", children: [
+      /* @__PURE__ */ jsx11("label", { className: "text-xs text-muted-foreground mb-1", children: "Your identity" }),
+      /* @__PURE__ */ jsxs9("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx11("code", { className: "text-sm font-mono bg-muted px-3 py-1 rounded", children: truncateDid(context.identity.did) }),
+        /* @__PURE__ */ jsx11(
+          "button",
+          {
+            className: "text-xs text-primary hover:text-primary/80 transition-colors",
+            onClick: handleCopy,
+            title: "Copy full DID",
+            children: copied ? "Copied!" : "Copy"
+          }
+        )
+      ] })
+    ] }),
+    context.hubUrl && /* @__PURE__ */ jsxs9("div", { className: "flex flex-col items-center mb-4", children: [
+      /* @__PURE__ */ jsx11("label", { className: "text-xs text-muted-foreground mb-1", children: "Connected to" }),
+      /* @__PURE__ */ jsx11("span", { className: "text-sm font-mono", children: context.hubUrl })
+    ] }),
+    context.isDemo && /* @__PURE__ */ jsx11("div", { className: "px-4 py-2 bg-amber-100 dark:bg-amber-900/30 text-amber-900 dark:text-amber-100 rounded-lg text-sm mb-6", children: "Demo mode \u2014 data is saved locally; encrypted backups expire after 24h of inactivity." }),
+    /* @__PURE__ */ jsx11(
+      "button",
+      {
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors",
+        onClick: () => send({ type: "CREATE_FIRST_PAGE" }),
+        children: "Create your first page"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/UnsupportedBrowserScreen.tsx
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function UnsupportedBrowserScreen() {
+  return /* @__PURE__ */ jsxs10("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx12("div", { className: "text-5xl mb-4", children: ":(" }),
+    /* @__PURE__ */ jsx12("h1", { className: "text-2xl font-semibold mb-2", children: "Browser not supported" }),
+    /* @__PURE__ */ jsxs10("p", { className: "text-muted-foreground text-center mb-6 max-w-md", children: [
+      "xNet requires ",
+      getPlatformAuthName(),
+      " which isn't available in this browser."
+    ] }),
+    /* @__PURE__ */ jsx12(
+      "a",
+      {
+        href: "/download",
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors mb-6 no-underline",
+        children: "Download Desktop App"
+      }
+    ),
+    /* @__PURE__ */ jsx12("p", { className: "text-xs text-muted-foreground", children: "Supported browsers: Chrome 116+, Safari 18+, Edge 116+" })
+  ] });
+}
+
+// src/onboarding/screens/WelcomeScreen.tsx
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+function WelcomeScreen() {
+  const { send } = useOnboarding();
+  return /* @__PURE__ */ jsxs11("div", { className: "flex flex-col items-center justify-center min-h-screen bg-gradient-to-b from-background to-muted/30 text-foreground p-6", children: [
+    /* @__PURE__ */ jsx13("div", { className: "w-16 h-16 mb-8 rounded-2xl bg-primary/10 flex items-center justify-center", children: /* @__PURE__ */ jsxs11(
+      "svg",
+      {
+        className: "w-8 h-8 text-primary",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        children: [
+          /* @__PURE__ */ jsx13("path", { d: "M12 2L2 7l10 5 10-5-10-5z" }),
+          /* @__PURE__ */ jsx13("path", { d: "M2 17l10 5 10-5" }),
+          /* @__PURE__ */ jsx13("path", { d: "M2 12l10 5 10-5" })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx13("h1", { className: "text-4xl font-bold mb-3 tracking-tight", children: "Welcome to xNet" }),
+    /* @__PURE__ */ jsx13("p", { className: "text-muted-foreground text-center mb-10 max-w-sm text-lg leading-relaxed", children: "Your private workspace that syncs everywhere and belongs to you." }),
+    /* @__PURE__ */ jsx13(
+      "button",
+      {
+        className: "group px-8 py-4 bg-primary text-primary-foreground rounded-xl font-semibold text-lg shadow-lg shadow-primary/25 hover:shadow-xl hover:shadow-primary/30 hover:scale-[1.02] active:scale-[0.98] transition-all duration-200 mb-4",
+        onClick: () => send({ type: "AUTHENTICATE" }),
+        children: /* @__PURE__ */ jsxs11("span", { className: "flex items-center gap-2", children: [
+          getPlatformAuthName() === "Touch ID" && /* @__PURE__ */ jsx13("svg", { className: "w-5 h-5", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx13("path", { d: "M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.48.38z" }) }),
+          getPlatformAuthName() === "Face ID" && /* @__PURE__ */ jsx13("svg", { className: "w-5 h-5", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx13("path", { d: "M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z" }) }),
+          getPlatformAuthName() === "Windows Hello" && /* @__PURE__ */ jsx13("svg", { className: "w-5 h-5", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx13("path", { d: "M3 5v14h18V5H3zm16 12H5V7h14v10z" }) }),
+          !["Touch ID", "Face ID", "Windows Hello"].includes(getPlatformAuthName()) && /* @__PURE__ */ jsxs11(
+            "svg",
+            {
+              className: "w-5 h-5",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              children: [
+                /* @__PURE__ */ jsx13("rect", { x: "3", y: "11", width: "18", height: "11", rx: "2", ry: "2" }),
+                /* @__PURE__ */ jsx13("path", { d: "M7 11V7a5 5 0 0 1 10 0v4" })
+              ]
+            }
+          ),
+          "Get started with ",
+          getPlatformAuthName()
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx13("p", { className: "text-xs text-muted-foreground/70 text-center max-w-xs mt-2 mb-6", children: "Creates a secure passkey on your device. No passwords needed." }),
+    /* @__PURE__ */ jsx13(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors underline-offset-4 hover:underline mb-2",
+        onClick: () => send({ type: "CREATE_RECOVERABLE" }),
+        children: "Set up a recovery phrase too"
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors underline-offset-4 hover:underline",
+        onClick: () => send({ type: "IMPORT_EXISTING" }),
+        children: "I already have an identity"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/GuardianRecoveryScreen.tsx
+import { parseShare as parseShare2 } from "@xnetjs/identity";
+import { useMemo as useMemo15, useState as useState24 } from "react";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function GuardianRecoveryScreen() {
+  const { send, context } = useOnboarding();
+  const [text, setText] = useState24("");
+  const { validCodes, invalidCount, threshold } = useMemo15(() => {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    const valid = [];
+    let invalid = 0;
+    let need = null;
+    for (const line of lines) {
+      try {
+        const share = parseShare2(line);
+        valid.push(line);
+        need ??= share.threshold;
+      } catch {
+        invalid += 1;
+      }
+    }
+    return { validCodes: valid, invalidCount: invalid, threshold: need };
+  }, [text]);
+  const canRecover = threshold !== null && validCodes.length >= threshold;
+  const hint = (() => {
+    if (context.error) return context.error.message;
+    if (text.trim().length === 0) return "Paste one share code per line";
+    if (invalidCount > 0)
+      return `${invalidCount} code${invalidCount === 1 ? "" : "s"} not recognized`;
+    if (threshold !== null) return `${validCodes.length} of ${threshold} needed`;
+    return `${validCodes.length} share${validCodes.length === 1 ? "" : "s"} pasted`;
+  })();
+  return /* @__PURE__ */ jsxs12("div", { className: "flex min-h-screen flex-col items-center justify-center bg-background p-6 text-foreground", children: [
+    /* @__PURE__ */ jsx14("h1", { className: "mb-2 text-2xl font-semibold", children: "Recover with your guardians" }),
+    /* @__PURE__ */ jsx14("p", { className: "mb-6 max-w-md text-center text-muted-foreground", children: "Paste the share codes your guardians gave you \u2014 one per line. You need enough of them to restore your identity; we\u2019ll tell you when you have enough." }),
+    /* @__PURE__ */ jsx14(
+      "textarea",
+      {
+        autoFocus: true,
+        spellCheck: false,
+        autoCapitalize: "none",
+        autoCorrect: "off",
+        value: text,
+        onChange: (e) => setText(e.target.value),
+        placeholder: "xnet-share:\u2026\nxnet-share:\u2026",
+        rows: 5,
+        className: "mb-2 w-80 max-w-full resize-none rounded-lg border border-border bg-muted/30 p-3 font-mono text-xs outline-none focus:border-primary"
+      }
+    ),
+    /* @__PURE__ */ jsx14("div", { className: "mb-4 h-5 text-xs", children: /* @__PURE__ */ jsx14(
+      "span",
+      {
+        className: context.error || invalidCount > 0 ? "text-destructive" : "text-muted-foreground",
+        children: hint
+      }
+    ) }),
+    /* @__PURE__ */ jsx14(
+      "button",
+      {
+        disabled: !canRecover,
+        className: "mb-3 w-64 rounded-lg bg-primary px-6 py-3 font-medium text-primary-foreground transition-colors hover:bg-primary/90 disabled:cursor-not-allowed disabled:opacity-50",
+        onClick: () => canRecover && send({ type: "SUBMIT_GUARDIAN_SHARES", codes: validCodes }),
+        children: "Recover my identity"
+      }
+    ),
+    /* @__PURE__ */ jsx14(
+      "button",
+      {
+        className: "text-sm text-muted-foreground transition-colors hover:text-foreground",
+        onClick: () => send({ type: "BACK_TO_WELCOME" }),
+        children: "Back"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/RecoveryPhraseScreen.tsx
+import { validateRecoveryPhrase } from "@xnetjs/identity";
+import { useMemo as useMemo16, useState as useState25 } from "react";
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+function RecoveryPhraseScreen() {
+  const { send, context } = useOnboarding();
+  const [phrase, setPhrase] = useState25("");
+  const validation = useMemo16(() => validateRecoveryPhrase(phrase), [phrase]);
+  const empty = phrase.trim().length === 0;
+  const hint = (() => {
+    if (empty || validation.ok) return null;
+    if (validation.reason === "too-short") {
+      return `Enter your full phrase (at least 12 words) \u2014 ${validation.wordCount} so far.`;
+    }
+    return `Not in the wordlist: ${validation.unknownWords.join(", ")}`;
+  })();
+  return /* @__PURE__ */ jsxs13("div", { className: "flex min-h-screen flex-col items-center justify-center bg-background p-6 text-foreground", children: [
+    /* @__PURE__ */ jsx15("h1", { className: "mb-2 text-2xl font-semibold", children: "Enter your recovery phrase" }),
+    /* @__PURE__ */ jsx15("p", { className: "mb-6 max-w-md text-center text-muted-foreground", children: "Type the recovery phrase you saved. It restores the same identity and your encrypted data on this device." }),
+    /* @__PURE__ */ jsx15(
+      "textarea",
+      {
+        autoFocus: true,
+        spellCheck: false,
+        autoCapitalize: "none",
+        autoCorrect: "off",
+        value: phrase,
+        onChange: (e) => setPhrase(e.target.value),
+        placeholder: "amber anchor apple \u2026",
+        rows: 3,
+        className: "mb-2 w-80 max-w-full resize-none rounded-lg border border-border bg-muted/30 p-3 font-mono text-sm outline-none focus:border-primary"
+      }
+    ),
+    /* @__PURE__ */ jsxs13("div", { className: "mb-4 h-5 text-xs", children: [
+      hint && /* @__PURE__ */ jsx15("span", { className: "text-destructive", children: hint }),
+      context.error && !hint && /* @__PURE__ */ jsx15("span", { className: "text-destructive", children: context.error.message })
+    ] }),
+    /* @__PURE__ */ jsx15(
+      "button",
+      {
+        disabled: !validation.ok,
+        className: "mb-3 w-64 rounded-lg bg-primary px-6 py-3 font-medium text-primary-foreground transition-colors hover:bg-primary/90 disabled:cursor-not-allowed disabled:opacity-50",
+        onClick: () => validation.ok && send({ type: "SUBMIT_PHRASE", phrase }),
+        children: "Recover my identity"
+      }
+    ),
+    /* @__PURE__ */ jsx15(
+      "button",
+      {
+        className: "text-sm text-muted-foreground transition-colors hover:text-foreground",
+        onClick: () => send({ type: "BACK_TO_WELCOME" }),
+        children: "Back"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/ShowRecoveryPhraseScreen.tsx
+import { useState as useState26 } from "react";
+import { jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+function ShowRecoveryPhraseScreen() {
+  const { send, context } = useOnboarding();
+  const [saved, setSaved] = useState26(false);
+  const [copied, setCopied] = useState26(false);
+  const phrase = context.recoveryPhrase ?? "";
+  const words = phrase.split(" ").filter(Boolean);
+  const copy = () => {
+    void navigator.clipboard?.writeText(phrase).then(
+      () => setCopied(true),
+      () => setCopied(false)
+    );
+  };
+  return /* @__PURE__ */ jsxs14("div", { className: "flex min-h-screen flex-col items-center justify-center bg-background p-6 text-foreground", children: [
+    /* @__PURE__ */ jsx16("h1", { className: "mb-2 text-2xl font-semibold", children: "Save your recovery phrase" }),
+    /* @__PURE__ */ jsx16("p", { className: "mb-6 max-w-md text-center text-muted-foreground", children: "Write these words down and keep them somewhere safe. They are the only way to recover your workspace if you lose your passkey \u2014 we can\u2019t recover them for you." }),
+    /* @__PURE__ */ jsx16("ol", { className: "mb-3 grid w-80 max-w-full grid-cols-2 gap-x-6 gap-y-1 rounded-lg border border-border bg-muted/30 p-4 font-mono text-sm", children: words.map((word, i) => /* @__PURE__ */ jsxs14("li", { className: "flex gap-2", children: [
+      /* @__PURE__ */ jsx16("span", { className: "w-5 select-none text-right text-muted-foreground", children: i + 1 }),
+      /* @__PURE__ */ jsx16("span", { children: word })
+    ] }, `${i}-${word}`)) }),
+    /* @__PURE__ */ jsx16(
+      "button",
+      {
+        className: "mb-5 text-xs text-muted-foreground transition-colors hover:text-foreground",
+        onClick: copy,
+        children: copied ? "Copied \u2713" : "Copy to clipboard"
+      }
+    ),
+    /* @__PURE__ */ jsxs14("label", { className: "mb-4 flex max-w-xs cursor-pointer items-start gap-2 text-sm text-muted-foreground", children: [
+      /* @__PURE__ */ jsx16(
+        "input",
+        {
+          type: "checkbox",
+          checked: saved,
+          onChange: (e) => setSaved(e.target.checked),
+          className: "mt-0.5"
+        }
+      ),
+      "I\u2019ve saved my recovery phrase somewhere safe."
+    ] }),
+    /* @__PURE__ */ jsx16(
+      "button",
+      {
+        disabled: !saved,
+        className: "w-64 rounded-lg bg-primary px-6 py-3 font-medium text-primary-foreground transition-colors hover:bg-primary/90 disabled:cursor-not-allowed disabled:opacity-50",
+        onClick: () => send({ type: "PHRASE_SAVED" }),
+        children: "Continue"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/OnboardingFlow.tsx
+import { Fragment, jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+function OnboardingFlow({ connectToHub, children }) {
+  const { state } = useOnboarding();
+  switch (state) {
+    case "welcome":
+      return /* @__PURE__ */ jsx17(WelcomeScreen, {});
+    case "authenticating":
+      return /* @__PURE__ */ jsx17(AuthenticatingScreen, {});
+    case "auth-error":
+      return /* @__PURE__ */ jsx17(AuthErrorScreen, {});
+    case "unsupported-browser":
+      return /* @__PURE__ */ jsx17(UnsupportedBrowserScreen, {});
+    case "import-identity":
+      return /* @__PURE__ */ jsx17(ImportIdentityScreen, {});
+    case "qr-scan":
+      return /* @__PURE__ */ jsxs15("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+        /* @__PURE__ */ jsx17("h1", { className: "text-2xl font-semibold mb-2", children: "QR Scan" }),
+        /* @__PURE__ */ jsx17("p", { className: "text-muted-foreground", children: "Coming soon \u2014 scan a QR code from another device." })
+      ] });
+    case "recovery-phrase":
+      return /* @__PURE__ */ jsx17(RecoveryPhraseScreen, {});
+    case "guardian-recovery":
+      return /* @__PURE__ */ jsx17(GuardianRecoveryScreen, {});
+    case "creating-recoverable":
+      return /* @__PURE__ */ jsx17(AuthenticatingScreen, {});
+    case "show-recovery-phrase":
+      return /* @__PURE__ */ jsx17(ShowRecoveryPhraseScreen, {});
+    case "connecting-hub":
+      return /* @__PURE__ */ jsx17(HubConnectScreen, { connectToHub });
+    case "ready":
+      return /* @__PURE__ */ jsx17(ReadyScreen, {});
+    case "complete":
+      return /* @__PURE__ */ jsx17(Fragment, { children });
+    default:
+      return /* @__PURE__ */ jsx17(WelcomeScreen, {});
+  }
+}
+
+// src/onboarding/screens/SmartWelcome.tsx
+import { discoverExistingPasskey } from "@xnetjs/identity";
+import { useEffect as useEffect20, useState as useState27 } from "react";
+import { jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+function SmartWelcome() {
+  const { send } = useOnboarding();
+  const [checking, setChecking] = useState27(true);
+  const [hasExisting, setHasExisting] = useState27(false);
+  useEffect20(() => {
+    let cancelled = false;
+    discoverExistingPasskey().then((passkey) => {
+      if (!cancelled) {
+        setHasExisting(passkey !== null);
+        setChecking(false);
+      }
+    }).catch(() => {
+      if (!cancelled) {
+        setChecking(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  if (checking) {
+    return /* @__PURE__ */ jsx18("div", { className: "onboarding-screen", children: /* @__PURE__ */ jsx18("p", { className: "spinner-text", children: "Checking for existing identity..." }) });
+  }
+  if (hasExisting) {
+    const authName = getPlatformAuthName();
+    return /* @__PURE__ */ jsxs16("div", { className: "onboarding-screen welcome-back", children: [
+      /* @__PURE__ */ jsx18("h1", { children: "Welcome back!" }),
+      /* @__PURE__ */ jsxs16("p", { className: "subtitle", children: [
+        "We found your xNet identity. Use ",
+        authName,
+        " to sign in."
+      ] }),
+      /* @__PURE__ */ jsxs16("button", { className: "primary-button", onClick: () => send({ type: "AUTHENTICATE" }), children: [
+        "Sign in with ",
+        authName
+      ] }),
+      /* @__PURE__ */ jsx18("button", { className: "text-button", onClick: () => send({ type: "CREATE_NEW" }), children: "Create a new identity instead" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx18(WelcomeScreen, {});
+}
+
+// src/onboarding/screens/SyncProgressOverlay.tsx
+import { formatBytes as formatBytes2 } from "@xnetjs/core";
+import { useEffect as useEffect21 } from "react";
+import { Fragment as Fragment2, jsx as jsx19, jsxs as jsxs17 } from "react/jsx-runtime";
+function SyncProgressOverlay({
+  progress,
+  onComplete
+}) {
+  useEffect21(() => {
+    if (progress.phase === "complete") {
+      const timer = setTimeout(onComplete, 1500);
+      return () => clearTimeout(timer);
+    }
+  }, [progress.phase, onComplete]);
+  return /* @__PURE__ */ jsx19("div", { className: "sync-progress-overlay", children: /* @__PURE__ */ jsxs17("div", { className: "sync-card", children: [
+    progress.phase === "connecting" && /* @__PURE__ */ jsxs17(Fragment2, { children: [
+      /* @__PURE__ */ jsx19("h2", { children: "Connecting to server..." }),
+      /* @__PURE__ */ jsx19("p", { className: "spinner-text", children: "Please wait" })
+    ] }),
+    progress.phase === "syncing" && /* @__PURE__ */ jsxs17(Fragment2, { children: [
+      /* @__PURE__ */ jsx19("h2", { children: "Syncing your data" }),
+      /* @__PURE__ */ jsx19("div", { className: "progress-bar", children: /* @__PURE__ */ jsx19(
+        "div",
+        {
+          className: "progress-fill",
+          style: {
+            width: `${progress.roomsSynced / Math.max(progress.roomsTotal, 1) * 100}%`
+          }
+        }
+      ) }),
+      /* @__PURE__ */ jsxs17("p", { className: "progress-text", children: [
+        progress.roomsSynced,
+        " of ",
+        progress.roomsTotal,
+        " items"
+      ] }),
+      /* @__PURE__ */ jsxs17("p", { className: "bytes-text", children: [
+        formatBytes2(progress.bytesReceived),
+        " received"
+      ] })
+    ] }),
+    progress.phase === "complete" && /* @__PURE__ */ jsxs17(Fragment2, { children: [
+      /* @__PURE__ */ jsx19("h2", { children: "All synced!" }),
+      /* @__PURE__ */ jsxs17("p", { children: [
+        progress.roomsTotal,
+        " items synchronized"
+      ] })
+    ] }),
+    progress.phase === "error" && /* @__PURE__ */ jsxs17(Fragment2, { children: [
+      /* @__PURE__ */ jsx19("h2", { children: "Sync issue" }),
+      /* @__PURE__ */ jsx19("p", { children: "Some data may not be up to date." }),
+      progress.error && /* @__PURE__ */ jsx19("p", { className: "error-detail", children: progress.error.message }),
+      /* @__PURE__ */ jsx19("button", { className: "primary-button", onClick: onComplete, children: "Continue anyway" })
+    ] })
+  ] }) });
+}
+
+// src/onboarding/templates.ts
+var QUICK_START_TEMPLATES = [
+  {
+    id: "blank-page",
+    name: "Blank Page",
+    description: "Start from scratch",
+    icon: "file"
+  },
+  {
+    id: "meeting-notes",
+    name: "Meeting Notes",
+    description: "Template for taking meeting notes",
+    icon: "users"
+  },
+  {
+    id: "project-tracker",
+    name: "Project Tracker",
+    description: "Database for tracking tasks",
+    icon: "kanban"
+  },
+  {
+    id: "canvas",
+    name: "Whiteboard",
+    description: "Infinite canvas for visual thinking",
+    icon: "pen-tool"
+  }
+];
+
+// src/components/pageTaskRows.ts
+function flattenTaskTree(items, depth = 0) {
+  return items.flatMap((item) => [
+    {
+      id: item.task.id,
+      title: item.task.title ?? "Untitled task",
+      completed: Boolean(item.task.completed),
+      dueDate: typeof item.task.dueDate === "number" ? item.task.dueDate : void 0,
+      depth,
+      assigneeCount: Array.isArray(item.task.assignees) ? item.task.assignees.length : 0
+    },
+    ...flattenTaskTree(item.children, depth + 1)
+  ]);
+}
+function formatTaskDueDate(timestamp) {
+  if (typeof timestamp !== "number") return null;
+  return new Date(timestamp).toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric"
+  });
+}
+function getStartOfUtcDay2(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+function isTaskOverdue(timestamp, completed) {
+  if (typeof timestamp !== "number" || completed) return false;
+  return getStartOfUtcDay2(timestamp) < getStartOfUtcDay2(Date.now());
+}
+
+// src/components/PageTasksPanel.tsx
+import { Calendar, CheckSquare2, ChevronDown, ChevronRight, Square, Users } from "lucide-react";
+import { useMemo as useMemo17, useState as useState28 } from "react";
+import { jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
+function PageTasksPanel({ pageId }) {
+  const [expanded, setExpanded] = useState28(true);
+  const { tree, loading } = useTasks({ pageId });
+  const rows = useMemo17(() => flattenTaskTree(tree), [tree]);
+  return /* @__PURE__ */ jsxs18("div", { className: "mt-8 overflow-hidden rounded-lg border border-border", children: [
+    /* @__PURE__ */ jsx20(
+      "button",
+      {
+        className: "w-full cursor-pointer border-none bg-secondary p-3 px-4 text-left",
+        onClick: () => setExpanded((value) => !value),
+        type: "button",
+        children: /* @__PURE__ */ jsxs18("h3", { className: "m-0 flex items-center justify-between text-sm font-semibold text-foreground", children: [
+          /* @__PURE__ */ jsxs18("span", { children: [
+            "Tasks on this page (",
+            rows.length,
+            ")"
+          ] }),
+          expanded ? /* @__PURE__ */ jsx20(ChevronDown, { size: 16, className: "text-muted-foreground" }) : /* @__PURE__ */ jsx20(ChevronRight, { size: 16, className: "text-muted-foreground" })
+        ] })
+      }
+    ),
+    expanded && /* @__PURE__ */ jsx20("div", { className: "p-3", children: loading ? /* @__PURE__ */ jsx20("p", { className: "m-0 text-sm text-muted-foreground", children: "Loading tasks..." }) : rows.length === 0 ? /* @__PURE__ */ jsx20("p", { className: "m-0 text-sm text-muted-foreground", children: "Checklist items on this page will appear here." }) : /* @__PURE__ */ jsx20("ul", { className: "m-0 list-none space-y-1 p-0", children: rows.map((task) => {
+      const dueDateLabel = formatTaskDueDate(task.dueDate);
+      const overdue = isTaskOverdue(task.dueDate, task.completed);
+      return /* @__PURE__ */ jsx20("li", { children: /* @__PURE__ */ jsxs18(
+        "div",
+        {
+          className: "flex items-start gap-2 rounded-md px-2 py-2 transition-colors hover:bg-accent/40",
+          style: { paddingLeft: `${task.depth * 18 + 8}px` },
+          children: [
+            task.completed ? /* @__PURE__ */ jsx20(CheckSquare2, { size: 15, className: "mt-0.5 flex-shrink-0 text-primary" }) : /* @__PURE__ */ jsx20(Square, { size: 15, className: "mt-0.5 flex-shrink-0 text-muted-foreground" }),
+            /* @__PURE__ */ jsxs18("div", { className: "min-w-0 flex-1", children: [
+              /* @__PURE__ */ jsx20(
+                "div",
+                {
+                  className: `text-sm ${task.completed ? "line-through text-muted-foreground" : "text-foreground"}`,
+                  children: task.title
+                }
+              ),
+              /* @__PURE__ */ jsxs18("div", { className: "mt-1 flex flex-wrap items-center gap-2 text-[11px] text-muted-foreground", children: [
+                dueDateLabel ? /* @__PURE__ */ jsxs18(
+                  "span",
+                  {
+                    className: `inline-flex items-center gap-1 ${overdue ? "text-red-500" : "text-muted-foreground"}`,
+                    children: [
+                      /* @__PURE__ */ jsx20(Calendar, { size: 11 }),
+                      dueDateLabel
+                    ]
+                  }
+                ) : null,
+                task.assigneeCount > 0 ? /* @__PURE__ */ jsxs18("span", { className: "inline-flex items-center gap-1", children: [
+                  /* @__PURE__ */ jsx20(Users, { size: 11 }),
+                  task.assigneeCount
+                ] }) : null
+              ] })
+            ] })
+          ]
+        }
+      ) }, task.id);
+    }) }) })
+  ] });
+}
+
+// src/components/TaskCollectionEmbed.tsx
+import { useMemo as useMemo18 } from "react";
+import { jsx as jsx21, jsxs as jsxs19 } from "react/jsx-runtime";
+function TaskCollectionEmbed({
+  currentPageId,
+  currentDid,
+  scope,
+  assignee,
+  dueDate,
+  status,
+  showHierarchy
+}) {
+  const missingPageContext = scope === "current-page" && !currentPageId;
+  const pageId = scope === "current-page" ? currentPageId ?? "__task_collection_embed_missing_page_context__" : void 0;
+  const assigneeDid = assignee === "me" ? currentDid : void 0;
+  const statuses = status === "done" ? ["done"] : void 0;
+  const includeCompleted = status !== "open";
+  const { data, tree, loading } = useTasks({
+    pageId,
+    assigneeDid,
+    includeCompleted,
+    statuses: statuses ? [...statuses] : void 0,
+    dueDateFilter: dueDate
+  });
+  const rows = useMemo18(() => {
+    if (showHierarchy) return flattenTaskTree(tree);
+    return data.map((task) => ({
+      id: task.id,
+      title: task.title ?? "Untitled task",
+      completed: Boolean(task.completed),
+      dueDate: typeof task.dueDate === "number" ? task.dueDate : void 0,
+      depth: 0
+    }));
+  }, [data, showHierarchy, tree]);
+  if (missingPageContext) {
+    return /* @__PURE__ */ jsx21("div", { className: "p-4 text-sm text-muted-foreground", children: "This view needs a page context." });
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsx21("div", { className: "p-4 text-sm text-muted-foreground", children: "Loading tasks..." });
+  }
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsx21("div", { className: "p-4 text-sm text-muted-foreground", children: "No tasks match the saved filters for this view." });
+  }
+  return /* @__PURE__ */ jsx21("div", { className: "p-3", children: /* @__PURE__ */ jsx21("ul", { className: "m-0 list-none space-y-1 p-0", children: rows.map((task) => {
+    const dueDateLabel = formatTaskDueDate(task.dueDate);
+    const overdue = isTaskOverdue(task.dueDate, task.completed);
+    return /* @__PURE__ */ jsx21("li", { children: /* @__PURE__ */ jsxs19(
+      "div",
+      {
+        className: "flex items-start gap-2 rounded-lg px-2 py-2 hover:bg-accent/40",
+        style: { paddingLeft: `${task.depth * 18 + 8}px` },
+        children: [
+          /* @__PURE__ */ jsx21("span", { className: task.completed ? "text-primary" : "text-muted-foreground", children: task.completed ? "\u2611" : "\u2610" }),
+          /* @__PURE__ */ jsxs19("div", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsx21(
+              "div",
+              {
+                className: task.completed ? "truncate text-sm text-muted-foreground line-through" : "truncate text-sm text-foreground",
+                children: task.title
+              }
+            ),
+            dueDateLabel ? /* @__PURE__ */ jsx21(
+              "div",
+              {
+                className: overdue ? "mt-1 text-[11px] text-red-500" : "mt-1 text-[11px] text-muted-foreground",
+                children: dueDateLabel
+              }
+            ) : null
+          ] })
+        ]
+      }
+    ) }, task.id);
+  }) }) });
+}
+
+// src/hooks/useSecurity.ts
+import {
+  hybridSign,
+  hybridVerify
+} from "@xnetjs/crypto";
+import { parseDID } from "@xnetjs/identity";
+import { useCallback as useCallback19, useMemo as useMemo19 } from "react";
+function useSecurity(options = {}) {
+  const context = useSecurityContext();
+  const effectiveLevel = options.level ?? context.level;
+  const hasPQKeys = useMemo19(
+    () => context.keyBundle?.pqSigningKey !== void 0,
+    [context.keyBundle]
+  );
+  const hasKeyBundle = useMemo19(() => context.keyBundle !== void 0, [context.keyBundle]);
+  const maxLevel = useMemo19(() => hasPQKeys ? 2 : 0, [hasPQKeys]);
+  const canSignAt = useCallback19(
+    (level) => {
+      if (!context.keyBundle) return false;
+      if (level === 0) return true;
+      return hasPQKeys;
+    },
+    [context.keyBundle, hasPQKeys]
+  );
+  const sign = useCallback19(
+    (data) => {
+      if (!context.keyBundle) {
+        throw new Error(
+          "No key bundle available. Ensure keyBundle is provided to SecurityProvider."
+        );
+      }
+      if (!canSignAt(effectiveLevel)) {
+        throw new Error(
+          `Cannot sign at Level ${effectiveLevel}: PQ keys required. Current key bundle only supports Level 0.`
+        );
+      }
+      return hybridSign(
+        data,
+        {
+          ed25519: context.keyBundle.signingKey,
+          mlDsa: context.keyBundle.pqSigningKey
+        },
+        effectiveLevel
+      );
+    },
+    [context.keyBundle, effectiveLevel, canSignAt]
+  );
+  const verify = useCallback19(
+    async (data, signature, did) => {
+      const ed25519PublicKey = parseDID(did);
+      const pqPublicKey = await context.registry.lookup(did);
+      return hybridVerify(
+        data,
+        signature,
+        {
+          ed25519: ed25519PublicKey,
+          mlDsa: pqPublicKey ?? void 0
+        },
+        {
+          minLevel: context.minVerificationLevel,
+          policy: context.verificationPolicy
+        }
+      );
+    },
+    [context.registry, context.minVerificationLevel, context.verificationPolicy]
+  );
+  return {
+    level: effectiveLevel,
+    hasPQKeys,
+    maxLevel,
+    sign,
+    verify,
+    setLevel: context.setLevel,
+    canSignAt,
+    hasKeyBundle
+  };
+}
+
+export {
+  useTaskProjectionSync,
+  usePageTaskSync,
+  useFind,
+  useTasks,
+  useComments,
+  summarizeModerationLabel,
+  summarizePublicInteractionPolicy,
+  selectActiveInteractionPolicy,
+  selectPublicInteractionMode,
+  createModerationLabelIndex,
+  evaluateInteractionPermission,
+  evaluateCommentModeration,
+  moderateThread,
+  useModeratedThread,
+  useVisibleComments,
+  summarizeReactionNode,
+  isReactionVisible,
+  dedupeReactions,
+  createReactionCounterSnapshot,
+  usePolicyFilteredReactionCounters,
+  createConversationKey,
+  summarizeMessageRequest,
+  findLatestMessageRequest,
+  hasAcceptedContact,
+  evaluateFirstContactDecision,
+  createMessageRequestProperties,
+  useMessageRequests,
+  useCommentCount,
+  useCommentCounts,
+  useHistory,
+  useUndo,
+  useAudit,
+  useDiff,
+  useBlame,
+  useVerification,
+  useHubStatus,
+  useCan,
+  useCanEdit,
+  describeGrantConsent,
+  useGrants,
+  summarizeAuthTrace,
+  useAuthTrace,
+  useBackup,
+  useFileUpload,
+  useHubSearch,
+  useRemoteSchema,
+  usePeerDiscovery,
+  HubStatusIndicator,
+  Skeleton,
+  injectSkeletonStyles,
+  DemoBanner,
+  DemoQuotaIndicator,
+  DemoDataExpiredScreen,
+  useDemoMode,
+  onboardingReducer,
+  createInitialState,
+  OnboardingProvider,
+  useOnboarding,
+  getPlatformAuthName,
+  truncateDid,
+  copyToClipboard,
+  AuthenticatingScreen,
+  AuthErrorScreen,
+  HubConnectScreen,
+  ImportIdentityScreen,
+  ReadyScreen,
+  UnsupportedBrowserScreen,
+  WelcomeScreen,
+  OnboardingFlow,
+  SmartWelcome,
+  SyncProgressOverlay,
+  QUICK_START_TEMPLATES,
+  flattenTaskTree,
+  formatTaskDueDate,
+  isTaskOverdue,
+  PageTasksPanel,
+  TaskCollectionEmbed,
+  useSecurity
+};