@decocms/blocks 7.0.0

package/src/cms/loadDecofileDirectory.test.ts

@@ -0,0 +1,52 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadDecofileDirectory } from "./loadDecofileDirectory";
+
+describe("loadDecofileDirectory", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "decofile-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("loads every .json file in the directory into a keyed map", async () => {
+    writeFileSync(
+      join(dir, "pages-home-123.json"),
+      JSON.stringify({ __resolveType: "website/pages/Page.tsx", path: "/" }),
+    );
+    writeFileSync(
+      join(dir, "Banner Grid - 01.json"),
+      JSON.stringify({ __resolveType: "site/sections/BannerGrid.tsx" }),
+    );
+
+    const blocks = await loadDecofileDirectory(dir);
+
+    expect(Object.keys(blocks)).toHaveLength(2);
+    expect(blocks["pages-home-123"]).toEqual({
+      __resolveType: "website/pages/Page.tsx",
+      path: "/",
+    });
+    expect(blocks["Banner Grid - 01"]).toEqual({
+      __resolveType: "site/sections/BannerGrid.tsx",
+    });
+  });
+
+  it("ignores non-.json files", async () => {
+    writeFileSync(join(dir, "readme.md"), "not a block");
+    writeFileSync(join(dir, "a.json"), JSON.stringify({ x: 1 }));
+
+    const blocks = await loadDecofileDirectory(dir);
+    expect(Object.keys(blocks)).toEqual(["a"]);
+  });
+
+  it("throws with the filename on invalid JSON", async () => {
+    writeFileSync(join(dir, "broken.json"), "{not valid json");
+    await expect(loadDecofileDirectory(dir)).rejects.toThrow(/broken\.json/);
+  });
+});

package/src/cms/loadDecofileDirectory.ts

@@ -0,0 +1,48 @@
+import * as fs from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * Loads a directory of legacy per-block JSON snapshot files (the format
+ * produced by the pre-v2 Deco admin, e.g. `.deco/blocks/<name>.json`) into
+ * a single blocks map suitable for setBlocks(). Each file becomes one
+ * entry keyed by its filename minus the .json extension.
+ *
+ * The key is not renamed or normalized beyond stripping the extension:
+ * whatever prefix convention a block's filename already carries (e.g. real
+ * page block snapshots are named `pages-<slug>-<id>.json`) is preserved
+ * verbatim, because getAllPages() in loader.ts filters blocks by
+ * `key.startsWith("pages-")` before findPageByPath() matches on each page's
+ * own `.path` field. So the key format IS load-bearing for page blocks —
+ * it must keep whatever prefix its source filename had — but this loader
+ * never needs to invent or choose that prefix itself, since it simply
+ * passes the on-disk filename through.
+ *
+ * Replaces the abandoned @decocms/start/node tier's loadAllDecofileBlocks,
+ * which no longer exists on any reachable deco-start version — ported
+ * fresh rather than resurrected. Namespace-imported node:fs/promises to
+ * match this codebase's existing pattern for Node-only code that must not
+ * break Vite/webpack client bundle analysis (see cms/loader.ts's
+ * AsyncLocalStorage import for the established precedent).
+ */
+export async function loadDecofileDirectory(dir: string): Promise<Record<string, unknown>> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const blocks: Record<string, unknown> = {};
+
+  await Promise.all(
+    entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+      .map(async (entry) => {
+        const key = entry.name.slice(0, -".json".length);
+        const content = await fs.readFile(join(dir, entry.name), "utf8");
+        try {
+          blocks[key] = JSON.parse(content);
+        } catch (error) {
+          throw new Error(
+            `loadDecofileDirectory: failed to parse ${entry.name}: ${(error as Error).message}`,
+          );
+        }
+      }),
+  );
+
+  return blocks;
+}

package/src/cms/loader.test.ts

