@levo-so/site-runtime 0.1.113

package/dist/inspector/originalsStash.js

@@ -0,0 +1,24 @@
+//#region src/inspector/originalsStash.ts
+var e = () => {
+	let e = /* @__PURE__ */ new Map(), t = () => {
+		if (e.size > 50) {
+			let t = e.keys().next().value;
+			t !== void 0 && e.delete(t);
+		}
+	};
+	return {
+		capture: (n, r) => {
+			e.set(n, r), t();
+		},
+		captureOnce: (n, r) => {
+			e.has(n) || (e.set(n, r), t());
+		},
+		get: (t) => e.get(t),
+		restore: (t) => {
+			let n = e.get(t);
+			return e.delete(t), n;
+		}
+	};
+};
+//#endregion
+export { e as createOriginalsStash };

package/dist/inspector/protocol.d.ts

@@ -0,0 +1,180 @@
+export interface IStagedStyleEntry {
+    kind: "style";
+    source: string;
+    index: number;
+    styles: Record<string, string>;
+    media?: string;
+}
+export interface IStagedTextEntry {
+    kind: "text";
+    source: string;
+    index: number;
+    value: string;
+}
+export type IStagedEntry = IStagedStyleEntry | IStagedTextEntry;
+export interface ILayersNode {
+    tag: string;
+    source?: string;
+    index?: number;
+    text?: string;
+    /** The element carries the `hidden` utility (display:none) — a reachability hint the
+     * Layers panel surfaces. Live + class-based, so it covers component internals too
+     * (the dashboard no longer parses JSX for this). Present only when true. */
+    hidden?: boolean;
+    childCount: number;
+    children: ILayersNode[];
+}
+export type IHistoryFn = History["pushState"];
+export interface IPatchedHistoryFn {
+    (this: History, ...args: Parameters<IHistoryFn>): ReturnType<IHistoryFn>;
+    __inspectorPatched?: boolean;
+    __orig?: IHistoryFn;
+}
+/** A nested element locator — `file:line:col` + occurrence index. Never top-level. */
+export interface IElementLocator {
+    source: string;
+    index?: number;
+}
+/** The element-selected payload — see `selectedPayload`. */
+export interface ISelectedElement {
+    tag: string;
+    classes: string;
+    text: string;
+    label: string;
+    path: string;
+    /** null when the element carries no `data-tsd-source` stamp. */
+    source: string | null;
+    index: number;
+    occurrences: number;
+    ancestors: {
+        tag: string;
+        text: string;
+        source?: string;
+    }[];
+    /** Whole normalized textContent — present ONLY for text-mode-editable nodes. */
+    fullText?: string;
+    /**
+     * The nearest `data-levo-source` binding container above the selection (inclusive) — a
+     * platform-data-bound region (`useLevoSource`/`useLevoRecord`). Present only when the
+     * selection sits inside one. `config` is the parsed binding ({mode, module, identifier,
+     * query,…}), omitted when the attribute is malformed JSON. `element` is the binding
+     * CONTAINER's own locator, so a data edit targets the hook call site — not the clicked
+     * child. Lets the editor's "Integrate" dialog open pre-filled without parsing JSX.
+     */
+    sourceBinding?: {
+        raw: string;
+        config?: unknown;
+        element: IElementLocator;
+    };
+}
+/** The element-text-changed payload — see `commit`. */
+export interface ITextChangedElement {
+    source: string | null;
+    index: number;
+    tag: string;
+    value: string;
+    previous?: string;
+    occurrences: number;
+}
+/** Editor → preview (received by `onMessage`; dashboard's `IOutboundMessage`). */
+export type IEditorToPreview = {
+    type: "set-inspect";
+    enabled: boolean;
+} | {
+    type: "set-text-edit";
+    enabled: boolean;
+} | {
+    type: "clear-selection";
+} | {
+    type: "select-element";
+    element: IElementLocator;
+} | {
+    type: "edit-element";
+    element: IElementLocator;
+} | {
+    type: "highlight-element";
+    element: IElementLocator;
+} | {
+    type: "clear-highlight";
+} | {
+    type: "request-layers";
+} | {
+    type: "request-sources";
+} | {
+    type: "revert-text";
+    element: IElementLocator;
+} | {
+    type: "navigate";
+    route: string;
+} | {
+    type: "stage-style";
+    stageId: string;
+    element: IElementLocator;
+    styles: Record<string, string>;
+    media?: string;
+} | {
+    type: "stage-text";
+    stageId: string;
+    element: IElementLocator;
+    value: string;
+} | {
+    type: "clear-staged";
+    stageId?: string;
+};
+/** Preview → editor (emitted by `send`; dashboard's `IInboundMessage`). */
+export type IPreviewToEditor = {
+    type: "ready";
+} | {
+    type: "inspect-state";
+    enabled: boolean;
+} | {
+    type: "text-edit-state";
+    enabled: boolean;
+} | {
+    type: "element-selected";
+    element: ISelectedElement;
+} | {
+    type: "element-text-changed";
+    element: ITextChangedElement;
+}
+/**
+ * `route` is the pathname (always present). `file` is the route's repo-relative source
+ * file (e.g. `src/routes/pricing.tsx`, no leading slash, no `:line:col`) — reserved:
+ * the runtime doesn't emit it yet; the dashboard falls back to url → file mapping.
+ */
+ | {
+    type: "route";
+    route: string;
+    file?: string;
+} | {
+    type: "staged-ack";
+    stageId: string;
+} | {
+    type: "layers-tree";
+    tree: ILayersNode;
+    truncated: boolean;
+} | {
+    type: "sources-list";
+    sources: IPageSource[];
+} | {
+    type: "select-miss";
+    element: IElementLocator;
+} | {
+    type: "highlight-miss";
+    element: IElementLocator;
+};
+/**
+ * One platform-data binding found on the page — a `data-levo-source` container. Emitted in
+ * `sources-list` (reply to `request-sources`) so the editor's page-level Data manager can list
+ * every binding without a selection. `element` is the container's own `data-tsd-source` locator
+ * (a data edit targets the hook call site); `config` is the parsed binding, omitted when the
+ * attribute is malformed JSON.
+ */
+export interface IPageSource {
+    raw: string;
+    config?: unknown;
+    element: IElementLocator;
+    tag: string;
+    label: string;
+}
+//# sourceMappingURL=protocol.d.ts.map

