@homepages/template-kit 0.0.0 → 0.1.0

package/dist/design-system/breakpoints.js

@@ -0,0 +1,14 @@
+//#region src/design-system/breakpoints.ts
+const VERIFICATION_WIDTHS = [
+	350,
+	390,
+	425,
+	512,
+	768,
+	1024,
+	1440,
+	1920
+];
+
+//#endregion
+export { VERIFICATION_WIDTHS };

package/dist/design-system/theme.d.ts

@@ -0,0 +1,307 @@
+import { z } from "zod";
+//#region src/design-system/theme.d.ts
+declare const COLOR_ROLE_VARS: {
+  readonly ink: "--tr-color-ink";
+  readonly inkSoft: "--tr-color-ink-soft";
+  readonly inkMute: "--tr-color-ink-mute";
+  readonly background: "--tr-color-background";
+  readonly surface: "--tr-color-surface";
+  readonly surfaceAlt: "--tr-color-surface-alt";
+  readonly border: "--tr-color-border";
+  readonly borderStrong: "--tr-color-border-strong";
+  readonly primary: "--tr-color-primary";
+  readonly primaryFg: "--tr-color-primary-fg";
+  readonly primaryStrong: "--tr-color-primary-darker";
+  readonly accent: "--tr-color-accent";
+  readonly accentFg: "--tr-color-accent-contrast";
+  readonly accentStrong: "--tr-color-accent-strong";
+  readonly overlay: "--tr-color-overlay";
+  readonly overlayStrong: "--tr-color-overlay-strong";
+  readonly overlayLight: "--tr-color-overlay-light";
+  readonly darkBg: "--tr-color-footer-bg";
+  readonly darkFg: "--tr-color-footer-fg";
+  readonly darkFgMute: "--tr-color-footer-fg-mute";
+  readonly darkBorder: "--tr-color-footer-divider";
+};
+type ColorRole = keyof typeof COLOR_ROLE_VARS;
+declare const FONT_ROLE_VARS: {
+  readonly body: "--tr-font-sans";
+  readonly heading: "--tr-font-serif";
+  readonly numeric: "--tr-font-num";
+  readonly label: "--tr-font-label";
+};
+declare const TYPE_STEP_VARS: {
+  readonly xs: "--tr-text-xs";
+  readonly sm: "--tr-text-sm";
+  readonly base: "--tr-text-base";
+  readonly lg: "--tr-text-lg";
+  readonly xl: "--tr-text-xl";
+  readonly "2xl": "--tr-text-2xl";
+  readonly "3xl": "--tr-text-3xl";
+  readonly "4xl": "--tr-text-4xl";
+  readonly "5xl": "--tr-text-5xl";
+  readonly display: "--tr-text-display";
+};
+declare const RADIUS_VARS: {
+  readonly sm: "--tr-radius-sm";
+  readonly md: "--tr-radius-md";
+  readonly lg: "--tr-radius-lg";
+  readonly full: "--tr-radius-full";
+};
+declare const SHADOW_VARS: {
+  readonly sm: "--tr-shadow-sm";
+  readonly md: "--tr-shadow-md";
+  readonly lg: "--tr-shadow-lg";
+};
+declare const LAYOUT_VARS: {
+  readonly containerMax: "--tr-container-max";
+  readonly containerPad: "--tr-container-pad";
+  readonly headerHeight: "--tr-header-height";
+};
+declare const TokenThemeSchema: z.ZodObject<{
+  colors: z.ZodObject<Record<"ink" | "inkSoft" | "inkMute" | "background" | "surface" | "surfaceAlt" | "border" | "borderStrong" | "primary" | "primaryFg" | "primaryStrong" | "accent" | "accentFg" | "accentStrong" | "overlay" | "overlayStrong" | "overlayLight" | "darkBg" | "darkFg" | "darkFgMute" | "darkBorder", z.ZodString>, "strip", z.ZodTypeAny, {
+    ink: string;
+    inkSoft: string;
+    inkMute: string;
+    background: string;
+    surface: string;
+    surfaceAlt: string;
+    border: string;
+    borderStrong: string;
+    primary: string;
+    primaryFg: string;
+    primaryStrong: string;
+    accent: string;
+    accentFg: string;
+    accentStrong: string;
+    overlay: string;
+    overlayStrong: string;
+    overlayLight: string;
+    darkBg: string;
+    darkFg: string;
+    darkFgMute: string;
+    darkBorder: string;
+  }, {
+    ink: string;
+    inkSoft: string;
+    inkMute: string;
+    background: string;
+    surface: string;
+    surfaceAlt: string;
+    border: string;
+    borderStrong: string;
+    primary: string;
+    primaryFg: string;
+    primaryStrong: string;
+    accent: string;
+    accentFg: string;
+    accentStrong: string;
+    overlay: string;
+    overlayStrong: string;
+    overlayLight: string;
+    darkBg: string;
+    darkFg: string;
+    darkFgMute: string;
+    darkBorder: string;
+  }>;
+  /** Optional open brand palette → `--tr-color-<name>` (the escape hatch). */
+  palette: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  fonts: z.ZodObject<Record<"body" | "heading" | "numeric" | "label", z.ZodString> & {
+    /** Font-loading block (@import / @font-face) emitted before :root. */
+    fontFaces: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    body: string;
+    heading: string;
+    numeric: string;
+    label: string;
+    fontFaces?: string | undefined;
+  }, {
+    body: string;
+    heading: string;
+    numeric: string;
+    label: string;
+    fontFaces?: string | undefined;
+  }>;
+  type: z.ZodObject<Record<"xs" | "sm" | "base" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "display", z.ZodString>, "strip", z.ZodTypeAny, {
+    xs: string;
+    sm: string;
+    base: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+    "5xl": string;
+    display: string;
+  }, {
+    xs: string;
+    sm: string;
+    base: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+    "5xl": string;
+    display: string;
+  }>;
+  radii: z.ZodObject<Record<"sm" | "lg" | "md" | "full", z.ZodString>, "strip", z.ZodTypeAny, {
+    sm: string;
+    lg: string;
+    md: string;
+    full: string;
+  }, {
+    sm: string;
+    lg: string;
+    md: string;
+    full: string;
+  }>;
+  shadows: z.ZodObject<Record<"sm" | "lg" | "md", z.ZodString>, "strip", z.ZodTypeAny, {
+    sm: string;
+    lg: string;
+    md: string;
+  }, {
+    sm: string;
+    lg: string;
+    md: string;
+  }>;
+  layout: z.ZodObject<Record<"containerMax" | "containerPad" | "headerHeight", z.ZodString>, "strip", z.ZodTypeAny, {
+    containerMax: string;
+    containerPad: string;
+    headerHeight: string;
+  }, {
+    containerMax: string;
+    containerPad: string;
+    headerHeight: string;
+  }>;
+}, "strict", z.ZodTypeAny, {
+  type: {
+    xs: string;
+    sm: string;
+    base: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+    "5xl": string;
+    display: string;
+  };
+  colors: {
+    ink: string;
+    inkSoft: string;
+    inkMute: string;
+    background: string;
+    surface: string;
+    surfaceAlt: string;
+    border: string;
+    borderStrong: string;
+    primary: string;
+    primaryFg: string;
+    primaryStrong: string;
+    accent: string;
+    accentFg: string;
+    accentStrong: string;
+    overlay: string;
+    overlayStrong: string;
+    overlayLight: string;
+    darkBg: string;
+    darkFg: string;
+    darkFgMute: string;
+    darkBorder: string;
+  };
+  fonts: {
+    body: string;
+    heading: string;
+    numeric: string;
+    label: string;
+    fontFaces?: string | undefined;
+  };
+  radii: {
+    sm: string;
+    lg: string;
+    md: string;
+    full: string;
+  };
+  shadows: {
+    sm: string;
+    lg: string;
+    md: string;
+  };
+  layout: {
+    containerMax: string;
+    containerPad: string;
+    headerHeight: string;
+  };
+  palette?: Record<string, string> | undefined;
+}, {
+  type: {
+    xs: string;
+    sm: string;
+    base: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+    "5xl": string;
+    display: string;
+  };
+  colors: {
+    ink: string;
+    inkSoft: string;
+    inkMute: string;
+    background: string;
+    surface: string;
+    surfaceAlt: string;
+    border: string;
+    borderStrong: string;
+    primary: string;
+    primaryFg: string;
+    primaryStrong: string;
+    accent: string;
+    accentFg: string;
+    accentStrong: string;
+    overlay: string;
+    overlayStrong: string;
+    overlayLight: string;
+    darkBg: string;
+    darkFg: string;
+    darkFgMute: string;
+    darkBorder: string;
+  };
+  fonts: {
+    body: string;
+    heading: string;
+    numeric: string;
+    label: string;
+    fontFaces?: string | undefined;
+  };
+  radii: {
+    sm: string;
+    lg: string;
+    md: string;
+    full: string;
+  };
+  shadows: {
+    sm: string;
+    lg: string;
+    md: string;
+  };
+  layout: {
+    containerMax: string;
+    containerPad: string;
+    headerHeight: string;
+  };
+  palette?: Record<string, string> | undefined;
+}>;
+type TokenTheme = z.infer<typeof TokenThemeSchema>;
+/**
+ * Compile a `TokenTheme` into the CSS a template's bundle ships: an optional
+ * font-loading block followed by a single `:root { --tr-*: … }` declaration.
+ * Deterministic (stable key order; palette keys sorted) so the same theme
+ * always content-hashes identically.
+ */
+declare function compileThemeToCss(theme: TokenTheme): string;
+//#endregion
+export { COLOR_ROLE_VARS, ColorRole, FONT_ROLE_VARS, LAYOUT_VARS, RADIUS_VARS, SHADOW_VARS, TYPE_STEP_VARS, TokenTheme, TokenThemeSchema, compileThemeToCss };

