@feeef.dev/cli 0.2.1 → 0.2.3

package/vendor/template-kit/lib/build.mjs

@@ -7,7 +7,7 @@
  * Components may be:
  * - Flat page-level: `pages/<page>/components/hero.tsx` → published as `sections.main`
  * - Legacy sections: `pages/<page>/sections/<id>/components/…`
- * - Flat or folder entries under any `components/` dir (`hero.tsx` or `hero/component.tsx`)
+ * - Flat or folder entries under any `components/` dir (`hero.tsx` or `hero/hero.tsx`)
  */
 
 import fs from "node:fs";

package/vendor/template-kit/lib/component-meta.mjs

@@ -4,7 +4,8 @@
  *
  * Entries may be:
  * - Flat file: `components/hero.tsx` (or `.jsx` / `.json`)
- * - Folder: `components/hero/component.tsx` (+ optional nested slots/children)
+ * - Folder: `components/hero/hero.tsx` (+ optional nested slots/children)
+ * - Legacy folder: `components/hero/component.tsx`
  */
 
 import fs from "node:fs";
@@ -64,6 +65,7 @@ export function isFlatComponentFile(root) {
 
 /**
  * Resolve the TSX/JSX source file for a component root (dir or flat file).
+ * Prefer `<id>/<id>.tsx`; fall back to legacy `component.tsx`.
  * @param {string} root Absolute path to component folder or flat `.tsx`/`.jsx`/`.json`
  * @returns {string | null}
  */
@@ -73,6 +75,11 @@ export function resolveComponentEntry(root) {
     if (FLAT_CODE_EXT.has(ext)) return root;
     return null;
   }
+  const id = path.basename(root);
+  const namedTsx = path.join(root, `${id}.tsx`);
+  const namedJsx = path.join(root, `${id}.jsx`);
+  if (fs.existsSync(namedTsx)) return namedTsx;
+  if (fs.existsSync(namedJsx)) return namedJsx;
   const tsx = path.join(root, "component.tsx");
   const jsx = path.join(root, "component.jsx");
   if (fs.existsSync(tsx)) return tsx;
@@ -80,6 +87,23 @@ export function resolveComponentEntry(root) {
   return null;
 }
 
+/**
+ * Resolve folder meta JSON (`<id>/<id>.json` or legacy `component.json`).
+ * @param {string} root Absolute component folder
+ * @returns {string | null}
+ */
+export function resolveComponentMetaJson(root) {
+  if (isFlatComponentFile(root)) {
+    return path.extname(root).toLowerCase() === ".json" ? root : null;
+  }
+  const id = path.basename(root);
+  const named = path.join(root, `${id}.json`);
+  if (fs.existsSync(named)) return named;
+  const legacy = path.join(root, "component.json");
+  if (fs.existsSync(legacy)) return legacy;
+  return null;
+}
+
 /**
  * List component entries under a `components/` (or `children/` / `slots/<id>/`) dir.
  * Supports flat `name.tsx|jsx|json` and legacy `name/` folders.
@@ -454,28 +478,88 @@ export function loadComponentMeta(root) {
     }
   }
 
-  const jsonPath = path.join(root, "component.json");
-  if (fs.existsSync(jsonPath)) {
+  const jsonPath = resolveComponentMetaJson(root);
+  if (jsonPath) {
     const meta = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
     return { meta, source: "json", entry, jsonPath };
   }
 
   throw new Error(
-    `Missing component meta in ${rel(root)} — add export const meta in component.tsx / <name>.tsx or component.json`,
+    `Missing component meta in ${rel(root)} — add export const meta in <name>/<name>.tsx or <name>.json`,
   );
 }
 
 /**
- * Serialize meta as a TS `export const meta = …` preamble for unpack.
+ * Indent a multi-line JSON value so it sits inside an object literal.
+ * @param {unknown} value
+ * @param {number} indent
+ */
+function indentJson(value, indent = 2) {
+  const pad = " ".repeat(indent);
+  return JSON.stringify(value, null, 2)
+    .split("\n")
+    .map((line, i) => (i === 0 ? line : pad + line))
+    .join("\n");
+}
+
+/**
+ * Serialize meta as a typed TS preamble for unpack (blank contract).
+ * Emits `propsSchema` + `satisfies FeeefComponentMeta` + `FeeefLivePropsOf`.
  * @param {Record<string, any>} meta
  */
 export function formatMetaExport(meta) {
   const clean = { ...meta };
   delete clean.$schema;
   delete clean.code;
-  // Keep order + COMPONENT_META_KEYS + any extra catalog fields already on meta
-  const json = JSON.stringify(clean, null, 2);
-  return `export const meta = ${json} as const;\n\n`;
+  delete clean.sourcePath;
+
+  const propsSchema =
+    clean.propsSchema && typeof clean.propsSchema === "object"
+      ? clean.propsSchema
+      : {};
+  delete clean.propsSchema;
+
+  if (!Object.prototype.hasOwnProperty.call(clean, "props")) {
+    clean.props = {};
+  }
+
+  /** Preferred key order for readable authoring files. */
+  const preferred = [
+    "order",
+    "type",
+    "instanceId",
+    "title",
+    "props",
+    "slotsSchema",
+    "slotsLayout",
+    "children",
+    "slots",
+    "refId",
+    "refVersion",
+  ];
+  const keys = [
+    ...preferred.filter((k) => Object.prototype.hasOwnProperty.call(clean, k)),
+    ...Object.keys(clean).filter((k) => !preferred.includes(k)),
+  ];
+
+  const lines = [];
+  for (const key of keys) {
+    if (key === "props") {
+      // propsSchema identifier sits just before props (blank hero order).
+      lines.push(`  propsSchema,`);
+    }
+    lines.push(`  ${key}: ${indentJson(clean[key], 2)},`);
+  }
+  if (!keys.includes("props")) {
+    lines.push(`  propsSchema,`);
+  }
+
+  return (
+    `const propsSchema = ${JSON.stringify(propsSchema, null, 2)} as const;\n\n` +
+    `export const meta = {\n${lines.join("\n")}\n` +
+    `} as const satisfies FeeefComponentMeta<typeof propsSchema>;\n\n` +
+    `type Props = FeeefLivePropsOf<typeof propsSchema>;\n\n`
+  );
 }
 
 export { COMPONENT_META_KEYS };

package/vendor/template-kit/lib/unpack.mjs

@@ -1,15 +1,21 @@
 /**
  * Unpack a Lithium TemplateData JSON blob into a folder-based source tree.
  *
- * Layout:
+ * Layout (always flat page components — rebuilds as sections.main):
  *   <out>/
  *     feeef.template.json
  *     props.json
+ *     shared/components/<id>.tsx | <id>/<id>.tsx   (from sourcePath shared/…)
+ *     library/components/<id>…                    (mirror of shared)
  *     pages/<pageId>/page.json
- *     pages/<pageId>/components/          (main-only pages — preferred)
- *       <name>.tsx | <name>.json | <name>/…
- *     pages/<pageId>/sections/<sectionId>/components/  (legacy multi-section)
- *       …
+ *     pages/<pageId>/components/
+ *       <name>.tsx | <name>.json | <name>/<name>.tsx | <name>/<name>.json
+ *
+ * Legacy multi-section keys in the blob are flattened into one ordered stack
+ * under `components/` so marketplace clones match the blank authoring contract.
+ *
+ * Components whose `sourcePath` starts with `shared/components/<id>` are
+ * promoted to the theme shared library; placements become `$ref` stubs.
  */
 
 import fs from "node:fs";
@@ -60,150 +66,337 @@ function sanitizeComponentSourceForEditor(code) {
 }
 
 /**
- * Write one component (and nested slots/children).
- * Leaf customs → `<name>.tsx`; leaf built-ins → `<name>.json`;
- * nested trees → `<name>/` folder (legacy layout).
- *
+ * @param {unknown} sourcePath
+ * @returns {string | null}
+ */
+function sharedIdFromSourcePath(sourcePath) {
+  if (typeof sourcePath !== "string" || !sourcePath.trim()) return null;
+  const norm = sourcePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  const m = /^shared\/components\/([^/]+)/.exec(norm);
+  return m ? m[1] : null;
+}
+
+/**
  * @param {Record<string, any>} component
- * @param {string} destPath Intended path without extension (`…/components/hero`)
  * @param {number} order
- * @param {{ files: number }} stats
+ * @param {string} schemaBase Dir used for relative $schema
  */
-function writeComponent(component, destPath, order, stats) {
-  const children = component.children;
-  const hasChildFolders = Array.isArray(children) && children.length > 0;
-
-  const slots = component.slots;
-  const slotEntries =
-    slots && typeof slots === "object" && !Array.isArray(slots)
-      ? Object.entries(slots)
-      : [];
-  const hasSlotFolders = slotEntries.some(
-    ([, list]) => Array.isArray(list) && list.length > 0,
-  );
-  const needsFolder = hasChildFolders || hasSlotFolders;
-
-  const schemaBase = needsFolder ? destPath : path.dirname(destPath);
+function buildMeta(component, order, schemaBase) {
   /** @type {Record<string, any>} */
   const meta = {
     $schema: path.relative(schemaBase, SCHEMA_ABS).split(path.sep).join("/"),
     order,
   };
   for (const key of COMPONENT_META_KEYS) {
-    // Preserve explicit nulls (Dawn/editor blobs often include them).
     if (Object.prototype.hasOwnProperty.call(component, key)) {
       meta[key] = component[key];
     }
   }
-  // Preserve unknown top-level keys (forward-compat) except tree/code.
   for (const [key, value] of Object.entries(component)) {
     if (
       key === "code" ||
       key === "children" ||
       key === "slots" ||
       key === "order" ||
+      key === "sourcePath" ||
       COMPONENT_META_KEYS.includes(key)
     ) {
       continue;
     }
     if (value !== undefined) meta[key] = value;
   }
+  return meta;
+}
+
+/**
+ * @param {Record<string, any>} component
+ */
+function componentNeedsFolder(component) {
+  const children = component.children;
+  const hasChildFolders = Array.isArray(children) && children.length > 0;
+  const slots = component.slots;
+  const slotEntries =
+    slots && typeof slots === "object" && !Array.isArray(slots)
+      ? Object.entries(slots)
+      : [];
+  const hasSlotFolders = slotEntries.some(
+    ([, list]) => Array.isArray(list) && list.length > 0,
+  );
+  return {
+    needsFolder: hasChildFolders || hasSlotFolders,
+    hasChildFolders,
+    hasSlotFolders,
+    slotEntries,
+    children,
+    slots,
+  };
+}
+
+/**
+ * Write custom TSX body (typed meta + App source).
+ * @param {string} filePath
+ * @param {Record<string, any>} meta
+ * @param {string} code
+ * @param {{ files: number }} stats
+ */
+function writeCustomTsx(filePath, meta, code, stats) {
+  const metaForExport = { ...meta };
+  delete metaForExport.$schema;
+  const tsx = `${formatMetaExport(metaForExport)}${sanitizeComponentSourceForEditor(code)}`;
+  writeText(filePath, tsx);
+  stats.files += 1;
+}
+
+/**
+ * Ensure shared (+ library mirror) definition exists once.
+ * Shared leaves are flat `.tsx`; shells with only schemas stay flat too
+ * (slot *contents* live on placements).
+ *
+ * @param {string} sharedId
+ * @param {Record<string, any>} component
+ * @param {{ outDir: string, sharedWritten: Set<string>, stats: { files: number } }} ctx
+ */
+function ensureSharedDefinition(sharedId, component, ctx) {
+  if (ctx.sharedWritten.has(sharedId)) return;
+  ctx.sharedWritten.add(sharedId);
+
+  const hasCode =
+    typeof component.code === "string" && component.code.trim().length > 0;
+
+  /** Canonical shared: no page-local slots/children trees. */
+  const canonical = { ...component };
+  delete canonical.sourcePath;
+  if (Array.isArray(canonical.children) && canonical.children.length > 0) {
+    canonical.children = [];
+  }
+  if (canonical.slots && typeof canonical.slots === "object") {
+    /** @type {Record<string, any[]>} */
+    const empty = {};
+    for (const key of Object.keys(canonical.slots)) {
+      empty[key] = [];
+    }
+    canonical.slots = empty;
+  }
+
+  for (const kind of ["shared", "library"]) {
+    const destPath = path.join(ctx.outDir, kind, "components", sharedId);
+    const schemaBase = path.dirname(destPath);
+    const meta = buildMeta(canonical, 0, schemaBase);
+    delete meta.instanceId;
+    meta.instanceId = null;
+    if (Object.prototype.hasOwnProperty.call(canonical, "children")) {
+      meta.children = canonical.children ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(canonical, "slots")) {
+      meta.slots = canonical.slots ?? null;
+    }
+
+    if (hasCode) {
+      writeCustomTsx(`${destPath}.tsx`, meta, component.code, ctx.stats);
+    } else {
+      if (Object.prototype.hasOwnProperty.call(component, "code")) {
+        meta.code = component.code ?? null;
+      }
+      writeJson(`${destPath}.json`, meta);
+      ctx.stats.files += 1;
+    }
+  }
+}
+
+/**
+ * Write nested slots/children under a folder placement.
+ * @param {Record<string, any>} component
+ * @param {string} dir
+ * @param {ReturnType<typeof componentNeedsFolder>} tree
+ * @param {{ outDir: string, sharedWritten: Set<string>, stats: { files: number } }} ctx
+ */
+function writeNestedTrees(component, dir, tree, ctx) {
+  if (tree.hasChildFolders) {
+    const used = new Set();
+    tree.children.forEach((child, i) => {
+      if (!child || typeof child !== "object") return;
+      const name = folderNameForComponent(child, i, used);
+      writeComponent(child, path.join(dir, "children", name), i, ctx);
+    });
+  }
+
+  if (tree.hasSlotFolders) {
+    for (const [slotId, list] of tree.slotEntries) {
+      if (!Array.isArray(list) || list.length === 0) continue;
+      const used = new Set();
+      list.forEach((child, i) => {
+        if (!child || typeof child !== "object") return;
+        const name = folderNameForComponent(child, i, used);
+        writeComponent(child, path.join(dir, "slots", slotId, name), i, ctx);
+      });
+    }
+    const emptySlots = {};
+    let anyEmpty = false;
+    for (const [slotId, list] of tree.slotEntries) {
+      if (!Array.isArray(list) || list.length === 0) {
+        emptySlots[slotId] = Array.isArray(list) ? list : [];
+        anyEmpty = true;
+      }
+    }
+    if (anyEmpty) {
+      writeJson(path.join(dir, "slots.empty.json"), emptySlots);
+      ctx.stats.files += 1;
+    }
+  }
+}
+
+/**
+ * Write one component (and nested slots/children).
+ * Leaf customs → `<name>.tsx`; leaf built-ins → `<name>.json`;
+ * nested trees → `<name>/<name>.tsx` (or `.json` for `$ref` / built-ins).
+ *
+ * @param {Record<string, any>} component
+ * @param {string} destPath Intended path without extension (`…/components/hero`)
+ * @param {number} order
+ * @param {{ outDir: string, sharedWritten: Set<string>, stats: { files: number } }} ctx
+ */
+function writeComponent(component, destPath, order, ctx) {
+  const tree = componentNeedsFolder(component);
+  const sharedId = sharedIdFromSourcePath(component.sourcePath);
+  const id = path.basename(destPath);
+
+  if (sharedId) {
+    ensureSharedDefinition(sharedId, component, ctx);
+
+    /** @type {Record<string, any>} */
+    const stub = {
+      $schema: path
+        .relative(
+          tree.needsFolder ? destPath : path.dirname(destPath),
+          SCHEMA_ABS,
+        )
+        .split(path.sep)
+        .join("/"),
+      order,
+      $ref: `shared.${sharedId}`,
+    };
+    if (component.instanceId != null) stub.instanceId = component.instanceId;
+    if (component.title != null) stub.title = component.title;
+    if (component.props && typeof component.props === "object") {
+      stub.props = component.props;
+    }
+
+    if (!tree.needsFolder) {
+      writeJson(`${destPath}.json`, stub);
+      ctx.stats.files += 1;
+      return;
+    }
+
+    const dir = destPath;
+    fs.mkdirSync(dir, { recursive: true });
+    writeJson(path.join(dir, `${id}.json`), stub);
+    ctx.stats.files += 1;
+    writeNestedTrees(component, dir, tree, ctx);
+    return;
+  }
+
+  const schemaBase = tree.needsFolder ? destPath : path.dirname(destPath);
+  const meta = buildMeta(component, order, schemaBase);
 
-  // Nested trees: non-empty → folders; empty/null → keep on meta for round-trip.
   if (Object.prototype.hasOwnProperty.call(component, "children")) {
-    if (hasChildFolders) {
+    if (tree.hasChildFolders) {
       delete meta.children;
     } else {
-      meta.children = children ?? null;
+      meta.children = tree.children ?? null;
     }
   }
 
   if (Object.prototype.hasOwnProperty.call(component, "slots")) {
-    if (hasSlotFolders) {
+    if (tree.hasSlotFolders) {
       delete meta.slots;
     } else {
-      meta.slots = slots ?? null;
+      meta.slots = tree.slots ?? null;
     }
   }
 
   const hasCode =
     typeof component.code === "string" && component.code.trim().length > 0;
 
-  if (!needsFolder) {
-    // Flat leaf: hero.tsx or hero.json
+  if (!tree.needsFolder) {
     if (hasCode) {
-      const metaForExport = { ...meta };
-      delete metaForExport.$schema;
-      const tsx = `${formatMetaExport(metaForExport)}${sanitizeComponentSourceForEditor(component.code)}`;
-      writeText(`${destPath}.tsx`, tsx);
-      stats.files += 1;
+      writeCustomTsx(`${destPath}.tsx`, meta, component.code, ctx.stats);
     } else {
       if (Object.prototype.hasOwnProperty.call(component, "code")) {
         meta.code = component.code ?? null;
       }
       writeJson(`${destPath}.json`, meta);
-      stats.files += 1;
+      ctx.stats.files += 1;
     }
     return;
   }
 
-  // Folder layout for nested children/slots
+  // Folder layout: `<name>/<name>.tsx` (not legacy component.tsx)
   const dir = destPath;
   fs.mkdirSync(dir, { recursive: true });
 
   if (hasCode) {
-    const metaForExport = { ...meta };
-    delete metaForExport.$schema;
-    const tsx = `${formatMetaExport(metaForExport)}${sanitizeComponentSourceForEditor(component.code)}`;
-    writeText(path.join(dir, "component.tsx"), tsx);
-    stats.files += 1;
+    writeCustomTsx(path.join(dir, `${id}.tsx`), meta, component.code, ctx.stats);
   } else {
     if (Object.prototype.hasOwnProperty.call(component, "code")) {
       meta.code = component.code ?? null;
     }
-    writeJson(path.join(dir, "component.json"), meta);
-    stats.files += 1;
+    writeJson(path.join(dir, `${id}.json`), meta);
+    ctx.stats.files += 1;
   }
 
-  if (hasChildFolders) {
-    const used = new Set();
-    children.forEach((child, i) => {
-      if (!child || typeof child !== "object") return;
-      const name = folderNameForComponent(child, i, used);
-      writeComponent(child, path.join(dir, "children", name), i, stats);
-    });
-  }
+  writeNestedTrees(component, dir, tree, ctx);
+}
 
-  if (hasSlotFolders) {
-    for (const [slotId, list] of slotEntries) {
-      if (!Array.isArray(list) || list.length === 0) {
-        continue;
-      }
-      const used = new Set();
-      list.forEach((child, i) => {
-        if (!child || typeof child !== "object") return;
-        const name = folderNameForComponent(child, i, used);
-        writeComponent(
-          child,
-          path.join(dir, "slots", slotId, name),
-          i,
-          stats,
-        );
-      });
-    }
-    const emptySlots = {};
-    let anyEmpty = false;
-    for (const [slotId, list] of slotEntries) {
-      if (!Array.isArray(list) || list.length === 0) {
-        emptySlots[slotId] = Array.isArray(list) ? list : [];
-        anyEmpty = true;
-      }
-    }
-    if (anyEmpty) {
-      writeJson(path.join(dir, "slots.empty.json"), emptySlots);
-      stats.files += 1;
+/**
+ * Stable order when coalescing legacy multi-section blobs into one flat stack.
+ * Unknown keys sort alphabetically after these.
+ */
+const SECTION_FLATTEN_ORDER = [
+  "header",
+  "announcement",
+  "top",
+  "start",
+  "hero",
+  "collection_header",
+  "sidebar",
+  "main",
+  "body",
+  "form",
+  "order_form",
+  "products",
+  "contact_details",
+  "contact_form",
+  "map",
+  "end",
+  "bottom",
+  "footer",
+];
+
+/**
+ * Collect components from all section keys into one ordered list.
+ * @param {Record<string, any>} sections
+ * @returns {any[]}
+ */
+function flattenSectionComponents(sections) {
+  if (!sections || typeof sections !== "object") return [];
+  const keys = Object.keys(sections).sort((a, b) => {
+    const ia = SECTION_FLATTEN_ORDER.indexOf(a);
+    const ib = SECTION_FLATTEN_ORDER.indexOf(b);
+    const ra = ia === -1 ? SECTION_FLATTEN_ORDER.length : ia;
+    const rb = ib === -1 ? SECTION_FLATTEN_ORDER.length : ib;
+    if (ra !== rb) return ra - rb;
+    return a.localeCompare(b);
+  });
+  /** @type {any[]} */
+  const out = [];
+  for (const key of keys) {
+    const list = sections[key]?.components;
+    if (!Array.isArray(list)) continue;
+    for (const comp of list) {
+      if (comp && typeof comp === "object") out.push(comp);
     }
   }
+  return out;
 }
 
 /**
@@ -236,6 +429,8 @@ export function unpackTemplate({ inputPath, outDir, force = false }) {
 
   const pageIds = Object.keys(data.pages);
   const stats = { files: 0, pages: pageIds.length, components: 0 };
+  /** @type {{ outDir: string, sharedWritten: Set<string>, stats: { files: number } }} */
+  const ctx = { outDir, sharedWritten: new Set(), stats };
 
   writeJson(path.join(outDir, "feeef.template.json"), {
     $schema: "../../template-kit/schemas/template.schema.json",
@@ -268,57 +463,22 @@ export function unpackTemplate({ inputPath, outDir, force = false }) {
     const sections =
       page.sections && typeof page.sections === "object" ? page.sections : {};
 
-    // Main-only pages → flat `pages/<id>/components/` (sections optional on disk).
-    // Multi-section pages → legacy `sections/<id>/components/`.
-    const sectionKeys = Object.keys(sections);
-    const nonEmptyKeys = sectionKeys.filter((id) => {
-      const list = sections[id]?.components;
-      return Array.isArray(list) && list.length > 0;
+    // Always unpack to flat `pages/<id>/components/` (→ sections.main on build).
+    // Coalesce legacy multi-section keys into one ordered stack.
+    const components = flattenSectionComponents(sections);
+    const componentsDir = path.join(pageDir, "components");
+    fs.mkdirSync(componentsDir, { recursive: true });
+    const used = new Set();
+    components.forEach((comp, i) => {
+      if (!comp || typeof comp !== "object") return;
+      const name = folderNameForComponent(comp, i, used);
+      writeComponent(comp, path.join(componentsDir, name), i, ctx);
+      stats.components += 1;
     });
-    const useFlatPageComponents =
-      nonEmptyKeys.length === 0
-        ? sectionKeys.length === 0 ||
-          (sectionKeys.length === 1 && sectionKeys[0] === "main")
-        : nonEmptyKeys.length === 1 && nonEmptyKeys[0] === "main";
-
-    if (useFlatPageComponents) {
-      const components = Array.isArray(sections.main?.components)
-        ? sections.main.components
-        : [];
-      const componentsDir = path.join(pageDir, "components");
-      fs.mkdirSync(componentsDir, { recursive: true });
-      const used = new Set();
-      components.forEach((comp, i) => {
-        if (!comp || typeof comp !== "object") return;
-        const name = folderNameForComponent(comp, i, used);
-        writeComponent(comp, path.join(componentsDir, name), i, stats);
-        stats.components += 1;
-      });
-      continue;
-    }
-
-    for (const [sectionId, section] of Object.entries(sections)) {
-      const components = Array.isArray(section?.components)
-        ? section.components
-        : [];
-      const sectionDir = path.join(pageDir, "sections", sectionId);
-      // Always create the section folder so empty sections round-trip.
-      fs.mkdirSync(path.join(sectionDir, "components"), { recursive: true });
-
-      const used = new Set();
-      components.forEach((comp, i) => {
-        if (!comp || typeof comp !== "object") return;
-        const name = folderNameForComponent(comp, i, used);
-        writeComponent(
-          comp,
-          path.join(sectionDir, "components", name),
-          i,
-          stats,
-        );
-        stats.components += 1;
-      });
-    }
   }
 
-  return stats;
+  return {
+    ...stats,
+    sharedCount: ctx.sharedWritten.size,
+  };
 }