package/dist/inspector/stagedOverrides.d.ts

@@ -0,0 +1,28 @@
+import { IStagedEntry } from './protocol';
+import { IOriginalsStash } from './originalsStash';
+export type IStagedOverrides = ReturnType<typeof createStagedOverrides>;
+export declare const createStagedOverrides: (deps: {
+    originals: IOriginalsStash;
+    /**
+     * The node currently in contenteditable (or null). A text override is never re-asserted
+     * onto the node being edited — see applyStagedEntry.
+     */
+    editingNode: () => Element | null;
+}) => {
+    upsert: (stageId: string, entry: IStagedEntry) => void;
+    clearOne: (stageId: string) => void;
+    clearAll: () => void;
+    scheduleReapply: () => void;
+    /** Registered override count — the DOM-observer arbitration reads this. */
+    count: () => number;
+    /** All registered stageIds — the clear-ALL ack loop reads these before clearing. */
+    ids: () => string[];
+    /**
+     * Unmount teardown: cancel the reapply rAF and hard-remove the injected sheet + every
+     * stamp. The registry can't survive a remount, and stale stamps/rules must not outlive
+     * it — the dashboard re-sends the full staged set on the next `ready`, so an
+     * HMR/StrictMode remount self-heals.
+     */
+    teardown: () => void;
+};
+//# sourceMappingURL=stagedOverrides.d.ts.map

package/dist/inspector/stagedOverrides.js

