@shivaedev/work-board 0.11.0 → 0.12.0

package/dist/client/page/navigationScript.js

@@ -0,0 +1,113 @@
+import { navigationHistoryScript } from "./navigationHistoryScript.js";
+import { reactNavigationScript } from "./reactNavigationScript.js";
+import { routeQueryOptions } from "./routeQuery.js";
+export function navigationScript() {
+    return `
+import { applyPage, capturePage } from "/_board/page-state.js";
+import { reportMissingPassage, restoreReading, scrollToPassage } from "/_board/reading-state.js";
+import { refreshLibrary } from "/_board/library.js";
+import { revealCurrentFile } from "/_board/sidebar.js";
+import { session } from "/_board/native.js";
+
+let router;
+export const connectRouter = (control) => {
+  router = control;
+  router.before(() => saveCurrent(false));
+  let resolved = location.href;
+  router.subscribe(() => {
+    if (location.href === resolved) return;
+    const previous = new URL(resolved);
+    const target = new URL(location.href);
+    resolved = location.href;
+    const entry = history.state?.workBoard;
+    const id = entry?.id && entry.id !== displayedId ? entry.id : newId();
+    const hashOnly = target.pathname === previous.pathname && target.search === previous.search;
+    navigate(target, { ...entry, id, reading: id === entry?.id ? entry.reading : null }, hashOnly);
+  });
+};
+const open = async (target) => {
+  if (!router) return navigate(target);
+  const sameRoute = target.href === location.href;
+  saveCurrent();
+  await router.navigate(target.pathname + target.search + target.hash);
+  if (!sameRoute || target.href !== location.href) return;
+  const native = session(window);
+  const page = document.getElementById("doc").hasAttribute("data-react-document") ? native.api.document.query({ url: target.pathname + target.search }, ${JSON.stringify(routeQueryOptions)}) : native.api.page.query({ url: target.pathname + target.search }, ${JSON.stringify(routeQueryOptions)});
+  if (native.registry.get(page)._tag === "Failure") {
+    delete document.getElementById("doc").dataset.route;
+    native.registry.refresh(page);
+    await navigate(target, history.state?.workBoard ?? { id: newId() });
+  }
+};
+${navigationHistoryScript()}
+
+${reactNavigationScript()}
+
+const navigate = async (target, entry, hashOnly = false) => {
+  const route = target.pathname + target.search;
+  const sameDocument = route === displayedRoute;
+  if (!router) saveCurrent(!entry);
+  const id = entry?.id ?? newId();
+  if (!entry) history.pushState(stateWith(id), "", target);
+  else if (history.state?.workBoard?.id !== id) history.replaceState(stateWith(id, entry.reading), "");
+  const mine = ++version;
+  controller?.abort();
+  controller = new AbortController();
+  const status = document.getElementById("navigation-status");
+  status.textContent = "";
+  if (sameDocument && (!entry || hashOnly)) {
+    displayedId = id;
+    const reading = savedReading[id] ?? entry?.reading;
+    if (reading) restoreReading(reading);
+    else scrollToPassage(target.hash);
+    return;
+  }
+  const cached = cache.get(id);
+  if (cached && !router) {
+    applyPage(cached.page);
+    displayedId = id;
+    displayedRoute = route;
+    restoreReading(cached.reading);
+  } else status.textContent = "Opening document…";
+  try {
+    if (router) { await navigateReact(route, mine, id, entry, cached, target, status); return; }
+    const native = session(window);
+    const response = await native.read(native.api.page.query({ url: target.pathname + target.search }, ${JSON.stringify(routeQueryOptions)}), controller.signal);
+    const page = new DOMParser().parseFromString(response.html, "text/html");
+    if (mine !== version) return;
+    if (!applyPage(page, Boolean(cached))) throw new Error("Invalid page");
+    displayedId = id;
+    displayedRoute = route;
+    status.textContent = response.status < 400 ? "" : response.status === 404 ? "This document is missing or was renamed." : "This document could not be opened.";
+    if (response.status < 400) reportMissingPassage();
+    if (!cached) {
+      document.getElementById("doc").focus({ preventScroll: true });
+      if (savedReading[id] ?? entry?.reading) restoreReading(savedReading[id] ?? entry.reading);
+      else scrollToPassage(target.hash);
+    }
+  } catch (error) {
+    if (mine !== version || controller.signal.aborted) return;
+    status.textContent = "Could not open this document. Retry the link or reload the page.";
+  }
+};
+document.addEventListener("click", (event) => {
+  const link = event.target.closest?.("a[href]");
+  if (!link || event.defaultPrevented || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey || link.hasAttribute("download") || (link.target && link.target !== "_self")) return;
+  const target = new URL(link.href, location.href);
+  if (target.origin !== location.origin || !(target.pathname === "/" || target.pathname === "/_board/diagnostics" || target.pathname === "/_board/handoff" || target.pathname === "/_board/result" || target.pathname === "/_board/respond" || target.pathname === "/_board/start" || target.pathname === "/_board/changes" || target.pathname === "/_board/inbox" || target.pathname === "/_board/overview" || target.pathname === "/_board/work" || target.pathname.startsWith("/_board/item/") || /\\.md$/i.test(target.pathname))) return;
+  event.preventDefault();
+  document.dispatchEvent(new Event("board-navigate"));
+  open(target);
+});
+document.addEventListener("submit", (event) => {
+  const form = event.target;
+  if (!form.matches?.("#work-filters")) return;
+  event.preventDefault();
+  const target = new URL(form.action, location.href);
+  target.search = new URLSearchParams([...new FormData(form)].map(([key, value]) => [key, String(value)])).toString();
+  open(target);
+});
+window.addEventListener("popstate", (event) => { if (!router) navigate(new URL(location.href), event.state?.workBoard ?? { id: newId() }); });
+`;
+}
+//# sourceMappingURL=navigationScript.js.map