@@ -0,0 +1,184 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { findPageByPath, matchPath, setBlocks } from "./loader";
+
+// Mirrors the behavior of the original deco-cx/deco Fresh framework
+// (runtime/features/render.tsx), which uses native `URLPattern` directly
+// and returns `result.pathname.groups`. Splats become numbered groups
+// ("0", "1", …) — there is no `_splat` rename.
+
+describe("matchPath", () => {
+  describe("literal segments", () => {
+    it("matches the root path", () => {
+      expect(matchPath("/", "/")).toEqual({});
+    });
+
+    it("matches exact literal paths", () => {
+      expect(matchPath("/foo/bar", "/foo/bar")).toEqual({});
+    });
+
+    it("returns null when literals differ", () => {
+      expect(matchPath("/foo/bar", "/foo/baz")).toBeNull();
+    });
+
+    it("returns null when literal-only pattern does not span the whole URL", () => {
+      expect(matchPath("/foo", "/foo/bar")).toBeNull();
+    });
+  });
+
+  describe("named params (:slug)", () => {
+    it("captures a single param", () => {
+      expect(matchPath("/foo/:slug", "/foo/sabonete")).toEqual({ slug: "sabonete" });
+    });
+
+    it("captures a param sandwiched between literals (VTEX PDP)", () => {
+      expect(matchPath("/produto/:slug/p", "/produto/sabonete/p")).toEqual({
+        slug: "sabonete",
+      });
+    });
+
+    it("returns null when the URL is shorter than the pattern", () => {
+      expect(matchPath("/foo/:slug", "/foo")).toBeNull();
+    });
+  });
+
+  describe("trailing splat (*)", () => {
+    it("captures the rest as group '0'", () => {
+      expect(matchPath("/*", "/foo/bar")).toEqual({ "0": "foo/bar" });
+    });
+
+    it("matches root with empty splat", () => {
+      expect(matchPath("/*", "/")).toEqual({ "0": "" });
+    });
+
+    it("captures the remainder under a prefix", () => {
+      expect(matchPath("/foo/*", "/foo/bar/baz")).toEqual({ "0": "bar/baz" });
+    });
+
+    // Intentional bug fix: the previous custom matchPath accidentally matched
+    // `/foo` against `/foo/*` due to its naive split("/") logic, which also
+    // mis-handled trailing slashes. Native URLPattern (and the Fresh original)
+    // require at least one segment after `/foo/`.
+    it("does NOT match the bare prefix without a trailing segment", () => {
+      expect(matchPath("/foo/*", "/foo")).toBeNull();
+    });
+  });
+
+  describe("URLPattern optional groups ({...}?)", () => {
+    // Patterns emitted by the deco-cx admin / present in production CMS data.
+    // These are the cases that issue #213 documents as broken.
+
+    it("matches with the optional group present", () => {
+      expect(matchPath("/{granado/}?*", "/granado/perfumaria")).toEqual({
+        "0": "perfumaria",
+      });
+    });
+
+    it("matches with the optional group absent", () => {
+      expect(matchPath("/{granado/}?*", "/perfumaria")).toEqual({ "0": "perfumaria" });
+    });
+
+    it("matches root when optional prefix and splat collapse to empty", () => {
+      expect(matchPath("/{granado/}?*", "/")).toEqual({ "0": "" });
+    });
+
+    it("matches with an optional prefix before a literal segment", () => {
+      expect(
+        matchPath("/{granado/}?campanhas/*", "/granado/campanhas/destaques-2023"),
+      ).toEqual({ "0": "destaques-2023" });
+      expect(
+        matchPath("/{granado/}?campanhas/*", "/campanhas/destaques-2023"),
+      ).toEqual({ "0": "destaques-2023" });
+    });
+
+    it("matches an optional suffix group present and absent", () => {
+      expect(matchPath("/black-friday{/70-off}?", "/black-friday")).toEqual({});
+      expect(matchPath("/black-friday{/70-off}?", "/black-friday/70-off")).toEqual({});
+    });
+  });
+
+  describe("error tolerance", () => {
+    it("returns null for malformed patterns instead of throwing", () => {
+      expect(() => matchPath("/[invalid", "/anything")).not.toThrow();
+      expect(matchPath("/[invalid", "/anything")).toBeNull();
+    });
+  });
+});
+
+describe("findPageByPath specificity", () => {
+  beforeEach(() => {
+    setBlocks({
+      "pages-bf": {
+        name: "Black Friday",
+        path: "/black-friday",
+        sections: [],
+      },
+      "pages-bf-splat": {
+        name: "Black Friday with optional suffix",
+        path: "/black-friday{/70-off}?",
+        sections: [],
+      },
+      "pages-pdp-plp": {
+        name: "PDP & PLP",
+        path: "/{granado/}?*",
+        sections: [],
+      },
+      "pages-product": {
+        name: "Product",
+        path: "/produto/:slug/p",
+        sections: [],
+      },
+    });
+  });
+
+  afterEach(() => {
+    setBlocks({});
+  });
+
+  it("prefers an exact literal over an optional-group splat", () => {
+    const match = findPageByPath("/black-friday");
+    expect(match?.blockKey).toBe("pages-bf");
+  });
+
+  it("prefers the home page over an optional-group splat catch-all", () => {
+    // Regression: /{granado/}?* matches "/" and was out-ranking the home
+    // because the `{granado` segment counted as a param. The home block
+    // is a literal-only `/` path and must always win.
+    setBlocks({
+      "pages-home": {
+        name: "Home",
+        path: "/",
+        sections: [],
+      },
+      "pages-pdp-plp": {
+        name: "PDP & PLP",
+        path: "/{granado/}?*",
+        sections: [],
+      },
+    });
+    const match = findPageByPath("/");
+    expect(match?.blockKey).toBe("pages-home");
+  });
+
+  it("falls back to the splat page for unknown URLs", () => {
+    const match = findPageByPath("/perfumaria");
+    expect(match?.blockKey).toBe("pages-pdp-plp");
+    expect(match?.params).toEqual({ "0": "perfumaria" });
+  });
+
+  it("matches the param-bearing route ahead of the splat catch-all", () => {
+    const match = findPageByPath("/produto/sabonete/p");
+    expect(match?.blockKey).toBe("pages-product");
+    expect(match?.params).toEqual({ slug: "sabonete" });
+  });
+
+  it("returns null when no page matches", () => {
+    setBlocks({
+      "pages-only-bf": {
+        name: "Black Friday",
+        path: "/black-friday",
+        sections: [],
+      },
+    });
+    expect(findPageByPath("/nope")).toBeNull();
+  });
+});