@@ -0,0 +1,60 @@
+import { addStagedKey as e, cssRuleFor as t, nodeForSource as n, removeStagedKey as r } from "./dom.js";
+//#region src/inspector/stagedOverrides.ts
+var i = (i) => {
+	let { originals: a, editingNode: o } = i, s = /* @__PURE__ */ new Map(), c = () => {
+		let e = document.getElementById("studio-staged");
+		return e || (e = document.createElement("style"), e.id = "studio-staged", document.head.appendChild(e)), e;
+	}, l = () => {
+		let e = [];
+		for (let [n, r] of s) if (r.kind === "style") {
+			let i = t(n, r);
+			i && e.push(i);
+		}
+		let n = e.join("\n");
+		if (!n && !document.getElementById("studio-staged")) return;
+		let r = c();
+		r.textContent !== n && (r.textContent = n);
+	}, u = (t, r) => {
+		let i = n(r.source, r.index);
+		if (i) if (r.kind === "style") e(i, t);
+		else {
+			if (i === o()) return;
+			let e = `${r.source}#${r.index}`;
+			a.captureOnce(e, i.textContent ?? ""), i.textContent !== r.value && (i.textContent = r.value);
+		}
+	}, d = (e, t) => {
+		s.set(e, t), u(e, t), t.kind === "style" && l();
+	}, f = (e) => {
+		let t = s.get(e);
+		if (!t) return;
+		s.delete(e);
+		let i = n(t.source, t.index);
+		if (t.kind === "style") i && r(i, e), l();
+		else {
+			let e = a.restore(`${t.source}#${t.index}`);
+			i && e != null && (i.textContent = e);
+		}
+	}, p = () => {
+		for (let e of [...s.keys()]) f(e);
+		for (let e of Array.from(document.querySelectorAll("[data-staged-key]"))) e.removeAttribute("data-staged-key");
+	}, m = 0;
+	return {
+		upsert: d,
+		clearOne: f,
+		clearAll: p,
+		scheduleReapply: () => {
+			m || !s.size || (m = requestAnimationFrame(() => {
+				m = 0;
+				for (let [e, t] of s) u(e, t);
+			}));
+		},
+		count: () => s.size,
+		ids: () => [...s.keys()],
+		teardown: () => {
+			m && cancelAnimationFrame(m), document.getElementById("studio-staged")?.remove();
+			for (let e of Array.from(document.querySelectorAll("[data-staged-key]"))) e.removeAttribute("data-staged-key");
+		}
+	};
+};
+//#endregion
+export { i as createStagedOverrides };

package/dist/inspector/textEditController.d.ts

@@ -0,0 +1,24 @@
+import { IEditorChannel } from './editorChannel';
+import { IOriginalsStash } from './originalsStash';
+export type ITextEditController = ReturnType<typeof createTextEditController>;
+export declare const createTextEditController: (deps: {
+    channel: IEditorChannel;
+    originals: IOriginalsStash;
+    /**
+     * Drop the text-mode hover affordance (outline + tracked hover target). Cursor is NOT
+     * reset here — the pointer tracker owns it (hovering the edited node clears it there).
+     */
+    clearTextHover: () => void;
+}) => {
+    startEdit: (el: Element, caretAtEnd?: boolean) => void;
+    /** The node currently in contenteditable, or null — read by hover/click/staged logic. */
+    editingNode: () => Element | null;
+    /** Commit any in-flight edit (mode exit, defensive re-entry). No-op when idle. */
+    commitIfEditing: () => void;
+    /**
+     * Teardown for unmount: end any in-flight edit WITHOUT committing (no report on
+     * teardown — matches the original closure's cleanup, which called endEdit directly).
+     */
+    teardown: () => void;
+};
+//# sourceMappingURL=textEditController.d.ts.map

package/dist/inspector/textEditController.js

@@ -0,0 +1,62 @@
+import { COLOR as e, nodesForSource as t, sourceIndex as n, sourceOf as r } from "./dom.js";
+//#region src/inspector/textEditController.ts
+var i = (i) => {
+	let { channel: a, originals: o, clearTextHover: s } = i, c = null, l = "", u = 0, d = (() => {
+		try {
+			let e = document.createElement("div");
+			return e.setAttribute("contenteditable", "plaintext-only"), e.contentEditable === "plaintext-only";
+		} catch {
+			return !1;
+		}
+	})(), f = () => {
+		c && _(c);
+	}, p = (e) => {
+		e.key === "Enter" ? (e.preventDefault(), c && _(c)) : e.key === "Escape" && (e.preventDefault(), c && v(c));
+	}, m = (e) => {
+		let t = window.getSelection();
+		if (!t) return;
+		let n = document.createRange();
+		n.selectNodeContents(e), n.collapse(!1), t.removeAllRanges(), t.addRange(n);
+	}, h = (t, i = !1) => {
+		if (c === t) return;
+		c && _(c), c = t, l = r(t) || "", u = n(t, l), s(), o.capture(`${l}#${u}`, t.textContent ?? ""), t.setAttribute("contenteditable", d ? "plaintext-only" : "true");
+		let a = t;
+		a.style.outline = `2px solid ${e.hover}`, a.style.outlineOffset = "3px", a.style.borderRadius = "3px", a.focus(), i && m(t), a.addEventListener("blur", f, !0), a.addEventListener("keydown", p, !0);
+	}, g = (e) => {
+		e.removeAttribute("contenteditable");
+		let t = e;
+		t.style.outline = "", t.style.outlineOffset = "", t.style.borderRadius = "", t.removeEventListener("blur", f, !0), t.removeEventListener("keydown", p, !0), c = null;
+	}, _ = (e) => {
+		let n = r(e), i = u, s = o.get(`${l}#${u}`);
+		g(e);
+		let c = (e.textContent ?? "").replace(/\s+/g, " ").trim();
+		a.send({
+			type: "element-text-changed",
+			element: {
+				source: n,
+				index: i,
+				tag: e.tagName.toLowerCase(),
+				value: c,
+				previous: s,
+				occurrences: n ? t(n).length : 1
+			}
+		});
+	}, v = (e) => {
+		let t = `${l}#${u}`;
+		g(e);
+		let n = o.restore(t);
+		n != null && (e.textContent = n);
+	};
+	return {
+		startEdit: h,
+		editingNode: () => c,
+		commitIfEditing: () => {
+			c && _(c);
+		},
+		teardown: () => {
+			c && g(c);
+		}
+	};
+};
+//#endregion
+export { i as createTextEditController };