package/dist/client/page/navigationScript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationScript.js","sourceRoot":"","sources":["../../../src/client/page/navigationScript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,UAAU,gBAAgB;IAC/B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0JA8BkJ,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,uEAAuE,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;;;;;;;EAOjS,uBAAuB,EAAE;;EAEzB,qBAAqB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yGA+BgF,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCzI,CAAC;AACF,CAAC"}

package/dist/client/page/preferencesScript.d.ts

@@ -0,0 +1,2 @@
+export declare function preferencesScript(): string;
+//# sourceMappingURL=preferencesScript.d.ts.map

package/dist/client/page/preferencesScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferencesScript.d.ts","sourceRoot":"","sources":["../../../src/client/page/preferencesScript.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,IAAI,MAAM,CA4C1C"}

package/dist/client/page/preferencesScript.js

@@ -0,0 +1,46 @@
+export function preferencesScript() {
+    return `
+import { setupSidebar } from "/_board/sidebar.js";
+const root = document.documentElement;
+const key = "work-board:appearance:" + root.dataset.workspace;
+const theme = document.getElementById("theme");
+const density = document.getElementById("density");
+const status = document.getElementById("preference-status");
+const system = matchMedia("(prefers-color-scheme: dark)");
+let saved = {};
+try {
+  const value = JSON.parse(localStorage.getItem(key) ?? "{}");
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) saved = value;
+} catch {
+  status.textContent = "Preferences apply to this page only.";
+}
+
+theme.value = ["light", "dark"].includes(saved.theme) ? saved.theme : "system";
+density.value = saved.density === "compact" ? "compact" : "comfortable";
+const sidebar = setupSidebar(typeof saved.closed === "boolean" && saved.closed);
+
+const appearance = () => {
+  root.dataset.theme = theme.value;
+  root.dataset.scheme = theme.value === "system" ? (system.matches ? "dark" : "light") : theme.value;
+  root.dataset.density = density.value;
+  document.dispatchEvent(new Event("board-theme"));
+};
+
+const save = () => {
+  appearance();
+  try {
+    localStorage.setItem(key, JSON.stringify({ theme: theme.value, density: density.value, closed: sidebar.closed() }));
+    status.textContent = "";
+  } catch {
+    status.textContent = "Preferences apply to this page only.";
+  }
+};
+
+theme.addEventListener("change", save);
+density.addEventListener("change", save);
+document.addEventListener("board-sidebar", save);
+system.addEventListener("change", appearance);
+appearance();
+`;
+}
+//# sourceMappingURL=preferencesScript.js.map

package/dist/client/page/preferencesScript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferencesScript.js","sourceRoot":"","sources":["../../../src/client/page/preferencesScript.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,iBAAiB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CP,CAAC;AACF,CAAC"}