package/src/cms/loader.ts

@@ -0,0 +1,284 @@
+import * as asyncHooks from "node:async_hooks";
+import { djb2Hex } from "../sdk/djb2";
+
+export type Resolvable = {
+  __resolveType?: string;
+  [key: string]: unknown;
+};
+
+export type DecoPage = {
+  name: string;
+  path?: string;
+  sections: Resolvable[] | Resolvable;
+  seo?: Record<string, unknown>;
+};
+
+// globalThis-backed storage: TanStack Start server function split modules
+// may get isolated module instances. globalThis ensures shared state.
+const G = globalThis as any;
+if (!G.__deco) G.__deco = {};
+
+let blockData: Record<string, unknown> = G.__deco.blockData ?? {};
+let revision: string | null = G.__deco.revision ?? null;
+
+interface ALSLike<T> {
+  getStore(): T | undefined;
+  run<R>(store: T, fn: () => R): R;
+}
+
+// AsyncLocalStorage might not be available in client builds (Vite replaces
+// node:async_hooks with an empty shim). The namespace import avoids Rollup's
+// named-export validation, and the runtime check prevents construction errors.
+const ALS = (asyncHooks as any).AsyncLocalStorage;
+const blocksOverrideStorage: ALSLike<Record<string, unknown>> = ALS
+  ? new ALS()
+  : { getStore: () => undefined, run: (_s: any, fn: any) => fn() };
+
+// ---------------------------------------------------------------------------
+// Change listeners
+// ---------------------------------------------------------------------------
+
+type ChangeListener = (blocks: Record<string, unknown>, revision: string) => void;
+const changeListeners: ChangeListener[] = [];
+
+/** Register a callback invoked whenever setBlocks() changes the decofile. */
+export function onChange(listener: ChangeListener) {
+  changeListeners.push(listener);
+  return () => {
+    const idx = changeListeners.indexOf(listener);
+    if (idx >= 0) changeListeners.splice(idx, 1);
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Revision hashing
+// ---------------------------------------------------------------------------
+
+function computeRevision(blocks: Record<string, unknown>): string {
+  return djb2Hex(JSON.stringify(blocks));
+}
+
+// ---------------------------------------------------------------------------
+// Block management
+// ---------------------------------------------------------------------------
+
+/**
+ * Set the blocks data. Called at startup with generated blocks,
+ * and by the admin on hot-reload.
+ * Notifies all onChange listeners and updates the revision.
+ */
+export function setBlocks(blocks: Record<string, unknown>) {
+  blockData = blocks;
+  revision = computeRevision(blocks);
+
+  // Persist to globalThis so other module instances see them
+  G.__deco.blockData = blockData;
+  G.__deco.revision = revision;
+
+  for (const listener of [...changeListeners]) {
+    try {
+      listener(blocks, revision);
+    } catch (e) {
+      console.error("[CMS] onChange listener error:", e);
+    }
+  }
+}
+
+/**
+ * Load the current blocks. If running inside a `withBlocksOverride` scope
+ * (admin preview), the override is merged on top of the base blocks.
+ */
+export function loadBlocks(): Record<string, unknown> {
+  // Re-sync from globalThis in case setBlocks was called in another module instance
+  if (G.__deco.blockData && G.__deco.blockData !== blockData) {
+    blockData = G.__deco.blockData;
+    revision = G.__deco.revision ?? null;
+  }
+
+  const override = blocksOverrideStorage.getStore();
+  if (override) {
+    const merged = { ...blockData };
+    for (const [key, value] of Object.entries(override)) {
+      if (value === null || value === undefined) {
+        delete merged[key];
+      } else {
+        merged[key] = value;
+      }
+    }
+    return merged;
+  }
+  return blockData;
+}
+
+/** Get the current decofile revision hash. Changes on each setBlocks(). */
+export function getRevision(): string | null {
+  return revision;
+}
+
+/**
+ * Run a function with a temporary blocks overlay.
+ *
+ * Used by admin preview: the admin sends a partial decofile (only the
+ * blocks that changed), and `loadBlocks()` returns the merged result
+ * for the duration of the render. Other concurrent requests are not
+ * affected (AsyncLocalStorage is per-request scoped).
+ */
+export function withBlocksOverride<T>(override: Record<string, unknown>, fn: () => T): T {
+  return blocksOverrideStorage.run(override, fn);
+}
+
+// Higher key wins. Compared lexicographically:
+//   [hasNoWildcard, literalSegments, paramSegments]
+//
+// `hasNoWildcard` is the top key so a literal-only path always beats any
+// pattern that contains `*` or `{group}?` — including the empty-parts case
+// `/` (literals=0) vs the catch-all `/{prefix/}?*` (literals=0, params=1).
+// Without this, the URLPattern fix (#213/#214) inadvertently lets a
+// `/{group/}?*` catch-all out-rank an exact `/` home page because the
+// `{group` segment counted as a param. See deco-sites/granadobr-tanstack
+// where `/` was being routed to the granado PDP/PLP block's NotFound
+// fallback.
+//
+// Order produced:
+//   /foo/bar (no wildcard, literals=2) > /foo/:x (no wildcard, lit=1, param=1)
+//   /foo (no wildcard) > /{granado/}?*  (has wildcard) > /*
+function pathSpecificityKey(path: string): [number, number, number] {
+  const parts = path.split("/").filter(Boolean);
+  let literals = 0;
+  let params = 0;
+  let hasWildcard = false;
+  for (const part of parts) {
+    // A wildcard is any `*`, optional group `{...}?`, or any segment
+    // bearing `?` — these all make the pattern match strictly more URLs
+    // than a plain literal/`:param`/`:slug([\w-]+)` segment, so they
+    // are demoted to "least specific" together regardless of count.
+    if (part.includes("*") || /[{}?]/.test(part)) {
+      hasWildcard = true;
+    } else if (part.startsWith(":") || part.startsWith("$")) {
+      params++;
+    } else {
+      literals++;
+    }
+  }
+  return [hasWildcard ? 0 : 1, literals, params];
+}
+
+export function getAllPages(): Array<{ key: string; page: DecoPage }> {
+  const blocks = loadBlocks();
+  const pages: Array<{ key: string; page: DecoPage; key2: [number, number, number] }> = [];
+
+  for (const [key, block] of Object.entries(blocks)) {
+    if (!key.startsWith("pages-")) continue;
+    const page = block as DecoPage;
+    if (!page.sections) continue;
+    if (!page.path) continue;
+
+    pages.push({ key, page, key2: pathSpecificityKey(page.path) });
+  }
+
+  return pages
+    .sort((a, b) => {
+      for (let i = 0; i < a.key2.length; i++) {
+        if (a.key2[i] !== b.key2[i]) return b.key2[i] - a.key2[i];
+      }
+      return 0;
+    })
+    .map(({ key, page }) => ({ key, page }));
+}
+
+// Module-scoped (NOT `declare global`) ambient declaration for the
+// `URLPattern` Web API. It's natively available at runtime in browsers,
+// Cloudflare Workers, Deno, and Node 24+, but its type declarations aren't
+// consistently present: TypeScript's bundled lib.dom.d.ts doesn't ship it
+// yet, and @types/node only started shipping a global augmentation for it
+// in newer major versions (via `node/web-globals/url.d.ts`).
+//
+// A `declare global` shim here would merge with @types/node's own global
+// `URLPattern`/`URLPatternResult` augmentation whenever a new-enough
+// @types/node wins the workspace's package hoist — and merging two
+// independently-authored global interfaces under the same name throws
+// TS2430 ("incorrectly extends") the moment their shapes don't line up
+// structurally. Declaring `URLPattern` and its result shape as file-local
+// bindings instead (no `declare global`) means this file typechecks the
+// same regardless of whether @types/node has its own `URLPattern` global or
+// not — there's nothing for a local declaration to collide with.
+type MatchPatternResult = {
+	pathname: { groups: Record<string, string | undefined> };
+};
+declare const URLPattern: {
+	new (init: { pathname: string }): {
+		exec(input: { pathname: string }): MatchPatternResult | null;
+	};
+};
+
+/**
+ * Match a CMS page path pattern against a URL path.
+ *
+ * Mirrors the original deco-cx/deco Fresh framework
+ * (`runtime/features/render.tsx`) by delegating to the platform's native
+ * `URLPattern`. Supports the full URLPattern syntax that the admin emits:
+ * `:slug`, `:slug([\w-]+)`, optional groups `{...}?`, and trailing `*`
+ * splats. Splats are exposed as the standard numbered groups (`"0"`, `"1"`,
+ * …), matching the Fresh shape.
+ *
+ * Malformed patterns return `null` instead of throwing — bad CMS data must
+ * never take down the worker.
+ */
+export function matchPath(
+  pattern: string,
+  urlPath: string,
+): Record<string, string> | null {
+  let result: MatchPatternResult | null;
+  try {
+    result = new URLPattern({ pathname: pattern }).exec({ pathname: urlPath });
+  } catch {
+    return null;
+  }
+  if (!result) return null;
+
+  const groups = result.pathname.groups as Record<string, string | undefined>;
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(groups)) {
+    if (v !== undefined) out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * Extract the site-wide SEO config from the "Site" app block.
+ *
+ * In the original deco-cx/deco framework this is `ctx.seo` — the app-level
+ * SEO configuration that provides fallback title, description, and templates
+ * when page-level seo blocks don't supply them.
+ */
+export function getSiteSeo(): {
+  title?: string;
+  description?: string;
+  titleTemplate?: string;
+  descriptionTemplate?: string;
+  image?: string;
+  favicon?: string;
+  themeColor?: string;
+  noIndexing?: boolean;
+} {
+  const blocks = loadBlocks();
+  const site = blocks["Site"] as Record<string, unknown> | undefined;
+  if (!site) return {};
+  const seo = site.seo as Record<string, unknown> | undefined;
+  if (!seo) return {};
+  return seo as ReturnType<typeof getSiteSeo>;
+}
+
+export function findPageByPath(
+  targetPath: string,
+): { page: DecoPage; params: Record<string, string>; blockKey: string } | null {
+  const allPages = getAllPages();
+
+  for (const { key, page } of allPages) {
+    if (!page.path) continue;
+    const params = matchPath(page.path, targetPath);
+    if (params !== null) return { page, params, blockKey: key };
+  }
+
+  return null;
+}

package/src/cms/registry.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import {
+  registerSection,
+  registerSectionsSync,
+  getSection,
+  getSectionOptions,
+  getSyncComponent,
+  getResolvedComponent,
+} from "./registry";
+
+// Reset globalThis.__deco between tests to avoid cross-test pollution
+beforeEach(() => {
+  const G = globalThis as any;
+  G.__deco.sectionRegistry = {};
+  G.__deco.sectionOptions = {};
+  G.__deco.resolvedComponents = {};
+  G.__deco.syncComponents = {};
+});
+
+describe("registerSection + getSection", () => {
+  it("registers and retrieves a section loader", () => {
+    const loader = async () => ({ default: () => null });
+    registerSection("site/sections/Hero.tsx", loader);
+
+    const retrieved = getSection("site/sections/Hero.tsx");
+    expect(retrieved).toBe(loader);
+  });
+
+  it("returns undefined for unregistered section", () => {
+    expect(getSection("nonexistent")).toBeUndefined();
+  });
+});
+
+describe("registerSection with options", () => {
+  it("stores loadingFallback in section options", () => {
+    const fallback = () => null;
+    registerSection(
+      "site/sections/Shelf.tsx",
+      async () => ({ default: () => null }),
+      { loadingFallback: fallback },
+    );
+
+    const opts = getSectionOptions("site/sections/Shelf.tsx");
+    expect(opts?.loadingFallback).toBe(fallback);
+  });
+
+  it("stores clientOnly flag in section options", () => {
+    registerSection(
+      "site/sections/Analytics.tsx",
+      async () => ({ default: () => null }),
+      { clientOnly: true },
+    );
+
+    const opts = getSectionOptions("site/sections/Analytics.tsx");
+    expect(opts?.clientOnly).toBe(true);
+  });
+
+  it("clientOnly defaults to undefined when not set", () => {
+    registerSection(
+      "site/sections/Normal.tsx",
+      async () => ({ default: () => null }),
+      { loadingFallback: () => null },
+    );
+
+    const opts = getSectionOptions("site/sections/Normal.tsx");
+    expect(opts?.clientOnly).toBeUndefined();
+  });
+
+  it("clientOnly false is preserved", () => {
+    registerSection(
+      "site/sections/Explicit.tsx",
+      async () => ({ default: () => null }),
+      { clientOnly: false },
+    );
+
+    const opts = getSectionOptions("site/sections/Explicit.tsx");
+    expect(opts?.clientOnly).toBe(false);
+  });
+
+  it("returns undefined options for section without options", () => {
+    registerSection("site/sections/Plain.tsx", async () => ({ default: () => null }));
+    expect(getSectionOptions("site/sections/Plain.tsx")).toBeUndefined();
+  });
+});
+
+describe("registerSectionsSync", () => {
+  it("registers component as sync and resolved", () => {
+    const MyComponent = () => null;
+    registerSectionsSync({ "site/sections/Header.tsx": MyComponent });
+
+    expect(getSyncComponent("site/sections/Header.tsx")).toBe(MyComponent);
+    expect(getResolvedComponent("site/sections/Header.tsx")).toBe(MyComponent);
+  });
+
+  it("accepts module objects with LoadingFallback", () => {
+    const MyComponent = () => null;
+    const MyFallback = () => null;
+
+    registerSectionsSync({
+      "site/sections/Footer.tsx": {
+        default: MyComponent,
+        LoadingFallback: MyFallback,
+      },
+    });
+
+    expect(getSyncComponent("site/sections/Footer.tsx")).toBe(MyComponent);
+    const opts = getSectionOptions("site/sections/Footer.tsx");
+    expect(opts?.loadingFallback).toBe(MyFallback);
+  });
+
+  it("skips entries without callable default export", () => {
+    registerSectionsSync({
+      "site/sections/Bad.tsx": { default: "not a function" } as any,
+    });
+
+    expect(getSyncComponent("site/sections/Bad.tsx")).toBeUndefined();
+  });
+});