package/dist/pageHead.d.ts

@@ -0,0 +1,75 @@
+/** One page's head metadata. Every field optional — site defaults fill gaps per-field. */
+export interface IPageMeta {
+    title?: string;
+    description?: string;
+    /** Absolute URL. Rendered as `<link rel="canonical">`. */
+    canonical?: string;
+    /** e.g. "index,follow" / "noindex,nofollow". */
+    robots?: string;
+    og?: {
+        title?: string;
+        description?: string;
+        image?: string;
+        /** Defaults to "website" when any og field is present. */
+        type?: string;
+    };
+    twitter?: {
+        /** Defaults to "summary_large_image" when any twitter field is present. */
+        card?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+    };
+    /** JSON-LD object(s) — each becomes a `<script type="application/ld+json">`. */
+    ldJson?: Record<string, unknown> | Array<Record<string, unknown>>;
+    /**
+     * Raw head snippet for THIS page. v1 supports `<script>`, `<meta>` and `<link>` tags
+     * only (the analytics / verification / preload cases) — anything else is dropped by
+     * `parseRawHead`, since arbitrary markup can't be expressed as document metadata.
+     */
+    customHead?: string;
+}
+/** Site-wide defaults + site-wide raw head, from `src/pages/_site.meta.ts`. */
+export interface ISiteMeta extends IPageMeta {
+    /** "%s · Acme" — %s is the page title. Applied only when the page provides a title. */
+    titleTemplate?: string;
+}
+interface IHeadEntry {
+    [attr: string]: string | undefined;
+}
+export interface IComposedHead {
+    meta: IHeadEntry[];
+    links: IHeadEntry[];
+    scripts: IHeadEntry[];
+}
+/**
+ * Tolerant extraction of `<script>` / `<meta>` / `<link>` tags from a raw head snippet.
+ * Unsupported tags are DROPPED (documented v1 limitation) — silently at runtime; the
+ * editor warns at save time.
+ */
+export declare const parseRawHead: (raw: string) => IComposedHead;
+/**
+ * Compose one page's document metadata from its sidecar + the site defaults. Page
+ * values win per-FIELD (an empty page og.title still inherits the site og.title).
+ * The object shape doubles as a TanStack Start route `head()` result for when the
+ * scaffold wires routes directly.
+ */
+export declare const pageHead: (meta?: IPageMeta, site?: ISiteMeta) => IComposedHead;
+/**
+ * Renders a page's metadata as document tags. Pages include it anywhere in their JSX —
+ * React 19 hoists <title>/<meta>/<link> into <head> (SSR too); scripts render in place
+ * (see the file header caveat). The studio wires this automatically on a page's first
+ * meta save:
+ *
+ *   import meta from "./about.meta";
+ *   import siteMeta from "./_site.meta";
+ *   import { PageHead } from "../lib/pageHead";
+ *   …
+ *   <PageHead meta={meta} site={siteMeta} />
+ */
+export declare function PageHead({ meta, site }: {
+    meta?: IPageMeta;
+    site?: ISiteMeta;
+}): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=pageHead.d.ts.map

package/dist/pageHead.js

