@homepages/template-kit 0.9.0-dev-20260719224319 → 0.9.0

package/dist/cli/dev/tsconfig-paths-plugin.js

@@ -1,90 +0,0 @@
-import { resolveFromWorkspace } from "../check/resolve-tool.js";
-import { isAbsolute, join, resolve } from "node:path";
-import { existsSync, statSync } from "node:fs";
-
-//#region src/cli/dev/tsconfig-paths-plugin.ts
-const RESOLVE_EXTENSIONS = [
-	"",
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	".mjs",
-	".cjs",
-	".json"
-];
-function toPattern(key, targets, baseUrl) {
-	const star = key.indexOf("*");
-	const hasWildcard = star !== -1;
-	return {
-		prefix: hasWildcard ? key.slice(0, star) : key,
-		suffix: hasWildcard ? key.slice(star + 1) : "",
-		hasWildcard,
-		targets: targets.map((target) => isAbsolute(target) ? target : join(baseUrl, target))
-	};
-}
-/** The wildcard capture for a match, `""` for a wildcard-free exact match, or `undefined` when `specifier` doesn't match. */
-function matchPattern(pattern, specifier) {
-	if (!pattern.hasWildcard) return specifier === pattern.prefix ? "" : void 0;
-	if (!specifier.startsWith(pattern.prefix) || !specifier.endsWith(pattern.suffix)) return void 0;
-	return specifier.slice(pattern.prefix.length, specifier.length - pattern.suffix.length);
-}
-function isFile(path) {
-	try {
-		return existsSync(path) && statSync(path).isFile();
-	} catch {
-		return false;
-	}
-}
-/** `candidate` resolved as tsc would: itself, itself with a resolvable extension, or a directory index. */
-function resolveCandidate(candidate) {
-	for (const ext of RESOLVE_EXTENSIONS) {
-		const withExt = candidate + ext;
-		if (isFile(withExt)) return withExt;
-	}
-	for (const ext of RESOLVE_EXTENSIONS.slice(1)) {
-		const indexFile = join(candidate, `index${ext}`);
-		if (isFile(indexFile)) return indexFile;
-	}
-}
-/**
-* Builds a Vite `resolveId` plugin from `root`'s tsconfig `paths`, or returns
-* `null` when the workspace has none configured, or its tsconfig/`typescript`
-* can't be read at all — `check` already owns reporting a broken tsconfig
-* cleanly; `dev` degrades to its pre-existing behavior (no `paths` support)
-* rather than introduce a new startup failure mode over it.
-*/
-async function createTsconfigPathsPlugin(root) {
-	try {
-		const ts = await resolveFromWorkspace(root, "typescript");
-		const configPath = join(root, "tsconfig.json");
-		const configFile = ts.readConfigFile(configPath, (file) => ts.sys.readFile(file));
-		if (configFile.error) return null;
-		const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, root);
-		const rawPaths = parsed.options.paths;
-		if (!rawPaths || Object.keys(rawPaths).length === 0) return null;
-		const baseUrl = parsed.options.baseUrl ? resolve(root, parsed.options.baseUrl) : root;
-		const patterns = Object.entries(rawPaths).map(([key, targets]) => toPattern(key, targets, baseUrl)).sort((a, b) => b.prefix.length - a.prefix.length);
-		return {
-			name: "template-kit:tsconfig-paths",
-			enforce: "pre",
-			resolveId(source) {
-				if (source.startsWith(".") || isAbsolute(source)) return null;
-				for (const pattern of patterns) {
-					const matched = matchPattern(pattern, source);
-					if (matched === void 0) continue;
-					for (const target of pattern.targets) {
-						const resolved = resolveCandidate(pattern.hasWildcard ? target.replace("*", () => matched) : target);
-						if (resolved) return resolved;
-					}
-				}
-				return null;
-			}
-		};
-	} catch {
-		return null;
-	}
-}
-
-//#endregion
-export { createTsconfigPathsPlugin };

package/dist/cli/dev/vite-server.js