package/dist/client/page/reactNavigationScript.d.ts

@@ -0,0 +1,2 @@
+export declare function reactNavigationScript(): string;
+//# sourceMappingURL=reactNavigationScript.d.ts.map

package/dist/client/page/reactNavigationScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactNavigationScript.d.ts","sourceRoot":"","sources":["../../../src/client/page/reactNavigationScript.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,IAAI,MAAM,CA6B9C"}

package/dist/client/page/reactNavigationScript.js

@@ -0,0 +1,31 @@
+export function reactNavigationScript() {
+    return `
+const navigateReact = async (route, mine, id, entry, cached, target, status) => {
+      await new Promise((resolve, reject) => {
+        const signal = controller.signal;
+        const check = () => { if (document.getElementById("doc")?.dataset.route === route) { cleanup(); resolve(); } };
+        const cancel = () => { cleanup(); reject(new Error("Navigation cancelled")); };
+        const cleanup = () => { document.removeEventListener("board-page", check); signal.removeEventListener("abort", cancel); };
+        document.addEventListener("board-page", check);
+        signal.addEventListener("abort", cancel, { once: true });
+        check();
+      });
+      if (mine !== version) return;
+      if (cached && document.querySelector("[data-legacy-main]") && document.getElementById("doc")?.dataset.view === "changes") applyPage(cached.page);
+      const doc = document.getElementById("doc");
+      displayedId = id;
+      displayedRoute = route;
+      const code = Number(doc.dataset.status ?? 200);
+      status.textContent = code < 400 ? "" : code === 404 ? "This document is missing or was renamed." : "Could not open this document. Retry the link or reload the page.";
+      if (code < 400) reportMissingPassage();
+      revealCurrentFile(true);
+      refreshLibrary(true);
+      doc.focus({ preventScroll: true });
+      const reading = savedReading[id] ?? entry?.reading ?? cached?.reading;
+      if (reading) restoreReading(reading);
+      else scrollToPassage(target.hash);
+      return;
+};
+`;
+}
+//# sourceMappingURL=reactNavigationScript.js.map

package/dist/client/page/reactNavigationScript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactNavigationScript.js","sourceRoot":"","sources":["../../../src/client/page/reactNavigationScript.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,qBAAqB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BP,CAAC;AACF,CAAC"}

package/dist/client/page/readingStateScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readingStateScript.d.ts","sourceRoot":"","sources":["../../../src/client/page/readingStateScript.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,IAAI,MAAM,CA+D3C"}

package/dist/client/page/readingStateScript.js

@@ -0,0 +1,65 @@
+export function readingStateScript() {
+    return `
+const pathOf = (node, root) => {
+  const path = [];
+  for (; node !== root; node = node.parentNode) {
+    if (!node?.parentNode) return null;
+    path.unshift([...node.parentNode.childNodes].indexOf(node));
+  }
+  return path;
+};
+const nodeAt = (path, root) => path.reduce((node, index) => node?.childNodes[index], root);
+
+export const captureReading = () => {
+  const root = document.getElementById("doc");
+  const selection = document.getSelection();
+  const anchor = selection?.anchorNode && pathOf(selection.anchorNode, root);
+  const focus = selection?.focusNode && pathOf(selection.focusNode, root);
+  return {
+    scroll: [scrollX, scrollY],
+    sidebar: document.getElementById("sidebar").scrollTop,
+    context: root.querySelector(".item-context")?.open,
+    details: [...root.querySelectorAll("details:not(.item-context)")].map((detail) => detail.open),
+    selection: anchor && focus ? { anchor, focus, a: selection.anchorOffset, f: selection.focusOffset } : null,
+  };
+};
+
+export const restoreReading = (state, restoreDetails = true) => {
+  if (!state || !Array.isArray(state.scroll) || state.scroll.length !== 2 || !state.scroll.every(Number.isFinite)) return;
+  const root = document.getElementById("doc");
+  const context = root.querySelector(".item-context");
+  if (restoreDetails && context && typeof state.context === "boolean") context.open = state.context;
+  [...root.querySelectorAll("details:not(.item-context)")].forEach((detail, index) => {
+    if (restoreDetails && typeof state.details?.[index] === "boolean") detail.open = state.details[index];
+  });
+  document.getElementById("sidebar").scrollTop = state.sidebar ?? 0;
+  const saved = state.selection;
+  if (saved && Array.isArray(saved.anchor) && Array.isArray(saved.focus) && Number.isInteger(saved.a) && Number.isInteger(saved.f) && saved.a >= 0 && saved.f >= 0) {
+    const anchor = nodeAt(saved.anchor, root);
+    const focus = nodeAt(saved.focus, root);
+    const limit = (node) => node.nodeType === 3 ? node.textContent.length : node.childNodes.length;
+    if (anchor && focus) document.getSelection()?.setBaseAndExtent(anchor, Math.min(saved.a, limit(anchor)), focus, Math.min(saved.f, limit(focus)));
+  }
+  scrollTo(...state.scroll);
+};
+
+const passageAt = (hash) => {
+  try { return document.getElementById(decodeURIComponent(hash.slice(1))); } catch { return null; }
+};
+export const reportMissingPassage = () => {
+  if (!location.hash || !document.getElementById("favorite-toggle")) return;
+  const status = document.getElementById("navigation-status");
+  if (!passageAt(location.hash)) status.textContent = "This passage is no longer in the document.";
+  else if (status.textContent === "This passage is no longer in the document.") status.textContent = "";
+};
+export const scrollToPassage = (hash) => {
+  if (!hash) { scrollTo(0, 0); return; }
+  const target = passageAt(hash);
+  if (!target) { reportMissingPassage(); return; }
+  for (let parent = target.parentElement; parent; parent = parent.parentElement) if (parent.tagName === "DETAILS") parent.open = true;
+  target.scrollIntoView();
+  target.focus({ preventScroll: true });
+};
+`;
+}
+//# sourceMappingURL=readingStateScript.js.map