@@ -0,0 +1,102 @@
+import { Fragment as e, jsx as t, jsxs as n } from "react/jsx-runtime";
+//#region src/pageHead.tsx
+var r = (e) => JSON.stringify(e).replace(/<\//g, "<\\/"), i = (e) => {
+	let t = {}, n = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("([^"]*)"|'([^']*)'|[^\s"'>]+))?/g;
+	for (let r = n.exec(e); r; r = n.exec(e)) {
+		let e = r[1];
+		!e || /^on/i.test(e) || (t[e] = r[3] ?? r[4] ?? (r[2] ? r[2] : ""));
+	}
+	return t;
+}, a = (e) => {
+	let t = {
+		meta: [],
+		links: [],
+		scripts: []
+	};
+	if (!e?.trim()) return t;
+	let n = e.replace(/<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi, (e, n, r) => {
+		let a = i(n), o = r.trim();
+		return o && (a.children = o), t.scripts.push(a), "";
+	});
+	return n = n.replace(/<(meta|link)\b([^>]*?)\/?>/gi, (e, n, r) => ((n.toLowerCase() === "meta" ? t.meta : t.links).push(i(r)), "")), t;
+}, o = (e = {}, t = {}) => {
+	let n = {
+		meta: [],
+		links: [],
+		scripts: []
+	}, i = e.title?.trim(), o = t.title?.trim(), s = t.titleTemplate?.includes("%s") ? t.titleTemplate : void 0, c = i ? s ? s.replace("%s", i) : i : o;
+	c && n.meta.push({ title: c });
+	let l = e.description ?? t.description;
+	l && n.meta.push({
+		name: "description",
+		content: l
+	});
+	let u = e.robots ?? t.robots;
+	u && n.meta.push({
+		name: "robots",
+		content: u
+	});
+	let d = e.canonical ?? t.canonical;
+	d && n.links.push({
+		rel: "canonical",
+		href: d
+	});
+	let f = {
+		...t.og,
+		...e.og
+	}, p = f.title ?? i ?? o, m = f.description ?? l;
+	(p || m || f.image) && (n.meta.push({
+		property: "og:type",
+		content: f.type ?? "website"
+	}), p && n.meta.push({
+		property: "og:title",
+		content: p
+	}), m && n.meta.push({
+		property: "og:description",
+		content: m
+	}), f.image && n.meta.push({
+		property: "og:image",
+		content: f.image
+	}));
+	let h = {
+		...t.twitter,
+		...e.twitter
+	}, g = h.title ?? p, _ = h.description ?? m, v = h.image ?? f.image;
+	(g || _ || v) && (n.meta.push({
+		name: "twitter:card",
+		content: h.card ?? "summary_large_image"
+	}), g && n.meta.push({
+		name: "twitter:title",
+		content: g
+	}), _ && n.meta.push({
+		name: "twitter:description",
+		content: _
+	}), v && n.meta.push({
+		name: "twitter:image",
+		content: v
+	}));
+	let y = e.ldJson ? Array.isArray(e.ldJson) ? e.ldJson : [e.ldJson] : [];
+	for (let e of y) n.scripts.push({
+		type: "application/ld+json",
+		children: r(e)
+	});
+	for (let r of [t.customHead, e.customHead]) {
+		if (!r) continue;
+		let e = a(r);
+		n.meta.push(...e.meta), n.links.push(...e.links), n.scripts.push(...e.scripts);
+	}
+	return n;
+};
+function s({ meta: r, site: i }) {
+	let a = o(r, i);
+	return /* @__PURE__ */ n(e, { children: [
+		a.meta.map((e, n) => e.title === void 0 ? /* @__PURE__ */ t("meta", { ...e }, `m${n}`) : /* @__PURE__ */ t("title", { children: e.title }, `t${n}`)),
+		a.links.map((e, n) => /* @__PURE__ */ t("link", { ...e }, `l${n}`)),
+		a.scripts.map(({ children: e, ...n }, r) => e === void 0 ? /* @__PURE__ */ t("script", { ...n }, `s${r}`) : /* @__PURE__ */ t("script", {
+			...n,
+			dangerouslySetInnerHTML: { __html: e }
+		}, `s${r}`))
+	] });
+}
+//#endregion
+export { s as PageHead, o as pageHead, a as parseRawHead };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@levo-so/site-runtime",
+  "version": "0.1.113",
+  "description": "Runtime for Levo Studio v3 sites — the editor preview inspector, page head metadata, and the Levo data client.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@levo-so/core": "0.1.113",
+    "@levo-so/insights": "0.1.113"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": ">=5",
+    "react": ">=19"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "5.91.2",
+    "@types/react": "19.2.14",
+    "@vitejs/plugin-react": "6.0.1",
+    "typescript": "5.9.3",
+    "vite": "8.0.8",
+    "vite-plugin-dts": "4.5.4",
+    "@levo/ts-config": "0.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "!dist/**/*.d.ts.map",
+    "!dist/**/*.js.map",
+    "package.json"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "vite build",
+    "check-types": "tsc -b --noEmit",
+    "clean": "npx rimraf dist node_modules .turbo",
+    "dev": "vite build --watch"
+  }
+}