@deneb-ui/cli 2.0.31 → 2.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/cli",
-  "version": "2.0.31",
+  "version": "2.0.33",
   "description": "Official DENEB CLI — scaffold, convert, validate, and package Fivora-ready storefront templates.",
   "bin": {
     "deneb": "bin/index.js",
@@ -49,7 +49,7 @@
   "license": "MIT",
   "dependencies": {
     "@babel/parser": "^7.28.0",
-    "@deneb-ui/core": "^2.0.31",
+    "@deneb-ui/core": "^2.0.33",
     "adm-zip": "^0.6.0",
     "recast": "^0.23.11"
   },

package/src/arc/__tests__/arc.test.cjs

@@ -10,11 +10,57 @@ const { scanProject, buildDependencyGraph } = require('../scanner.cjs');
 const { analyzeFile } = require('../semantic.cjs');
 const { planTransformations } = require('../planner.cjs');
 const { applyFilePlan } = require('../transformer.cjs');
-const { buildFieldPath, inferFieldName } = require('../field-paths.cjs');
+const { buildFieldPath, inferFieldName, isListActionCtaKey } = require('../field-paths.cjs');
+const { enrichSchemasFromContent } = require('../manifest.cjs');
 const { runDenebArc } = require('../index.cjs');
 const { parseSource } = require('../ast.cjs');
 const { loadFingerprintBoost } = require('../learning.cjs');
 
+test('field-paths recognizes list action CTA keys', () => {
+  assert.equal(isListActionCtaKey('preOrderCta'), true);
+  assert.equal(isListActionCtaKey('addToTrayCta'), true);
+  assert.equal(isListActionCtaKey('features'), false);
+});
+
+test('manifest enrichSchemasFromContent registers list CTA and paired directions fields', () => {
+  const sections = [
+    {
+      id: 'contact',
+      path: 'contact',
+      type: 'object',
+      label: 'Contact',
+      fields: [],
+    },
+    {
+      id: 'home',
+      path: 'home',
+      type: 'object',
+      label: 'Home',
+      fields: [],
+    },
+  ];
+  enrichSchemasFromContent(
+    {
+      contact: {
+        directionsLabel: 'Get Directions',
+        directionsUrl: 'https://maps.example',
+      },
+      home: {
+        demoPreOrderCta: [{ buttonLabel: 'Order', buttonUrl: 'https://wa.me/123' }],
+      },
+    },
+    sections
+  );
+  const contactFields = sections.find((s) => s.id === 'contact').fields;
+  assert.ok(contactFields.some((f) => f.key === 'directionsUrl' && f.type === 'url'));
+  assert.ok(contactFields.some((f) => f.key === 'directionsLabel'));
+  const homeFields = sections.find((s) => s.id === 'home').fields;
+  const list = homeFields.find((f) => f.key === 'demoPreOrderCta');
+  assert.ok(list && list.type === 'list');
+  assert.ok(list.fields.some((f) => f.key === 'buttonLabel'));
+  assert.ok(list.fields.some((f) => f.key === 'buttonUrl' && f.type === 'url'));
+});
+
 test('unseen fingerprints do not change planner confidence', () => {
   const hint = loadFingerprintBoost(null);
   assert.equal(hint.boost, 0);
@@ -109,6 +155,8 @@ test('AST transformer preserves className and uses nullish fallbacks', () => {
   assert.match(result.code, /data-preview-field-path=/);
   assert.match(result.code, /\?\?/);
   assert.match(result.code, /<span[\s\S]*data-preview-field-path="/);
+  assert.match(result.code, /<span[^>]*hidden[^>]*data-preview-field-path="/);
+  assert.match(result.code, /data-preview-static="action-link"/);
   assert.doesNotMatch(result.code, /'use client'/);
   assert.match(result.code, /site-data\.json|@\/data\/site-data\.json/);
   assert.match(result.code, /data-preview-style-target=/);
@@ -519,3 +567,62 @@ test('conflicting data-preview-static is stripped when element has editable mark
   const placementErrors = errors.filter((e) => e.includes('cannot share an element with data-preview-static'));
   assert.equal(placementErrors.length, 0);
 });
+
+test('sanitizeDuplicateBindings keeps a single useSiteData import', () => {
+  const { parseSource, printSource, sanitizeDuplicateBindings } = require('../ast.cjs');
+  const code = `'use client';
+import { useSiteData, contentText } from '@/lib/siteDataContext';
+import { useSiteData, contentObject } from '@deneb-ui/ui';
+export function Shop() {
+  const siteData = useSiteData();
+  return <div>{contentText(contentObject(siteData).title)}</div>;
+}
+`;
+  const ast = parseSource(code, 'shop.tsx');
+  sanitizeDuplicateBindings(ast);
+  const out = printSource(ast, code);
+  const importUses = [...out.matchAll(/import\s*\{([^}]+)\}\s*from/g)].flatMap((m) =>
+    m[1].split(',').map((s) => s.trim()).filter((s) => s === 'useSiteData')
+  );
+  assert.equal(importUses.length, 1);
+  assert.match(out, /siteDataContext/);
+  assert.doesNotMatch(out, /import\s*\{[^}]*useSiteData[^}]*\}\s*from\s*['"]@deneb-ui\/ui['"]/);
+});
+
+test('recursive SiteDataProvider wrappers are flattened to a package re-export', () => {
+  const { rewriteRecursiveSiteDataContext } = require('../transformer.cjs');
+  const code = `'use client';
+import { SiteDataProvider as BaseSiteDataProvider } from '@deneb-ui/ui';
+import initialSiteData from '@/data/site-data.json';
+export function SiteDataProvider({ children, ...props }) {
+  return (
+    <BaseSiteDataProvider initialSiteData={initialSiteData} {...props}>
+      {children}
+    </BaseSiteDataProvider>
+  );
+}
+`;
+  const out = rewriteRecursiveSiteDataContext(code);
+  assert.equal(out.updated, true);
+  assert.match(out.code, /export \{/);
+  assert.match(out.code, /SiteDataProvider/);
+  assert.match(out.code, /from '@deneb-ui\/ui'/);
+  assert.doesNotMatch(out.code, /export function SiteDataProvider/);
+  assert.doesNotMatch(out.code, /BaseSiteDataProvider/);
+});
+
+test('import plus export of useSiteData is rewritten to export-from', () => {
+  const { parseSource, printSource, sanitizeDuplicateBindings } = require('../ast.cjs');
+  const code = `'use client';
+import { SiteDataProvider as BaseSiteDataProvider, useSiteData, contentText } from '@deneb-ui/ui';
+export function SiteDataProvider({ children }) {
+  return <BaseSiteDataProvider>{children}</BaseSiteDataProvider>;
+}
+export { useSiteData, contentText };
+`;
+  const ast = parseSource(code, 'siteDataContext.tsx');
+  sanitizeDuplicateBindings(ast);
+  const out = printSource(ast, code);
+  assert.match(out, /export\s*\{[^}]*useSiteData[^}]*\}\s*from\s*['"]@deneb-ui\/ui['"]/);
+  assert.doesNotMatch(out, /import\s*\{[^}]*useSiteData/);
+});

package/src/arc/ast.cjs

@@ -264,11 +264,144 @@ function hasDirective(ast, value) {
   return false;
 }
 
+function localNameOfSpecifier(spec) {
+  return spec?.local?.name || spec?.imported?.name || spec?.exported?.name || null;
+}
+
+function dedupeImportSpecifiers(ast) {
+  const program = ast.program || ast;
+  const seenLocals = new Set();
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration' || !Array.isArray(node.specifiers)) continue;
+    node.specifiers = node.specifiers.filter((spec) => {
+      const local = localNameOfSpecifier(spec);
+      if (!local) return true;
+      if (seenLocals.has(local)) return false;
+      seenLocals.add(local);
+      return true;
+    });
+  }
+}
+
+function preferLocalSiteDataImport(ast) {
+  const program = ast.program || ast;
+  const body = program.body || [];
+  const localNames = new Set();
+  for (const node of body) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    if (typeof src !== 'string' || !/siteDataContext/.test(src)) continue;
+    for (const spec of node.specifiers || []) {
+      const local = localNameOfSpecifier(spec);
+      if (local) localNames.add(local);
+    }
+  }
+  if (localNames.size === 0) return;
+  for (const node of body) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    if (src !== '@deneb-ui/ui' && src !== 'deneb-ui' && src !== '@fivora/editable-components') continue;
+    node.specifiers = (node.specifiers || []).filter((spec) => !localNames.has(localNameOfSpecifier(spec)));
+  }
+}
+
+function dropImportedNameIfLocallyDeclared(ast) {
+  const program = ast.program || ast;
+  const declared = new Set();
+  for (const node of program.body || []) {
+    if (node.type === 'FunctionDeclaration' && node.id && node.id.name) {
+      declared.add(node.id.name);
+    }
+    if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+      const decl = node.declaration;
+      if (decl.type === 'FunctionDeclaration' && decl.id && decl.id.name) {
+        declared.add(decl.id.name);
+      }
+      if (decl.type === 'VariableDeclaration') {
+        for (const d of decl.declarations || []) {
+          if (d.id && d.id.type === 'Identifier') declared.add(d.id.name);
+        }
+      }
+    }
+  }
+  if (declared.size === 0) return;
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration') continue;
+    node.specifiers = (node.specifiers || []).filter((spec) => !declared.has(localNameOfSpecifier(spec)));
+  }
+}
+
+function rewriteImportedReexports(ast) {
+  const program = ast.program || ast;
+  const importSourceByLocal = new Map();
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    for (const spec of node.specifiers || []) {
+      const local = localNameOfSpecifier(spec);
+      if (local && src) importSourceByLocal.set(local, src);
+    }
+  }
+
+  const exportDecls = (program.body || []).filter(
+    (node) => node.type === 'ExportNamedDeclaration' && !node.source && node.specifiers && node.specifiers.length
+  );
+  for (const node of exportDecls) {
+    const groups = new Map();
+    const keep = [];
+    for (const spec of node.specifiers) {
+      const local = spec.local?.name;
+      const src = local && importSourceByLocal.get(local);
+      if (!src) {
+        keep.push(spec);
+        continue;
+      }
+      if (!groups.has(src)) groups.set(src, []);
+      groups.get(src).push(spec);
+    }
+    if (!groups.size) continue;
+    node.specifiers = keep;
+    let insertAt = program.body.indexOf(node) + 1;
+    for (const [src, specs] of groups.entries()) {
+      program.body.splice(insertAt, 0, b.exportNamedDeclaration(null, specs, b.stringLiteral(src)));
+      insertAt++;
+      for (const spec of specs) {
+        const local = spec.local?.name;
+        for (const imp of program.body) {
+          if (imp.type !== 'ImportDeclaration') continue;
+          if (!imp.specifiers) continue;
+          imp.specifiers = imp.specifiers.filter((s) => localNameOfSpecifier(s) !== local);
+        }
+      }
+    }
+  }
+}
+
+function stripEmptyImportAndExportDecls(ast) {
+  const program = ast.program || ast;
+  program.body = (program.body || []).filter((node) => {
+    if (node.type === 'ImportDeclaration') {
+      return (node.specifiers || []).length > 0;
+    }
+    if (node.type === 'ExportNamedDeclaration' && !node.declaration && !node.source) {
+      return (node.specifiers || []).length > 0;
+    }
+    return true;
+  });
+}
+
+function sanitizeDuplicateBindings(ast) {
+  dropImportedNameIfLocallyDeclared(ast);
+  preferLocalSiteDataImport(ast);
+  rewriteImportedReexports(ast);
+  dedupeImportSpecifiers(ast);
+  stripEmptyImportAndExportDecls(ast);
+}
+
 function ensureImport(ast, source, names) {
   const program = ast.program || ast;
   const body = program.body || [];
 
-  // Deduplicate against any import in the entire module so we never import the same identifier twice
   const alreadyImported = new Set();
   for (const node of body) {
     if (node.type === 'ImportDeclaration' && Array.isArray(node.specifiers)) {
@@ -277,6 +410,10 @@ function ensureImport(ast, source, names) {
         if (local) alreadyImported.add(local);
       }
     }
+    if (node.type === 'FunctionDeclaration' && node.id?.name) alreadyImported.add(node.id.name);
+    if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'FunctionDeclaration' && node.declaration.id?.name) {
+      alreadyImported.add(node.declaration.id.name);
+    }
   }
 
   const namesToImport = names.filter((name) => !alreadyImported.has(name));
