@pie-element/cli 0.1.1 → 0.1.2-next.0

package/dist/lib/upstream/sync-package-manager.js

@@ -4,13 +4,41 @@
  * This module consolidates all package.json generation and management logic
  * to eliminate the massive duplication between controllers-strategy and react-strategy.
  */
-import { existsSync } from 'node:fs';
-import { readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
 import { loadPackageJson } from '../../utils/package-json.js';
 import { existsAny } from './sync-filesystem.js';
 import { applyPackageJsonTransforms } from './sync-transforms.js';
-import { BUILD_TOOLS, REACT, PACKAGE_DEFAULTS, SCRIPTS, WORKSPACE } from './sync-constants.js';
+import { BUILD_TOOLS, PACKAGE_DEFAULTS, REACT, SCRIPTS, WORKSPACE, composeElementBuildScript, } from './sync-constants.js';
+import { getPieLibDependencyAugmentations, getPieLibDependencyOverride, shouldGenerateConfigUiFractionHelper, shouldGenerateAutosizeInputComponent, } from './sync-presets.js';
+function getLegacyConfigureEntry(entryPoints) {
+    if (entryPoints.hasConfigure) {
+        return 'configure';
+    }
+    if (entryPoints.hasAuthor) {
+        return 'author';
+    }
+    return null;
+}
+function distEntryExport(entry) {
+    return {
+        types: `./dist/${entry}/index.d.ts`,
+        default: `./dist/${entry}/index.js`,
+    };
+}
+function readBrowserEsmPolicy(rootDir) {
+    const policyPath = join(rootDir, 'tools/vite/browser-esm-policy.json');
+    if (!existsSync(policyPath)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(policyPath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * Detect available entry points in an element package
  */
@@ -52,6 +80,12 @@ export function detectEntryPoints(elementDir) {
             join(elementDir, 'src/print/index.js'),
             join(elementDir, 'src/print/index.jsx'),
         ]),
+        hasRuntimeSupport: existsAny([
+            join(elementDir, 'src/runtime-support.ts'),
+            join(elementDir, 'src/runtime-support.tsx'),
+            join(elementDir, 'src/runtime-support.js'),
+            join(elementDir, 'src/runtime-support.jsx'),
+        ]),
         hasTypes: existsAny([
             join(elementDir, 'src/types/index.ts'),
             join(elementDir, 'src/types/index.tsx'),
@@ -63,7 +97,8 @@ export function detectEntryPoints(elementDir) {
 /**
  * Generate exports object based on available entry points
  */
-export function generateExportsObject(entryPoints) {
+export function generateExportsObject(entryPoints, options = {}) {
+    const includeBrowserExports = options.includeBrowserExports ?? false;
     const exports = {
         '.': {
             types: './dist/index.d.ts',
@@ -75,30 +110,56 @@ export function generateExportsObject(entryPoints) {
             types: './dist/delivery/index.d.ts',
             default: './dist/delivery/index.js',
         };
+        if (includeBrowserExports) {
+            exports['./browser/delivery'] = {
+                default: './dist/browser/delivery/index.js',
+            };
+        }
     }
     if (entryPoints.hasAuthor) {
         exports['./author'] = {
             types: './dist/author/index.d.ts',
             default: './dist/author/index.js',
         };
+        if (includeBrowserExports) {
+            exports['./browser/author'] = {
+                default: './dist/browser/author/index.js',
+            };
+        }
+    }
+    const legacyConfigureEntry = getLegacyConfigureEntry(entryPoints);
+    if (legacyConfigureEntry) {
+        exports['./configure'] = distEntryExport(legacyConfigureEntry);
     }
     if (entryPoints.hasController) {
         exports['./controller'] = {
             types: './dist/controller/index.d.ts',
             default: './dist/controller/index.js',
         };
-    }
-    if (entryPoints.hasConfigure) {
-        exports['./configure'] = {
-            types: './dist/configure/index.d.ts',
-            default: './dist/configure/index.js',
+        exports['./controller.js'] = {
+            types: './dist/controller/index.d.ts',
+            default: './dist/controller/index.js',
         };
+        if (includeBrowserExports) {
+            exports['./browser/controller'] = {
+                default: './dist/browser/controller/index.js',
+            };
+        }
     }
     if (entryPoints.hasPrint) {
         exports['./print'] = {
             types: './dist/print/index.d.ts',
             default: './dist/print/index.js',
         };
+        exports['./print.js'] = {
+            types: './dist/print/index.d.ts',
+            default: './dist/print/index.js',
+        };
+        if (includeBrowserExports) {
+            exports['./browser/print'] = {
+                default: './dist/browser/print/index.js',
+            };
+        }
     }
     if (entryPoints.hasTypes) {
         exports['./types'] = {
@@ -106,8 +167,44 @@ export function generateExportsObject(entryPoints) {
             default: './dist/types/index.js',
         };
     }
+    if (entryPoints.hasRuntimeSupport) {
+        exports['./runtime-support'] = {
+            types: './dist/runtime-support.d.ts',
+            default: './dist/runtime-support.js',
+        };
+    }
     return exports;
 }
+function generateRuntimeSupportSource(elementName, entryPoints) {
+    const packageName = `${WORKSPACE.PIE_ELEMENT_PREFIX}${elementName}`;
+    return `export const runtimeSupport = {
+  schemaVersion: 1,
+  packageName: '${packageName}',
+  supports: {
+    esm: {
+      delivery: ${entryPoints.hasDelivery},
+      author: ${entryPoints.hasAuthor},
+      print: ${entryPoints.hasPrint},
+    },
+  },
+};
+
+export default runtimeSupport;
+`;
+}
+async function ensureBrowserRuntimeSupportSource(elementName, elementDir, entryPoints) {
+    const runtimeSupportPath = join(elementDir, 'src', 'runtime-support.ts');
+    const nextContent = generateRuntimeSupportSource(elementName, entryPoints);
+    const currentContent = existsSync(runtimeSupportPath)
+        ? await readFile(runtimeSupportPath, 'utf-8').catch(() => null)
+        : null;
+    if (currentContent === nextContent) {
+        return false;
+    }
+    await mkdir(dirname(runtimeSupportPath), { recursive: true });
+    await writeFile(runtimeSupportPath, nextContent, 'utf-8');
+    return true;
+}
 /**
  * Extract imports from source files to determine runtime dependencies
  */
@@ -139,7 +236,9 @@ export async function extractImportsFromSources(elementDir) {
                             const importPath = match[1];
                             // Only track package imports (not relative imports)
                             if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
-                                imports.add(importPath);
+                                const normalized = normalizePackageImport(importPath);
+                                if (normalized)
+                                    imports.add(normalized);
                             }
                             match = importRegex.exec(content);
                         }
@@ -147,7 +246,9 @@ export async function extractImportsFromSources(elementDir) {
                         while (match !== null) {
                             const importPath = match[1];
                             if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
-                                imports.add(importPath);
+                                const normalized = normalizePackageImport(importPath);
+                                if (normalized)
+                                    imports.add(normalized);
                             }
                             match = dynamicImportRegex.exec(content);
                         }
@@ -165,10 +266,21 @@ export async function extractImportsFromSources(elementDir) {
     await scanDirectory(srcDir);
     return imports;
 }
+function normalizePackageImport(specifier) {
+    if (!specifier || specifier.startsWith('.') || specifier.startsWith('/')) {
+        return null;
+    }
+    if (specifier.startsWith('@')) {
+        const parts = specifier.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    }
+    return specifier.split('/')[0] || null;
+}
+const LEGACY_PEERS_TO_SKIP = new Set(['@emotion/core']);
 async function findInstalledPackageJson(packageName, fromDir) {
     try {
         const { createRequire } = await import('node:module');
-        const req = createRequire(join(fromDir, 'package.json'));
+        const req = createRequire(resolve(fromDir, 'package.json'));
         const resolvedEntry = req.resolve(packageName);
         let currentDir = dirname(resolvedEntry);
         while (true) {
@@ -191,7 +303,7 @@ async function findInstalledPackageJson(packageName, fromDir) {
     }
     return null;
 }
-async function addTransitivePeerDependencies(deps, fromDir) {
+async function addTransitivePeerDependencies(deps, fromDir, declaredPeerDeps = new Set()) {
     const depNames = Object.keys(deps);
     for (const depName of depNames) {
         if (depName.startsWith(WORKSPACE.PIE_LIB_PREFIX) ||
@@ -201,8 +313,14 @@ async function addTransitivePeerDependencies(deps, fromDir) {
         }
         const installedPkg = await findInstalledPackageJson(depName, fromDir);
         const peerDeps = installedPkg?.peerDependencies ?? {};
+        const optionalPeers = new Set(Object.entries(installedPkg?.peerDependenciesMeta ?? {})
+            .filter(([, meta]) => meta?.optional)
+            .map(([peerName]) => peerName));
         for (const [peerName, peerVersion] of Object.entries(peerDeps)) {
-            if (deps[peerName]) {
+            if (deps[peerName] ||
+                declaredPeerDeps.has(peerName) ||
+                optionalPeers.has(peerName) ||
+                LEGACY_PEERS_TO_SKIP.has(peerName)) {
                 continue;
             }
             if (peerName.startsWith(WORKSPACE.PIE_LIB_PREFIX) ||
@@ -231,6 +349,26 @@ async function inferPeerVersionFromDeclaredDeps(targetDep, deps, fromDir) {
     }
     return null;
 }
+function addKnownPeerFallbacks(deps) {
+    // Some widely used packages rely on peers that upstream metadata can omit
+    // or that may not be inferable from local resolution during sync.
+    if ((deps.recharts || deps['styled-components']) && !deps['react-is']) {
+        deps['react-is'] = '^18.3.1';
+    }
+    if (deps['@tiptap/extension-character-count'] && !deps['@tiptap/extensions']) {
+        deps['@tiptap/extensions'] = '^3.20.0';
+    }
+    if (deps['@tiptap/extension-list-item'] && !deps['@tiptap/extension-list']) {
+        const tiptapVersion = deps['@tiptap/extension-list-item'];
+        deps['@tiptap/extension-list'] = tiptapVersion;
+    }
+    if (deps['@testing-library/user-event'] && !deps['@testing-library/dom']) {
+        deps['@testing-library/dom'] = '^10.4.1';
+    }
+    if (deps['@visx/curve'] && !deps['d3-shape']) {
+        deps['d3-shape'] = '^3.2.0';
+    }
+}
 /**
  * Extract and normalize dependencies from upstream package.json
  */
@@ -238,7 +376,7 @@ export function extractUpstreamDependencies(upstreamPkg) {
     if (!upstreamPkg)
         return {};
     const upstreamDeps = upstreamPkg.dependencies ?? {};
-    const expectedDeps = {};
+    let expectedDeps = {};
     for (const [name, version] of Object.entries(upstreamDeps)) {
         if (name.startsWith(WORKSPACE.PIE_LIB_PREFIX)) {
             expectedDeps[name] = WORKSPACE.VERSION;
@@ -249,31 +387,38 @@ export function extractUpstreamDependencies(upstreamPkg) {
     }
     return expectedDeps;
 }
+function resolveSyncedVersion(upstreamPkg, existingPkg) {
+    const existingVersion = typeof existingPkg?.version === 'string' ? existingPkg.version : null;
+    if (existingVersion) {
+        return existingVersion;
+    }
+    const upstreamVersion = typeof upstreamPkg?.version === 'string' ? upstreamPkg.version : null;
+    return upstreamVersion || '0.1.0';
+}
 /**
- * Ensure devDependencies include all required build tools
+ * Ensure devDependencies include all required build tools.
+ *
+ * The pinned versions in BUILD_TOOLS / REACT are the source of truth for the
+ * monorepo's toolchain, so we overwrite any existing entries instead of only
+ * filling in missing ones. This prevents an upstream package.json from
+ * silently downgrading vite / @vitejs/plugin-react / typescript across the
+ * pie-lib packages during `upstream:update`.
  */
 export function ensureBuildToolDependencies(pkg) {
     if (!pkg.devDependencies || typeof pkg.devDependencies !== 'object') {
         pkg.devDependencies = {};
     }
     const devDeps = pkg.devDependencies;
-    if (!devDeps.vite)
-        devDeps.vite = BUILD_TOOLS.VITE;
-    if (!devDeps.typescript)
-        devDeps.typescript = BUILD_TOOLS.TYPESCRIPT;
-    if (!devDeps['@vitejs/plugin-react'])
-        devDeps['@vitejs/plugin-react'] = BUILD_TOOLS.VITE_REACT_PLUGIN;
-    if (!devDeps['@types/react'])
-        devDeps['@types/react'] = REACT.TYPES_VERSION;
-    if (!devDeps['@types/react-dom'])
-        devDeps['@types/react-dom'] = REACT.TYPES_VERSION;
+    devDeps.vite = BUILD_TOOLS.VITE;
+    devDeps.typescript = BUILD_TOOLS.TYPESCRIPT;
+    devDeps['@vitejs/plugin-react'] = BUILD_TOOLS.VITE_REACT_PLUGIN;
+    devDeps['@types/react'] = REACT.TYPES_VERSION;
+    devDeps['@types/react-dom'] = REACT.TYPES_VERSION;
 }
 /**
  * Check if a @pie-framework or @pie-element/shared- package exists in the workspace
  *
- * Supports both legacy @pie-framework naming and new @pie-element/shared- naming:
- * - @pie-framework/mathquill → packages/shared/mathquill (legacy, should migrate)
- * - @pie-element/shared-mathquill → packages/shared/mathquill (new convention)
+ * Supports both legacy @pie-framework naming and new @pie-element/shared- naming.
  */
 function isPieFrameworkWorkspacePackage(packageName, config) {
     let pkgName;
@@ -297,12 +442,13 @@ function isPieFrameworkWorkspacePackage(packageName, config) {
  * This function consolidates the ~400 lines of duplicated package.json management
  * logic from controllers-strategy and react-strategy into a single, maintainable function.
  */
-export async function ensureElementPackageJson(elementName, elementDir, config) {
+export async function ensureElementPackageJson(elementName, elementDir, config, options = {}) {
     if (!existsSync(elementDir)) {
         return false;
     }
     const pkgPath = join(elementDir, 'package.json');
     const upstreamPkgPath = join(config.pieElements, 'packages', elementName, 'package.json');
+    const includeBrowserExports = options.includeBrowserExports ?? false;
     // Load existing package.json
     let pkg = null;
     if (existsSync(pkgPath)) {
@@ -314,6 +460,11 @@ export async function ensureElementPackageJson(elementName, elementDir, config)
         : null;
     // Extract and normalize upstream dependencies
     const expectedDeps = extractUpstreamDependencies(upstreamPkg);
+    const declaredPeerDeps = new Set([
+        ...Object.keys(pkg?.peerDependencies ?? {}),
+        'react',
+        'react-dom',
+    ]);
     // Scan source files for actual imports to catch dependencies from skipped directories
     const importedPackages = await extractImportsFromSources(elementDir);
     // Add workspace dependencies found in imports
@@ -323,6 +474,9 @@ export async function ensureElementPackageJson(elementName, elementDir, config)
         if (imported === currentPackageName) {
             continue;
         }
+        if (imported === 'react' || imported === 'react-dom') {
+            continue;
+        }
         if (imported.startsWith(WORKSPACE.PIE_LIB_PREFIX)) {
             expectedDeps[imported] = WORKSPACE.VERSION;
         }
@@ -341,14 +495,29 @@ export async function ensureElementPackageJson(elementName, elementDir, config)
                 }
             }
         }
+        else if (!expectedDeps[imported]) {
+            // Keep element package.json aligned with actual runtime imports from src/.
+            // Upstream package.json can miss third-party deps after source transforms.
+            const installedPkg = await findInstalledPackageJson(imported, elementDir);
+            if (installedPkg?.version) {
+                expectedDeps[imported] = `^${installedPkg.version}`;
+            }
+            else {
+                const inferredPeerVersion = await inferPeerVersionFromDeclaredDeps(imported, expectedDeps, elementDir);
+                if (inferredPeerVersion) {
+                    expectedDeps[imported] = inferredPeerVersion;
+                }
+            }
+        }
     }
-    await addTransitivePeerDependencies(expectedDeps, elementDir);
+    await addTransitivePeerDependencies(expectedDeps, elementDir, declaredPeerDeps);
+    addKnownPeerFallbacks(expectedDeps);
     // Create minimal package.json if missing
     if (!pkg) {
         pkg = {
             name: `${WORKSPACE.PIE_ELEMENT_PREFIX}${elementName}`,
             private: true,
-            version: '0.1.0',
+            version: resolveSyncedVersion(upstreamPkg, null),
             description: upstreamPkg?.description ??
                 `React implementation of ${elementName} element synced from pie-elements`,
             dependencies: expectedDeps,
@@ -362,19 +531,90 @@ export async function ensureElementPackageJson(elementName, elementDir, config)
     if (Object.keys(expectedDeps).length > 0) {
         pkg.dependencies = expectedDeps;
     }
+    pkg.peerDependencies = {
+        ...(pkg.peerDependencies ?? {}),
+        react: REACT.VERSION,
+        'react-dom': REACT.VERSION,
+    };
     // Preserve pie metadata (if present upstream or locally)
     const pieMetadata = (upstreamPkg?.pie ??
         pkg?.pie ??
         undefined);
     // Apply all standard transformations
     pkg = applyPackageJsonTransforms(pkg);
-    if (pieMetadata) {
-        pkg.pie = pieMetadata;
+    // React must also be a real dependency, not only a peer. Legacy webpack
+    // bundlers (builder.pie-api.com) install `dependencies` and never install
+    // peers, so peer-only React leaves node_modules/react absent in the build
+    // snapshot and every @mui / @emotion / @dnd-kit peer fails with
+    // "Module not found: Can't resolve 'react'".
+    //
+    // This must run AFTER applyPackageJsonTransforms: transformPackageJsonBrowserEsmDependencies
+    // unconditionally deletes react/react-dom from dependencies to drop whatever
+    // arbitrary range upstream declared. We re-add them here as the final word,
+    // pinned to the policy version.
+    //
+    // Install metadata only. The browser runtime singleton contract stays governed
+    // by pie.browserSharedDependencies plus the player import map, and isExternal()
+    // in sync-externals.ts keeps React external in every bundle regardless of what
+    // is declared here, so bundle output is unaffected.
+    //
+    // Versions come from tools/vite/browser-esm-policy.json - the same source as
+    // pie.browserSharedDependencies below.
+    //
+    // Declared as a caret range, NOT an exact pin. An exact pin resolves to its own
+    // copy alongside the root's `^`-resolved one, and two React instances break
+    // hooks at runtime ("Invalid hook call", useRef of null). The installed version
+    // only has to resolve for the legacy webpack path, so a range is sufficient.
+    const sharedRuntimeDeps = readBrowserEsmPolicy(config.pieElementsNg).sharedDependencyVersions;
+    if (sharedRuntimeDeps && Object.keys(sharedRuntimeDeps).length > 0) {
+        const rangedRuntimeDeps = Object.fromEntries(Object.entries(sharedRuntimeDeps).map(([name, version]) => [name, `^${version}`]));
+        pkg.dependencies = {
+            ...(pkg.dependencies ?? {}),
+            ...rangedRuntimeDeps,
+        };
     }
     // Detect available entry points
     const entryPoints = detectEntryPoints(elementDir);
-    // Generate exports based on entry points
-    pkg.exports = generateExportsObject(entryPoints);
+    const wroteRuntimeSupport = includeBrowserExports && !entryPoints.hasRuntimeSupport
+        ? await ensureBrowserRuntimeSupportSource(elementName, elementDir, entryPoints)
+        : false;
+    if (includeBrowserExports) {
+        entryPoints.hasRuntimeSupport = true;
+    }
+    // Generate dist-only exports based on entry points. Do not preserve
+    // source-backed `development` conditions; PIE-605 makes raw source paths a
+    // private implementation detail and keeps public package surfaces dist-only.
+    const nextPieMetadata = pieMetadata ? { ...pieMetadata } : {};
+    if (entryPoints.hasController) {
+        nextPieMetadata.controller = `${WORKSPACE.PIE_ELEMENT_PREFIX}${elementName}/controller`;
+    }
+    else {
+        delete nextPieMetadata.controller;
+    }
+    const legacyConfigureEntry = getLegacyConfigureEntry(entryPoints);
+    if (legacyConfigureEntry) {
+        nextPieMetadata.configure = `${WORKSPACE.PIE_ELEMENT_PREFIX}${elementName}/configure`;
+    }
+    else {
+        delete nextPieMetadata.configure;
+    }
+    if (includeBrowserExports) {
+        const browserEsmPolicy = readBrowserEsmPolicy(config.pieElementsNg);
+        if (browserEsmPolicy.sharedDependencyVersions) {
+            nextPieMetadata.browserSharedDependencies = browserEsmPolicy.sharedDependencyVersions;
+        }
+    }
+    else {
+        delete nextPieMetadata.browserSharedDependencies;
+    }
+    if (Object.keys(nextPieMetadata).length > 0) {
+        pkg.pie = nextPieMetadata;
+    }
+    else {
+        delete pkg.pie;
+    }
+    const hasBrowserBuild = includeBrowserExports;
+    pkg.exports = generateExportsObject(entryPoints, { includeBrowserExports: hasBrowserBuild });
     // Warn when metadata/structure disagree for core capabilities
     const metadataCapabilities = Array.isArray(pieMetadata?.capabilities)
         ? new Set(pieMetadata.capabilities)
@@ -402,14 +642,35 @@ export async function ensureElementPackageJson(elementName, elementDir, config)
     }
     // Set core package.json fields
     pkg.name = `${WORKSPACE.PIE_ELEMENT_PREFIX}${elementName}`;
+    pkg.version = resolveSyncedVersion(upstreamPkg, pkg);
     pkg.type = PACKAGE_DEFAULTS.TYPE;
     pkg.main = './dist/index.js';
     pkg.types = './dist/index.d.ts';
-    // Ensure files array
+    // Ensure publish surface is dist-only. Source remains available in the repo,
+    // but must not be published as a public package API. Controller-bearing
+    // elements additionally publish the root shim required by legacy builders.
     const files = Array.isArray(pkg.files) ? pkg.files : [];
     const normalizedFiles = new Set(files.filter((v) => typeof v === 'string'));
     normalizedFiles.add('dist');
-    normalizedFiles.add('src');
+    normalizedFiles.delete('src');
+    if (entryPoints.hasController) {
+        normalizedFiles.add('controller.js');
+    }
+    else {
+        normalizedFiles.delete('controller.js');
+    }
+    if (legacyConfigureEntry) {
+        normalizedFiles.add('configure.js');
+    }
+    else {
+        normalizedFiles.delete('configure.js');
+    }
+    if (entryPoints.hasPrint) {
+        normalizedFiles.add('print.js');
+    }
+    else {
+        normalizedFiles.delete('print.js');
+    }
     pkg.files = Array.from(normalizedFiles).sort();
     // Set sideEffects
     if (typeof pkg.sideEffects === 'undefined') {
@@ -424,20 +685,85 @@ export async function ensureElementPackageJson(elementName, elementDir, config)
     const scripts = pkg.scripts;
     const hasIifeEntry = existsSync(join(elementDir, 'src/index.iife.ts')) ||
         existsSync(join(elementDir, 'vite.config.iife.ts'));
-    scripts.build = hasIifeEntry ? SCRIPTS.BUILD_WITH_IIFE : SCRIPTS.BUILD;
+    // A print entry point means this package also needs the legacy print lane, so
+    // module/print.js is emitted for the current @pie-framework/pie-print loader.
+    scripts.build = composeElementBuildScript({
+        browser: hasBrowserBuild,
+        legacyPrint: entryPoints.hasPrint,
+        iife: hasIifeEntry,
+    });
     scripts.dev = SCRIPTS.DEV;
     scripts.demo = SCRIPTS.DEMO;
     scripts.test = SCRIPTS.TEST;
+    const controllerShimPath = join(elementDir, 'controller.js');
+    const controllerShimContent = "export * from './dist/controller/index.js';\n";
+    const hasControllerShim = existsSync(controllerShimPath);
+    const currentControllerShim = hasControllerShim
+        ? await readFile(controllerShimPath, 'utf-8').catch(() => null)
+        : null;
+    const shouldWriteControllerShim = entryPoints.hasController && currentControllerShim !== controllerShimContent;
+    const shouldRemoveControllerShim = !entryPoints.hasController && hasControllerShim;
+    const configureShimPath = join(elementDir, 'configure.js');
+    const configureShimContent = legacyConfigureEntry
+        ? `export { default } from './dist/${legacyConfigureEntry}/index.js';\nexport * from './dist/${legacyConfigureEntry}/index.js';\n`
+        : null;
+    const hasConfigureShim = existsSync(configureShimPath);
+    const currentConfigureShim = hasConfigureShim
+        ? await readFile(configureShimPath, 'utf-8').catch(() => null)
+        : null;
+    const shouldWriteConfigureShim = configureShimContent !== null && currentConfigureShim !== configureShimContent;
+    const shouldRemoveConfigureShim = configureShimContent === null && hasConfigureShim;
+    // The IIFE bundlers alias `@pie-element/<element>` to a directory, so a `/print`
+    // request resolves as a literal path and never consults `exports`. The root shim is
+    // what makes that request land on the built print entry, the same way controller.js
+    // and configure.js do for their views.
+    const printShimPath = join(elementDir, 'print.js');
+    const printShimContent = entryPoints.hasPrint
+        ? "export { default } from './dist/print/index.js';\nexport * from './dist/print/index.js';\n"
+        : null;
+    const hasPrintShim = existsSync(printShimPath);
+    const currentPrintShim = hasPrintShim
+        ? await readFile(printShimPath, 'utf-8').catch(() => null)
+        : null;
+    const shouldWritePrintShim = printShimContent !== null && currentPrintShim !== printShimContent;
+    const shouldRemovePrintShim = printShimContent === null && hasPrintShim;
     // Check if content changed
     const nextContent = `${JSON.stringify(pkg, null, 2)}\n`;
     const currentContent = existsSync(pkgPath)
         ? await readFile(pkgPath, 'utf-8').catch(() => null)
         : null;
-    if (currentContent === nextContent) {
+    if (currentContent === nextContent &&
+        !wroteRuntimeSupport &&
+        !shouldWriteControllerShim &&
+        !shouldRemoveControllerShim &&
+        !shouldWriteConfigureShim &&
+        !shouldRemoveConfigureShim &&
+        !shouldWritePrintShim &&
+        !shouldRemovePrintShim) {
         return false;
     }
     // Write updated package.json
-    await writeFile(pkgPath, nextContent, 'utf-8');
+    if (currentContent !== nextContent) {
+        await writeFile(pkgPath, nextContent, 'utf-8');
+    }
+    if (shouldWriteControllerShim) {
+        await writeFile(controllerShimPath, controllerShimContent, 'utf-8');
+    }
+    else if (shouldRemoveControllerShim) {
+        await unlink(controllerShimPath).catch(() => { });
+    }
+    if (shouldWriteConfigureShim && configureShimContent !== null) {
+        await writeFile(configureShimPath, configureShimContent, 'utf-8');
+    }
+    else if (shouldRemoveConfigureShim) {
+        await unlink(configureShimPath).catch(() => { });
+    }
+    if (shouldWritePrintShim && printShimContent !== null) {
+        await writeFile(printShimPath, printShimContent, 'utf-8');
+    }
+    else if (shouldRemovePrintShim) {
+        await unlink(printShimPath).catch(() => { });
+    }
     return true;
 }
 /**
@@ -458,13 +784,9 @@ export async function ensurePieLibPackageJson(pkgName, pkgDir, config) {
         : null;
     // Extract upstream dependencies
     const upstreamDeps = upstreamPkg?.dependencies ?? {};
-    const expectedDeps = {};
+    let expectedDeps = {};
     for (const [name, version] of Object.entries(upstreamDeps)) {
-        // Transform @pie-framework/mathquill to @pie-element/shared-mathquill
-        if (name === '@pie-framework/mathquill') {
-            expectedDeps['@pie-element/shared-mathquill'] = WORKSPACE.VERSION;
-        }
-        else if (name.startsWith(WORKSPACE.PIE_LIB_PREFIX)) {
+        if (name.startsWith(WORKSPACE.PIE_LIB_PREFIX)) {
             expectedDeps[name] = WORKSPACE.VERSION;
         }
         else {
@@ -473,10 +795,6 @@ export async function ensurePieLibPackageJson(pkgName, pkgDir, config) {
     }
     const importedPackages = await extractImportsFromSources(pkgDir);
     for (const importedPkg of importedPackages) {
-        if (importedPkg === '@pie-framework/mathquill') {
-            expectedDeps['@pie-element/shared-mathquill'] = WORKSPACE.VERSION;
-            continue;
-        }
         if (importedPkg.startsWith(WORKSPACE.PIE_LIB_PREFIX)) {
             expectedDeps[importedPkg] = WORKSPACE.VERSION;
             continue;
@@ -500,16 +818,26 @@ export async function ensurePieLibPackageJson(pkgName, pkgDir, config) {
             }
         }
     }
-    // graphing imports @dnd-kit/core directly in source but upstream metadata can omit it.
-    if (pkgName === 'graphing' && !expectedDeps['@dnd-kit/core']) {
-        expectedDeps['@dnd-kit/core'] = '^6.3.0';
+    await addTransitivePeerDependencies(expectedDeps, pkgDir);
+    addKnownPeerFallbacks(expectedDeps);
+    const dependencyAugmentations = getPieLibDependencyAugmentations(pkgName);
+    for (const [depName, version] of Object.entries(dependencyAugmentations)) {
+        if (!expectedDeps[depName]) {
+            expectedDeps[depName] = version;
+        }
     }
+    const declaresReactRuntime = typeof expectedDeps.react === 'string' || typeof expectedDeps['react-dom'] === 'string';
+    expectedDeps =
+        applyPackageJsonTransforms({ dependencies: expectedDeps }, {
+            removeReactInputAutosize: shouldGenerateAutosizeInputComponent(pkgName),
+            removeMathjs: shouldGenerateConfigUiFractionHelper(pkgName) && !importedPackages.has('mathjs'),
+        }).dependencies ?? {};
     // Create minimal package.json if missing
     if (!pkg) {
         pkg = {
             name: `${WORKSPACE.PIE_LIB_PREFIX}${pkgName}`,
             private: true,
-            version: '0.1.0',
+            version: resolveSyncedVersion(upstreamPkg, null),
             description: upstreamPkg?.description ??
                 `React implementation of @pie-lib/${pkgName} synced from pie-lib`,
             dependencies: expectedDeps,
@@ -519,36 +847,41 @@ export async function ensurePieLibPackageJson(pkgName, pkgDir, config) {
     if (Object.keys(expectedDeps).length > 0) {
         pkg.dependencies = expectedDeps;
     }
-    // Special handling for math-rendering: reference MathJax adapter package
-    if (pkgName === 'math-rendering') {
-        pkg.dependencies = {
-            [`${WORKSPACE.PIE_ELEMENT_PREFIX}shared-math-rendering-mathjax`]: WORKSPACE.VERSION,
+    const dependencyOverride = getPieLibDependencyOverride(pkgName);
+    if (dependencyOverride) {
+        pkg.dependencies = dependencyOverride;
+    }
+    if (declaresReactRuntime) {
+        pkg.peerDependencies = {
+            ...(pkg.peerDependencies ?? {}),
+            react: REACT.VERSION,
+            'react-dom': REACT.VERSION,
         };
     }
-    // Generate exports
-    const exportsObj = {
-        ...(typeof pkg.exports === 'object' && pkg.exports
-            ? pkg.exports
-            : {}),
-    };
+    // Generate dist-only exports. Pie-lib packages expose only their compiled
+    // top-level entry; raw source paths are intentionally not public.
+    const exportsObj = {};
     exportsObj['.'] = {
         types: './dist/index.d.ts',
         default: './dist/index.js',
     };
     pkg.name = `${WORKSPACE.PIE_LIB_PREFIX}${pkgName}`;
+    pkg.version = resolveSyncedVersion(upstreamPkg, pkg);
     pkg.type = PACKAGE_DEFAULTS.TYPE;
     pkg.main = './dist/index.js';
     pkg.types = './dist/index.d.ts';
     pkg.exports = exportsObj;
-    // Ensure files array
-    const files = Array.isArray(pkg.files) ? pkg.files : [];
-    const normalizedFiles = new Set(files.filter((v) => typeof v === 'string'));
-    normalizedFiles.add('dist');
-    normalizedFiles.add('src');
-    pkg.files = Array.from(normalizedFiles).sort();
+    // Ensure publish surface is dist-only. Source remains available in the repo,
+    // but must not be published as a public package API.
+    pkg.files = ['dist'];
     if (typeof pkg.sideEffects === 'undefined') {
         pkg.sideEffects = PACKAGE_DEFAULTS.SIDE_EFFECTS;
     }
+    // Pie-lib packages use a vite.config.ts that imports @vitejs/plugin-react,
+    // so their devDependencies must include the same build toolchain that
+    // element packages do. Without this, a fresh `bun install` (no hoisting)
+    // fails to resolve the plugin when turbo runs `vite build` per package.
+    ensureBuildToolDependencies(pkg);
     // Ensure build scripts
     if (!pkg.scripts || typeof pkg.scripts !== 'object') {
         pkg.scripts = {};