@@ -1,39 +0,0 @@
-import { resolveFromWorkspace } from "../check/resolve-tool.js";
-import { islandTransformPlugin } from "./island-transform.js";
-import { createTsconfigPathsPlugin } from "./tsconfig-paths-plugin.js";
-
-//#region src/cli/dev/vite-server.ts
-async function createDevViteServer(root, opts = {}) {
-	const vite = await resolveFromWorkspace(root, "vite");
-	const reactPlugin = await resolveFromWorkspace(root, "@vitejs/plugin-react");
-	const tsconfigPathsPlugin = await createTsconfigPathsPlugin(root);
-	return vite.createServer({
-		root,
-		appType: "custom",
-		configFile: false,
-		plugins: [
-			reactPlugin.default(),
-			islandTransformPlugin({ root }),
-			...tsconfigPathsPlugin ? [tsconfigPathsPlugin] : []
-		],
-		server: {
-			middlewareMode: true,
-			fs: { allow: [root] },
-			...opts.hmrPort !== void 0 ? { hmr: { port: opts.hmrPort } } : {}
-		},
-		ssr: { external: [
-			"react",
-			"react-dom",
-			"react-dom/server",
-			"react-dom/client"
-		] },
-		optimizeDeps: { include: [
-			"react",
-			"react-dom",
-			"react-dom/client"
-		] }
-	});
-}
-
-//#endregion
-export { createDevViteServer };

package/dist/cli/dev/workspace.js