package/dist/design-system/theme.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+
+//#region src/design-system/theme.ts
+const COLOR_ROLE_VARS = {
+	ink: "--tr-color-ink",
+	inkSoft: "--tr-color-ink-soft",
+	inkMute: "--tr-color-ink-mute",
+	background: "--tr-color-background",
+	surface: "--tr-color-surface",
+	surfaceAlt: "--tr-color-surface-alt",
+	border: "--tr-color-border",
+	borderStrong: "--tr-color-border-strong",
+	primary: "--tr-color-primary",
+	primaryFg: "--tr-color-primary-fg",
+	primaryStrong: "--tr-color-primary-darker",
+	accent: "--tr-color-accent",
+	accentFg: "--tr-color-accent-contrast",
+	accentStrong: "--tr-color-accent-strong",
+	overlay: "--tr-color-overlay",
+	overlayStrong: "--tr-color-overlay-strong",
+	overlayLight: "--tr-color-overlay-light",
+	darkBg: "--tr-color-footer-bg",
+	darkFg: "--tr-color-footer-fg",
+	darkFgMute: "--tr-color-footer-fg-mute",
+	darkBorder: "--tr-color-footer-divider"
+};
+const FONT_ROLE_VARS = {
+	body: "--tr-font-sans",
+	heading: "--tr-font-serif",
+	numeric: "--tr-font-num",
+	label: "--tr-font-label"
+};
+const TYPE_STEP_VARS = {
+	xs: "--tr-text-xs",
+	sm: "--tr-text-sm",
+	base: "--tr-text-base",
+	lg: "--tr-text-lg",
+	xl: "--tr-text-xl",
+	"2xl": "--tr-text-2xl",
+	"3xl": "--tr-text-3xl",
+	"4xl": "--tr-text-4xl",
+	"5xl": "--tr-text-5xl",
+	display: "--tr-text-display"
+};
+const RADIUS_VARS = {
+	sm: "--tr-radius-sm",
+	md: "--tr-radius-md",
+	lg: "--tr-radius-lg",
+	full: "--tr-radius-full"
+};
+const SHADOW_VARS = {
+	sm: "--tr-shadow-sm",
+	md: "--tr-shadow-md",
+	lg: "--tr-shadow-lg"
+};
+const LAYOUT_VARS = {
+	containerMax: "--tr-container-max",
+	containerPad: "--tr-container-pad",
+	headerHeight: "--tr-header-height"
+};
+const colorRoles = Object.fromEntries(Object.keys(COLOR_ROLE_VARS).map((k) => [k, z.string().min(1)]));
+const scale = (keys) => z.object(Object.fromEntries(keys.map((k) => [k, z.string().min(1)])));
+const TokenThemeSchema = z.object({
+	colors: z.object(colorRoles),
+	/** Optional open brand palette → `--tr-color-<name>` (the escape hatch). */
+	palette: z.record(z.string().min(1)).optional(),
+	fonts: scale(Object.keys(FONT_ROLE_VARS)).extend({ 
+	/** Font-loading block (@import / @font-face) emitted before :root. */
+fontFaces: z.string().optional() }),
+	type: scale(Object.keys(TYPE_STEP_VARS)),
+	radii: scale(Object.keys(RADIUS_VARS)),
+	shadows: scale(Object.keys(SHADOW_VARS)),
+	layout: scale(Object.keys(LAYOUT_VARS))
+}).strict();
+/**
+* Compile a `TokenTheme` into the CSS a template's bundle ships: an optional
+* font-loading block followed by a single `:root { --tr-*: … }` declaration.
+* Deterministic (stable key order; palette keys sorted) so the same theme
+* always content-hashes identically.
+*/
+function compileThemeToCss(theme) {
+	const decls = [];
+	for (const role of Object.keys(COLOR_ROLE_VARS)) decls.push(`  ${COLOR_ROLE_VARS[role]}: ${theme.colors[role]};`);
+	if (theme.palette) for (const name of Object.keys(theme.palette).sort()) decls.push(`  --tr-color-${name}: ${theme.palette[name]};`);
+	for (const k of Object.keys(FONT_ROLE_VARS)) decls.push(`  ${FONT_ROLE_VARS[k]}: ${theme.fonts[k]};`);
+	for (const k of Object.keys(TYPE_STEP_VARS)) decls.push(`  ${TYPE_STEP_VARS[k]}: ${theme.type[k]};`);
+	for (const k of Object.keys(RADIUS_VARS)) decls.push(`  ${RADIUS_VARS[k]}: ${theme.radii[k]};`);
+	for (const k of Object.keys(SHADOW_VARS)) decls.push(`  ${SHADOW_VARS[k]}: ${theme.shadows[k]};`);
+	for (const k of Object.keys(LAYOUT_VARS)) decls.push(`  ${LAYOUT_VARS[k]}: ${theme.layout[k]};`);
+	const root = `:root {\n${decls.join("\n")}\n}`;
+	return theme.fonts.fontFaces ? `${theme.fonts.fontFaces}\n\n${root}\n` : `${root}\n`;
+}
+
+//#endregion
+export { COLOR_ROLE_VARS, FONT_ROLE_VARS, LAYOUT_VARS, RADIUS_VARS, SHADOW_VARS, TYPE_STEP_VARS, TokenThemeSchema, compileThemeToCss };

