@octane-xplat/ui 0.7.3 → 0.10.0

package/dist/web/markdown-stream.js

@@ -0,0 +1,264 @@
+import { WORD_CHAR, mdInlineLen, parseMdNodesMarked } from "./markdown-parse.js";
+//#region src/markdown-stream.ts
+function createMarkdownIncrementalState() {
+	return {
+		input: "",
+		settledSource: "",
+		settled: [],
+		marks: [],
+		output: []
+	};
+}
+var FENCE_OPEN = /^(`{3,}|~{3,})/;
+/**
+* Line index of the last blank line that is not inside a fenced code block —
+* the offset where the immutable prefix ends. A trailing blank line does not
+* count: it may be mid-append. An open fence collapses the boundary to the
+* blank line before it opened, since fenced content can't change what came
+* before.
+*/
+function findSettledBoundary(lines) {
+	let inFence = false;
+	let fenceMarker = "";
+	let lastBoundary = -1;
+	let boundaryBeforeFence = -1;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const fenceMatch = line.match(FENCE_OPEN);
+		if (inFence) {
+			if (fenceMatch && fenceMatch[1][0] === fenceMarker[0] && fenceMatch[1].length >= fenceMarker.length) {
+				inFence = false;
+				fenceMarker = "";
+			}
+			continue;
+		}
+		if (fenceMatch) {
+			inFence = true;
+			fenceMarker = fenceMatch[1];
+			boundaryBeforeFence = lastBoundary;
+			continue;
+		}
+		if (line.trim() === "" && i > 0 && i < lines.length - 1) lastBoundary = i;
+	}
+	return {
+		boundary: inFence ? boundaryBeforeFence : lastBoundary,
+		openFence: inFence
+	};
+}
+/**
+* Strip trailing incomplete inline syntax from the last line so half-typed
+* constructs don't render as literal markup: an unclosed `[`/`![` (link or
+* image), a trailing unclosed backtick run, and unpaired `*`/`_` emphasis
+* markers. Mid-line unclosed emphasis is auto-closed instead of trimmed, so
+* `**partial` renders bold immediately rather than flashing raw asterisks.
+*/
+function trimStreamingArtifacts(input) {
+	const lastNL = input.lastIndexOf("\n");
+	const prefix = lastNL === -1 ? "" : input.slice(0, lastNL + 1);
+	let tail = lastNL === -1 ? input : input.slice(lastNL + 1);
+	const lastBracket = tail.lastIndexOf("[");
+	if (lastBracket !== -1) {
+		const after = tail.slice(lastBracket);
+		if (!(after.includes("](") && after.includes(")"))) {
+			const trimTo = lastBracket > 0 && tail[lastBracket - 1] === "!" ? lastBracket - 1 : lastBracket;
+			tail = tail.slice(0, trimTo);
+		}
+	}
+	let end = tail.length;
+	while (end > 0 && tail[end - 1] === "`") end--;
+	if (end === 0 && tail.length > 0) tail = "";
+	else if (end < tail.length) {
+		const ticks = tail.length - end;
+		if (tail.lastIndexOf("`".repeat(ticks), end - 1) === -1) tail = tail.slice(0, end);
+	}
+	{
+		const markers = [];
+		let scan = 0;
+		while (scan < tail.length) {
+			const idx1 = tail.indexOf("*", scan);
+			const idx2 = tail.indexOf("_", scan);
+			const idx = idx1 === -1 ? idx2 : idx2 === -1 ? idx1 : Math.min(idx1, idx2);
+			if (idx === -1) break;
+			const ch = tail[idx];
+			let len = 0;
+			while (tail[idx + len] === ch) len++;
+			scan = idx + len;
+			if (len > 3) continue;
+			if (ch === "_" && idx > 0 && WORD_CHAR.test(tail[idx - 1])) continue;
+			markers.push({
+				pos: idx,
+				len
+			});
+		}
+		const paired = /* @__PURE__ */ new Set();
+		for (let a = 0; a < markers.length; a++) {
+			if (paired.has(a)) continue;
+			for (let b = a + 1; b < markers.length; b++) if (!paired.has(b) && markers[b].len === markers[a].len && tail[markers[b].pos] === tail[markers[a].pos]) {
+				paired.add(a);
+				paired.add(b);
+				break;
+			}
+		}
+		for (let k = markers.length - 1; k >= 0; k--) {
+			if (paired.has(k)) continue;
+			const m = markers[k];
+			if (m.pos + m.len < tail.length) tail += tail[m.pos].repeat(m.len);
+			else tail = tail.slice(0, m.pos);
+		}
+	}
+	return prefix + tail;
+}
+/**
+* Withhold trailing lines in the unsettled zone that look like the start of
+* a block but are incomplete: bare list markers (`- `, `1. `) with no item
+* text and trailing empty lines. Skipped entirely while a code fence is
+* open — inside a fence a `- ` is literal code.
+*/
+function trimUnsettledStructural(text) {
+	const lines = text.split("\n");
+	while (lines.length > 0) {
+		const last = lines[lines.length - 1];
+		if (last.trim() === "") {
+			lines.pop();
+			continue;
+		}
+		if (/^ {0,9}[-*+] ?$/.test(last) || /^ {0,9}\d+[.)] ?$/.test(last)) {
+			lines.pop();
+			continue;
+		}
+		if (/^ {0,3}> ?$/.test(last) || /^ {0,3}#{1,6} ?$/.test(last)) {
+			lines.pop();
+			continue;
+		}
+		break;
+	}
+	return lines.join("\n");
+}
+/**
+* Parse one cumulative snapshot of a streaming Markdown doc. Settled
+* blocks (everything before the last safe blank line) parse once and are
+* shared by reference between calls; only the open tail reparses. Incomplete
+* trailing constructs are withheld or auto-closed, so intermediate output
+* shows no raw markup — and once the input stops growing, the result equals
+* `parseMdNodes` on the final text.
+*
+* Non-append input (a different doc, an edit) resets the cache and
+* reparses whole.
+*/
+function parseMarkdownIncremental(input, state) {
+	if (input === state.input) return state.output;
+	if (!input.startsWith(state.settledSource)) {
+		state.settledSource = "";
+		state.settled = [];
+		state.marks = [];
+	}
+	const trimmedInput = trimStreamingArtifacts(input);
+	const tailLines = trimmedInput.slice(state.settledSource.length).split("\n");
+	const { boundary, openFence } = findSettledBoundary(tailLines);
+	const settledDelta = boundary >= 0 ? tailLines.slice(0, boundary).join("\n") : "";
+	if (settledDelta !== "") {
+		const { nodes, listMarks } = parseMdNodesMarked(settledDelta);
+		const last = state.settled[state.settled.length - 1];
+		const first = nodes[0];
+		if (last?.t === "list" && first?.t === "list" && last.ordered === first.ordered && state.marks[state.marks.length - 1] === listMarks[0]) {
+			state.settled[state.settled.length - 1] = {
+				t: "list",
+				ordered: last.ordered,
+				items: [...last.items, ...first.items]
+			};
+			state.settled.push(...nodes.slice(1));
+			state.marks.push(...listMarks.slice(1));
+		} else {
+			state.settled.push(...nodes);
+			state.marks.push(...listMarks);
+		}
+		state.settledSource += settledDelta;
+	}
+	const unsettledRaw = trimmedInput.slice(state.settledSource.length).trim();
+	const unsettled = openFence ? unsettledRaw : trimUnsettledStructural(unsettledRaw);
+	const parsed = unsettled === "" ? {
+		nodes: [],
+		listMarks: []
+	} : parseMdNodesMarked(unsettled);
+	const last = state.settled[state.settled.length - 1];
+	const first = parsed.nodes[0];
+	if (last?.t === "list" && first?.t === "list" && last.ordered === first.ordered && state.marks[state.marks.length - 1] === parsed.listMarks[0]) state.output = [
+		...state.settled.slice(0, -1),
+		{
+			t: "list",
+			ordered: last.ordered,
+			items: [...last.items, ...first.items]
+		},
+		...parsed.nodes.slice(1)
+	];
+	else state.output = [...state.settled, ...parsed.nodes];
+	state.input = input;
+	return state.output;
+}
+/**
+* Push the previous rendered length onto the boundary ring when output grew.
+* The ring caps at `maxSpans`; evicted boundaries merge into settled text.
+*/
+function computeBoundaries(prevBoundaries, prevRenderedLen, maxSpans) {
+	if (prevBoundaries.length === 0 || prevRenderedLen > prevBoundaries[prevBoundaries.length - 1]) {
+		const next = [...prevBoundaries, prevRenderedLen];
+		while (next.length > maxSpans) next.shift();
+		return next;
+	}
+	return prevBoundaries;
+}
+/**
+* Split one text run at the stream boundaries it crosses. Returns null when
+* the whole run is settled (no splitting needed). Segment keys never change
+* once created — `settled-{nodeKey}` for pre-boundary text and
+* `fade-{nodeKey}-b{offset}` per boundary span — so a fading span stays
+* mounted until it merges into the settled segment.
+*/
+function computeSegments(content, startOffset, boundaries, nodeKey) {
+	const endOffset = startOffset + content.length;
+	if (boundaries.length === 0 || endOffset <= boundaries[0]) return null;
+	const segments = [];
+	let pos = startOffset;
+	if (pos < boundaries[0]) {
+		segments.push({
+			key: `settled-${nodeKey}`,
+			text: content.slice(0, boundaries[0] - startOffset),
+			fading: false
+		});
+		pos = boundaries[0];
+	}
+	for (let i = 0; i < boundaries.length; i++) {
+		const bStart = boundaries[i];
+		const bEnd = i + 1 < boundaries.length ? boundaries[i + 1] : endOffset;
+		if (bStart >= endOffset || bEnd <= pos) continue;
+		const lo = Math.max(bStart, pos);
+		const hi = Math.min(bEnd, endOffset);
+		if (lo >= hi) continue;
+		segments.push({
+			key: `fade-${nodeKey}-b${bStart}`,
+			text: content.slice(lo - startOffset, hi - startOffset),
+			fading: true
+		});
+		pos = hi;
+	}
+	return segments.length > 0 ? segments : null;
+}
+/** Total rendered text length of a node list — the cursor metric fade
+*  boundaries are computed against. */
+function markdownTextLength(nodes) {
+	let n = 0;
+	for (const node of nodes) switch (node.t) {
+		case "h":
+		case "p":
+		case "quote":
+			n += mdInlineLen(node.children);
+			break;
+		case "code":
+			n += node.text.length;
+			break;
+		case "list": for (const item of node.items) n += mdInlineLen(item);
+	}
+	return n;
+}
+//#endregion
+export { computeBoundaries, computeSegments, createMarkdownIncrementalState, markdownTextLength, parseMarkdownIncremental, trimStreamingArtifacts };

package/dist/web/menu-context.js

@@ -0,0 +1,11 @@
+import { createContext, useContext } from "octane";
+//#region src/menu-context.ts
+var DropdownMenuContext = /* @__PURE__ */ createContext(null);
+var MenuProvider = DropdownMenuContext;
+function useDropdownMenuContext() {
+	return useContext(DropdownMenuContext);
+}
+var MenuRadioContext = /* @__PURE__ */ createContext(null);
+var MenuRadioProvider = MenuRadioContext;
+//#endregion
+export { DropdownMenuContext, MenuProvider, MenuRadioContext, MenuRadioProvider, useDropdownMenuContext };

package/dist/web/metadata-list-context.js

@@ -0,0 +1,6 @@
+import { createContext } from "octane";
+//#region src/metadata-list-context.ts
+var MetadataListContext = /* @__PURE__ */ createContext(null);
+var MetadataListProvider = MetadataListContext;
+//#endregion
+export { MetadataListContext, MetadataListProvider };

package/dist/web/modal-focus.web.js

@@ -0,0 +1,130 @@
+import { isTopLayer, layerContains, registerLayer } from "./layer-stack.js";
+import "./layer-keys.web.js";
+//#region src/modal-focus.web.ts
+var TAB_STOP_SELECTOR = "a[href],button,input,textarea,select,[tabindex],[contenteditable=\"true\"]";
+var CLICK_TRIGGER_MAX_AGE_MS = 1e3;
+var recentClickTargets = /* @__PURE__ */ new WeakMap();
+var clickCaptureDocuments = /* @__PURE__ */ new WeakSet();
+var scopes = [];
+var originalInert = /* @__PURE__ */ new Map();
+var observer;
+function topScope() {
+	return scopes[scopes.length - 1];
+}
+function updateIsolation() {
+	const top = topScope();
+	if (!top) {
+		for (const [element, inert] of originalInert) if (!inert) element.removeAttribute("inert");
+		originalInert.clear();
+		return;
+	}
+	for (const element of Array.from(top.layer.ownerDocument.body.children)) {
+		if (!originalInert.has(element)) originalInert.set(element, element.hasAttribute("inert"));
+		const inert = originalInert.get(element) || !element.contains(top.layer);
+		element.toggleAttribute("inert", inert);
+	}
+}
+function isTabStop(element) {
+	if (element.tabIndex < 0 || element.matches(":disabled") || element.closest("[inert],[hidden]")) return false;
+	for (let parent = element; parent; parent = parent.parentElement) {
+		const style = getComputedStyle(parent);
+		if (style.display === "none" || style.visibility === "hidden") return false;
+	}
+	return true;
+}
+function tabStops(panel) {
+	return Array.from(panel.querySelectorAll(TAB_STOP_SELECTOR)).filter(isTabStop);
+}
+function captureClickTargets(document) {
+	if (clickCaptureDocuments.has(document)) return;
+	clickCaptureDocuments.add(document);
+	document.addEventListener("click", (event) => {
+		recentClickTargets.delete(document);
+		for (const target of event.composedPath()) {
+			if (!target || typeof target !== "object" || !("nodeType" in target) || target.nodeType !== 1) continue;
+			const element = target;
+			if (element.matches(TAB_STOP_SELECTOR) && isTabStop(element)) {
+				recentClickTargets.set(document, {
+					element,
+					at: Date.now()
+				});
+				return;
+			}
+		}
+	}, true);
+}
+if (typeof document !== "undefined") captureClickTargets(document);
+/** Own keyboard focus only for a modal body portal. Inert preserves the
+* background's state while hiding it from both focus and the browser AX tree. */
+function isolateModalFocus(layer, panel, dismiss, depth = scopes.length) {
+	const document = layer.ownerDocument;
+	captureClickTargets(document);
+	const recentClick = recentClickTargets.get(document);
+	const clickTrigger = recentClick && Date.now() - recentClick.at <= CLICK_TRIGGER_MAX_AGE_MS ? recentClick.element : null;
+	recentClickTargets.delete(document);
+	const scope = {
+		layer,
+		panel,
+		trigger: clickTrigger ?? document.activeElement
+	};
+	const tabIndex = panel.getAttribute("tabindex");
+	if (tabIndex === null) panel.tabIndex = -1;
+	const token = {};
+	const removeLayer = registerLayer({
+		token,
+		depth,
+		behavior: "close",
+		dismiss,
+		contains: (target) => panel.contains(target)
+	});
+	scopes.push(scope);
+	updateIsolation();
+	(tabStops(panel)[0] ?? panel).focus({ preventScroll: true });
+	if (!observer) {
+		observer = new MutationObserver(updateIsolation);
+		observer.observe(document.body, { childList: true });
+	}
+	const focusInside = () => (tabStops(panel)[0] ?? panel).focus({ preventScroll: true });
+	const onFocus = (event) => {
+		if (topScope() === scope && !panel.contains(event.target) && !layerContains(event.target)) focusInside();
+	};
+	const onKey = (event) => {
+		if (topScope() !== scope || !isTopLayer(token) || event.isComposing || event.keyCode === 229) return;
+		if (event.key === "Tab") {
+			const stops = tabStops(panel);
+			const index = stops.indexOf(document.activeElement);
+			if (!stops.length || index < 0 || (event.shiftKey ? index === 0 : index === stops.length - 1)) {
+				event.preventDefault();
+				(stops.length ? stops[event.shiftKey ? stops.length - 1 : 0] : panel).focus({ preventScroll: true });
+			}
+		}
+	};
+	document.addEventListener("focusin", onFocus);
+	document.addEventListener("keydown", onKey, true);
+	return () => {
+		const wasTop = topScope() === scope;
+		const index = scopes.indexOf(scope);
+		if (index < 0) return;
+		for (const other of scopes) if (other !== scope && other.trigger && scope.layer.contains(other.trigger)) other.trigger = scope.trigger;
+		scopes.splice(index, 1);
+		removeLayer();
+		document.removeEventListener("focusin", onFocus);
+		document.removeEventListener("keydown", onKey, true);
+		if (tabIndex === null) panel.removeAttribute("tabindex");
+		updateIsolation();
+		if (!scopes.length) {
+			observer?.disconnect();
+			observer = void 0;
+		}
+		if (wasTop) {
+			const trigger = scope.trigger;
+			if (trigger?.isConnected && !trigger.closest("[inert]")) trigger.focus({ preventScroll: true });
+			else {
+				const remaining = topScope();
+				if (remaining) (tabStops(remaining.panel)[0] ?? remaining.panel).focus({ preventScroll: true });
+			}
+		}
+	};
+}
+//#endregion
+export { isolateModalFocus };

package/dist/web/nav-contexts.js

@@ -0,0 +1,82 @@
+import { createContext, useContext } from "octane";
+//#region src/nav-contexts.ts
+/** AppShell → MobileNav/MobileNavToggle/TopNav mobile state. The default is
+*  the disabled, non-mobile value so consumers outside an AppShell behave
+*  sanely (the toggle renders nothing). */
+var defaultAppShellMobile = {
+	isMobile: false,
+	isMobileNavOpen: false,
+	toggleMobileNav: () => {},
+	openMobileNav: () => {},
+	closeMobileNav: () => {},
+	isMobileNavEnabled: false,
+	hasAutoToggle: true
+};
+var AppShellMobileContext = /* @__PURE__ */ createContext(defaultAppShellMobile);
+function useAppShellMobile() {
+	return useContext(AppShellMobileContext) ?? defaultAppShellMobile;
+}
+/** AppShell sets this so TopNav can switch between the full bar, the
+*  reduced mobile bar, and drawer rendering below the breakpoint. */
+var TopNavRenderContext = /* @__PURE__ */ createContext("default");
+function useTopNavRenderMode() {
+	return useContext(TopNavRenderContext) ?? "default";
+}
+/** Which TopNav slot an item renders in — items use it for slot-specific
+*  styling (e.g. drawer layouts stretch items full width). */
+var TopNavSlotContext = /* @__PURE__ */ createContext("start");
+function useTopNavSlot() {
+	return useContext(TopNavSlotContext) ?? "start";
+}
+/** Extra drawer content AppShell hands to TopNav's drawer render — the
+*  SideNav's items travel this way when the drawer is combined. */
+var TopNavMobileContentContext = /* @__PURE__ */ createContext(null);
+function useTopNavMobileContent() {
+	return useContext(TopNavMobileContentContext) ?? null;
+}
+/** AppShell sets this so SideNav can switch between the full sidebar, the
+*  horizontal topbar, and the two drawer renderings. */
+var SideNavRenderContext = /* @__PURE__ */ createContext("default");
+function useSideNavRenderMode() {
+	return useContext(SideNavRenderContext) ?? "default";
+}
+/** SideNav collapse state shared with collapse buttons and items. */
+var SideNavCollapseContext = /* @__PURE__ */ createContext(null);
+function useSideNavCollapse() {
+	return useContext(SideNavCollapseContext);
+}
+/** TabList → Tab/TabMenu selection contract. Throws when read outside a
+*  TabList, matching upstream. */
+var TabListContext = /* @__PURE__ */ createContext(null);
+function useTabListContext() {
+	const ctx = useContext(TabListContext);
+	if (ctx == null) throw new Error("useTabListContext must be used within TabList. Wrap your Tab/TabMenu in <TabList>.");
+	return ctx;
+}
+/** Heading-popover close callback — NavHeadingMenu reads it to dismiss the
+*  popover on item selection and Escape. */
+var NavHeadingCloseContext = /* @__PURE__ */ createContext(null);
+function useNavHeadingCloseContext() {
+	return useContext(NavHeadingCloseContext);
+}
+/** NavHeadingMenu → its items: size + the close callback. */
+var NavHeadingMenuContext = /* @__PURE__ */ createContext(null);
+function useNavHeadingMenuContext() {
+	return useContext(NavHeadingMenuContext);
+}
+/** Toolbar → family children that want the resolved size. This is the
+*  local seam standing in for Astryx's SizeContext until the shared size
+*  context lands with the forms/layout task. */
+var ToolbarSizeContext = /* @__PURE__ */ createContext(null);
+var AppShellMobileProvider = AppShellMobileContext;
+var SideNavRenderProvider = SideNavRenderContext;
+var TopNavRenderProvider = TopNavRenderContext;
+var TopNavSlotProvider = TopNavSlotContext;
+var TopNavMobileContentProvider = TopNavMobileContentContext;
+var SideNavCollapseProvider = SideNavCollapseContext;
+var NavHeadingCloseProvider = NavHeadingCloseContext;
+var NavHeadingMenuProvider = NavHeadingMenuContext;
+var TabListProvider = TabListContext;
+var ToolbarSizeProvider = ToolbarSizeContext;
+//#endregion
+export { AppShellMobileContext, AppShellMobileProvider, NavHeadingCloseContext, NavHeadingCloseProvider, NavHeadingMenuContext, NavHeadingMenuProvider, SideNavCollapseContext, SideNavCollapseProvider, SideNavRenderContext, SideNavRenderProvider, TabListContext, TabListProvider, ToolbarSizeContext, ToolbarSizeProvider, TopNavMobileContentContext, TopNavMobileContentProvider, TopNavRenderContext, TopNavRenderProvider, TopNavSlotContext, TopNavSlotProvider, useAppShellMobile, useNavHeadingCloseContext, useNavHeadingMenuContext, useSideNavCollapse, useSideNavRenderMode, useTabListContext, useTopNavMobileContent, useTopNavRenderMode, useTopNavSlot };

package/dist/web/nav-href.web.js

@@ -0,0 +1 @@
+import "./route.web.js";

package/dist/web/navigation-request.js

@@ -0,0 +1,26 @@
+//#region src/navigation-request.ts
+function createNavigationRequests() {
+	const versions = /* @__PURE__ */ new Map();
+	const invalidate = (stack) => {
+		const version = (versions.get(stack) ?? 0) + 1;
+		versions.set(stack, version);
+		return version;
+	};
+	return {
+		invalidate,
+		begin(stack) {
+			const owned = /* @__PURE__ */ new Map([[stack, invalidate(stack)]]);
+			const isCurrent = () => [...owned].every(([name, version]) => versions.get(name) === version);
+			return {
+				isCurrent,
+				claim(name) {
+					if (!isCurrent()) return false;
+					if (!owned.has(name)) owned.set(name, invalidate(name));
+					return true;
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createNavigationRequests };

package/dist/web/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "0ba2ee91-551d-42cf-a6c9-dedc87a8a53b",
+  "buildId": "1f8903f8-0ddb-4fe9-904d-a4c7652f5a67",
   "mode": "production",
   "capabilities": {
     "independentHydration": false

package/dist/web/outline-dom.web.tsrx.js

@@ -0,0 +1,52 @@
+import { slugify, uniqueSlug } from "./outline-utils.js";
+import { hookSlots, useEffect, useState } from "octane";
+//#region src/outline-dom.web.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(2);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+function outlineItemsFromDOM(container, selector = "h1, h2, h3, h4, h5, h6") {
+	const root = container ?? (typeof document !== "undefined" ? document : void 0);
+	if (!root) return [];
+	const nodes = root.querySelectorAll(selector);
+	const counts = /* @__PURE__ */ new Map();
+	const items = [];
+	for (const node of nodes) {
+		const el = node;
+		const level = Number(el.tagName?.slice(1)) || 2;
+		const label = (el.innerText ?? el.textContent ?? "").trim();
+		if (!label) continue;
+		const id = el.id || uniqueSlug(slugify(label), counts);
+		items.push({
+			id,
+			label,
+			level
+		});
+	}
+	return items;
+}
+function useOutlineFromDOM(containerRef, options) {
+	const [items, setItems] = useState([], _h$0);
+	const resolve = () => {
+		return (containerRef && typeof containerRef === "object" && "current" in containerRef ? containerRef.current : containerRef) ?? options?.root ?? (typeof document !== "undefined" ? document : null);
+	};
+	useEffect(() => {
+		const refresh = () => setItems(outlineItemsFromDOM(resolve(), options?.selector));
+		refresh();
+		const root = resolve();
+		const observer = new MutationObserver(refresh);
+		if (root) observer.observe(root, {
+			childList: true,
+			subtree: true,
+			characterData: true
+		});
+		else if (typeof document !== "undefined") observer.observe(document.body, {
+			childList: true,
+			subtree: true,
+			characterData: true
+		});
+		return () => observer.disconnect();
+	}, [options?.selector], _h$1);
+	return items;
+}
+//#endregion
+export { outlineItemsFromDOM, useOutlineFromDOM };

package/dist/web/outline-hooks.tsrx.js

@@ -0,0 +1,17 @@
+import { outlineFromDoc, parseOutlineFromMarkdown } from "./outline-utils.js";
+import { hookSlots } from "octane";
+import { memoPublish, memoSlot, memoTake1 } from "octane/internal/client";
+//#region src/outline-hooks.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(2);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+function useOutlineFromMarkdown(markdown) {
+	let __hks, __hkd0, __hke;
+	return __hkd0 = markdown, __hks = memoSlot(_h$0, "useMemo"), __hke = memoTake1(__hks, __hkd0), __hke === null ? memoPublish(__hks, parseOutlineFromMarkdown(markdown), __hkd0) : __hke.value;
+}
+function useOutlineFromDoc(doc) {
+	let __hks$, __hkd0$, __hke$;
+	return __hkd0$ = doc, __hks$ = memoSlot(_h$1, "useMemo"), __hke$ = memoTake1(__hks$, __hkd0$), __hke$ === null ? memoPublish(__hks$, outlineFromDoc(doc), __hkd0$) : __hke$.value;
+}
+//#endregion
+export { useOutlineFromDoc, useOutlineFromMarkdown };