Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
import { createHash } from "node:crypto";
import { execFileSync } from "node:child_process";
import { realpathSync } from "node:fs";
import { copyFile, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
import { dirname, extname, join, relative, resolve, sep } from "node:path";
import { fileURLToPath } from "node:url";
import { createServer } from "vite";
import { sanitizeNeuformIsolatedEffects, sanitizeSectionElementsCss, sanitizeSectionElementsModule } from "./community-sanitizers.mjs";
const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const sourceRoot = resolve(process.env.THREEUI_SOURCE_ROOT ?? process.argv[2] ?? "");
const canonicalSourceRoot = realpathSync(sourceRoot);
if (!process.env.THREEUI_SOURCE_ROOT && !process.argv[2]) {
throw new Error("Pass the private ThreeUI source snapshot path or set THREEUI_SOURCE_ROOT.");
}
const sourceInventoryPath = join(sourceRoot, "inventory", "source-code.json");
await stat(sourceInventoryPath);
const shellFiles = [
"src/browseTaxonomy.js",
"src/catalogPresentation.js",
"src/detailPreviews.ts",
"src/mediaUrls.js",
"src/routes.js",
"src/seo.js",
"src/styles.css",
"src/theme.ts",
"src/components/BrandMark.tsx",
"src/components/browse-sort-toggle.css",
"src/components/CheckpointSliderControl.tsx",
"src/components/GitHubStars.tsx",
"src/components/InstallationDocumentation.tsx",
"src/components/InstallationSteps.tsx",
"src/components/PreviewFpsMeter.tsx",
"src/components/ShaderTags.tsx",
"src/components/SyntaxHighlightedCode.tsx",
"src/components/ThemeButtons.tsx",
"src/components/buildCopyBundles.js",
"src/components/icons.tsx",
"src/data/catalogResults.ts",
"index.html",
];
// These retain the main project's layout and interaction contracts while applying
// the public-only boundary (no auth, Pro catalog, Beta catalog, or protected APIs).
// Preserve them across syncs instead of replacing them with private-app adapters.
const publicAdapterFiles = [
"src/App.tsx",
"src/main.tsx",
"src/vite-env.d.ts",
"src/components/BrowsePage.tsx",
"src/components/McpDocumentation.tsx",
"src/components/MainContentFooter.tsx",
"src/components/RightRailPromos.tsx",
"src/components/SearchDialog.tsx",
"src/components/ShaderDocumentation.tsx",
"src/components/Sidebar.tsx",
"src/components/UpgradeLink.tsx",
"src/data/publicShaders.ts",
"src/shaderMetrics.ts",
];
const publicRuntimeFiles = [
"public/japanese-tower.html",
"public/threeui-mark.svg",
"public/robots.txt",
];
const generatedRendererPaths = new Set([
"src/shaders/threeui.css",
"src/shaders/globe/GlobeCollection.tsx",
"src/shaders/landing-pages/LandingPages.tsx",
"src/shaders/landing-pages/pageRecipes.ts",
"src/shaders/neuform-isolated/NeuformIsolatedEffects.tsx",
"src/shaders/section-elements/SectionElements.tsx",
"src/shaders/section-elements/section-elements.css",
"src/shaders/sketchbook/sketchbookDocument.js",
"src/shaders/spark-badge/SparkBadge.tsx",
"src/shaders/sylva-living-world/SylvaLivingWorldScene.tsx",
"src/shaders/temple-night/TempleNightScene.tsx",
]);
const excludedAssetPaths = new Set([
"src/shaders/section-elements/assets/sf-bold.woff2",
"src/shaders/section-elements/assets/sf-light.woff2",
"src/shaders/section-elements/assets/sf-medium.woff2",
"src/shaders/section-elements/assets/sf-regular.woff2",
"src/shaders/section-elements/assets/sf-semibold.woff2",
]);
const textExtensions = new Set([".css", ".glsl", ".html", ".js", ".jsx", ".json", ".mjs", ".ts", ".tsx", ".txt"]);
const mediaOrigin = "https://threeui.com";
const publicExcludedParentIds = new Set(["orrery-page"]);
const mixedAccessParentIds = new Set(["energy-orb", "spark-badge", "sylva-hero", "sylva-living-world", "temple-night"]);
function posixPath(value) {
return value.split(sep).join("/");
}
async function copyFromSource(path) {
const from = join(sourceRoot, path);
const to = join(projectRoot, path);
await mkdir(dirname(to), { recursive: true });
await copyFile(from, to);
}
async function writeGenerated(path, contents) {
const target = join(projectRoot, path);
await mkdir(dirname(target), { recursive: true });
await writeFile(target, contents);
}
function publicMediaUrl(value) {
if (typeof value !== "string" || !value) return value;
if (/^https:\/\//.test(value)) return value;
return new URL(value.startsWith("/") ? value : `/${value}`, mediaOrigin).toString();
}
function rendererDescriptor(shader, componentEntry) {
const component = shader.component;
if (!component) throw new Error(`${shader.id} has no renderer component.`);
if (typeof component === "function") {
const path = componentEntry?.files?.find((file) => file.path.endsWith(".tsx"))?.path;
if (!path) throw new Error(`Cannot resolve the eager renderer path for ${shader.id}.`);
return { exportName: shader.importName, path: `/${path}`, eager: true };
}
const loader = String(component?._payload?._result ?? "");
const match = loader.match(/__vite_ssr_dynamic_import__\("([^"]+)"\).*default: module\.([A-Za-z0-9_$]+)/s);
if (!match) throw new Error(`Cannot resolve the lazy renderer for ${shader.id}.`);
let path = match[1];
const fileSystemIndex = path.indexOf("@fs/");
if (fileSystemIndex >= 0) {
const absolutePath = path.slice(fileSystemIndex + 3);
const sourceRelativePath = relative(canonicalSourceRoot, absolutePath);
if (sourceRelativePath.startsWith("..")) throw new Error(`Renderer ${shader.id} resolved outside the source snapshot.`);
path = `/${posixPath(sourceRelativePath)}`;
}
return { exportName: match[2], path, eager: false };
}
function sanitizeMetadata(shader, freeIds, getShaderAccess) {
const value = { ...shader };
delete value.component;
delete value.access;
delete value.status;
if (value.variantAliases) {
value.variantAliases = Object.fromEntries(
Object.entries(value.variantAliases).filter(([alias, id]) => freeIds.has(alias) && freeIds.has(String(id))),
);
if (!Object.keys(value.variantAliases).length) delete value.variantAliases;
}
if (value.variants) {
value.variants = value.variants
.filter((variant) => getShaderAccess(shader, variant) !== "pro")
.map((variant) => {
const next = { ...variant };
delete next.access;
next.thumbnail = publicMediaUrl(next.thumbnail);
next.preview = publicMediaUrl(next.preview);
return next;
});
}
value.thumbnail = publicMediaUrl(value.thumbnail);
if (value.preview) value.preview = publicMediaUrl(value.preview);
const onlyVariant = value.variants?.[0];
if (value.id === "energy-orb") {
value.description = onlyVariant.description;
value.sourceFiles = value.sourceFiles.filter((file) => !/constellation|network-globe/i.test(file));
value.contract = [
{ name: "renderer", type: "fixed", value: "Raw WebGL" },
{ name: "variant", type: "fixed", value: "Energy Orb" },
{ name: "interaction", type: "adaptive", value: "Pointer + visibility" },
{ name: "assets", type: "fixed", value: "None" },
];
value.interaction = "Pointer-responsive energy sphere with visibility-aware animation and customizable motion, scale, palette, and opacity";
value.asset = "No runtime assets";
} else if (value.id === "spark-badge") {
value.asset = "One self-contained authored HTML badge scene; no external assets";
} else if (value.id === "sylva-hero") {
value.description = `The complete Sylva Living Green page, preserved with its Three.js scene, local typography, card imagery, and embedded liquid-metal buttons. ${onlyVariant.description}`;
value.contract = value.contract
.filter((row) => row.name !== "derived")
.map((row) => row.name === "variant" ? { ...row, type: "fixed", value: "Living Green" } : row);
} else if (value.id === "sylva-living-world") {
value.description = onlyVariant.description;
value.contract = value.contract.map((row) => {
if (row.name === "variant") return { ...row, type: "fixed", value: "Living Green" };
if (row.name === "scene") return { ...row, type: "fixed", value: "Moss roots" };
return row;
});
} else if (value.id === "temple-night") {
value.description = onlyVariant.description;
value.contract = value.contract.map((row) => {
if (row.name === "variant") return { ...row, type: "fixed", value: "temple-night" };
if (row.name === "scene") return { ...row, type: "fixed", value: "Procedural Kyoto mountain temple world" };
return row;
});
}
return value;
}
function generateShadersModule(shaders, registryById, getShaderAccess) {
const freeIds = new Set(shaders.map((shader) => String(shader.id)));
const descriptors = new Map();
const rendererNameByShader = new Map();
for (const shader of shaders) {
const descriptor = rendererDescriptor(shader, registryById.get(String(shader.id)) ?? registryById.get(String(shader.variantOf)));
const key = `${descriptor.eager ? "eager" : "lazy"}:${descriptor.path}:${descriptor.exportName}`;
if (!descriptors.has(key)) descriptors.set(key, { ...descriptor, localName: `CommunityRenderer${descriptors.size + 1}` });
rendererNameByShader.set(String(shader.id), descriptors.get(key).localName);
}
const imports = [...descriptors.values()].map(({ eager, exportName, path, localName }) => {
const relativePath = posixPath(relative(join(projectRoot, "src", "data"), join(projectRoot, path.replace(/^\//, ""))));
const specifier = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
return eager
? `import { ${exportName} as ${localName} } from ${JSON.stringify(specifier.replace(/\.(?:tsx?|jsx?)$/, ""))};`
: `const ${localName} = lazy(() => import(${JSON.stringify(specifier.replace(/\.(?:tsx?|jsx?)$/, ""))}).then((module) => ({ default: module.${exportName} })));`;
}).join("\n");
const entries = shaders.map((shader) => {
const metadata = sanitizeMetadata(shader, freeIds, getShaderAccess);
return ` { ...${JSON.stringify(metadata, null, 2).replaceAll("\n", "\n ")}, component: ${rendererNameByShader.get(String(shader.id))} }`;
}).join(",\n");
return `import { lazy, type ComponentType } from "react";
${imports}
export type ContractRow = { name: string; type: string; value: string };
export type RangeControl = { kind?: "range"; key: string; label: string; min: number; max: number; step: number; digits: number; default: number };
export type ChoiceControl = { kind: "choice"; key: string; label: string; options: readonly { value: string; label: string }[]; default: string };
export type CheckpointControl = { kind: "checkpoint"; key: string; label: string; options: readonly { value: string; label: string }[]; default: string };
export type ColorControl = { kind: "color"; key: string; label: string; default: \`#\${string}\` };
export type TextControl = { kind: "text"; key: string; label: string; default: string; maxLength?: number; placeholder?: string };
export type ShaderControl = RangeControl | ChoiceControl | CheckpointControl | ColorControl | TextControl;
export type ShaderVariant = { id: string; label: string; description: string; thumbnail: string; preview: string; props: Readonly<Record<string, boolean | number | string>>; controls?: readonly ShaderControl[] };
export const READY_SHADER_CATEGORIES = ["Landing Pages", "Hero", "Three.js", "Motion Design", "Sections", "Backgrounds", "Buttons", "Text Animation", "UI Elements", "CSS"] as const;
export type ReadyShaderCategory = (typeof READY_SHADER_CATEGORIES)[number];
export type ReadyShader = {
id: string;
variantOf?: string;
variantAliases?: Readonly<Record<string, string>>;
category: ReadyShaderCategory;
label: string;
thumbnail: string;
preview?: string;
tags: readonly string[];
description: string;
runtime: string;
component?: ComponentType<any>;
origin: string;
sourceCommit: string;
sourceFiles: string[];
passes: string;
interaction: string;
asset: string;
assetCount: number;
importName: string;
contract: readonly ContractRow[];
controls?: readonly ShaderControl[];
variants?: readonly ShaderVariant[];
};
export function getShaderAccess() { return undefined; }
export const READY_SHADERS: readonly ReadyShader[] = [
${entries}
];
export const VISIBLE_READY_SHADERS = READY_SHADERS.filter((shader) => !shader.variantOf);
export const READY_SHADER_COLLECTION_COUNT = VISIBLE_READY_SHADERS.reduce((total, shader) => total + (shader.variants?.length || 1), 0);
export function getReadyShader(id: string): ReadyShader { return READY_SHADERS.find((shader) => shader.id === id) ?? READY_SHADERS[0]; }
`;
}
function generatePageRecipes(recipeModule) {
const names = ["KAGE_TYPOGRAPHY", "SYLVA_TYPOGRAPHY", "COMPLETE_SHELF_TYPOGRAPHY", "BESTSELLERS_TYPOGRAPHY"];
const recipes = names.map((name) => {
const recipe = recipeModule[name];
if (!recipe) throw new Error(`Missing ${name}.`);
return `export const ${name}: PageTypographyRecipe = ${JSON.stringify({ ...recipe, css: undefined }, null, 2).replace(/,?\n "css": undefined/, "").replace(/\n}$/, `,\n css: ${String(recipe.css)}\n}`)};`;
});
return `import type { PageTypographyRecipe } from "./pageTypography";
const n = (value: number) => Number(value.toFixed(3));
const px = (value: number) => \`\${n(value)}px\`;
const unit = (value: number) => \`calc(\${n(value)} * var(--u))\`;
function withAlpha(hex: string, alpha: number) {
const [red, green, blue] = [1, 3, 5].map((index) => Number.parseInt(hex.slice(index, index + 2), 16));
return \`rgba(\${red}, \${green}, \${blue}, \${alpha})\`;
}
${recipes.join("\n\n")}
`;
}
function generateLandingPagesModule() {
return `import { useEffect, useRef, useState, type CSSProperties } from "react";
import { applyPageCustomization, splitTypographyProps, usePageTypography, type LandingPageCustomization, type PageTypographyProps } from "./pageTypography";
import { BESTSELLERS_TYPOGRAPHY, COMPLETE_SHELF_TYPOGRAPHY, KAGE_TYPOGRAPHY, SYLVA_TYPOGRAPHY } from "./pageRecipes";
export type LandingPageFrameProps = { className?: string; sourceUrl: string; srcDoc?: string; style?: CSSProperties; title: string; customization?: LandingPageCustomization };
export type LandingPageProps = Omit<LandingPageFrameProps, "sourceUrl" | "title" | "customization">;
const FRAME_SANDBOX = "allow-downloads allow-forms allow-modals allow-popups allow-same-origin allow-scripts";
export function LandingPageFrame({ className = "", customization, sourceUrl, srcDoc, style, title }: LandingPageFrameProps) {
const [ready, setReady] = useState(false);
const frameRef = useRef<HTMLIFrameElement>(null);
useEffect(() => { applyPageCustomization(frameRef.current, customization); }, [customization]);
return <div className={\`threeui-background landing-page-frame\${className ? \` \${className}\` : ""}\`} data-state={ready ? "ready" : "loading"} style={{ position: "relative", overflow: "hidden", background: "#080808", pointerEvents: "auto", ...style }}>
<iframe ref={frameRef} title={title} {...(srcDoc ? { srcDoc } : { src: sourceUrl })} sandbox={FRAME_SANDBOX} loading="eager" onLoad={(event) => { applyPageCustomization(event.currentTarget, customization); setReady(true); }} style={{ position: "absolute", inset: 0, display: "block", width: "100%", height: "100%", border: 0, background: "#080808" }} />
</div>;
}
function TypographyPage({ recipe, title, sourceUrl, ...props }: LandingPageProps & PageTypographyProps & { recipe: typeof KAGE_TYPOGRAPHY; title: string; sourceUrl: string }) {
const [type, frame] = splitTypographyProps(props);
const customization = usePageTypography(recipe, type);
return <LandingPageFrame {...frame} customization={customization} title={title} sourceUrl={sourceUrl} />;
}
export function KageLandingPage(props: LandingPageProps & PageTypographyProps) { return <TypographyPage {...props} recipe={KAGE_TYPOGRAPHY} title="Kage — Where stillness reveals the unseen" sourceUrl="/landing-pages/kage.html" />; }
export function CompleteShelfLandingPage(props: LandingPageProps & PageTypographyProps) { return <TypographyPage {...props} recipe={COMPLETE_SHELF_TYPOGRAPHY} title="Working Volumes — Seven Tools for Making" sourceUrl="/landing-pages/complete-shelf-v2.html" />; }
export function BestsellersBookShowcase(props: LandingPageProps & PageTypographyProps) { return <TypographyPage {...props} recipe={BESTSELLERS_TYPOGRAPHY} title="Field Manuals — Tools for Thought" sourceUrl="/landing-pages/bestsellers-book-showcase.html" />; }
export function MengToSketchbookLandingPage(props: LandingPageProps) { return <LandingPageFrame {...props} title="Meng To — Singapore Sketchbook" sourceUrl="/landing-pages/meng-to-sketchbook.html" />; }
export function SylvaHero(props: LandingPageProps & PageTypographyProps) { return <TypographyPage {...props} recipe={SYLVA_TYPOGRAPHY} title="Sylva — Into the living world" sourceUrl="/landing-pages/inner-green-3d.html" />; }
`;
}
function generateGlobeCollectionModule() {
return `import { lazy, Suspense } from "react";
import type { EnergyOrbProps } from "../energy-orb/EnergyOrb";
export type GlobeVariant = "energy-orb";
export type GlobeCollectionProps = EnergyOrbProps & { variant?: "energy-orb" };
const EnergyOrbVariant = lazy(() => import("../energy-orb/EnergyOrb").then((module) => ({ default: module.EnergyOrb })));
export function GlobeCollection({ variant: _variant, ...props }: GlobeCollectionProps) {
return <Suspense fallback={<div className="threeui-background energy-orb" style={{ background: "#05030e" }} />}><EnergyOrbVariant {...props} /></Suspense>;
}
`;
}
function generateSparkBadgeModule() {
return `import { useEffect, useRef, useState } from "react";
export type SparkBadgeVariant = "badge";
export type SparkBadgeProps = { className?: string; sourceUrl?: string; variant?: SparkBadgeVariant };
export function SparkBadge({ className = "", sourceUrl = "/spark-badge.html" }: SparkBadgeProps) {
const hostRef = useRef<HTMLDivElement>(null); const intersectsRef = useRef(true); const [mounted, setMounted] = useState(true); const [ready, setReady] = useState(false);
useEffect(() => { const host = hostRef.current; if (!host) return; const sync = () => setMounted(intersectsRef.current && document.visibilityState !== "hidden"); const observer = new IntersectionObserver(([entry]) => { intersectsRef.current = entry.isIntersecting; sync(); }, { rootMargin: "80px" }); observer.observe(host); document.addEventListener("visibilitychange", sync); return () => { observer.disconnect(); document.removeEventListener("visibilitychange", sync); }; }, []);
useEffect(() => { if (!mounted) setReady(false); }, [mounted]);
return <div ref={hostRef} className={\`spark-badge\${className ? \` \${className}\` : ""}\`} data-state={!mounted ? "paused" : ready ? "ready" : "loading"} data-variant="badge">{mounted ? <iframe className={\`spark-badge__frame\${ready ? " is-ready" : ""}\`} title="Animated credential badge in rain" src={sourceUrl} sandbox="allow-scripts" loading="eager" onLoad={() => setReady(true)} /> : null}</div>;
}
`;
}
function generateTempleNightModule() {
return `import { useEffect, useRef, useState } from "react";
import { createTempleNightRenderer } from "./templeNightRenderer.js";
export type TempleNightVariant = "temple-night";
export type TempleNightSceneProps = { className?: string; variant?: TempleNightVariant };
export function TempleNightScene({ className = "" }: TempleNightSceneProps) {
const hostRef = useRef<HTMLDivElement>(null); const canvasRef = useRef<HTMLCanvasElement>(null); const [state, setState] = useState<"loading" | "ready" | "unavailable">("loading"); const [errorMessage, setErrorMessage] = useState("");
useEffect(() => { const host = hostRef.current; const canvas = canvasRef.current; if (!host || !canvas) return; let renderer; try { renderer = createTempleNightRenderer(canvas); } catch (error) { setErrorMessage(error instanceof Error ? error.message : "Unknown renderer error"); setState("unavailable"); return; } if (!renderer) { setState("unavailable"); return; } let frame = 0; let visible = true; let disposed = false; let rendered = false; const schedule = () => { if (!disposed && visible && !document.hidden && !frame) frame = requestAnimationFrame(render); }; const render = (time: number) => { frame = 0; renderer.render(time); if (!rendered) { rendered = true; setState("ready"); } if (!renderer.reducedMotion) schedule(); }; const resize = () => { renderer.resize(); schedule(); }; const setPointer = (event: PointerEvent) => { const bounds = canvas.getBoundingClientRect(); renderer.setPointer(((event.clientX - bounds.left) / Math.max(1, bounds.width)) * 2 - 1, 1 - ((event.clientY - bounds.top) / Math.max(1, bounds.height)) * 2, true); schedule(); }; const clearPointer = () => { renderer.setPointer(0, 0, false); schedule(); }; const onVisibility = () => { if (document.hidden && frame) { cancelAnimationFrame(frame); frame = 0; } else schedule(); }; const resizeObserver = new ResizeObserver(resize); resizeObserver.observe(host); const intersectionObserver = new IntersectionObserver(([entry]) => { visible = entry?.isIntersecting ?? true; if (!visible && frame) { cancelAnimationFrame(frame); frame = 0; } else schedule(); }); intersectionObserver.observe(host); canvas.addEventListener("pointermove", setPointer, { passive: true }); canvas.addEventListener("pointerenter", setPointer, { passive: true }); canvas.addEventListener("pointerleave", clearPointer, { passive: true }); window.addEventListener("blur", clearPointer); document.addEventListener("visibilitychange", onVisibility); resize(); return () => { disposed = true; if (frame) cancelAnimationFrame(frame); resizeObserver.disconnect(); intersectionObserver.disconnect(); canvas.removeEventListener("pointermove", setPointer); canvas.removeEventListener("pointerenter", setPointer); canvas.removeEventListener("pointerleave", clearPointer); window.removeEventListener("blur", clearPointer); document.removeEventListener("visibilitychange", onVisibility); renderer.dispose(); }; }, []);
return <div className={\`temple-night-scene\${className ? \` \${className}\` : ""}\`} ref={hostRef} data-state={state}><canvas ref={canvasRef} className={\`temple-night-canvas\${state === "ready" ? " is-ready" : ""}\`} aria-label="Interactive Kage mountain temple world after dark" />{state === "unavailable" ? <p className="temple-night-unavailable" role="status">WebGL is unavailable: {errorMessage || "unsupported context"}.</p> : null}</div>;
}
`;
}
function generateSylvaLivingWorldModule() {
return `import { useEffect, useMemo, useRef, useState, type CSSProperties } from "react";
import innerGreenSource from "./sources/inner-green-3d.html?raw";
import threeRuntime from "./sources/inner-green-assets/three.min.js?raw";
export const SYLVA_LIVING_WORLD_VARIANTS = ["living-green"] as const;
export type SylvaLivingWorldVariant = "living-green";
export type SylvaLivingWorldSceneProps = { variant?: SylvaLivingWorldVariant; className?: string; style?: CSSProperties };
const SCENE_ONLY_MARKUP = \`<main class="hero" id="hero"><canvas id="scene" role="img" aria-label="Sylva Living Green"></canvas><div class="stage" id="stage" aria-hidden="true"></div></main>\`;
const SCENE_ONLY_STYLE = \`<style data-threeui-sylva-scene>html,body{width:100%!important;height:100%!important;min-height:0!important;margin:0!important;overflow:hidden!important}body{position:relative!important;background:#4a4d44!important}.hero{height:100%!important;min-height:0!important}#scene{pointer-events:auto!important}</style>\`;
function buildSceneDocument(reducedMotion: boolean) { const presentationStart = innerGreenSource.indexOf('<main class="hero" id="hero">'); const runtimeStart = innerGreenSource.indexOf('<script src="inner-green-assets/three.min.js"></script>'); if (presentationStart < 0 || runtimeStart < 0 || runtimeStart <= presentationStart) throw new Error("Sylva scene adapter could not isolate the authored Three.js scene."); let source = \`\${innerGreenSource.slice(0, presentationStart)}\${SCENE_ONLY_MARKUP}\n\n\${innerGreenSource.slice(runtimeStart)}\`.replace("</head>", \`\${SCENE_ONLY_STYLE}</head>\`).replace('<script src="inner-green-assets/three.min.js"></script>', \`<script data-threeui-three-runtime>\${threeRuntime}</script>\`); if (reducedMotion) source = source.replace("(function loop() { requestAnimationFrame(loop); tick(); })();", "(function loop() { if (!REDUCED) requestAnimationFrame(loop); tick(); })();"); return source; }
export function SylvaLivingWorldScene({ className = "", style }: SylvaLivingWorldSceneProps) { const hostRef = useRef<HTMLDivElement>(null); const [hostVisible, setHostVisible] = useState(true); const [documentVisible, setDocumentVisible] = useState(() => typeof document === "undefined" || !document.hidden); const [reducedMotion, setReducedMotion] = useState(() => typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches); const [ready, setReady] = useState(false); useEffect(() => { const host = hostRef.current; if (!host || typeof IntersectionObserver === "undefined") return; const observer = new IntersectionObserver(([entry]) => setHostVisible(entry?.isIntersecting ?? true)); observer.observe(host); return () => observer.disconnect(); }, []); useEffect(() => { if (typeof document === "undefined") return; const update = () => setDocumentVisible(!document.hidden); document.addEventListener("visibilitychange", update); return () => document.removeEventListener("visibilitychange", update); }, []); useEffect(() => { const media = window.matchMedia("(prefers-reduced-motion: reduce)"); const update = () => setReducedMotion(media.matches); media.addEventListener("change", update); return () => media.removeEventListener("change", update); }, []); const source = useMemo(() => buildSceneDocument(reducedMotion), [reducedMotion]); const mounted = hostVisible && documentVisible; useEffect(() => setReady(false), [mounted, reducedMotion]); return <div ref={hostRef} className={\`threeui-background sylva-living-world-scene\${className ? \` \${className}\` : ""}\`} role="img" aria-label="Sylva Living Green with ferns, flowers, pollen, and a butterfly" data-variant="living-green" data-state={ready ? "ready" : "loading"} style={{ background: "#4a4d44", pointerEvents: "auto", ...style }}>{mounted ? <iframe key={reducedMotion ? "reduced" : "motion"} title="Sylva Living Green" srcDoc={source} sandbox="allow-scripts" loading="eager" onLoad={() => setReady(true)} style={{ position: "absolute", inset: 0, display: "block", width: "100%", height: "100%", border: 0, background: "#4a4d44" }} /> : null}</div>; }
`;
}
function sanitizeSparkBadgeHtml(source) {
const replaceBetween = (value, start, end, replacement = "") => {
const from = value.indexOf(start);
const to = value.indexOf(end, from + start.length);
if (from < 0 || to < 0) throw new Error(`Could not isolate Spark Badge source between ${start} and ${end}.`);
return `${value.slice(0, from)}${replacement}${value.slice(to)}`;
};
const variantStart = "const params = new URLSearchParams(location.search);";
const variantEnd = "const runtimeControls = {";
let result = replaceBetween(source, variantStart, variantEnd, "const sceneVariant = 'badge';\n");
const silhouetteStart = " if (sceneVariant === 'browser') {";
const badgeBranchStart = " } else {\n /* ---- lanyard";
const silhouetteEnd = "\n }\n\n // snapshot the un-carved silhouette for rain occlusion";
const silhouetteFrom = result.indexOf(silhouetteStart);
const badgeFrom = result.indexOf(badgeBranchStart, silhouetteFrom + silhouetteStart.length);
const silhouetteTo = result.indexOf(silhouetteEnd, badgeFrom + badgeBranchStart.length);
if (silhouetteFrom < 0 || badgeFrom < 0 || silhouetteTo < 0) {
throw new Error("Could not isolate the Spark Badge Community silhouette.");
}
const badgeBody = result.slice(badgeFrom + " } else {\n".length, silhouetteTo);
result = `${result.slice(0, silhouetteFrom)}${badgeBody}${result.slice(silhouetteTo + "\n }".length)}`;
result = replaceBetween(result, " if (sceneVariant === 'browser') {", "\n if (sceneVariant === 'iphone') {");
result = replaceBetween(result, " if (sceneVariant === 'iphone') {", "\n if (sceneVariant === 'studio-display') {");
result = replaceBetween(result, " if (sceneVariant === 'studio-display') {", "\n tilt(gm); tilt(ge);");
for (const forbidden of ["requestedVariant", "sceneVariant ===", "studio-display", "iPhone", "browser chrome"]) {
if (result.includes(forbidden)) throw new Error(`Spark Badge sanitization retained ${forbidden}.`);
}
return result;
}
function generateCommunityStyles(source, freeIds) {
const sliceBetween = (start, end) => {
const from = source.indexOf(start);
const to = source.indexOf(end, from + start.length);
if (from < 0 || to < 0) throw new Error(`Could not isolate Community styles between ${start} and ${end}.`);
return source.slice(from, to).trim();
};
const firstOpen = source.indexOf("{");
const firstClose = source.indexOf("}", firstOpen + 1);
if (firstOpen < 0 || firstClose < 0) throw new Error("Could not read the shared renderer sizing rule.");
const sharedSizing = source.slice(firstOpen, firstClose + 1);
const communityRoots = [
".threeui-mount",
".text-path-study",
".article-headings-component",
".animated-top-dock-component",
".typography-vortex-component",
".landscape-scene",
".japanese-tower-landscape",
".liquid-metal-button",
".spark-badge",
".threeui-background",
];
if (freeIds.has("hypnotic-loops")) communityRoots.push(".hypnotic-loops");
if (freeIds.has("at-the-horizon")) communityRoots.push(".at-the-horizon");
const communityOnly = [
`${communityRoots.join(",\n")} ${sharedSizing}`,
sliceBetween(".japanese-tower-landscape {", ".sakura-branch-scene {"),
sliceBetween(".liquid-metal-button {", ".iso-mail-lightshafts {"),
sliceBetween(".spark-badge {", ".hypnotic-loops {"),
...(freeIds.has("hypnotic-loops") ? [sliceBetween(".hypnotic-loops {", ".at-the-horizon {")] : []),
...(freeIds.has("at-the-horizon") ? [sliceBetween(".at-the-horizon {", ".scalability-bricks {")] : []),
sliceBetween(".text-path-study {", ".cross-beam-canvas,"),
sliceBetween(".temple-night-scene,", ".yosemite-sunset-scene,"),
sliceBetween(".bookshelf,", "@font-face {"),
source.slice(source.indexOf("@font-face {")).trim(),
].join("\n\n");
const forbidden = [
"mechanical-keyboard",
"sakura-branch-scene",
"isometric-motion-grid",
"isometric-charging-dock",
"tetrahedron-365",
"iso-mail-lightshafts",
"scalability-bricks",
"terrain-plume",
"sunset-valley",
"yosemite-sunset",
"presidio-sunset",
"lake-louise",
...(freeIds.has("hypnotic-loops") ? [] : ["hypnotic-loops"]),
...(freeIds.has("at-the-horizon") ? [] : ["at-the-horizon"]),
];
for (const selector of forbidden) {
if (communityOnly.includes(selector)) throw new Error(`Community renderer CSS retained ${selector}.`);
}
return `/* Generated from the main renderer stylesheet; Community selectors only. */\n${communityOnly}\n`;
}
function generateSkillMarkdownModule(skillById) {
return `const SKILLS = ${JSON.stringify(Object.fromEntries(skillById), null, 2)};\nexport function buildSkillMarkdown(shader) { const skill = SKILLS[shader.id]; if (!skill) throw new Error(\`No standalone implementation guide exists for \${shader.id}.\`); return skill; }\n`;
}
function fallbackSkillMarkdown(shader) {
const sourceFiles = shader.sourceFiles.map((file) => `- \`${file}\``).join("\n");
return `---\nname: add-${shader.id}\ndescription: ${JSON.stringify(`Build ${shader.label} from its verified Community source with the complete renderer, interactions, controls, and required assets.`)}\n---\n\n# Build ${shader.label}\n\n${shader.description}\n\n## Verified source material\n\n${sourceFiles}\n\nSource revision: \`${shader.sourceCommit}\`\n\n## Requirements\n\n- Preserve the complete ${shader.runtime} renderer and every published Community option.\n- Preserve its interaction contract: ${shader.interaction}.\n- Preserve its assets: ${shader.asset}.\n- Verify resize, mobile, reduced motion, visibility, teardown, and console health.\n`;
}
async function fileRecord(path, original) {
const absolute = join(projectRoot, path);
const code = await readFile(absolute, "utf8");
return {
path,
language: original?.language ?? (extname(path).slice(1) || "text"),
role: original?.role ?? "source",
bytes: Buffer.byteLength(code),
lines: code.split("\n").length,
sha256: createHash("sha256").update(code).digest("hex"),
code,
};
}
async function readJsonIfPresent(path) {
try {
return JSON.parse(await readFile(path, "utf8"));
} catch (error) {
if (error?.code === "ENOENT") return undefined;
throw error;
}
}
function sourceRevision() {
try {
return execFileSync("git", ["-C", sourceRoot, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
} catch {
return "working-tree";
}
}
function withoutGeneratedAt(value) {
if (!value) return value;
const clone = structuredClone(value);
delete clone.generatedAt;
return clone;
}
function withoutSyncMetadata(value) {
const clone = withoutGeneratedAt(value);
if (clone) delete clone.sourceCommit;
return clone;
}
function hasProjectChangesOutsideSyncReport() {
const status = execFileSync(
"git",
["-C", projectRoot, "status", "--porcelain=v1", "--untracked-files=all", "--", ".", ":(exclude)public/community-sync-report.json"],
{ encoding: "utf8" },
);
return status.trim().length > 0;
}
const inventory = JSON.parse(await readFile(sourceInventoryPath, "utf8"));
const registryById = new Map(inventory.components.map((component) => [String(component.id), component]));
const previousSourceRegistry = await readJsonIfPresent(join(projectRoot, "public", "source-code.json"));
const previousSyncReport = await readJsonIfPresent(join(projectRoot, "public", "community-sync-report.json"));
const vite = await createServer({ root: sourceRoot, server: { middlewareMode: true }, appType: "custom", logLevel: "silent" });
let shaderModule;
let recipeModule;
let skillModule;
try {
shaderModule = await vite.ssrLoadModule("/src/data/shaders.tsx");
recipeModule = await vite.ssrLoadModule("/src/shaders/landing-pages/pageRecipes.ts");
skillModule = await vite.ssrLoadModule("/src/components/buildSkillMarkdown.js");
} finally {
await vite.close();
}
const freeShaders = shaderModule.READY_SHADERS.filter((shader) => (
shader.status !== "beta"
&& shaderModule.getShaderAccess(shader) !== "pro"
&& !publicExcludedParentIds.has(String(shader.id))
&& !publicExcludedParentIds.has(String(shader.variantOf))
));
const visibleFreeShaders = freeShaders.filter((shader) => !shader.variantOf);
const freeIds = new Set(freeShaders.map((shader) => String(shader.id)));
const publicAdapters = new Map();
for (const path of publicAdapterFiles) {
publicAdapters.set(path, await readFile(join(projectRoot, path), "utf8"));
}
await rm(join(projectRoot, "src"), { recursive: true, force: true });
await rm(join(projectRoot, "public"), { recursive: true, force: true });
await mkdir(join(projectRoot, "src", "data"), { recursive: true });
await mkdir(join(projectRoot, "public"), { recursive: true });
for (const path of shellFiles) await copyFromSource(path);
for (const [path, contents] of publicAdapters) await writeGenerated(path, contents);
for (const path of publicRuntimeFiles) await copyFromSource(path);
if (freeIds.has("hypnotic-loops")) await copyFromSource("public/hypnotic-loops.html");
const componentPaths = new Set();
const assetPaths = new Set();
for (const shader of freeShaders) {
const component = registryById.get(String(shader.id)) ?? registryById.get(String(shader.variantOf));
if (!component) throw new Error(`Missing source inventory for ${shader.id}.`);
for (const file of component.files ?? []) componentPaths.add(file.path);
for (const asset of component.assets ?? []) assetPaths.add(asset.path);
}
for (const path of componentPaths) {
if (generatedRendererPaths.has(path)) continue;
if (path === "src/shaders/globe/sources/network-globe.html" || path === "src/shaders/globe/sources/tangled-constellations.html") continue;
await copyFromSource(path);
}
for (const path of assetPaths) {
if (!excludedAssetPaths.has(path)) await copyFromSource(path);
}
await writeGenerated("src/data/shaders.tsx", generateShadersModule(freeShaders, registryById, shaderModule.getShaderAccess));
const mainSidebarSource = await readFile(join(sourceRoot, "src/components/Sidebar.tsx"), "utf8");
const newestBlock = mainSidebarSource.match(/const NEWEST_SHADER_IDS = \[([\s\S]*?)\] as const/)?.[1];
if (!newestBlock) throw new Error("Could not read the main sidebar ordering.");
const publicParentIds = new Set(visibleFreeShaders.map((shader) => String(shader.id)));
const communityNewestIds = [...newestBlock.matchAll(/"([^"]+)"/g)].map((match) => match[1]).filter((id) => publicParentIds.has(id));
await writeGenerated(
"src/data/communityOrder.ts",
`// Updated by scripts/sync-community-from-main.mjs.\nexport const COMMUNITY_NEWEST_SHADER_IDS = ${JSON.stringify(communityNewestIds, null, 2)} as const;\n`,
);
await writeGenerated(
"src/data/mainCatalogSummary.ts",
`// Updated by scripts/sync-community-from-main.mjs.\nexport const FULL_THREEUI_COLLECTION_COUNT = ${shaderModule.VISIBLE_READY_SHADERS.filter((shader) => shader.status !== "beta").reduce((total, shader) => total + (shader.variants?.length || 1), 0)};\n`,
);
await writeGenerated("src/shaders/landing-pages/pageRecipes.ts", generatePageRecipes(recipeModule));
await writeGenerated("src/shaders/landing-pages/LandingPages.tsx", generateLandingPagesModule());
await writeGenerated("src/shaders/globe/GlobeCollection.tsx", generateGlobeCollectionModule());
await writeGenerated(
"src/shaders/community.css",
generateCommunityStyles(await readFile(join(sourceRoot, "src/shaders/threeui.css"), "utf8"), freeIds),
);
await writeGenerated(
"src/shaders/neuform-isolated/NeuformIsolatedEffects.tsx",
sanitizeNeuformIsolatedEffects(await readFile(join(sourceRoot, "src/shaders/neuform-isolated/NeuformIsolatedEffects.tsx"), "utf8")),
);
await writeGenerated(
"src/shaders/section-elements/SectionElements.tsx",
sanitizeSectionElementsModule(await readFile(join(sourceRoot, "src/shaders/section-elements/SectionElements.tsx"), "utf8")),
);
await writeGenerated(
"src/shaders/section-elements/section-elements.css",
sanitizeSectionElementsCss(await readFile(join(sourceRoot, "src/shaders/section-elements/section-elements.css"), "utf8")),
);
await writeGenerated(
"src/shaders/sketchbook/sketchbookDocument.js",
(await readFile(join(sourceRoot, "src/shaders/sketchbook/sketchbookDocument.js"), "utf8"))
.replace(/\/\* Canonical source: .* \*\//, "/* Canonical source: public/landing-pages/meng-to-sketchbook.html */"),
);
await writeGenerated("src/shaders/spark-badge/SparkBadge.tsx", generateSparkBadgeModule());
await writeGenerated("src/shaders/temple-night/TempleNightScene.tsx", generateTempleNightModule());
await writeGenerated("src/shaders/sylva-living-world/SylvaLivingWorldScene.tsx", generateSylvaLivingWorldModule());
const sparkHtml = sanitizeSparkBadgeHtml(await readFile(join(sourceRoot, "public", "spark-badge.html"), "utf8"));
await writeFile(join(projectRoot, "public", "spark-badge.html"), sparkHtml);
const skillById = new Map(visibleFreeShaders.map((shader) => {
const publicShader = sanitizeMetadata(shader, freeIds, shaderModule.getShaderAccess);
if (mixedAccessParentIds.has(String(shader.id))) return [String(shader.id), fallbackSkillMarkdown(publicShader)];
try {
return [String(shader.id), skillModule.buildSkillMarkdown(shader)];
} catch {
return [String(shader.id), fallbackSkillMarkdown(publicShader)];
}
}));
await writeFile(join(projectRoot, "src", "components", "buildSkillMarkdown.js"), generateSkillMarkdownModule(skillById));
const pathUseCount = new Map();
const componentPathsById = new Map();
const publicSourcePath = (path) => path === "src/shaders/threeui.css" ? "src/shaders/community.css" : path;
for (const shader of visibleFreeShaders) {
const component = registryById.get(String(shader.id));
const paths = [
...(component?.files ?? []).map((file) => file.path),
...(component?.sharedFilePaths ?? []),
].map(publicSourcePath).filter((path) => {
if (path === "src/shaders/globe/sources/network-globe.html" || path === "src/shaders/globe/sources/tangled-constellations.html") return false;
return textExtensions.has(extname(path));
});
componentPathsById.set(String(shader.id), paths);
for (const path of new Set(paths)) pathUseCount.set(path, (pathUseCount.get(path) ?? 0) + 1);
}
const sharedPaths = new Set([...pathUseCount].filter(([, count]) => count > 1).map(([path]) => path));
const originalFileByPath = new Map([
...(inventory.sharedFiles ?? []),
...inventory.components.flatMap((component) => component.files ?? []),
].map((file) => [publicSourcePath(file.path), file]));
const sharedFiles = await Promise.all([...sharedPaths].sort().map((path) => fileRecord(path, originalFileByPath.get(path))));
const sourceComponents = [];
for (const shader of visibleFreeShaders) {
const original = registryById.get(String(shader.id));
const paths = componentPathsById.get(String(shader.id));
const files = await Promise.all(paths.filter((path) => !sharedPaths.has(path)).map((path) => fileRecord(path, originalFileByPath.get(path))));
sourceComponents.push({
id: String(shader.id),
exportName: shader.importName,
sourceCommit: shader.sourceCommit,
runtime: shader.runtime,
sharedFilePaths: paths.filter((path) => sharedPaths.has(path)),
files,
assets: (original?.assets ?? []).filter((asset) => !excludedAssetPaths.has(asset.path)).map((asset) => ({ ...asset })),
});
}
const sourceRegistry = { schemaVersion: 1, generatedAt: new Date().toISOString(), readyIds: visibleFreeShaders.map((shader) => String(shader.id)), sharedFiles, components: sourceComponents };
if (previousSourceRegistry && JSON.stringify(withoutGeneratedAt(previousSourceRegistry)) === JSON.stringify(withoutGeneratedAt(sourceRegistry))) {
sourceRegistry.generatedAt = previousSourceRegistry.generatedAt;
}
await writeFile(join(projectRoot, "public", "source-code.json"), `${JSON.stringify(sourceRegistry, null, 2)}\n`);
const syncReport = {
schemaVersion: 1,
generatedAt: new Date().toISOString(),
sourceCommit: sourceRevision(),
communityParents: visibleFreeShaders.length,
communityRoutes: freeShaders.length,
communityVariants: visibleFreeShaders.reduce((total, shader) => total + (shader.variants?.filter((variant) => shaderModule.getShaderAccess(shader, variant) !== "pro").length || 0), 0),
excludedProParents: shaderModule.VISIBLE_READY_SHADERS.filter((shader) => shaderModule.getShaderAccess(shader) === "pro").length,
excludedBetaParents: shaderModule.VISIBLE_READY_SHADERS.filter((shader) => shader.status === "beta").length,
layoutStylesSha256: createHash("sha256").update(await readFile(join(projectRoot, "src", "styles.css"))).digest("hex"),
rendererStylesSha256: createHash("sha256").update(await readFile(join(projectRoot, "src", "shaders", "community.css"))).digest("hex"),
components: visibleFreeShaders.map((shader) => {
const variants = (shader.variants ?? []).filter((variant) => shaderModule.getShaderAccess(shader, variant) !== "pro");
return {
id: String(shader.id),
variantIds: variants.map((variant) => String(variant.id)),
controlKeys: (shader.controls ?? []).map((control) => String(control.key)),
variantControlKeys: Object.fromEntries(
variants.map((variant) => [String(variant.id), (variant.controls ?? []).map((control) => String(control.key))]),
),
};
}),
};
if (
previousSyncReport
&& !hasProjectChangesOutsideSyncReport()
&& JSON.stringify(withoutSyncMetadata(previousSyncReport)) === JSON.stringify(withoutSyncMetadata(syncReport))
) {
syncReport.generatedAt = previousSyncReport.generatedAt;
syncReport.sourceCommit = previousSyncReport.sourceCommit;
}
await writeFile(join(projectRoot, "public", "community-sync-report.json"), `${JSON.stringify(syncReport, null, 2)}\n`);
console.log(`Synced ${syncReport.communityParents} Community parents, ${syncReport.communityRoutes} routes, and ${syncReport.communityVariants} free variants from the main project.`);