package/dist/client/page/readingStateScript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readingStateScript.js","sourceRoot":"","sources":["../../../src/client/page/readingStateScript.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,kBAAkB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DP,CAAC;AACF,CAAC"}

package/dist/client/page/resolvedDocumentFailure.d.ts

@@ -0,0 +1,3 @@
+import { Cause } from "effect";
+export declare function resolvedDocumentFailure(cause: Cause.Cause<unknown>): boolean;
+//# sourceMappingURL=resolvedDocumentFailure.d.ts.map

package/dist/client/page/resolvedDocumentFailure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvedDocumentFailure.d.ts","sourceRoot":"","sources":["../../../src/client/page/resolvedDocumentFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAqB,MAAM,QAAQ,CAAC;AAElD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAG5E"}

package/dist/client/page/resolvedDocumentFailure.js

@@ -0,0 +1,6 @@
+import { Cause, Option, Predicate } from "effect";
+export function resolvedDocumentFailure(cause) {
+    const error = Option.getOrUndefined(Cause.findErrorOption(cause));
+    return Predicate.isTagged(error, "NotFound") || Predicate.isTagged(error, "Conflict");
+}
+//# sourceMappingURL=resolvedDocumentFailure.js.map

package/dist/client/page/resolvedDocumentFailure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvedDocumentFailure.js","sourceRoot":"","sources":["../../../src/client/page/resolvedDocumentFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAElD,MAAM,UAAU,uBAAuB,CAAC,KAA2B;IAClE,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAClE,OAAO,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AACvF,CAAC"}

package/dist/client/page/routeQuery.d.ts