@@ -340,6 +477,7 @@ module.exports = {
   hasDirective,
   ensureImport,
   ensureDefaultImport,
+  sanitizeDuplicateBindings,
   codeHasIdentifier,
   t,
   b,

package/src/arc/field-paths.cjs

@@ -141,6 +141,14 @@ function humanLabel(fieldPath) {
     .trim();
 }
 
+function isListActionCtaKey(key) {
+  return /Cta$/i.test(String(key || ''));
+}
+
+function listActionCtaItemFieldNames() {
+  return ['buttonLabel', 'buttonUrl'];
+}
+
 function classifyFieldType(kind, value) {
   if (kind === 'image') return 'image';
   if (kind === 'url') return 'url';
@@ -162,4 +170,6 @@ module.exports = {
   buildFieldPath,
   humanLabel,
   classifyFieldType,
+  isListActionCtaKey,
+  listActionCtaItemFieldNames,
 };

package/src/arc/index.cjs

@@ -17,7 +17,7 @@ const { walkFiles, isJsxFile, rel, copyFilePreserve, writeJson, readJsonSafe, fi
 const { scanProject, buildDependencyGraph, inferOwnerScope } = require('./scanner.cjs');
 const { analyzeFile, collectDesignSnapshot } = require('./semantic.cjs');
 const { planTransformations } = require('./planner.cjs');
-const { applyFilePlan, instrumentLayoutSource, instrumentPageKey, resolveSiteDataSpecifier, ensureJsonModule, sanitizeContradictoryMarkersInSource } = require('./transformer.cjs');
+const { applyFilePlan, instrumentLayoutSource, instrumentPageKey, resolveSiteDataSpecifier, resolveSiteDataRuntimeSpecifier, rewriteRecursiveSiteDataContext, ensureJsonModule, sanitizeContradictoryMarkersInSource } = require('./transformer.cjs');
 const { parseSource } = require('./ast.cjs');
 const { buildSiteDataAndManifest, writeDataBank, loadExistingData, countSchemaFields } = require('./manifest.cjs');
 const { validateAstFiles, validateContracts, designPreservationScore, coverageMetrics } = require('./validator.cjs');
@@ -306,8 +306,9 @@ function runDenebArc(projectDir, projectName, options = {}) {
     backupFile(projectDir, backupDir, layoutFile);
     const layoutRel = rel(projectDir, layoutFile);
     const siteDataImport = resolveSiteDataSpecifier(profile, layoutRel);
+    const providerImport = resolveSiteDataRuntimeSpecifier(profile);
     const original = fs.readFileSync(layoutFile, 'utf8');
-    const instrumented = instrumentLayoutSource(original, siteDataImport);
+    const instrumented = instrumentLayoutSource(original, siteDataImport, providerImport);
     if (instrumented.updated && instrumented.code !== original) {
       fs.writeFileSync(layoutFile, instrumented.code, 'utf8');
       changedFiles.push(layoutRel);
@@ -315,6 +316,23 @@ function runDenebArc(projectDir, projectName, options = {}) {
     }
   }
 
+  const contextCandidates = [
+    path.join(projectDir, 'src', 'lib', 'siteDataContext.tsx'),
+    path.join(projectDir, 'src', 'lib', 'siteDataContext.ts'),
+    path.join(projectDir, 'lib', 'siteDataContext.tsx'),
+    path.join(projectDir, 'lib', 'siteDataContext.ts'),
+  ];
+  for (const abs of contextCandidates) {
+    if (!fs.existsSync(abs)) continue;
+    backupFile(projectDir, backupDir, abs);
+    const original = fs.readFileSync(abs, 'utf8');
+    const rewritten = rewriteRecursiveSiteDataContext(original);
+    if (rewritten.updated && rewritten.code !== original) {
+      fs.writeFileSync(abs, rewritten.code, 'utf8');
+      changedFiles.push(rel(projectDir, abs));
+    }
+  }
+
   for (const filePlan of plan.files) {
     if (!filePlan.transformations.length || filePlan.skippedFile) continue;
     const abs = path.join(projectDir, filePlan.file);

package/src/arc/manifest.cjs

@@ -59,7 +59,7 @@ function upsertSchemaField(sections, fieldPath, fieldType, label, required = fal
       if (!existing) {
         fields.push({
           key,
-          type: fieldType === 'url' ? 'text' : fieldType === 'textarea' ? 'textarea' : fieldType,
+          type: fieldType === 'url' ? 'url' : fieldType === 'textarea' ? 'textarea' : fieldType === 'phone' ? 'tel' : fieldType,
           label: label || humanLabel(key),
           ...(required ? { required: true } : {}),
         });
@@ -119,12 +119,77 @@ function upsertSchemaList(sections, listPath, itemFields, items) {
     maxItems: Math.max((items || []).length, 12),
     fields: (itemFields || []).map((field) => ({
       key: field.key,
-      type: field.type === 'url' ? 'url' : field.type === 'image' ? 'image' : 'text',
+      type:
+        field.type === 'url'
+          ? 'url'
+          : field.type === 'image'
+            ? 'image'
+            : field.type === 'textarea'
+              ? 'textarea'
+              : field.type === 'tel' || field.type === 'phone'
+                ? 'tel'
+                : field.type === 'email'
+                  ? 'email'
+                  : field.type || 'text',
       label: humanLabel(field.key),
     })),
   });
 }
 
+const LIST_ACTION_CTA_ITEM_FIELDS = [
+  { key: 'buttonLabel', type: 'text' },
+  { key: 'buttonUrl', type: 'url' },
+];
+
+function isListActionCtaKey(key) {
+  return /Cta$/i.test(String(key || ''));
+}
+
+/**
+ * Walks merged site-data content and registers schemas ARC learns from merchant patterns:
+ * list CTAs (`*Cta` with buttonLabel/buttonUrl) and paired *Label/*Url siblings.
+ */
+function enrichSchemasFromContent(content, sections) {
+  if (!content || typeof content !== 'object') return;
+
+  function walk(node, prefix) {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) {
+      const listKey = prefix.split('.').pop() || '';
+      if (isListActionCtaKey(listKey)) {
+        const sample = node[0];
+        if (sample && typeof sample === 'object' && ('buttonLabel' in sample || 'buttonUrl' in sample)) {
+          upsertSchemaList(sections, prefix, LIST_ACTION_CTA_ITEM_FIELDS, node);
+        }
+      }
+      node.forEach((item, idx) => {
+        if (item && typeof item === 'object') walk(item, `${prefix}[${idx}]`);
+      });
+      return;
+    }
+
+    for (const [key, value] of Object.entries(node)) {
+      const nextPath = prefix ? `${prefix}.${key}` : key;
+      if (Array.isArray(value) && isListActionCtaKey(key)) {
+        const sample = value[0];
+        if (sample && typeof sample === 'object' && ('buttonLabel' in sample || 'buttonUrl' in sample)) {
+          upsertSchemaList(sections, nextPath, LIST_ACTION_CTA_ITEM_FIELDS, value);
+        }
+      } else if (typeof value === 'string' && /Url$/i.test(key)) {
+        upsertSchemaField(sections, nextPath, 'url', humanLabel(key));
+        const labelKey = key.replace(/Url$/i, 'Label');
+        if (Object.prototype.hasOwnProperty.call(node, labelKey)) {
+          upsertSchemaField(sections, `${prefix}.${labelKey}`, 'text', humanLabel(labelKey));
+        }
+      } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        walk(value, nextPath);
+      }
+    }
+  }
+
+  walk(content, '');
+}
+
 function collectFieldsFromPlan(plan) {
   const fields = [];
   for (const file of plan.files || []) {
@@ -362,6 +427,7 @@ function buildSiteDataAndManifest({
   siteData.template.structure.pages = routes.map((p) => p.id);
 
   assignSectionPageKeys(editorSections, routes, markerRoutes);
+  enrichSchemasFromContent(content, editorSections);
 
   const controlOnlyPaths = computeControlOnlyPaths(
     content,
@@ -435,4 +501,6 @@ module.exports = {
   computeControlOnlyPaths,
   assignSectionPageKeys,
   upsertSchemaList,
+  enrichSchemasFromContent,
+  isListActionCtaKey,
 };

package/src/arc/transformer.cjs

@@ -2,6 +2,7 @@
 
 const recast = require('recast');
 const path = require('path');
+const fs = require('fs');
 const {
   parseSource,
   printSource,
@@ -12,6 +13,7 @@ const {
   hasDirective,
   ensureImport,
   ensureDefaultImport,
+  sanitizeDuplicateBindings,
   siteDataBinding,
   siteDataListBinding,
   jsxPreviewAttr,
@@ -124,13 +126,42 @@ function splitActionChildren(node, labelField, labelFallback) {
   node.children = nextChildren;
 }
 
+function wrapHiddenUrlSibling(pathNode, urlField, fallback) {
+  const urlParts = urlField.split('.');
+  const hiddenUrl = b.jsxElement(
+    b.jsxOpeningElement(
+      b.jsxIdentifier('span'),
+      [
+        b.jsxAttribute(b.jsxIdentifier('hidden')),
+        b.jsxAttribute(b.jsxIdentifier('aria-hidden'), b.stringLiteral('true')),
+        jsxPreviewAttr(urlField),
+      ],
+      false
+    ),
+    b.jsxClosingElement(b.jsxIdentifier('span')),
+    [b.jsxExpressionContainer(siteDataBinding(urlParts, fallback, 'url'))],
+    false
+  );
+  pathNode.insertAfter(hiddenUrl);
+}
+
 function applyTransformToElement(pathNode, transform) {
   const node = pathNode.node;
   if (transform.operation === 'split-action-contract') {
     const urlParts = transform.urlField.split('.');
     replaceAttrValue(node, 'href', siteDataBinding(urlParts, transform.fallback, 'url'));
-    ensurePreviewPath(node, transform.urlField);
+    if (!hasJsxAttribute(node, 'data-preview-static')) {
+      node.openingElement.attributes.push(
+        b.jsxAttribute(b.jsxIdentifier('data-preview-static'), b.stringLiteral('action-link'))
+      );
+    }
+    if (hasJsxAttribute(node, 'data-preview-field-path')) {
+      node.openingElement.attributes = node.openingElement.attributes.filter(
+        (attr) => !(attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'data-preview-field-path')
+      );
+    }
     splitActionChildren(node, transform.labelField, transform.labelFallback || '');
+    wrapHiddenUrlSibling(pathNode, transform.urlField, transform.fallback);
     return;
   }
   if (transform.operation === 'extract-url') {
@@ -370,6 +401,43 @@ function bindArrayDeclaration(ast, mapCallPath, listPath) {
   return bound;
 }
 
+function fileAlreadyUsesSiteDataHook(ast) {
+  let found = false;
+  recast.types.visit(ast, {
+    visitCallExpression(pathNode) {
+      const callee = pathNode.node.callee;
+      if (callee && callee.type === 'Identifier' && callee.name === 'useSiteData') {
+        found = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return found;
+}
+
+function resolveSiteDataRuntimeSpecifier(profile) {
+  const root = profile && profile.root;
+  if (!root) return '@deneb-ui/ui';
+  const candidates = [
+    ['src/lib/siteDataContext.tsx', '@/lib/siteDataContext'],
+    ['src/lib/siteDataContext.ts', '@/lib/siteDataContext'],
+    ['lib/siteDataContext.tsx', '@/lib/siteDataContext'],
+    ['lib/siteDataContext.ts', '@/lib/siteDataContext'],
+  ];
+  const hasAt = Object.keys(profile.aliasMap || {}).some((k) => k === '@/*' || k.startsWith('@/'));
+  for (const [relative, alias] of candidates) {
+    if (!fs.existsSync(path.join(root, relative))) continue;
+    if (hasAt) return alias;
+    const fromAbs = path.join(root, 'src/components/placeholder.tsx');
+    const toAbs = path.join(root, relative.replace(/\.tsx?$/, ''));
+    let relSpec = path.relative(path.dirname(fromAbs), toAbs).replace(/\\/g, '/');
+    if (!relSpec.startsWith('.')) relSpec = './' + relSpec;
+    return relSpec;
+  }
+  return '@deneb-ui/ui';
+}
+
 function injectSiteDataHook(ast) {
   const program = ast.program || ast;
   let injected = false;
@@ -508,11 +576,15 @@ function applyFilePlan(filePlan, profile) {
 
   const siteDataImport = resolveSiteDataSpecifier(profile, filePlan.file);
   if (isClient) {
-    ensureImport(ast, '@deneb-ui/ui', ['useSiteData']);
-    injectSiteDataHook(ast);
+    const runtimeSpecifier = resolveSiteDataRuntimeSpecifier(profile);
+    if (!fileAlreadyUsesSiteDataHook(ast)) {
+      injectSiteDataHook(ast);
+    }
+    ensureImport(ast, runtimeSpecifier, ['useSiteData']);
   } else {
     ensureDefaultImport(ast, siteDataImport, 'siteData');
   }
+  sanitizeDuplicateBindings(ast);
 
   // Sanitize any conflicting data-preview-static on elements with editable markers
   sanitizeContradictoryMarkers(ast);
@@ -610,57 +682,91 @@ function ensureHtmlBodyHydration(ast) {
   });
 }
 
-function instrumentLayoutSource(code, siteDataImport) {
-  if (/SiteDataProvider|DenebDataProvider/.test(code)) {
-    if (/suppressHydrationWarning/.test(code)) {
-      return { code, updated: false };
-    }
-    const ast = parseSource(code, 'layout.tsx');
-    ensureHtmlBodyHydration(ast);
-    return { code: printSource(ast, code), updated: true };
+function findSiteDataJsonLocalName(ast) {
+  const program = ast.program || ast;
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    if (typeof src !== 'string' || !/site-data\.json/.test(src)) continue;
+    const spec = (node.specifiers || []).find((s) => s.type === 'ImportDefaultSpecifier');
+    if (spec && spec.local) return spec.local.name;
   }
+  return null;
+}
 
-  const ast = parseSource(code, 'layout.tsx');
-  ensureHtmlBodyHydration(ast);
-  ensureImport(ast, '@deneb-ui/ui', ['SiteDataProvider']);
-  ensureDefaultImport(ast, siteDataImport, 'initialSiteData');
-
-  let wrapped = false;
+function ensureProviderInitialData(ast, ident) {
+  let added = false;
   recast.types.visit(ast, {
-    visitJSXExpressionContainer(pathNode) {
-      if (wrapped) return false;
-      const expr = pathNode.node.expression;
-      if (expr && expr.type === 'Identifier' && expr.name === 'children') {
-        pathNode.replace(
-          b.jsxElement(
-            b.jsxOpeningElement(
-              b.jsxIdentifier('SiteDataProvider'),
-              [
-                b.jsxAttribute(
-                  b.jsxIdentifier('initialSiteData'),
-                  b.jsxExpressionContainer(b.identifier('initialSiteData'))
-                ),
-              ],
-              false
-            ),
-            b.jsxClosingElement(b.jsxIdentifier('SiteDataProvider')),
-            [pathNode.node],
-            false
-          )
-        );
-        wrapped = true;
-        return false;
+    visitJSXOpeningElement(pathNode) {
+      const name = pathNode.node.name;
+      const tag = name && name.type === 'JSXIdentifier' ? name.name : '';
+      if (tag === 'SiteDataProvider' || tag === 'DenebDataProvider' || tag === 'DenebSiteDataProvider') {
+        const has = hasJsxAttribute(pathNode.node, 'initialSiteData');
+        if (!has) {
+          pathNode.node.attributes = pathNode.node.attributes || [];
+          pathNode.node.attributes.push(
+            b.jsxAttribute(
+              b.jsxIdentifier('initialSiteData'),
+              b.jsxExpressionContainer(b.identifier(ident))
+            )
+          );
+          added = true;
+        }
       }
       this.traverse(pathNode);
     },
   });
+  return added;
+}
 
-  if (!wrapped) {
+const CANONICAL_SITE_DATA_CONTEXT = `'use client';
+
+export {
+  SiteDataProvider,
+  useSiteData,
+  contentText,
+  contentObject,
+  contentList,
+  PREVIEW_DATA_MESSAGE,
+  LEGACY_PREVIEW_DATA_MESSAGE,
+  PREVIEW_READY_MESSAGE,
+  LEGACY_PREVIEW_READY_MESSAGE,
+  PREVIEW_FOCUS_MESSAGE,
+  LEGACY_PREVIEW_FOCUS_MESSAGE,
+  PREVIEW_FIELD_ATTRIBUTE,
+} from '@deneb-ui/ui';
+
+export type { SiteData, SiteDataProviderProps } from '@deneb-ui/ui';
+`;
+
+function rewriteRecursiveSiteDataContext(code) {
+  const recursive =
+    /export\s+function\s+SiteDataProvider\b/.test(code) &&
+    /<(?:Base)?SiteDataProvider\b/.test(code);
+  if (!recursive) return { code, updated: false };
+  return { code: CANONICAL_SITE_DATA_CONTEXT, updated: true };
+}
+
+function instrumentLayoutSource(code, siteDataImport, providerImport = '@deneb-ui/ui') {
+  const ast = parseSource(code, 'layout.tsx');
+  ensureHtmlBodyHydration(ast);
+
+  let jsonIdent = findSiteDataJsonLocalName(ast);
+  if (!jsonIdent) {
+    jsonIdent = 'initialSiteData';
+    ensureDefaultImport(ast, siteDataImport, jsonIdent);
+  }
+
+  const hasProvider = /SiteDataProvider|DenebDataProvider/.test(code);
+  let wrapped = hasProvider;
+
+  if (!hasProvider) {
+    ensureImport(ast, providerImport, ['SiteDataProvider']);
     recast.types.visit(ast, {
-      visitJSXElement(pathNode) {
+      visitJSXExpressionContainer(pathNode) {
         if (wrapped) return false;
-        const name = getJsxName(pathNode.node);
-        if (name === 'Component') {
+        const expr = pathNode.node.expression;
+        if (expr && expr.type === 'Identifier' && expr.name === 'children') {
           pathNode.replace(
             b.jsxElement(
               b.jsxOpeningElement(
@@ -668,7 +774,7 @@ function instrumentLayoutSource(code, siteDataImport) {
                 [
                   b.jsxAttribute(
                     b.jsxIdentifier('initialSiteData'),
-                    b.jsxExpressionContainer(b.identifier('initialSiteData'))
+                    b.jsxExpressionContainer(b.identifier(jsonIdent))
                   ),
                 ],
                 false
@@ -684,9 +790,43 @@ function instrumentLayoutSource(code, siteDataImport) {
         this.traverse(pathNode);
       },
     });
+
+    if (!wrapped) {
+      recast.types.visit(ast, {
+        visitJSXElement(pathNode) {
+          if (wrapped) return false;
+          const name = getJsxName(pathNode.node);
+          if (name === 'Component') {
+            pathNode.replace(
+              b.jsxElement(
+                b.jsxOpeningElement(
+                  b.jsxIdentifier('SiteDataProvider'),
+                  [
+                    b.jsxAttribute(
+                      b.jsxIdentifier('initialSiteData'),
+                      b.jsxExpressionContainer(b.identifier(jsonIdent))
+                    ),
+                  ],
+                  false
+                ),
+                b.jsxClosingElement(b.jsxIdentifier('SiteDataProvider')),
+                [pathNode.node],
+                false
+              )
+            );
+            wrapped = true;
+            return false;
+          }
+          this.traverse(pathNode);
+        },
+      });
+    }
   }
 
-  return { code: printSource(ast, code), updated: wrapped };
+  ensureProviderInitialData(ast, jsonIdent);
+  sanitizeDuplicateBindings(ast);
+  const next = printSource(ast, code);
+  return { code: next, updated: next !== code };
 }
 
 function ensureJsonModule(tsconfig) {
@@ -752,6 +892,8 @@ module.exports = {
   instrumentLayoutSource,
   instrumentPageKey,
   resolveSiteDataSpecifier,
+  resolveSiteDataRuntimeSpecifier,
+  rewriteRecursiveSiteDataContext,
   ensureJsonModule,
   inferPageKey,
   sanitizeContradictoryMarkers,

package/src/tools/template-converter.cjs

@@ -615,8 +615,8 @@ function transformFileContent(filePath, pageKey, extractedData, backupDir, proje
       code = "'use client';\n\n" + code;
     }
 
-    // Add useSiteData import if needed
-    if (!code.includes('useSiteData')) {
+    // Add useSiteData import if needed. Skip when any binding already exists.
+    if (!/\buseSiteData\b/.test(code)) {
       code = code.replace(
         /(import\s+[^;]+;\n)/,
         `$1import { useSiteData } from '@deneb-ui/ui';\n`