package/dist/eslint/is-client-file.js

@@ -0,0 +1,79 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+//#region src/eslint/is-client-file.ts
+function hasClientDirective(text) {
+	let i = 0;
+	while (i < text.length) {
+		const rest = text.slice(i);
+		const ws = /^\s+/.exec(rest);
+		if (ws) {
+			i += ws[0].length;
+			continue;
+		}
+		const line = /^\/\/[^\n]*/.exec(rest);
+		if (line) {
+			i += line[0].length;
+			continue;
+		}
+		const block = /^\/\*[\s\S]*?\*\//.exec(rest);
+		if (block) {
+			i += block[0].length;
+			continue;
+		}
+		const directive = /^(["'])([^"']*)\1\s*;?/.exec(rest);
+		if (!directive) return false;
+		if (directive[2] === "use client") return true;
+		i += directive[0].length;
+	}
+	return false;
+}
+const cache = /* @__PURE__ */ new Map();
+function isClientFile(filename) {
+	const absolute = resolve(filename);
+	let mtimeMs;
+	try {
+		mtimeMs = statSync(absolute).mtimeMs;
+	} catch {
+		return false;
+	}
+	const key = `${absolute}:${mtimeMs}`;
+	const hit = cache.get(key);
+	if (hit !== void 0) return hit;
+	let answer = false;
+	try {
+		answer = hasClientDirective(readFileSync(absolute, "utf8"));
+	} catch {
+		answer = false;
+	}
+	cache.set(key, answer);
+	return answer;
+}
+const SOURCE_EXTS = [
+	".tsx",
+	".ts",
+	".jsx",
+	".js"
+];
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function resolveImportedFile(specifier, fromFile) {
+	if (!specifier.startsWith(".")) return null;
+	const base = resolve(dirname(fromFile), specifier);
+	const candidates = [];
+	const jsExt = /\.(js|jsx)$/.exec(base);
+	if (jsExt) {
+		const stem = base.slice(0, -jsExt[0].length);
+		candidates.push(...SOURCE_EXTS.filter((ext) => ext !== ".js").map((ext) => stem + ext));
+	}
+	candidates.push(base, ...SOURCE_EXTS.map((ext) => base + ext));
+	return candidates.find(isFile) ?? null;
+}
+
+//#endregion
+export { hasClientDirective, isClientFile, resolveImportedFile };

package/dist/eslint/rules/image-bare-needs-reason.js

@@ -0,0 +1,38 @@
+//#region src/eslint/rules/image-bare-needs-reason.ts
+const imageBareNeedsReason = {
+	meta: {
+		type: "problem",
+		docs: { description: "<Image bare> requires a `// bare:` reason comment" },
+		schema: [],
+		messages: { bareNeedsReason: "`<Image bare>` skips the framed wrapper's aspect-ratio box and fallback rect. Fix: document why this case warrants it with a `// bare: <reason>` comment immediately above the element." }
+	},
+	create(context) {
+		const comments = context.sourceCode.getAllComments();
+		const LOOKBACK_LINES = 5;
+		let previousBareElementEnd = -1;
+		return { JSXOpeningElement(node) {
+			if (node.name.type !== "JSXIdentifier" || node.name.name !== "Image") return;
+			if (!node.attributes.some((a) => a.type === "JSXAttribute" && a.name?.name === "bare")) return;
+			const startLine = node.loc?.start.line;
+			const watermark = previousBareElementEnd;
+			const hasReason = startLine != null && comments.some((c) => {
+				if (!/\bbare:/.test(c.value)) return false;
+				const endLine = c.loc?.end.line;
+				if (endLine == null) return false;
+				const linesAbove = startLine - endLine;
+				if (linesAbove <= 0 || linesAbove > LOOKBACK_LINES) return false;
+				const commentStart = c.range?.[0];
+				return commentStart != null && commentStart > watermark;
+			});
+			if (node.range) previousBareElementEnd = node.range[1];
+			if (hasReason) return;
+			context.report({
+				node,
+				messageId: "bareNeedsReason"
+			});
+		} };
+	}
+};
+
+//#endregion
+export { imageBareNeedsReason };

package/dist/eslint/rules/no-client-directive-in-contract.js

@@ -0,0 +1,26 @@
+//#region src/eslint/rules/no-client-directive-in-contract.ts
+const noClientDirectiveInContract = {
+	meta: {
+		type: "problem",
+		docs: { description: "Ban the \"use client\" directive in a section's four contract files" },
+		schema: [],
+		messages: { clientContractFile: "A section's contract files (Renderer.tsx, schema.ts, fill-spec.ts, fixtures.ts) are server-only and must not carry \"use client\" — the platform reads them outside a browser. Fix: put the interactive part in its own \"use client\" component in the section folder and render it from the Renderer." }
+	},
+	create(context) {
+		return { Program(node) {
+			for (const stmt of node.body) {
+				if (stmt.type !== "ExpressionStatement" || stmt.expression.type !== "Literal" || typeof stmt.expression.value !== "string") return;
+				if (stmt.expression.value === "use client") {
+					context.report({
+						node: stmt,
+						messageId: "clientContractFile"
+					});
+					return;
+				}
+			}
+		} };
+	}
+};
+
+//#endregion
+export { noClientDirectiveInContract };

package/dist/eslint/rules/no-client-runtime-in-server.js

@@ -0,0 +1,99 @@
+import { hasClientDirective, isClientFile, resolveImportedFile } from "../is-client-file.js";
+
+//#region src/eslint/rules/no-client-runtime-in-server.ts
+const BANNED_HOOKS = /* @__PURE__ */ new Set([
+	"useEffect",
+	"useLayoutEffect",
+	"useState",
+	"useReducer",
+	"useRef",
+	"useSyncExternalStore",
+	"useImperativeHandle"
+]);
+const BANNED_GLOBALS = /* @__PURE__ */ new Set([
+	"fetch",
+	"XMLHttpRequest",
+	"window",
+	"document",
+	"localStorage",
+	"sessionStorage",
+	"navigator"
+]);
+const noClientRuntimeInServer = {
+	meta: {
+		type: "problem",
+		docs: { description: "Ban effects, state, handlers, network, and browser globals in server-rendered section code" },
+		schema: [],
+		messages: {
+			clientRuntime: "`{{what}}` is browser-only and is banned in server-rendered code — a Renderer must be a pure function of its props. Fix: move this into a `\"use client\"` component in the section folder and render it from the Renderer; it will be hydrated as an island.",
+			clientHandler: "`{{what}}` is an event handler, which cannot cross the server→browser boundary — it is dropped from the published HTML. Fix: move the interactive markup into a `\"use client\"` component in the section folder and render it from the Renderer."
+		}
+	},
+	create(context) {
+		if (hasClientDirective(context.sourceCode.getText())) return {};
+		const sourceCode = context.sourceCode;
+		const filename = context.filename;
+		const islandNames = /* @__PURE__ */ new Map();
+		function isIsland(name) {
+			return islandNames.get(name) ?? false;
+		}
+		return {
+			ImportDeclaration(node) {
+				const source = node.source.value;
+				if (typeof source !== "string") return;
+				const resolved = resolveImportedFile(source, filename);
+				if (resolved === null) return;
+				const island = isClientFile(resolved);
+				for (const spec of node.specifiers) islandNames.set(spec.local.name, island);
+			},
+			CallExpression(node) {
+				if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && BANNED_HOOKS.has(node.callee.property.name)) {
+					context.report({
+						node,
+						messageId: "clientRuntime",
+						data: { what: node.callee.property.name }
+					});
+					return;
+				}
+				if (node.callee.type !== "Identifier") return;
+				const name = node.callee.name;
+				if (!BANNED_HOOKS.has(name)) return;
+				const ref = sourceCode.getScope(node).references.find((r) => r.identifier === node.callee);
+				if (ref?.resolved && ref.resolved.defs.some((d) => d.type !== "ImportBinding")) return;
+				context.report({
+					node,
+					messageId: "clientRuntime",
+					data: { what: name }
+				});
+			},
+			Identifier(node) {
+				if (!BANNED_GLOBALS.has(node.name)) return;
+				const ref = sourceCode.getScope(node).references.find((r) => r.identifier === node);
+				if (!ref) return;
+				if (ref.resolved && ref.resolved.defs.length > 0) return;
+				context.report({
+					node,
+					messageId: "clientRuntime",
+					data: { what: node.name }
+				});
+			},
+			JSXAttribute(node) {
+				const attrName = node.name.name;
+				if (typeof attrName !== "string" || !/^on[A-Z]/.test(attrName)) return;
+				if (node.value === null || node.value.type !== "JSXExpressionContainer") return;
+				const expr = node.value.expression;
+				if (expr && (expr.type === "Literal" || expr.type === "JSXElement")) return;
+				const parent = node.parent;
+				if (parent?.type === "JSXOpeningElement" && parent.name?.type === "JSXIdentifier" && typeof parent.name.name === "string" && isIsland(parent.name.name)) return;
+				context.report({
+					node,
+					messageId: "clientHandler",
+					data: { what: attrName }
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+export { noClientRuntimeInServer };

package/dist/eslint/rules/no-css-import-from-render-path.js

@@ -0,0 +1,23 @@
+//#region src/eslint/rules/no-css-import-from-render-path.ts
+const noCssImportFromRenderPath = {
+	meta: {
+		type: "problem",
+		docs: { description: "Ban CSS imports from a section's render path" },
+		schema: [],
+		messages: { cssFromRenderPath: "`{{source}}` is a CSS import in the render path — the renderer is compiled for SSR, where this is dropped, so the styles would silently not ship. Fix: `@import` it from the section's root `styles.css`, which is the entry the CSS build actually reads." }
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			const source = node.source.value;
+			if (typeof source !== "string" || !source.endsWith(".css")) return;
+			context.report({
+				node,
+				messageId: "cssFromRenderPath",
+				data: { source }
+			});
+		} };
+	}
+};
+
+//#endregion
+export { noCssImportFromRenderPath };