@@ -0,0 +1,190 @@
+import type { BrowserClient } from "#client/client.ts";
+interface PageApi {
+    readonly document: Pick<BrowserClient["api"]["document"], "query">;
+    readonly page: Pick<BrowserClient["api"]["page"], "query">;
+}
+export declare const routeQueryOptions: {
+    timeToLive: number;
+};
+export declare function documentQuery(api: PageApi, url: string): import("effect/unstable/reactivity/Atom").Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly diagnostics: readonly {
+        readonly field?: string | undefined;
+        readonly line: number;
+        readonly message: string;
+    }[];
+    readonly file: string;
+    readonly identity?: string | undefined;
+    readonly links: {
+        readonly [x: string]: string;
+    };
+    readonly metadata: {
+        readonly areas?: readonly string[] | undefined;
+        readonly attention?: readonly {
+            readonly id: string;
+            readonly kind: "blocker" | "decision" | "review";
+            readonly managed?: boolean | undefined;
+            readonly reason: string;
+            readonly responseFrom: readonly string[];
+            readonly state: "closed" | "open";
+            readonly unblocks: readonly string[];
+        }[] | undefined;
+        readonly criteria?: readonly {
+            readonly id: string;
+            readonly text: string;
+        }[] | undefined;
+        readonly evidence?: readonly {
+            readonly checkedRevision?: string | undefined;
+            readonly criterion?: string | undefined;
+            readonly method?: string | undefined;
+            readonly observedAt?: string | undefined;
+            readonly outcome?: string | undefined;
+            readonly source: string;
+        }[] | undefined;
+        readonly handoff?: {
+            readonly by?: string | undefined;
+            readonly constraints: string;
+            readonly goal: string;
+            readonly item: string;
+            readonly nextAction: string;
+            readonly note?: string | undefined;
+            readonly preparedAt: number;
+            readonly recipient: string;
+            readonly reviewedRevision: string;
+            readonly source: string;
+            readonly state: "acknowledged" | "rejected" | "requested" | "unavailable";
+        } | undefined;
+        readonly id?: string | undefined;
+        readonly items?: readonly string[] | undefined;
+        readonly kind?: "board" | "decision" | "handoff" | "investigation" | "project" | "question" | "response" | "result" | "task" | undefined;
+        readonly nextAction?: string | undefined;
+        readonly options?: readonly {
+            readonly description: string;
+            readonly label: string;
+        }[] | undefined;
+        readonly owner?: string | undefined;
+        readonly question?: {
+            readonly deadline: number;
+            readonly item: string;
+            readonly reason: string;
+            readonly registeredAt: number;
+            readonly request: string;
+            readonly reviewedRevision: string;
+            readonly source: string;
+        } | undefined;
+        readonly recommended?: string | undefined;
+        readonly relationships?: readonly {
+            readonly kind: "depends_on" | "implements" | "informs" | "relates_to";
+            readonly target: string;
+        }[] | undefined;
+        readonly requestReceipt?: {
+            readonly disposition: "applied" | "superseded";
+            readonly question: string;
+            readonly recordedAt: number;
+            readonly response?: string | undefined;
+            readonly reviewedRevision: string;
+        } | undefined;
+        readonly response?: {
+            readonly answers?: readonly {
+                readonly prompt: string;
+                readonly selected: readonly string[];
+                readonly text: string;
+            }[] | undefined;
+            readonly author: string;
+            readonly question: string;
+            readonly recordedAt: number;
+            readonly reviewedRevision: string;
+            readonly supersedes?: string | undefined;
+            readonly type: "answer" | "clarify" | "not_now";
+        } | undefined;
+        readonly status?: string | undefined;
+    };
+    readonly modified: number;
+    readonly questionActions: {
+        readonly [x: string]: string;
+    };
+    readonly reading?: {
+        readonly backlinks: readonly {
+            readonly href: string;
+            readonly kind: string;
+            readonly label: string;
+        }[];
+        readonly board: boolean;
+        readonly claims: {
+            readonly [x: string]: readonly {
+                readonly href?: string | undefined;
+                readonly label: string;
+            }[];
+        };
+        readonly evidenceSources: readonly {
+            readonly href?: string | undefined;
+            readonly problem: string;
+        }[];
+        readonly lines: {
+            readonly [x: string]: number;
+        };
+        readonly proseLine: number;
+        readonly raw?: string | undefined;
+        readonly receipts: {
+            readonly [x: string]: {
+                readonly disposition: "applied" | "superseded";
+                readonly question: string;
+                readonly recordedAt: number;
+                readonly response?: string | undefined;
+                readonly reviewedRevision: string;
+            };
+        };
+    } | undefined;
+    readonly references: {
+        readonly [x: string]: string;
+    };
+    readonly requests: readonly {
+        readonly id: string;
+        readonly open: boolean;
+        readonly preview?: {
+            readonly context: string;
+            readonly id: string;
+            readonly item: string;
+            readonly reason: string;
+            readonly request: string;
+            readonly reviewedRevision: string;
+            readonly source: string;
+        } | undefined;
+        readonly prompts?: readonly {
+            readonly id: string;
+            readonly mode: "many" | "one" | "text";
+            readonly options: readonly {
+                readonly id: string;
+                readonly source: string;
+            }[];
+            readonly source: string;
+        }[] | undefined;
+        readonly promptUnavailable?: string | undefined;
+        readonly responses?: readonly {
+            readonly body: string;
+            readonly id: string;
+            readonly response: {
+                readonly answers?: readonly {
+                    readonly prompt: string;
+                    readonly selected: readonly string[];
+                    readonly text: string;
+                }[] | undefined;
+                readonly author: string;
+                readonly question: string;
+                readonly recordedAt: number;
+                readonly reviewedRevision: string;
+                readonly supersedes?: string | undefined;
+                readonly type: "answer" | "clarify" | "not_now";
+            };
+        }[] | undefined;
+        readonly unavailable?: string | undefined;
+    }[];
+    readonly source: string;
+    readonly unavailable: readonly string[];
+    readonly writable: boolean;
+}, import("@shivaedev/platform/errors/taxonomy.ts").Conflict | import("@shivaedev/platform/errors/taxonomy.ts").InternalServerError | import("@shivaedev/platform/errors/taxonomy.ts").NotFound | import("effect/unstable/rpc/RpcClientError").RpcClientError | import("@shivaedev/platform/errors/taxonomy.ts").ServiceUnavailable>>;
+export declare function pageQuery(api: PageApi, url: string): import("effect/unstable/reactivity/Atom").Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly html: string;
+    readonly status: number;
+}, import("@shivaedev/platform/errors/taxonomy.ts").InternalServerError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+export {};
+//# sourceMappingURL=routeQuery.d.ts.map

