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

package/dist/media/pack.d.ts

@@ -0,0 +1,49 @@
+//#region src/media/pack.d.ts
+/** The four library kinds the editor's media picker lists. */
+type MediaKind = "photo" | "plan" | "library" | "video";
+type MediaAsset = {
+  id: string;
+  kind: MediaKind;
+  name: string;
+  caption: string;
+  tags: Record<string, string>;
+  /** Pack-relative path to the source bytes. */
+  file: string;
+  /** True intrinsic dimensions of `file`. Absent for vector assets. */
+  width?: number;
+  height?: number;
+  /** `video` only. */
+  poster?: string;
+  duration_ms?: number;
+};
+/**
+ * URL prefix every resolved media URL carries. Root-relative so a section page at
+ * any depth resolves it identically, and so the dev server can mount the pack under
+ * one known path. Kept in sync with the dev server's static mount.
+ */
+declare const DEV_MEDIA_URL_PREFIX = "/__dev-media/";
+/** The pack entry for an asset id, or null when the id names nothing in the pack. */
+declare function getMediaAsset(id: string): MediaAsset | null;
+/**
+ * Every asset the pack ships, in manifest order.
+ *
+ * Exposes the asset list and NOT the whole manifest on purpose. The manifest's
+ * `sets` are generated FROM the scenario ownership a consumer derives out of the
+ * kit fixtures, so a consumer that read `sets` back to compute ownership would be
+ * checking its own output.
+ */
+declare function listMediaAssets(): MediaAsset[];
+/**
+ * Inverse of `mediaUrl` — the pack-relative path a served URL names, or null when
+ * the URL is not a pack URL. Lets a consumer (render-invariants) check a rendered
+ * `src` back against the manifest.
+ */
+declare function packRelativeFromUrl(url: string): string | null;
+/**
+ * Whether a pack-relative path names real bytes in the pack. Pair with
+ * `packRelativeFromUrl` to check a rendered `src`/`srcset` back against the
+ * manifest — asserting a media URL RESOLVES rather than merely being non-empty.
+ */
+declare function mediaPackHasFile(packRelative: string): boolean;
+//#endregion
+export { DEV_MEDIA_URL_PREFIX, MediaAsset, MediaKind, getMediaAsset, listMediaAssets, mediaPackHasFile, packRelativeFromUrl };

package/dist/media/pack.js

@@ -0,0 +1,69 @@
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/media/pack.ts
+/**
+* URL prefix every resolved media URL carries. Root-relative so a section page at
+* any depth resolves it identically, and so the dev server can mount the pack under
+* one known path. Kept in sync with the dev server's static mount.
+*/
+const DEV_MEDIA_URL_PREFIX = "/__dev-media/";
+const MANIFEST_CANDIDATES = ["../manifest.json", "../../../dev-media/manifest.json"];
+function loadManifest() {
+	for (const candidate of MANIFEST_CANDIDATES) {
+		const path = fileURLToPath(new URL(candidate, import.meta.url));
+		if (existsSync(path)) return JSON.parse(readFileSync(path, "utf8"));
+	}
+	throw new Error("dev media manifest not found — expected it beside the kit build (dist/manifest.json) or in the workspace sibling (packages/dev-media/manifest.json)");
+}
+let cached = null;
+/** The pack index. Parsed once per process. */
+function mediaManifest() {
+	cached ??= loadManifest();
+	return cached;
+}
+let byId = null;
+/** The pack entry for an asset id, or null when the id names nothing in the pack. */
+function getMediaAsset(id) {
+	byId ??= new Map(mediaManifest().assets.map((asset) => [asset.id, asset]));
+	return byId.get(id) ?? null;
+}
+/**
+* Every asset the pack ships, in manifest order.
+*
+* Exposes the asset list and NOT the whole manifest on purpose. The manifest's
+* `sets` are generated FROM the scenario ownership a consumer derives out of the
+* kit fixtures, so a consumer that read `sets` back to compute ownership would be
+* checking its own output.
+*/
+function listMediaAssets() {
+	return mediaManifest().assets;
+}
+/**
+* The served URL for a pack-relative reference (an asset's `file` or `poster`).
+* This is the ONLY place the pack's on-disk layout becomes a URL.
+*/
+function mediaUrl(packRelative) {
+	return `${DEV_MEDIA_URL_PREFIX}${packRelative}`;
+}
+/**
+* Inverse of `mediaUrl` — the pack-relative path a served URL names, or null when
+* the URL is not a pack URL. Lets a consumer (render-invariants) check a rendered
+* `src` back against the manifest.
+*/
+function packRelativeFromUrl(url) {
+	return url.startsWith("/__dev-media/") ? url.slice(13) : null;
+}
+let files = null;
+/**
+* Whether a pack-relative path names real bytes in the pack. Pair with
+* `packRelativeFromUrl` to check a rendered `src`/`srcset` back against the
+* manifest — asserting a media URL RESOLVES rather than merely being non-empty.
+*/
+function mediaPackHasFile(packRelative) {
+	files ??= new Set(mediaManifest().assets.flatMap((asset) => asset.poster ? [asset.file, asset.poster] : [asset.file]));
+	return files.has(packRelative);
+}
+
+//#endregion
+export { DEV_MEDIA_URL_PREFIX, getMediaAsset, listMediaAssets, mediaManifest, mediaPackHasFile, mediaUrl, packRelativeFromUrl };