@@ -1,63 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { existsSync } from "node:fs";
-
-//#region src/cli/dev/workspace.ts
-/** Walk up from `cwd` to the nearest ancestor that contains a `templates/` dir. */
-function findWorkspaceRoot(cwd) {
-	let dir = resolve(cwd);
-	for (;;) {
-		if (existsSync(join(dir, "templates"))) return dir;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-/**
-* Resolve the workspace at (or above) `cwd`: its root, every template under
-* `templates/`, and the template inferred from the cwd. Throws if no workspace
-* is found.
-*/
-async function resolveWorkspace(cwd) {
-	const root = findWorkspaceRoot(cwd);
-	if (!root) throw new Error(`no templates/ directory found in ${cwd} or any parent — run this from a workspace`);
-	const templatesDir = join(root, "templates");
-	const entries = await readdir(templatesDir, { withFileTypes: true });
-	const templates = [];
-	for (const entry of entries) {
-		if (!entry.isDirectory()) continue;
-		const dir = join(templatesDir, entry.name);
-		const manifestPath = join(dir, "manifest.json");
-		if (!existsSync(manifestPath)) continue;
-		templates.push({
-			key: await readTemplateKey(manifestPath, entry.name),
-			dir,
-			manifestPath,
-			themePath: existsSync(join(dir, "theme.ts")) ? join(dir, "theme.ts") : null
-		});
-	}
-	templates.sort((a, b) => a.key.localeCompare(b.key));
-	return {
-		root,
-		templatesDir,
-		templates,
-		cwdTemplate: inferTemplateFromCwd(templatesDir, cwd, templates)
-	};
-}
-async function readTemplateKey(manifestPath, fallback) {
-	try {
-		const raw = JSON.parse(await readFile(manifestPath, "utf8"));
-		return typeof raw.key === "string" && raw.key.length > 0 ? raw.key : fallback;
-	} catch {
-		return fallback;
-	}
-}
-function inferTemplateFromCwd(templatesDir, cwd, templates) {
-	const rel = relative(templatesDir, resolve(cwd));
-	if (rel === "" || rel.startsWith("..")) return null;
-	const folder = rel.split(sep)[0];
-	return templates.find((t) => basename(t.dir) === folder)?.key ?? null;
-}
-
-//#endregion
-export { findWorkspaceRoot, resolveWorkspace };

package/dist/cli/link/index.js

@@ -1,74 +0,0 @@
-import { KIT_PKG_SUBPATH, findKitRoot, overlayKit, readLinkMarker } from "./overlay.js";
-import { findWorkspaceRoot } from "../check/workspace.js";
-import { parseArgs, promisify } from "node:util";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { execFile } from "node:child_process";
-
-//#region src/cli/link/index.ts
-const execFileAsync = promisify(execFile);
-const defaultBuild = async (kitRoot) => {
-	await execFileAsync("npm", ["run", "build"], { cwd: kitRoot });
-};
-const defaultNpmCi = async (workspaceRoot) => {
-	await execFileAsync("npm", ["ci"], { cwd: workspaceRoot });
-};
-async function resolveWorkspace(argv, cwd) {
-	const { positionals } = parseArgs({
-		args: argv,
-		allowPositionals: true
-	});
-	return positionals[0] !== void 0 ? positionals[0] : findWorkspaceRoot(cwd);
-}
-async function installedKitVersion(workspaceRoot) {
-	try {
-		const raw = await readFile(join(workspaceRoot, KIT_PKG_SUBPATH, "package.json"), "utf8");
-		return JSON.parse(raw).version ?? "unknown";
-	} catch {
-		return "not installed";
-	}
-}
-async function runLinkOnce(argv, cwd, build = defaultBuild, now = (/* @__PURE__ */ new Date()).toISOString()) {
-	const workspaceRoot = await resolveWorkspace(argv, cwd);
-	const kitRoot = await findKitRoot(cwd);
-	return {
-		code: 0,
-		output: `template-kit link\n  overlaid kit ${(await overlayKit(kitRoot, workspaceRoot, build, now)).kitVersion} from ${kitRoot}\n  into ${workspaceRoot}`,
-		watch: {
-			kitSrcDir: join(kitRoot, "src"),
-			kitRoot,
-			workspaceRoot
-		}
-	};
-}
-async function runStatus(argv, cwd) {
-	const workspaceRoot = await resolveWorkspace(argv, cwd);
-	const marker = await readLinkMarker(workspaceRoot);
-	if (marker !== void 0) return {
-		code: 0,
-		output: `template-kit status\n  overlay — linked from ${marker.linkedFrom} (kit ${marker.kitVersion})`
-	};
-	return {
-		code: 0,
-		output: `template-kit status\n  registry — kit ${await installedKitVersion(workspaceRoot)}`
-	};
-}
-async function runUnlink(argv, cwd, npmCi = defaultNpmCi) {
-	const workspaceRoot = await resolveWorkspace(argv, cwd);
-	if (await readLinkMarker(workspaceRoot) === void 0) return {
-		code: 0,
-		output: "template-kit unlink\n  not linked — nothing to do."
-	};
-	await npmCi(workspaceRoot);
-	return {
-		code: 0,
-		output: "template-kit unlink\n  restored the registry install (npm ci)."
-	};
-}
-/** One rebuild+recopy for the watch loop — a real tsdown build, then the overlay copy. */
-async function rebuildOverlay(kitRoot, workspaceRoot) {
-	await overlayKit(kitRoot, workspaceRoot, defaultBuild, (/* @__PURE__ */ new Date()).toISOString());
-}
-
-//#endregion
-export { rebuildOverlay, runLinkOnce, runStatus, runUnlink };

package/dist/cli/link/overlay.js

@@ -1,59 +0,0 @@
-import { KIT_VERSION } from "../../index.js";
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-
-//#region src/cli/link/overlay.ts
-const KIT_PKG_SUBPATH = join("node_modules", "@homepages", "template-kit");
-const LINK_MARKER_NAME = ".template-kit-link.json";
-const PUBLISHABLE = [
-	"dist",
-	"guide",
-	"package.json",
-	"tsconfig.json",
-	"tsconfig.base.json",
-	"CHANGELOG.md"
-];
-async function readLinkMarker(workspaceRoot) {
-	try {
-		const raw = await readFile(join(workspaceRoot, KIT_PKG_SUBPATH, LINK_MARKER_NAME), "utf8");
-		return JSON.parse(raw);
-	} catch {
-		return;
-	}
-}
-const isPackageManifest = (value) => typeof value === "object" && value !== null;
-async function findKitRoot(from) {
-	let dir = resolve(from);
-	for (;;) {
-		try {
-			const raw = await readFile(join(dir, "package.json"), "utf8");
-			const parsed = JSON.parse(raw);
-			if (isPackageManifest(parsed) && parsed.name === "@homepages/template-kit") return dir;
-		} catch {}
-		const parent = dirname(dir);
-		if (parent === dir) throw new Error("not inside the template-kit repo — run `template-kit link` from a kit checkout.");
-		dir = parent;
-	}
-}
-async function overlayKit(kitRoot, workspaceRoot, build, now) {
-	await build(kitRoot);
-	const dest = join(workspaceRoot, KIT_PKG_SUBPATH);
-	await rm(dest, {
-		recursive: true,
-		force: true
-	});
-	await mkdir(dest, { recursive: true });
-	for (const item of PUBLISHABLE) await cp(join(kitRoot, item), join(dest, item), { recursive: true }).catch((cause) => {
-		if (cause.code !== "ENOENT") throw cause;
-	});
-	const marker = {
-		linkedFrom: kitRoot,
-		kitVersion: KIT_VERSION,
-		linkedAt: now
-	};
-	await writeFile(join(dest, LINK_MARKER_NAME), `${JSON.stringify(marker, null, 2)}\n`);
-	return marker;
-}
-
-//#endregion
-export { KIT_PKG_SUBPATH, LINK_MARKER_NAME, PUBLISHABLE, findKitRoot, overlayKit, readLinkMarker };

package/dist/cli/link/watch.js

@@ -1,25 +0,0 @@
-import { watch } from "node:fs";
-
-//#region src/cli/link/watch.ts
-function watchAndRebuild(kitSrcDir, onChange, onError, debounceMs = 150) {
-	let timer;
-	const watcher = watch(kitSrcDir, { recursive: true }, () => {
-		if (timer !== void 0) clearTimeout(timer);
-		timer = setTimeout(() => {
-			timer = void 0;
-			onChange();
-		}, debounceMs);
-	});
-	const stop = () => {
-		if (timer !== void 0) clearTimeout(timer);
-		watcher.close();
-	};
-	watcher.on("error", (err) => {
-		stop();
-		onError(err);
-	});
-	return stop;
-}
-
-//#endregion
-export { watchAndRebuild };

package/dist/cli/new/emit.js

@@ -1,48 +0,0 @@
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import { join, relative } from "node:path";
-
-//#region src/cli/new/emit.ts
-const RENAME = {
-	"_gitignore": ".gitignore",
-	"_package.json": "package.json",
-	"_manifest.json": "manifest.json",
-	"_Renderer.tsx": "Renderer.tsx",
-	"_schema.ts": "schema.ts",
-	"_fill-spec.ts": "fill-spec.ts",
-	"_fixtures.ts": "fixtures.ts"
-};
-function substitute(body, tokens) {
-	return body.replace(/\{\{(\w+)\}\}/g, (_m, key) => {
-		const value = tokens[key];
-		if (value === void 0) throw new Error(`scaffold: no value for token {{${key}}}`);
-		return value;
-	});
-}
-async function walk(dir) {
-	const out = [];
-	for (const entry of await readdir(dir, { withFileTypes: true })) {
-		const full = join(dir, entry.name);
-		if (entry.isDirectory()) out.push(...await walk(full));
-		else out.push(full);
-	}
-	return out;
-}
-/** Emit `srcDir` into `destDir`; returns dest-relative paths written. */
-async function emitTree(srcDir, destDir, tokens) {
-	const files = await walk(srcDir);
-	const written = [];
-	for (const file of files) {
-		const parts = relative(srcDir, file).split("/");
-		const base = parts[parts.length - 1];
-		parts[parts.length - 1] = RENAME[base] ?? base;
-		const destRel = parts.join("/");
-		const destPath = join(destDir, destRel);
-		await mkdir(join(destPath, ".."), { recursive: true });
-		await writeFile(destPath, substitute(await readFile(file, "utf8"), tokens), "utf8");
-		written.push(destRel);
-	}
-	return written;
-}
-
-//#endregion
-export { emitTree };

package/dist/cli/new/index.js

@@ -1,69 +0,0 @@
-import { findWorkspaceRoot } from "../check/workspace.js";
-import { emitTree } from "./emit.js";
-import { sectionAssetsDir, templateAssetsDir } from "./scaffold-assets.js";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-
-//#region src/cli/new/index.ts
-const KEY_RE = /^[a-z][a-z0-9-]*$/;
-function pascal(key) {
-	return key.split("-").map((p) => p ? p[0].toUpperCase() + p.slice(1) : p).join("");
-}
-function titleCase(key) {
-	return key.split("-").map((p) => p ? p[0].toUpperCase() + p.slice(1) : p).join(" ");
-}
-async function runNew(argv, cwd) {
-	const name = argv[0];
-	if (!name || !KEY_RE.test(name)) return {
-		code: 1,
-		output: `new: expected a kebab-case template name (${KEY_RE.source}). Usage: template-kit new <template>`
-	};
-	const dest = join(await findWorkspaceRoot(cwd), "templates", name);
-	if (existsSync(dest)) return {
-		code: 1,
-		output: `new: templates/${name}/ already exists. Refusing to overwrite.`
-	};
-	await emitTree(templateAssetsDir(), dest, {
-		TEMPLATE_KEY: name,
-		TEMPLATE_NAME: titleCase(name)
-	});
-	return {
-		code: 0,
-		output: `Created templates/${name}/ (starter template)\n  Next: npm run check -- ${name}   then   npm run dev -- ${name}`
-	};
-}
-async function runNewSection(argv, cwd) {
-	const arg = argv[0] ?? "";
-	const slash = arg.indexOf("/");
-	if (slash < 0) return {
-		code: 1,
-		output: `new-section: expected <template>/<section>. e.g. template-kit new-section starter/gallery`
-	};
-	const template = arg.slice(0, slash);
-	const section = arg.slice(slash + 1);
-	if (!KEY_RE.test(template) || !KEY_RE.test(section)) return {
-		code: 1,
-		output: `new-section: template and section must be kebab-case (${KEY_RE.source}).`
-	};
-	const templateDir = join(await findWorkspaceRoot(cwd), "templates", template);
-	if (!existsSync(templateDir)) return {
-		code: 1,
-		output: `new-section: templates/${template}/ does not exist. Create it with: template-kit new ${template}`
-	};
-	const dest = join(templateDir, "sections", section);
-	if (existsSync(dest)) return {
-		code: 1,
-		output: `new-section: ${dest} already exists. Refusing to overwrite.`
-	};
-	await emitTree(sectionAssetsDir(), dest, {
-		SECTION_PASCAL: pascal(section),
-		SECTION_DISPLAY: titleCase(section)
-	});
-	return {
-		code: 0,
-		output: `Created templates/${template}/sections/${section}/ (Renderer.tsx, schema.ts, fill-spec.ts, fixtures.ts)\n  Reference it as "${section}" in templates/${template}/manifest.json, then npm run check -- ${template}`
-	};
-}
-
-//#endregion
-export { runNew, runNewSection };

package/dist/cli/new/scaffold/section/_Renderer.tsx

@@ -1,20 +0,0 @@
-import type { ReactNode } from "react";
-
-import { Section, Slot } from "@homepages/template-kit";
-
-import type { Props } from "./schema";
-
-// {{SECTION_DISPLAY}} — a pure, server-rendered function of its props. Wrap
-// every editable slot in <Slot id="…"> so the editor can resolve clicks. For
-// interactivity, add a "use client" island file beside this one.
-export default function {{SECTION_PASCAL}}Renderer({ slots, nav }: Props): ReactNode {
-  return (
-    <Section id={nav.selfAnchor} className="bg-background text-ink">
-      <div className="mx-auto max-w-3xl px-6 py-12">
-        <Slot id="headline" textLeaf>
-          <h2 className="text-2xl font-semibold">{slots.headline}</h2>
-        </Slot>
-      </div>
-    </Section>
-  );
-}

package/dist/cli/new/scaffold/section/_fill-spec.ts

@@ -1,18 +0,0 @@
-import type { FillSpecShape } from "@homepages/template-kit";
-
-// Decision ids must match the `produced_by` references in schema.ts.
-export const fillSpec = {
-  reads: [],
-  decisions: [
-    {
-      id: "headline_text",
-      type: "text-block",
-      produces: ["headline"],
-      length_cap: 80,
-      structure: "single_sentence",
-      perspective: "third",
-      voice_prompt: "Write a short, confident heading for this section.",
-      content_prompt: "Anchor the section's purpose in one sentence.",
-    },
-  ],
-} as const satisfies FillSpecShape;

package/dist/cli/new/scaffold/section/_fixtures.ts

@@ -1,13 +0,0 @@
-import type { FixtureModule } from "@homepages/template-kit";
-
-// Base content only. Nullability coverage is derived from schema.ts. Add a
-// `states` entry for a designed content-length or cardinality branch.
-const fixtures: FixtureModule = {
-  base: {
-    slots: {
-      headline: "A typical headline that reads well in a short line",
-    },
-  },
-};
-
-export default fixtures;

package/dist/cli/new/scaffold/section/_schema.ts

@@ -1,24 +0,0 @@
-import type { SectionProps, SectionSchemaShape } from "@homepages/template-kit";
-
-// Replace the slots/options with the real shape this section needs. Every
-// editable slot declares either a `source` (baked from the property graph via
-// `direct(...)`/`derived(...)`) or a `produced_by` naming a decision in
-// fill-spec.ts.
-export const schema = {
-  meta: {
-    displayName: "{{SECTION_DISPLAY}}",
-  },
-  slots: {
-    headline: {
-      type: "text",
-      size: "medium",
-      editable_by_user: true,
-      required: true,
-      produced_by: "headline_text",
-      display_name: "Headline",
-    },
-  },
-} as const satisfies SectionSchemaShape;
-
-// Renderer prop type — derived from `schema`; do not hand-write it.
-export type Props = SectionProps<typeof schema>;

package/dist/cli/new/scaffold/template/_manifest.json

@@ -1,9 +0,0 @@
-{
-  "key": "{{TEMPLATE_KEY}}",
-  "name": "{{TEMPLATE_NAME}}",
-  "deliverable_type": "single_property_website",
-  "sections": [
-    { "section": "hero", "instance_id": "hero-1", "options": {}, "locked": [], "required": true, "reorderable": false }
-  ],
-  "reconcile": []
-}

package/dist/cli/new/scaffold/template/sections/hero/ExpandableText.tsx

@@ -1,45 +0,0 @@
-"use client";
-
-import { type ReactNode, useState } from "react";
-
-import type { IslandEditorOptions } from "@homepages/template-kit";
-
-// A "use client" island: interactive, hydrated in the browser as its own React
-// root. State, effects, and event handlers are fine here (they are NOT in a
-// Renderer). Its props cross the server→browser boundary as JSON, so they must
-// be strictly serializable — here, two strings and a number.
-export default function ExpandableText({
-  text,
-  collapsedChars,
-  moreLabel,
-}: {
-  text: string;
-  collapsedChars: number;
-  moreLabel: string;
-}): ReactNode {
-  const [open, setOpen] = useState(false);
-  const isLong = text.length > collapsedChars;
-  const shown = open || !isLong ? text : `${text.slice(0, collapsedChars).trimEnd()}…`;
-  return (
-    <p className="text-base leading-relaxed text-ink/80">
-      {shown}
-      {isLong ? (
-        <button
-          type="button"
-          data-testid="expand-toggle"
-          className="ml-2 font-medium text-accent underline"
-          onClick={() => setOpen((v) => !v)}
-        >
-          {open ? "Show less" : moreLabel}
-        </button>
-      ) : null}
-    </p>
-  );
-}
-
-// Optional: how this island behaves inside the editor canvas. Omit `editor`
-// entirely and the island renders as static markup in the editor (right for
-// most). Here we hydrate it live so the toggle works while editing.
-export const editor: IslandEditorOptions = {
-  live: true,
-};

package/dist/cli/new/scaffold/template/sections/hero/Renderer.tsx

@@ -1,40 +0,0 @@
-import type { ReactNode } from "react";
-
-import { Image, Section, Slot } from "@homepages/template-kit";
-
-import { Feature } from "./components/Feature";
-import ExpandableText from "./ExpandableText";
-import type { Props } from "./schema";
-
-// Hero — a pure server-rendered function of its props: no fetches, no globals,
-// no state. Every editable slot's outer DOM is wrapped in <Slot id="…"> (or a
-// primitive with slotId="…") so the editor can map a click back to the slot.
-// The one interactive part is the <ExpandableText> island.
-export default function HeroRenderer({ slots, options, nav }: Props): ReactNode {
-  const align = options.align === "left" ? "items-start text-left" : "items-center text-center";
-  return (
-    <Section id={nav.selfAnchor} className="bg-background text-ink">
-      <Image
-        slotId="hero_image"
-        src={slots.hero_image.url}
-        responsive={slots.hero_image.responsive}
-        alt={slots.hero_image.alt}
-        loading="eager"
-        className="w-full"
-      />
-      <div className={`mx-auto flex max-w-3xl flex-col gap-4 px-6 py-12 ${align}`}>
-        <Slot id="headline" textLeaf>
-          <h1 className="text-3xl font-semibold">{slots.headline}</h1>
-        </Slot>
-        <Slot id="blurb">
-          {/* The island receives JSON-serializable props only. */}
-          <ExpandableText text={slots.blurb} collapsedChars={140} moreLabel="Read more" />
-        </Slot>
-        <div className="mt-2 grid w-full grid-cols-2 gap-3">
-          <Feature label="Status" value="For sale" />
-          <Feature label="Type" value="Single-family" />
-        </div>
-      </div>
-    </Section>
-  );
-}

package/dist/cli/new/scaffold/template/sections/hero/components/Feature.tsx

@@ -1,14 +0,0 @@
-import type { ReactNode } from "react";
-
-// A nested server component. Proof that a section folder is free-form: only the
-// four contract files (Renderer/schema/fill-spec/fixtures) are reserved — a
-// components/ dir (or hooks/, utils/, any nesting) is yours to organize. This
-// renders as static HTML and ships zero JavaScript.
-export function Feature({ label, value }: { label: string; value: string }): ReactNode {
-  return (
-    <div className="rounded-lg border border-ink/10 p-4">
-      <div className="text-sm text-ink/60">{label}</div>
-      <div className="text-lg font-semibold text-ink">{value}</div>
-    </div>
-  );
-}