@kky42/pievo-server 1.0.0

package/.output/server/_ssr/routes-Bcs4T1ox.mjs

@@ -0,0 +1,28 @@
+import { C as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { f as useRouter } from "../_libs/@tanstack/react-router+[...].mjs";
+import { r as LoadErrorCard } from "./actionUi-CZbEixbf.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/routes-Bcs4T1ox.js
+var import_jsx_runtime = require_jsx_runtime();
+/**
+* The home route. Under the auth gate it is now a THIN redirect to the explicit
+* team URL (`/t/<lastUsed|personal>`) so the dashboard's team lives in the path
+* (bookmarkable, multi-tab). `/` keeps working forever: a signed-out visitor gets
+* the sign-in CTA; open mode (no gate ⇒ a single shared workspace with no team to
+* expose in the URL) renders the dashboard right here, unchanged.
+*/
+/** First-load failure screen — a calm retry instead of the router's default
+*  error dump. Only the initial loader can land here; the in-page poll is
+*  fetch-then-set and keeps stale data on a transient blip. */
+function LoadError({ error }) {
+	const router = useRouter();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("main", {
+		className: "mx-auto max-w-[1180px] px-8 pt-12",
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoadErrorCard, {
+			title: "Couldn't load the dashboard.",
+			detail: String(error),
+			onRetry: () => void router.invalidate()
+		})
+	});
+}
+//#endregion
+export { LoadError as errorComponent };

package/.output/server/_ssr/routes-BoGrcf-b.mjs

@@ -0,0 +1,43 @@
+import { c as createFileRoute, p as redirect, s as lazyRouteComponent } from "../_libs/@tanstack/react-router+[...].mjs";
+import { d as getDefaultTeam, g as listTemplates, l as getAuthState } from "./loopApi-Cxe8WyOB.mjs";
+import { a as authClient } from "./LoopPlaybook-BXH8mhiX.mjs";
+import { n as fetchLiveData } from "./DashboardView-CC7htv28.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/routes-BoGrcf-b.js
+var $$splitErrorComponentImporter = () => import("./routes-Bcs4T1ox.mjs");
+var $$splitComponentImporter = () => import("./routes-D4am3Zff.mjs");
+/**
+* The home route. Under the auth gate it is now a THIN redirect to the explicit
+* team URL (`/t/<lastUsed|personal>`) so the dashboard's team lives in the path
+* (bookmarkable, multi-tab). `/` keeps working forever: a signed-out visitor gets
+* the sign-in CTA; open mode (no gate ⇒ a single shared workspace with no team to
+* expose in the URL) renders the dashboard right here, unchanged.
+*/
+var Route = createFileRoute("/")({
+	ssr: false,
+	loader: async () => {
+		const auth = await getAuthState();
+		if (auth.enabled) {
+			const { data: session } = await authClient.getSession();
+			if (!session) return {
+				mode: "signin",
+				auth
+			};
+			throw redirect({
+				to: "/t/$teamId",
+				params: { teamId: await getDefaultTeam() }
+			});
+		}
+		return {
+			mode: "dashboard",
+			auth,
+			initial: {
+				...await fetchLiveData(),
+				templates: await listTemplates()
+			}
+		};
+	},
+	component: lazyRouteComponent($$splitComponentImporter, "component"),
+	errorComponent: lazyRouteComponent($$splitErrorComponentImporter, "errorComponent")
+});
+//#endregion
+export { Route as t };

package/.output/server/_ssr/routes-D4am3Zff.mjs

@@ -0,0 +1,28 @@
+import { C as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { s as useSession } from "./LoopPlaybook-BXH8mhiX.mjs";
+import { t as SignIn } from "./SignIn-dTndU6Hw.mjs";
+import { t as DashboardView } from "./DashboardView-CC7htv28.mjs";
+import { t as Route } from "./routes-BoGrcf-b.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/routes-D4am3Zff.js
+var import_jsx_runtime = require_jsx_runtime();
+/**
+* The home route. Under the auth gate it is now a THIN redirect to the explicit
+* team URL (`/t/<lastUsed|personal>`) so the dashboard's team lives in the path
+* (bookmarkable, multi-tab). `/` keeps working forever: a signed-out visitor gets
+* the sign-in CTA; open mode (no gate ⇒ a single shared workspace with no team to
+* expose in the URL) renders the dashboard right here, unchanged.
+*/
+/** First-load failure screen — a calm retry instead of the router's default
+*  error dump. Only the initial loader can land here; the in-page poll is
+*  fetch-then-set and keeps stale data on a transient blip. */
+/** Open mode renders the dashboard; the gated signed-out case renders SignIn. The
+*  gated signed-in case never reaches here (the loader threw a redirect). */
+function Home() {
+	const loaded = Route.useLoaderData();
+	const { data: session, isPending } = useSession();
+	if (loaded?.auth?.enabled && !isPending && !session) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SignIn, {});
+	if (loaded?.mode === "signin") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SignIn, {});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DashboardView, { initial: loaded.initial });
+}
+//#endregion
+export { Home as component };