package/dist/media/resolve-fixture-media.d.ts

@@ -0,0 +1,22 @@
+//#region src/media/resolve-fixture-media.d.ts
+/**
+ * `resolveFixtureMedia` over a built fixture set — the form every node-only caller
+ * (the SSR loader, `template-kit check`) actually needs.
+ */
+declare function resolveFixtureSetMedia<T extends {
+  props: unknown;
+}>(fixtures: T[]): T[];
+/** A fixture stating a media asset id the pack does not carry. */
+type UnresolvedMedia = {
+  /** Where the id sits — `photo_id`, `video_id`, `floor_plans[].id`. */
+  field: string;
+  id: string;
+};
+/**
+ * Every media asset id a fixture states that the pack does not carry. Run over
+ * PRE-resolution props — after resolution the id is gone, replaced by the empty
+ * default.
+ */
+declare function findUnresolvedMedia(props: unknown): UnresolvedMedia[];
+//#endregion
+export { UnresolvedMedia, findUnresolvedMedia, resolveFixtureSetMedia };

package/dist/media/resolve-fixture-media.js

@@ -0,0 +1,73 @@
+import { getMediaAsset } from "./pack.js";
+import { resolveFloorplan, resolveImageValue, resolveVideoValue } from "./resolve-media.js";
+
+//#region src/media/resolve-fixture-media.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasStringKey(value, key) {
+	return typeof value[key] === "string";
+}
+function resolveValue(value, key) {
+	if (Array.isArray(value)) {
+		const entries = value;
+		if (key === "floor_plans") return entries.map((entry) => isPlainObject(entry) && typeof entry.id === "string" ? resolveFloorplan(entry) : entry);
+		return entries.map((entry) => resolveValue(entry, null));
+	}
+	if (!isPlainObject(value)) return value;
+	if (hasStringKey(value, "video_id")) return resolveVideoValue(value);
+	if (hasStringKey(value, "photo_id") || hasStringKey(value, "asset_id")) return resolveImageValue(value);
+	return Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => [childKey, resolveValue(childValue, childKey)]));
+}
+/**
+* Resolve every media reference in a fixture's props against the dev media pack,
+* returning a new props object. Props with no media pass through unchanged in
+* value, though the object identity is not preserved.
+*/
+function resolveFixtureMedia(props) {
+	return resolveValue(props, null);
+}
+/**
+* `resolveFixtureMedia` over a built fixture set — the form every node-only caller
+* (the SSR loader, `template-kit check`) actually needs.
+*/
+function resolveFixtureSetMedia(fixtures) {
+	return fixtures.map((fixture) => ({
+		...fixture,
+		props: resolveFixtureMedia(fixture.props)
+	}));
+}
+function collectUnresolved(value, key, out) {
+	if (Array.isArray(value)) {
+		for (const entry of value) if (key === "floor_plans" && isPlainObject(entry) && typeof entry.id === "string") {
+			if (entry.id && !getMediaAsset(entry.id)) out.set(entry.id, "floor_plans[].id");
+		} else collectUnresolved(entry, null, out);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	for (const field of [
+		"photo_id",
+		"asset_id",
+		"video_id"
+	]) {
+		const id = value[field];
+		if (typeof id === "string" && id && !getMediaAsset(id)) out.set(id, field);
+	}
+	for (const [childKey, childValue] of Object.entries(value)) collectUnresolved(childValue, childKey, out);
+}
+/**
+* Every media asset id a fixture states that the pack does not carry. Run over
+* PRE-resolution props — after resolution the id is gone, replaced by the empty
+* default.
+*/
+function findUnresolvedMedia(props) {
+	const found = /* @__PURE__ */ new Map();
+	collectUnresolved(props, null, found);
+	return [...found].map(([id, field]) => ({
+		field,
+		id
+	}));
+}
+
+//#endregion
+export { findUnresolvedMedia, resolveFixtureMedia, resolveFixtureSetMedia };

package/dist/media/resolve-media.js

@@ -0,0 +1,195 @@
+import { getMediaAsset, mediaUrl } from "./pack.js";
+
+//#region src/media/resolve-media.ts
+const EMPTY_IMAGE = {
+	photo_id: "",
+	url: "",
+	alt: ""
+};
+const EMPTY_VIDEO = {
+	video_id: "",
+	url: "",
+	poster: "",
+	alt: ""
+};
+const RUNG_WIDTHS = [
+	320,
+	640,
+	960,
+	1200,
+	1600,
+	2048
+];
+const MIME_BY_EXTENSION = {
+	avif: "image/avif",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	png: "image/png",
+	webp: "image/webp"
+};
+function mimeFor(file) {
+	return MIME_BY_EXTENSION[file.split(".").pop()?.toLowerCase() ?? ""] ?? null;
+}
+/**
+* The responsive descriptor for a pack asset, or null when the asset cannot carry
+* one (a vector, or a raster whose intrinsic dimensions the manifest omits).
+*
+* TWO DELIBERATE DIVERGENCES FROM PRODUCTION, both recorded in the design record:
+*
+*  1. Every rung points at the SAME source file. Production pre-encodes one file per
+*     rung; generating those here would put `sharp` — a platform-specific native
+*     binary — into every agency install and make output vary by encoder version.
+*     The manifest still declares each asset's TRUE dimensions, so layout and
+*     authoring behave exactly as in production; only transferred bytes differ.
+*  2. One source, carrying the file's REAL mime type, where production emits an
+*     avif/webp/jpeg triple. Claiming `image/avif` over PNG bytes would not be a
+*     harmless fiction — the browser would select that source and fail to decode it.
+*/
+function responsiveFor(asset) {
+	const type = mimeFor(asset.file);
+	if (!type || !asset.width || !asset.height) return null;
+	const url = mediaUrl(asset.file);
+	const widths = RUNG_WIDTHS.filter((w) => w <= asset.width);
+	if (widths.length === 0) widths.push(asset.width);
+	return {
+		sources: [{
+			type,
+			srcset: widths.map((w) => `${url} ${w}w`).join(", ")
+		}],
+		width: asset.width,
+		height: asset.height
+	};
+}
+function clamp01(n) {
+	return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function normalizeRect(v) {
+	const nx = typeof v.nx === "number" ? v.nx : 0;
+	const ny = typeof v.ny === "number" ? v.ny : 0;
+	const nw = typeof v.nw === "number" ? v.nw : 1;
+	const nh = typeof v.nh === "number" ? v.nh : 1;
+	if (![
+		nx,
+		ny,
+		nw,
+		nh
+	].every(Number.isFinite)) return null;
+	const r = {
+		nx: clamp01(nx),
+		ny: clamp01(ny),
+		nw: clamp01(nw),
+		nh: clamp01(nh)
+	};
+	if (r.nx === 0 && r.ny === 0 && r.nw === 1 && r.nh === 1) return null;
+	return r;
+}
+/**
+* Resolve one image-slot value against the pack.
+*
+* `null` passes through as `null`, so an optional image slot stays null and the
+* renderer skips it. Every other miss — an unknown id, an object with neither id
+* nor url — degrades to the empty default rather than throwing: image resolution
+* must degrade soft, and the empty `url` is what makes a dead id VISIBLE to
+* render-invariants instead of silently plausible.
+*/
+function resolveImageValue(value) {
+	if (value === null) return null;
+	if (typeof value !== "object") return { ...EMPTY_IMAGE };
+	const v = value;
+	const rect = v.rect && typeof v.rect === "object" ? normalizeRect(v.rect) : null;
+	const ar = typeof v.ar === "number" ? v.ar : null;
+	const cropKey = typeof v.crop_key === "string" && v.crop_key.length > 0 ? v.crop_key : null;
+	const photoId = typeof v.photo_id === "string" && v.photo_id ? v.photo_id : typeof v.asset_id === "string" && v.asset_id ? v.asset_id : "";
+	let base;
+	let cropKeyForAttach;
+	let source;
+	if (cropKey && photoId) {
+		source = getMediaAsset(cropKey);
+		if (!source) return { ...EMPTY_IMAGE };
+		base = {
+			photo_id: photoId,
+			url: mediaUrl(source.file),
+			alt: source.caption
+		};
+		cropKeyForAttach = cropKey;
+	} else if (photoId) {
+		source = getMediaAsset(photoId);
+		if (!source) return { ...EMPTY_IMAGE };
+		base = {
+			photo_id: photoId,
+			url: mediaUrl(source.file),
+			alt: source.caption
+		};
+		cropKeyForAttach = null;
+	} else if (typeof v.url === "string" && v.url.length > 0) {
+		base = {
+			photo_id: "",
+			url: v.url,
+			alt: typeof v.alt === "string" ? v.alt : ""
+		};
+		cropKeyForAttach = null;
+		source = null;
+	} else return { ...EMPTY_IMAGE };
+	if (rect) base.rect = rect;
+	if (ar) base.ar = ar;
+	if (cropKeyForAttach) base.crop_key = cropKeyForAttach;
+	const responsive = source ? responsiveFor(source) : null;
+	if (responsive) base.responsive = responsive;
+	return base;
+}
+/**
+* Attach the render-time fields to one floorplan ref. A saved plan ref carries only
+* id/upload_id/floor_label/position; url, alt, and the responsive descriptor appear
+* only after resolution. An unknown id yields an empty url — the same visible miss
+* an unknown image id produces.
+*/
+function resolveFloorplan(ref) {
+	const asset = getMediaAsset(ref.id);
+	if (!asset) return {
+		...ref,
+		url: "",
+		alt: ""
+	};
+	const responsive = responsiveFor(asset);
+	return {
+		...ref,
+		url: mediaUrl(asset.file),
+		alt: asset.caption,
+		...responsive ? { responsive } : {}
+	};
+}
+/**
+* Resolve one video-slot value against the pack. There is exactly one progressive
+* rendition per video, so there is no ladder and no mobile variant; the poster is
+* always present because the transcode derives one.
+*/
+function resolveVideoValue(value) {
+	if (value === null) return null;
+	if (typeof value !== "object") return { ...EMPTY_VIDEO };
+	const v = value;
+	const videoId = typeof v.video_id === "string" && v.video_id ? v.video_id : typeof v.asset_id === "string" && v.asset_id ? v.asset_id : "";
+	if (!videoId) {
+		if (typeof v.url === "string" && v.url.length > 0) return {
+			video_id: "",
+			url: v.url,
+			poster: typeof v.poster === "string" ? v.poster : "",
+			alt: typeof v.alt === "string" ? v.alt : ""
+		};
+		return { ...EMPTY_VIDEO };
+	}
+	const asset = getMediaAsset(videoId);
+	if (!asset) return { ...EMPTY_VIDEO };
+	return {
+		video_id: videoId,
+		url: mediaUrl(asset.file),
+		poster: asset.poster ? mediaUrl(asset.poster) : "",
+		alt: asset.caption,
+		...asset.width && asset.height ? {
+			width: asset.width,
+			height: asset.height
+		} : {}
+	};
+}
+
+//#endregion
+export { resolveFloorplan, resolveImageValue, resolveVideoValue };

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.9.0-dev-20260719205406";
+var version = "0.9.0";
 
 //#endregion
 export { version };

package/dist/schema/property-facts.d.ts

@@ -7,8 +7,8 @@ type Coordinates = {
 type FloorplanAssignment = {
   id: string;
   upload_id?: string;
-  url: string;
-  alt: string;
+  url?: string;
+  alt?: string;
   floor_label: string | null;
   position: number;
   responsive?: ResponsiveImage | null;

package/dist/schema/resolve-section-ref.d.ts

@@ -0,0 +1,4 @@
+//#region src/schema/resolve-section-ref.d.ts
+declare function resolveSectionRef(templateKey: string, ref: string): string;
+//#endregion
+export { resolveSectionRef };

package/dist/schema/rows.d.ts

@@ -0,0 +1,9 @@
+//#region src/schema/rows.d.ts
+type LayoutEntry = string | readonly [string, string];
+declare function flattenLayout(layout: readonly LayoutEntry[]): string[];
+declare function isShortSlot(slot: {
+  type: string;
+  size?: string;
+}): boolean;
+//#endregion
+export { LayoutEntry, flattenLayout, isShortSlot };

package/dist/schema/section-nav.d.ts

@@ -3,5 +3,9 @@ type SectionNav = {
   selfAnchor: string;
   anchors: Record<string, string>;
 };
+declare function resolveAnchorMap(sections: ReadonlyArray<{
+  key: string;
+  anchor: string;
+}>): Record<string, string>;
 //#endregion
-export { SectionNav };
+export { SectionNav, resolveAnchorMap };

package/dist/schema/slot-types.d.ts

@@ -11,8 +11,8 @@ declare function slotDefTypes(): SlotType[];
 declare const ContentSlot: z.ZodObject<{
   type: z.ZodEnum<{
     number: "number";
-    select: "select";
     text: "text";
+    select: "select";
     image: "image";
     image_collection: "image_collection";
     list: "list";

package/dist/ssr.d.ts

@@ -1,10 +1,16 @@
+import { resolveAnchorMap } from "./schema/section-nav.js";
 import { ResolvedFixture } from "./schema/fixture-schema.js";
 import "./schema/index.js";
 import { hasClientDirective, isClientFile, resetClientFileCache, resolveImportedFile } from "./islands/client-directive.js";
 import { isClientComponentFile, islandKey } from "./islands/detect.js";
-import { wrapClientModuleSource } from "./islands/wrap.js";
+import { wrapClientModuleMagic, wrapClientModuleSource } from "./islands/wrap.js";
 import { findSectionIslands } from "./islands/discover.js";
 import { islandTransformEsbuildPlugin } from "./islands/esbuild-plugin.js";
+import { DEV_MEDIA_URL_PREFIX, MediaAsset, MediaKind, getMediaAsset, listMediaAssets, mediaPackHasFile, packRelativeFromUrl } from "./media/pack.js";
+import { UnresolvedMedia, findUnresolvedMedia, resolveFixtureSetMedia } from "./media/resolve-fixture-media.js";
+import { Treatment, parseTreatment } from "./contracts/fill-treatments.js";
+import { LayoutEntry, flattenLayout, isShortSlot } from "./schema/rows.js";
+import { resolveSectionRef } from "./schema/resolve-section-ref.js";
 import { ComponentType } from "react";
 //#region src/ssr/index.d.ts
 type LoadedSection = {
@@ -16,6 +22,11 @@ type LoadedSection = {
     editable_by_user?: boolean;
     required?: boolean;
   }>;
+  unresolvedMedia: {
+    fixture: string;
+    field: string;
+    id: string;
+  }[];
 };
 type SectionModuleLoader = (dir: string, file: string) => Promise<unknown>;
 declare const nativeSectionLoader: SectionModuleLoader;
@@ -23,6 +34,12 @@ declare const nativeSectionLoader: SectionModuleLoader;
  * Load a bundle's Renderer plus its resolved snapshot and invariant fixture
  * sets from the bundle directory `dir`. `load` resolves each of the four
  * contract files; it defaults to native dynamic import.
+ *
+ * Media references resolve here, against the dev media pack: fixtures state the
+ * asset id `content_doc` holds, and a Renderer must receive the post-resolution
+ * `url`. This is the single fixture loader, so every Node-side caller — the
+ * registry's render + invariant gates, the dev server — gets resolved media
+ * without asking for it.
  */
 declare function loadSectionBundle(dir: string, load?: SectionModuleLoader): Promise<LoadedSection>;
 /**
@@ -31,4 +48,4 @@ declare function loadSectionBundle(dir: string, load?: SectionModuleLoader): Pro
  */
 declare function renderSectionHtml(renderer: ComponentType<Record<string, unknown>>, props: Record<string, unknown>): string;
 //#endregion
-export { LoadedSection, SectionModuleLoader, findSectionIslands, hasClientDirective, isClientComponentFile, isClientFile, islandKey, islandTransformEsbuildPlugin, loadSectionBundle, nativeSectionLoader, renderSectionHtml, resetClientFileCache, resolveImportedFile, wrapClientModuleSource };
+export { DEV_MEDIA_URL_PREFIX, type LayoutEntry, LoadedSection, type MediaAsset, type MediaKind, SectionModuleLoader, type Treatment, type UnresolvedMedia, findSectionIslands, findUnresolvedMedia, flattenLayout, getMediaAsset, hasClientDirective, isClientComponentFile, isClientFile, isShortSlot, islandKey, islandTransformEsbuildPlugin, listMediaAssets, loadSectionBundle, mediaPackHasFile, nativeSectionLoader, packRelativeFromUrl, parseTreatment, renderSectionHtml, resetClientFileCache, resolveAnchorMap, resolveFixtureSetMedia, resolveImportedFile, resolveSectionRef, wrapClientModuleMagic, wrapClientModuleSource };

package/dist/ssr.js

@@ -1,9 +1,15 @@
 import { FixtureModuleShape, buildFixtureSet, buildInvariantFixtures } from "./schema/fixture-schema.js";
+import { DEV_MEDIA_URL_PREFIX, getMediaAsset, listMediaAssets, mediaPackHasFile, packRelativeFromUrl } from "./media/pack.js";
+import { findUnresolvedMedia, resolveFixtureSetMedia } from "./media/resolve-fixture-media.js";
 import { hasClientDirective, isClientFile, resetClientFileCache, resolveImportedFile } from "./islands/client-directive.js";
 import { isClientComponentFile, islandKey } from "./islands/detect.js";
-import { wrapClientModuleSource } from "./islands/wrap.js";
+import { wrapClientModuleMagic, wrapClientModuleSource } from "./islands/wrap.js";
 import { findSectionIslands } from "./islands/discover.js";
 import { islandTransformEsbuildPlugin } from "./islands/esbuild-plugin.js";
+import { parseTreatment } from "./contracts/fill-treatments.js";
+import { flattenLayout, isShortSlot } from "./schema/rows.js";
+import { resolveSectionRef } from "./schema/resolve-section-ref.js";
+import { resolveAnchorMap } from "./schema/section-nav.js";
 import { createElement } from "react";
 import { basename, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -15,6 +21,12 @@ const nativeSectionLoader = (dir, file) => import(pathToFileURL(join(dir, file))
 * Load a bundle's Renderer plus its resolved snapshot and invariant fixture
 * sets from the bundle directory `dir`. `load` resolves each of the four
 * contract files; it defaults to native dynamic import.
+*
+* Media references resolve here, against the dev media pack: fixtures state the
+* asset id `content_doc` holds, and a Renderer must receive the post-resolution
+* `url`. This is the single fixture loader, so every Node-side caller — the
+* registry's render + invariant gates, the dev server — gets resolved media
+* without asking for it.
 */
 async function loadSectionBundle(dir, load = nativeSectionLoader) {
 	const rendererMod = await load(dir, "Renderer.tsx");
@@ -22,19 +34,26 @@ async function loadSectionBundle(dir, load = nativeSectionLoader) {
 	const schemaMod = await load(dir, "schema.ts");
 	const parsed = FixtureModuleShape.parse(fixturesMod.default);
 	const selfAnchor = schemaMod.schema.meta?.anchor ?? basename(dir);
+	const snapshot = buildFixtureSet({
+		schema: schemaMod.schema,
+		module: parsed,
+		selfAnchor
+	});
+	const invariant = buildInvariantFixtures({
+		schema: schemaMod.schema,
+		module: parsed,
+		selfAnchor
+	});
+	const unresolvedMedia = invariant.flatMap((fixture) => findUnresolvedMedia(fixture.props).map((miss) => ({
+		fixture: fixture.id,
+		...miss
+	})));
 	return {
 		Renderer: rendererMod.default,
-		snapshotFixtures: buildFixtureSet({
-			schema: schemaMod.schema,
-			module: parsed,
-			selfAnchor
-		}),
-		invariantFixtures: buildInvariantFixtures({
-			schema: schemaMod.schema,
-			module: parsed,
-			selfAnchor
-		}),
-		schemaSlots: schemaMod.schema.slots
+		snapshotFixtures: resolveFixtureSetMedia(snapshot),
+		invariantFixtures: resolveFixtureSetMedia(invariant),
+		schemaSlots: schemaMod.schema.slots,
+		unresolvedMedia
 	};
 }
 /**
@@ -46,4 +65,4 @@ function renderSectionHtml(renderer, props) {
 }
 
 //#endregion
-export { findSectionIslands, hasClientDirective, isClientComponentFile, isClientFile, islandKey, islandTransformEsbuildPlugin, loadSectionBundle, nativeSectionLoader, renderSectionHtml, resetClientFileCache, resolveImportedFile, wrapClientModuleSource };
+export { DEV_MEDIA_URL_PREFIX, findSectionIslands, findUnresolvedMedia, flattenLayout, getMediaAsset, hasClientDirective, isClientComponentFile, isClientFile, isShortSlot, islandKey, islandTransformEsbuildPlugin, listMediaAssets, loadSectionBundle, mediaPackHasFile, nativeSectionLoader, packRelativeFromUrl, parseTreatment, renderSectionHtml, resetClientFileCache, resolveAnchorMap, resolveFixtureSetMedia, resolveImportedFile, resolveSectionRef, wrapClientModuleMagic, wrapClientModuleSource };

package/guide/INDEX.md

@@ -11,6 +11,11 @@ This tree **ships in the npm tarball** (`guide/` is listed in `package.json`'s
 LLM agents, reading it from inside `node_modules`. Keep it free of internal-only
 detail.
 
+Every `template-kit <command>` on these pages is spelled exactly as you type it.
+The package that provides that command is `@homepages/template-cli`, a
+devDependency alongside the kit — see [Upgrading](upgrading.md) for its separate
+version line.
+
 | Doc | What it covers | Read when you're touching... |
 |---|---|---|
 | `quickstart.md` | The cold-start tutorial: create a workspace, preview the starter's `hero` section, read its four files, make one edit, and check it — owns the author-loop anchor every recipe links to | your first section, end to end |

package/guide/check.md

@@ -28,6 +28,7 @@ one or pass `--all`.
 ### What it needs installed
 
 ```bash
+npm i -D @homepages/template-cli   # provides the `template-kit` command
 npm i -D typescript eslint @typescript-eslint/parser esbuild @homepages/eslint-plugin-template
 ```
 

package/guide/dev.md

@@ -28,6 +28,7 @@ command runs until you interrupt it (Ctrl-C).
 ### What it needs installed
 
 ```bash
+npm i -D @homepages/template-cli   # provides the `template-kit` command
 npm i -D vite @vitejs/plugin-react tailwindcss @tailwindcss/cli
 ```
 

package/guide/llms.txt

@@ -1,8 +1,8 @@
 # @homepages/template-kit
 
 > The authoring kit for HomePages marketing-section templates. This corpus ships
-> inside the npm package so an agent can read it locally, versioned in lockstep
-> with the code it describes.
+> inside the npm package so an agent can read it locally, versioned with the
+> authoring contract it describes.
 
 Status: 0.x — pre-1.0, so a minor is the breaking axis and a patch carries features
 as well as fixes; see [Upgrading](upgrading.md). The schema system, the contract
@@ -13,6 +13,12 @@ implemented — see [Check](check.md), [Theme and CSS](theme-and-css.md#generati
 [Dev](dev.md), [Pack](pack.md), and [Adding templates](new.md); its remaining
 commands arrive with the surfaces they drive.
 
+The **command is `template-kit`; the package that provides it is
+`@homepages/template-cli`**, a devDependency alongside the kit. It versions on its
+own line and declares the kit as a peer dependency, so a workspace resolves exactly
+one kit. Every command written in this corpus is spelled the same either way — only
+the install line names the CLI package.
+
 Everything an author writes a section against is imported from the package root —
 `@homepages/template-kit`. The exceptions are deliberate: the two CSS entries
 (`./styles.css`, `./base.css`), and `./fixtures` — the golden scenarios, which only
@@ -102,7 +108,9 @@ and [Pick a scenario](recipes/pick-a-scenario.md).
   patch (0.4.0 → 0.4.1) carries features AND fixes and `npm update` takes it, while
   a minor (0.4.x → 0.5.0) is breaking and needs an explicit
   `npm install @homepages/template-kit@^0.5.0` — a 0.x caret never crosses a minor.
-  Submissions are accepted against the current kit line and the one before it.
+  `@homepages/template-cli` and `@homepages/eslint-plugin-template` each version on
+  their own line and update separately. Submissions are accepted against the current
+  kit line and the one before it.
 - [Adding templates](new.md): the `template-kit new <template>` and
   `template-kit new-section <template>/<section>` CLI commands — scaffolding a new
   template with a working starter section, or adding a bare section (the four