package/dist/client/page/routeQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeQuery.d.ts","sourceRoot":"","sources":["../../../src/client/page/routeQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,UAAU,OAAO;IAChB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;IACnE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;CAC3D;AAED,eAAO,MAAM,iBAAiB;IAAK,UAAU;CAAU,CAAC;AAExD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sUAEtD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM;;;wIAElD"}

package/dist/client/page/routeQuery.js

@@ -0,0 +1,8 @@
+export const routeQueryOptions = { timeToLive: 60_000 };
+export function documentQuery(api, url) {
+    return api.document.query({ url }, routeQueryOptions);
+}
+export function pageQuery(api, url) {
+    return api.page.query({ url }, routeQueryOptions);
+}
+//# sourceMappingURL=routeQuery.js.map

package/dist/client/page/routeQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeQuery.js","sourceRoot":"","sources":["../../../src/client/page/routeQuery.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;AAExD,MAAM,UAAU,aAAa,CAAC,GAAY,EAAE,GAAW;IACtD,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,iBAAiB,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,GAAY,EAAE,GAAW;IAClD,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,iBAAiB,CAAC,CAAC;AACnD,CAAC"}

package/dist/client/page/runtime.d.ts

@@ -0,0 +1,3 @@
+export declare const client: string;
+export declare const preferences: string;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/client/page/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/client/page/runtime.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM,QAyGlB,CAAC;AACF,eAAO,MAAM,WAAW,QAAsB,CAAC"}

package/dist/client/page/runtime.js