package/.output/server/_ssr/runDiff-CpEFqo7G.mjs

@@ -0,0 +1,113 @@
+import { Ft as prevRunSnapshot, V as getArtifactSync, et as getRun, tt as getRunSnapshot } from "./boot-BbtG0ImW.mjs";
+import { t as createTwoFilesPatch } from "../_libs/diff.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/runDiff-CpEFqo7G.js
+/**
+* Per-run artifact diff (Phase 3). Computed lazily on the SERVER at read time
+* (no stored diffs): load run N's snapshot + the previous run's snapshot and diff
+* the two path → metadata maps. For changed TEXT files we load both blobs and
+* compute a unified line diff with `diff` (jsdiff) — a pure-string library, no
+* process execution, so the server's zero-exec invariant holds. Binary/oversize
+* files emit a size-delta marker only (no inline diff).
+*/
+/**
+* Upper bound for computing an inline unified diff. jsdiff is synchronous and
+* roughly O(N*D); on a multi-MB or minified text file it would block the
+* single-process server (which also owns the scheduler) for seconds. Above this
+* a changed text file degrades to the size-delta marker, like binary/oversize.
+*/
+var MAX_DIFF_BYTES = 512 * 1024;
+/** A file is text-diffable only when it has stored bytes and isn't binary/oversize. */
+function isText(e) {
+	return !!e && !e.binary && !e.oversize && !!e.hash;
+}
+/** Within the inline-diff size cap (unknown size ⇒ allowed). */
+function withinDiffCap(e) {
+	return !!e && (e.size == null || e.size <= MAX_DIFF_BYTES);
+}
+/** Decode a snapshot entry's blob to text, or null when bytes are absent. */
+async function textOf(e) {
+	if (!e || !e.hash) return null;
+	const bytes = await (await getArtifactSync()).readBlob(e.hash);
+	return bytes ? bytes.toString("utf8") : null;
+}
+/** Unified diff between two versions of a path (empty string ⇒ added/removed side). */
+function unified(path, oldText, newText) {
+	return createTwoFilesPatch(path, path, oldText, newText, "previous run", "this run");
+}
+async function computeRunDiff(runId) {
+	const run = await getRun(runId);
+	if (!run) return {
+		hasSnapshot: false,
+		files: []
+	};
+	const snap = await getRunSnapshot(runId);
+	if (!snap) return {
+		hasSnapshot: false,
+		files: []
+	};
+	const curr = snap.manifest ?? {};
+	const prev = (await prevRunSnapshot(run.loopId, run.ts))?.manifest ?? {};
+	const paths = [...new Set([...Object.keys(curr), ...Object.keys(prev)])].sort();
+	const files = [];
+	for (const path of paths) {
+		const c = curr[path];
+		const p = prev[path];
+		if (c && !p) {
+			const text = isText(c);
+			const tooLarge = text && !withinDiffCap(c);
+			const file = {
+				path,
+				status: "added",
+				binary: !text,
+				tooLarge,
+				sizeDelta: c.size ?? null
+			};
+			if (text && !tooLarge) {
+				const body = await textOf(c);
+				if (body != null) file.diff = unified(path, "", body);
+				else file.binary = true;
+			}
+			files.push(file);
+		} else if (!c && p) {
+			const text = isText(p);
+			const tooLarge = text && !withinDiffCap(p);
+			const file = {
+				path,
+				status: "removed",
+				binary: !text,
+				tooLarge,
+				sizeDelta: p.size != null ? -p.size : null
+			};
+			if (text && !tooLarge) {
+				const body = await textOf(p);
+				if (body != null) file.diff = unified(path, body, "");
+				else file.binary = true;
+			}
+			files.push(file);
+		} else if (c && p) {
+			if (c.hash === p.hash && c.oversize === p.oversize && c.size === p.size) continue;
+			const sizeDelta = c.size != null && p.size != null ? c.size - p.size : null;
+			const bothText = isText(c) && isText(p);
+			const tooLarge = bothText && !(withinDiffCap(c) && withinDiffCap(p));
+			const file = {
+				path,
+				status: "modified",
+				binary: !bothText,
+				tooLarge,
+				sizeDelta
+			};
+			if (bothText && !tooLarge) {
+				const [oldText, newText] = await Promise.all([textOf(p), textOf(c)]);
+				if (oldText != null && newText != null) file.diff = unified(path, oldText, newText);
+				else file.binary = true;
+			}
+			files.push(file);
+		}
+	}
+	return {
+		hasSnapshot: true,
+		files
+	};
+}
+//#endregion
+export { computeRunDiff };