@@ -0,0 +1,111 @@
+import { itemContextScript } from "./itemContextScript.js";
+import { preferencesScript } from "./preferencesScript.js";
+import { routeQueryOptions } from "./routeQuery.js";
+export const client = `
+import "/_board/diagnostics.js";
+import "/_board/saved-views.js";
+import "/_board/history.js";
+import "/_board/preferences.js";
+import "/_board/search.js";
+import { tick } from "/_board/ages.js";
+import { renderDiagrams } from "/_board/diagrams.js";
+import { applyNavigation, applyPage } from "/_board/page-state.js";
+import "/_board/navigation.js";
+import { remember, swap } from "/_board/swap.js";
+import { refreshLibrary } from "/_board/library.js";
+import { revealCurrentFile } from "/_board/sidebar.js";
+import { resolvedDocumentFailure, session } from "/_board/native.js";
+
+document.documentElement.dataset.js = "true";
+${itemContextScript()}
+remember(document.getElementById("doc"));
+let native = session(window);
+const live = document.getElementById("live");
+const toggle = document.getElementById("updates-toggle");
+let pageFailure = "";
+let navFailure = "";
+let pageWaiting = true;
+let watching = false;
+let navWaiting = true;
+let active = "";
+let releasePage;
+let selected;
+let releaseNavigation;
+const show = () => {
+  const state = native.registry.get(native.updates.status);
+  const paused = native.registry.get(native.updates.paused);
+  const failure = pageFailure || navFailure;
+  live.dataset.state = paused ? "paused" : failure ? "stale" : !watching || state.connection !== "live" ? "down" : pageWaiting || navWaiting ? "refreshing" : "live";
+  live.textContent = paused ? "updates paused · " + state.pending + (state.pending === 256 ? "+" : "") + " pending updates" : failure || (!watching || state.connection !== "live" ? "reconnecting" : pageWaiting || navWaiting ? "refreshing" : "live");
+  toggle.textContent = paused ? "Resume updates" : "Pause updates";
+  toggle.setAttribute("aria-pressed", String(paused));
+  live.title = "Connection: " + state.connection + "; last observed source watcher: " + (watching ? "watching" : "unavailable") + "; " + (paused ? "automatic reads paused" : pageWaiting || navWaiting ? "reads pending" : failure ? "showing retained source" : "reads settled");
+};
+const watchNavigation = () => {
+  const doc = document.getElementById("doc");
+  const current = doc.dataset.view ? "" : doc.dataset.file;
+  if (current === selected) return;
+  selected = current;
+  releaseNavigation?.();
+  releaseNavigation = native.registry.subscribe(native.api.navigation.query({ current }), (value) => {
+    navWaiting = value.waiting || value._tag === "Initial";
+    if (value._tag === "Failure") navFailure = "navigation refresh failed";
+    if (value._tag === "Success" && !value.waiting) {
+      navFailure = "";
+      if (!document.querySelector("[data-board-react-root]")) applyNavigation(value.value);
+    }
+    show();
+  }, { immediate: true });
+};
+const watchPage = () => {
+  watchNavigation();
+  const doc = document.getElementById("doc");
+  const path = location.pathname + location.search;
+  const selection = path + (doc.hasAttribute("data-react-document") ? ":document" : ":page");
+  if (selection === active) return;
+  active = selection;
+  releasePage?.();
+  pageFailure = "";
+  const atom = doc.hasAttribute("data-react-document") ? native.api.document.query({ url: path }, ${JSON.stringify(routeQueryOptions)}) : native.api.page.query({ url: path }, ${JSON.stringify(routeQueryOptions)});
+  releasePage = native.registry.subscribe(atom, (value) => {
+    pageWaiting = value.waiting || value._tag === "Initial";
+    if (value._tag === "Failure") pageFailure = resolvedDocumentFailure(value.cause) ? "" : "refresh failed";
+    if (value._tag === "Success" && !value.waiting && active === selection && path === location.pathname + location.search) {
+      if (document.querySelector("[data-board-react-root]")) { pageFailure = ""; show(); return; }
+      const next = new DOMParser().parseFromString(value.value.html, "text/html");
+      pageFailure = applyPage(next, true) ? "" : "refresh failed";
+      tick();
+    }
+    show();
+  }, { immediate: true });
+};
+const observe = () => {
+native.registry.subscribe(native.api.watcher.query(), (value) => {
+  watching = value._tag === "Success" && value.value.watching;
+  show();
+}, { immediate: true });
+native.registry.subscribe(native.updates.status, show);
+native.registry.subscribe(native.updates.paused, (paused) => { show(); if (!paused) document.dispatchEvent(new Event("board-updates-resumed")); });
+};
+document.addEventListener("board-page", () => { tick(); renderDiagrams(document); refreshLibrary(); });
+document.addEventListener("board-index-change", () => { tick(); refreshLibrary(); revealCurrentFile(); });
+observe();
+toggle.disabled = false;
+toggle.addEventListener("click", () => native.registry.set(native.updates.paused, !native.registry.get(native.updates.paused)));
+document.addEventListener("board-page", watchPage);
+watchPage();
+window.addEventListener("pagehide", () => { releasePage?.(); releaseNavigation?.(); selected = undefined; active = ""; });
+window.addEventListener("pageshow", (event) => {
+  if (!event.persisted) return;
+  native = session(window);
+  pageWaiting = navWaiting = true;
+  watching = false;
+  pageFailure = navFailure = "";
+  observe();
+  watchPage();
+});
+
+renderDiagrams(document);
+`;
+export const preferences = preferencesScript();
+//# sourceMappingURL=runtime.js.map

package/dist/client/page/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/client/page/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;EAgBpB,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAiD+E,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,4CAA4C,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCjN,CAAC;AACF,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,EAAE,CAAC"}