@edge-base/cli 0.2.7 → 0.2.9

package/dist/lib/runtime-scaffold.js

@@ -1,7 +1,9 @@
-import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, unlinkSync, symlinkSync, writeFileSync, } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
+import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, realpathSync, readdirSync, readFileSync, readlinkSync, rmSync, unlinkSync, symlinkSync, writeFileSync, } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, join, posix, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { buildManagedD1DatabaseName } from './managed-resource-names.js';
+import { normalizeFrontendMountPath } from './frontend-config.js';
+import { buildManagedD1DatabaseName, buildManagedR2BucketName, buildManagedWorkerName, } from './managed-resource-names.js';
 import { deriveProjectSlug, INTERNAL_D1_BINDINGS } from './project-runtime.js';
 import { resolveWranglerTool } from './wrangler.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -14,7 +16,9 @@ const MONOREPO_ADMIN_BUILD_SOURCES = [
 const CLI_NODE_MODULES_SOURCE = resolve(__dirname, '../../node_modules');
 const WORKSPACE_NODE_MODULES_SOURCE = resolve(WORKSPACE_ROOT, 'node_modules');
 const SERVER_NODE_MODULES_SOURCE = resolve(__dirname, '../../../server/node_modules');
+const MONOREPO_SERVER_PACKAGE_MANIFEST_SOURCE = resolve(__dirname, '../../../server/package.json');
 const MONOREPO_SHARED_SOURCE = resolve(__dirname, '../../../shared');
+const EDGEBASE_ASSETS_DIRNAME = 'app-assets';
 export { deriveProjectSlug, INTERNAL_D1_BINDINGS } from './project-runtime.js';
 export function getRuntimeRoot(projectDir) {
     return join(projectDir, '.edgebase', 'runtime', 'server');
@@ -25,17 +29,21 @@ export function getRuntimeServerSrcDir(projectDir) {
 export function getRuntimeAdminBuildDir(projectDir) {
     return join(getRuntimeRoot(projectDir), 'admin-build');
 }
-export function ensureRuntimeScaffold(projectDir) {
+export function getRuntimeAssetsDir(projectDir) {
+    return join(getRuntimeRoot(projectDir), EDGEBASE_ASSETS_DIRNAME);
+}
+export function ensureRuntimeScaffold(projectDir, options = {}) {
     const runtimeRoot = getRuntimeRoot(projectDir);
     mkdirSync(runtimeRoot, { recursive: true });
     copyRuntimeDir(resolveServerRuntimeSource(projectDir), getRuntimeServerSrcDir(projectDir));
     const adminBuildDir = getRuntimeAdminBuildDir(projectDir);
     copyRuntimeDir(resolveAdminBuildSource(projectDir), adminBuildDir);
     normalizeAdminBuildBase(adminBuildDir);
-    ensureRuntimeNodeModulesLink(projectDir, runtimeRoot);
-    ensureProjectSharedPackageLink(projectDir);
-    writeRuntimeConfigShim(projectDir);
-    writeRuntimeTestConfigShim(projectDir);
+    prepareRuntimeAssets(projectDir, options.frontendProjectDir ?? projectDir, adminBuildDir, options.frontend ?? undefined);
+    ensureRuntimeNodeModules(projectDir, runtimeRoot, options.dependencyMode ?? 'symlink', options.dependencyProfile ?? 'portable');
+    ensureProjectSharedPackageLink(projectDir, options.dependencyMode ?? 'symlink');
+    writeRuntimeConfigShim(projectDir, undefined, { importPath: options.configImportPath });
+    writeRuntimeTestConfigShim(projectDir, { importPath: options.testConfigImportPath });
 }
 export function ensureLocalWranglerToml(projectDir) {
     const wranglerPath = join(projectDir, 'wrangler.toml');
@@ -45,14 +53,15 @@ export function ensureLocalWranglerToml(projectDir) {
     return wranglerPath;
 }
 export function buildDefaultWranglerToml(accountId, projectName = 'edgebase') {
+    const workerName = buildManagedWorkerName(projectName);
     const accountLine = accountId ? `account_id = "${accountId}"\n` : '';
     const internalD1Blocks = INTERNAL_D1_BINDINGS.map(({ name, binding }) => `[[d1_databases]]
 binding = "${binding}"
-database_name = "${buildManagedD1DatabaseName(projectName, name)}"
+database_name = "${buildManagedD1DatabaseName(workerName, name)}"
 database_id = "local"
 `).join('\n');
     return `# Auto-generated by edgebase
-name = "${projectName}"
+name = "${workerName}"
 ${accountLine}main = ".edgebase/runtime/server/src/index.ts"
 compatibility_date = "2025-02-10"
 compatibility_flags = ["nodejs_compat"]
@@ -76,7 +85,7 @@ new_sqlite_classes = ["LogsDO"]
 
 [[r2_buckets]]
 binding = "STORAGE"
-bucket_name = "${projectName}-storage"
+bucket_name = "${buildManagedR2BucketName(workerName)}"
 
 [[kv_namespaces]]
 binding = "KV"
@@ -85,7 +94,7 @@ id = "local"
 ${internalD1Blocks}
 
 [assets]
-directory = ".edgebase/runtime/server/admin-build"
+directory = ".edgebase/runtime/server/app-assets"
 binding = "ASSETS"
 run_worker_first = true
 `;
@@ -106,10 +115,10 @@ function copyRuntimeDir(source, target) {
 }
 function resolveServerRuntimeSource(projectDir) {
     const candidates = dedupeCandidates([
+        MONOREPO_SERVER_RUNTIME_SOURCE,
         join(projectDir, 'node_modules', '@edge-base', 'server', 'src'),
         resolve(CLI_NODE_MODULES_SOURCE, '@edge-base/server', 'src'),
         resolve(WORKSPACE_NODE_MODULES_SOURCE, '@edge-base/server', 'src'),
-        MONOREPO_SERVER_RUNTIME_SOURCE,
     ]);
     for (const candidate of candidates) {
         if (existsSync(join(candidate, 'index.ts'))) {
@@ -120,10 +129,10 @@ function resolveServerRuntimeSource(projectDir) {
 }
 function resolveAdminBuildSource(projectDir) {
     const candidates = dedupeCandidates([
+        ...MONOREPO_ADMIN_BUILD_SOURCES,
         join(projectDir, 'node_modules', '@edge-base', 'server', 'admin-build'),
         resolve(CLI_NODE_MODULES_SOURCE, '@edge-base/server', 'admin-build'),
         resolve(WORKSPACE_NODE_MODULES_SOURCE, '@edge-base/server', 'admin-build'),
-        ...MONOREPO_ADMIN_BUILD_SOURCES,
     ]);
     for (const candidate of candidates) {
         if (existsSync(join(candidate, 'index.html'))) {
@@ -132,6 +141,31 @@ function resolveAdminBuildSource(projectDir) {
     }
     throw new Error(`Admin build source is missing. Checked: ${candidates.join(', ')}`);
 }
+function prepareRuntimeAssets(projectDir, sourceProjectDir, adminBuildDir, frontend) {
+    const assetsDir = getRuntimeAssetsDir(projectDir);
+    rmSync(assetsDir, { recursive: true, force: true });
+    mkdirSync(assetsDir, { recursive: true });
+    copyRuntimeDir(adminBuildDir, join(assetsDir, 'admin'));
+    copyFrontendBuild(sourceProjectDir, assetsDir, frontend);
+}
+function copyFrontendBuild(projectDir, assetsDir, frontend) {
+    if (!frontend?.directory)
+        return;
+    const source = resolve(projectDir, frontend.directory);
+    if (!existsSync(source)) {
+        throw new Error(`Frontend build directory is missing: ${source}`);
+    }
+    const mountPath = normalizeFrontendMountPath(frontend.mountPath);
+    if (mountPath === '/') {
+        const conflicts = readdirSync(source).filter((entry) => entry === 'admin');
+        if (conflicts.length > 0) {
+            throw new Error(`Frontend build directory '${frontend.directory}' contains reserved top-level entries: ${conflicts.join(', ')}.`);
+        }
+    }
+    const target = mountPath === '/' ? assetsDir : join(assetsDir, mountPath.slice(1));
+    mkdirSync(target, { recursive: true });
+    copyRuntimeDir(source, target);
+}
 function normalizeAdminBuildBase(adminBuildDir) {
     const indexPath = join(adminBuildDir, 'index.html');
     if (!existsSync(indexPath))
@@ -146,11 +180,15 @@ function normalizeAdminBuildBase(adminBuildDir) {
         writeFileSync(indexPath, normalized, 'utf-8');
     }
 }
-function ensureRuntimeNodeModulesLink(projectDir, runtimeRoot) {
-    const source = resolveRuntimeNodeModulesSource(projectDir);
+function ensureRuntimeNodeModules(projectDir, runtimeRoot, mode, profile) {
+    const source = resolveRuntimeNodeModulesSource(projectDir, mode);
     if (!source)
         return;
     const target = join(runtimeRoot, 'node_modules');
+    if (mode === 'copy') {
+        materializeNodeModulesTree(source, target, getRuntimeNodeModulesCandidates(projectDir, mode), resolveRuntimeDependencySelection(projectDir, profile));
+        return;
+    }
     const currentLink = readExistingSymlinkTarget(target);
     if (currentLink === source)
         return;
@@ -159,16 +197,16 @@ function ensureRuntimeNodeModulesLink(projectDir, runtimeRoot) {
     }
     symlinkSync(source, target, process.platform === 'win32' ? 'junction' : 'dir');
 }
-export function ensureProjectSharedPackageLink(projectDir) {
+export function ensureProjectSharedPackageLink(projectDir, mode = 'symlink') {
     const source = resolveSharedPackageSource(projectDir);
     if (!source)
         return;
     for (const root of resolveSharedPackageLinkRoots(projectDir)) {
-        ensureSharedPackageLinkAtRoot(root, source);
+        ensureSharedPackageLinkAtRoot(root, source, mode);
     }
 }
-function resolveRuntimeNodeModulesSource(projectDir) {
-    return resolveRuntimeNodeModulesSourceFromCandidates(getRuntimeNodeModulesCandidates(projectDir));
+function resolveRuntimeNodeModulesSource(projectDir, mode = 'symlink') {
+    return resolveRuntimeNodeModulesSourceFromCandidates(getRuntimeNodeModulesCandidates(projectDir, mode));
 }
 export function resolveRuntimeNodeModulesSourceFromCandidates(candidates) {
     for (const candidate of candidates) {
@@ -189,7 +227,15 @@ export function resolveSharedPackageSourceFromCandidates(candidates) {
     }
     return null;
 }
-function getRuntimeNodeModulesCandidates(projectDir) {
+function getRuntimeNodeModulesCandidates(projectDir, mode = 'symlink') {
+    if (mode === 'copy') {
+        return dedupeCandidates([
+            SERVER_NODE_MODULES_SOURCE,
+            CLI_NODE_MODULES_SOURCE,
+            join(projectDir, 'node_modules'),
+            WORKSPACE_NODE_MODULES_SOURCE,
+        ]);
+    }
     return dedupeCandidates([
         SERVER_NODE_MODULES_SOURCE,
         CLI_NODE_MODULES_SOURCE,
@@ -197,6 +243,174 @@ function getRuntimeNodeModulesCandidates(projectDir) {
         join(projectDir, 'node_modules'),
     ]);
 }
+function materializeNodeModulesTree(sourceRoot, targetRoot, candidateRoots, selectedPackages) {
+    rmSync(targetRoot, { recursive: true, force: true });
+    mkdirSync(targetRoot, { recursive: true });
+    const normalizedRoots = dedupeCandidates(candidateRoots)
+        .filter((candidate) => existsSync(candidate))
+        .map((candidate) => resolve(candidate))
+        .sort((left, right) => right.length - left.length);
+    const copiedTargets = new Set();
+    if (selectedPackages && selectedPackages.length > 0) {
+        for (const selection of selectedPackages) {
+            materializeNodeModulesEntry(selection.packageDir, join(targetRoot, ...selection.packageName.split('/')), targetRoot, normalizedRoots, copiedTargets);
+        }
+        return;
+    }
+    for (const entry of readdirSync(sourceRoot)) {
+        materializeNodeModulesEntry(join(sourceRoot, entry), join(targetRoot, entry), targetRoot, normalizedRoots, copiedTargets);
+    }
+}
+function resolvePackageDirectoryPath(packageName, candidateRoots) {
+    const topLevelEntry = resolveTopLevelPackageEntry(packageName, candidateRoots);
+    if (topLevelEntry) {
+        return topLevelEntry;
+    }
+    const packageSegments = packageName.split('/');
+    for (const candidateRoot of dedupeCandidates(candidateRoots)) {
+        const pnpmDir = join(candidateRoot, '.pnpm');
+        if (!existsSync(pnpmDir))
+            continue;
+        for (const entry of readdirSync(pnpmDir)) {
+            const candidatePath = join(pnpmDir, entry, 'node_modules', ...packageSegments);
+            if (existsSync(candidatePath)) {
+                return candidatePath;
+            }
+        }
+    }
+    return null;
+}
+function resolveTopLevelPackageEntry(packageName, candidateRoots) {
+    const packagePath = packageName.split('/');
+    for (const candidateRoot of candidateRoots) {
+        const candidatePath = join(candidateRoot, ...packagePath);
+        if (existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+function materializeNodeModulesEntry(sourceEntry, targetEntry, targetRoot, candidateRoots, copiedTargets, skipNestedNodeModules = false) {
+    const stat = lstatSync(sourceEntry);
+    if (stat.isSymbolicLink()) {
+        const sourceLinkTarget = readlinkSync(sourceEntry);
+        const resolvedSourceTarget = resolve(dirname(sourceEntry), sourceLinkTarget);
+        const sourceContainerRoot = findContainingRoot(resolvedSourceTarget, candidateRoots);
+        if (!existsSync(resolvedSourceTarget)) {
+            rmSync(targetEntry, { recursive: true, force: true });
+            mkdirSync(dirname(targetEntry), { recursive: true });
+            symlinkSync(buildDirectoryLinkTarget(targetEntry, resolvedSourceTarget), targetEntry, process.platform === 'win32' ? 'junction' : 'dir');
+            return;
+        }
+        if (!sourceContainerRoot) {
+            const targetKey = `${resolvedSourceTarget}=>${targetEntry}`;
+            if (copiedTargets.has(targetKey)) {
+                return;
+            }
+            copiedTargets.add(targetKey);
+            materializeNodeModulesEntry(resolvedSourceTarget, targetEntry, targetRoot, candidateRoots, copiedTargets, true);
+            return;
+        }
+        const materialization = getNodeModulesMaterialization(resolvedSourceTarget, sourceContainerRoot, targetRoot);
+        const targetKey = `${materialization.sourceRoot}=>${materialization.targetRoot}`;
+        if (!copiedTargets.has(targetKey)) {
+            copiedTargets.add(targetKey);
+            materializeNodeModulesEntry(materialization.sourceRoot, materialization.targetRoot, targetRoot, candidateRoots, copiedTargets, skipNestedNodeModules);
+        }
+        rmSync(targetEntry, { recursive: true, force: true });
+        mkdirSync(dirname(targetEntry), { recursive: true });
+        symlinkSync(buildDirectoryLinkTarget(targetEntry, materialization.targetPath), targetEntry, process.platform === 'win32' ? 'junction' : 'dir');
+        return;
+    }
+    if (stat.isDirectory()) {
+        mkdirSync(targetEntry, { recursive: true });
+        for (const entry of readdirSync(sourceEntry)) {
+            if (skipNestedNodeModules && entry === 'node_modules') {
+                continue;
+            }
+            materializeNodeModulesEntry(join(sourceEntry, entry), join(targetEntry, entry), targetRoot, candidateRoots, copiedTargets, skipNestedNodeModules);
+        }
+        return;
+    }
+    mkdirSync(dirname(targetEntry), { recursive: true });
+    copyFileSync(sourceEntry, targetEntry);
+}
+function findContainingRoot(targetPath, candidateRoots) {
+    for (const candidateRoot of candidateRoots) {
+        if (getRelativePathSegmentsWithinRoot(candidateRoot, targetPath) !== null) {
+            return candidateRoot;
+        }
+    }
+    return null;
+}
+function getNodeModulesMaterialization(sourcePath, sourceContainerRoot, targetRoot) {
+    const relativeSegments = getRelativePathSegmentsWithinRoot(sourceContainerRoot, sourcePath);
+    if (!relativeSegments) {
+        throw new Error(`Could not resolve '${sourcePath}' inside runtime dependency root '${sourceContainerRoot}'.`);
+    }
+    const targetPath = join(targetRoot, ...relativeSegments);
+    if (relativeSegments[0] === '.pnpm' && relativeSegments.length >= 2) {
+        const packageRoot = join(sourceContainerRoot, '.pnpm', relativeSegments[1]);
+        return {
+            sourceRoot: packageRoot,
+            targetRoot: join(targetRoot, '.pnpm', relativeSegments[1]),
+            targetPath,
+        };
+    }
+    return {
+        sourceRoot: sourcePath,
+        targetRoot: targetPath,
+        targetPath,
+    };
+}
+function getRelativePathSegmentsWithinRoot(rootPath, targetPath) {
+    const rootSegments = splitCrossPlatformPathSegments(rootPath);
+    const targetSegments = splitCrossPlatformPathSegments(targetPath);
+    if (rootSegments.length > targetSegments.length) {
+        return null;
+    }
+    for (let index = 0; index < rootSegments.length; index += 1) {
+        if (rootSegments[index] !== targetSegments[index]) {
+            return null;
+        }
+    }
+    return targetSegments.slice(rootSegments.length);
+}
+function splitCrossPlatformPathSegments(pathValue) {
+    const normalized = normalizeCrossPlatformPath(pathValue);
+    return normalized.split('/').filter(Boolean);
+}
+function normalizeCrossPlatformPath(pathValue) {
+    let normalized = pathValue.replace(/\\/g, '/').replace(/\/+/g, '/');
+    if (normalized.length > 1 && normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    if (/^[A-Z]:($|\/)/.test(normalized)) {
+        normalized = `${normalized[0].toLowerCase()}${normalized.slice(1)}`;
+    }
+    return normalized;
+}
+function buildDirectoryLinkTarget(linkPath, destinationPath, platform = process.platform) {
+    if (platform === 'win32') {
+        if (/^[A-Za-z]:[\\/]/.test(destinationPath)) {
+            return destinationPath.replace(/\//g, '\\');
+        }
+        return resolve(destinationPath);
+    }
+    const sourceDir = normalizeCrossPlatformPath(dirname(linkPath));
+    const targetPath = normalizeCrossPlatformPath(destinationPath);
+    return posix.relative(sourceDir, targetPath) || '.';
+}
+export const __runtimeScaffoldTestUtils = {
+    buildDirectoryLinkTarget,
+    findContainingRoot,
+    getNodeModulesMaterialization,
+    getRelativePathSegmentsWithinRoot,
+    resolvePackageSelectionFromManifestCandidates,
+    resolvePackageDirectoryPath,
+    resolveRuntimePackageSelections,
+    resolveRuntimePackageSelectionsFromInitialSelections,
+};
 function getSharedPackageSourceCandidates(projectDir) {
     return dedupeCandidates([
         join(projectDir, 'node_modules', '@edge-base', 'shared'),
@@ -206,6 +420,169 @@ function getSharedPackageSourceCandidates(projectDir) {
         MONOREPO_SHARED_SOURCE,
     ]);
 }
+function resolveRuntimeDependencySelection(projectDir, profile) {
+    const candidateRoots = getRuntimeNodeModulesCandidates(projectDir, 'copy');
+    const serverDependencies = readPackageDependencyNamesFromCandidates(getServerPackageManifestCandidates(projectDir));
+    if (!serverDependencies) {
+        return null;
+    }
+    const initialSelections = [];
+    for (const packageName of dedupeCandidates(serverDependencies)) {
+        const selection = resolveRuntimePackageSelection(packageName, candidateRoots);
+        if (selection) {
+            initialSelections.push(selection);
+        }
+    }
+    if (profile === 'portable') {
+        const wranglerSelection = resolvePackageSelectionFromManifestCandidates('wrangler', getPortableWranglerManifestCandidates(projectDir)) ?? resolveRuntimePackageSelection('wrangler', candidateRoots);
+        if (wranglerSelection) {
+            initialSelections.push(wranglerSelection);
+        }
+    }
+    return resolveRuntimePackageSelectionsFromInitialSelections(initialSelections, candidateRoots);
+}
+function getPortableWranglerManifestCandidates(projectDir) {
+    return dedupeCandidates([
+        join(projectDir, 'node_modules', 'wrangler', 'package.json'),
+        resolve(CLI_NODE_MODULES_SOURCE, 'wrangler', 'package.json'),
+        resolve(WORKSPACE_NODE_MODULES_SOURCE, 'wrangler', 'package.json'),
+        resolve(SERVER_NODE_MODULES_SOURCE, 'wrangler', 'package.json'),
+    ]);
+}
+function getServerPackageManifestCandidates(projectDir) {
+    return dedupeCandidates([
+        MONOREPO_SERVER_PACKAGE_MANIFEST_SOURCE,
+        join(projectDir, 'node_modules', '@edge-base', 'server', 'package.json'),
+        resolve(CLI_NODE_MODULES_SOURCE, '@edge-base', 'server', 'package.json'),
+        resolve(WORKSPACE_NODE_MODULES_SOURCE, '@edge-base', 'server', 'package.json'),
+    ]);
+}
+function readPackageDependencyNamesFromCandidates(candidates) {
+    for (const candidate of dedupeCandidates(candidates)) {
+        if (!existsSync(candidate))
+            continue;
+        try {
+            return readPackageDependencyNames(candidate);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function resolveRuntimePackageSelections(initialPackages, candidateRoots) {
+    const initialSelections = [];
+    for (const packageName of dedupeCandidates(initialPackages)) {
+        const selection = resolveRuntimePackageSelection(packageName, candidateRoots);
+        if (!selection) {
+            continue;
+        }
+        initialSelections.push(selection);
+    }
+    return resolveRuntimePackageSelectionsFromInitialSelections(initialSelections, candidateRoots);
+}
+function resolveRuntimePackageSelectionsFromInitialSelections(initialSelections, candidateRoots) {
+    const selections = new Map();
+    const visitedManifestPaths = new Set();
+    const queue = [];
+    for (const selection of initialSelections) {
+        if (selections.has(selection.packageName)) {
+            continue;
+        }
+        selections.set(selection.packageName, selection);
+        queue.push(selection);
+    }
+    while (queue.length > 0) {
+        const selection = queue.shift();
+        if (!selection || visitedManifestPaths.has(selection.manifestPath)) {
+            continue;
+        }
+        visitedManifestPaths.add(selection.manifestPath);
+        const packageRequire = createRequire(selection.manifestPath);
+        for (const dependencyName of readPackageDependencyNames(selection.manifestPath)) {
+            const dependencySelection = resolveRuntimePackageSelection(dependencyName, candidateRoots, packageRequire);
+            if (!dependencySelection) {
+                continue;
+            }
+            queue.push(dependencySelection);
+            if (!selections.has(dependencyName)) {
+                selections.set(dependencyName, dependencySelection);
+            }
+        }
+    }
+    return Array.from(selections.values());
+}
+function resolvePackageSelectionFromManifestCandidates(packageName, manifestCandidates) {
+    for (const manifestCandidate of dedupeCandidates(manifestCandidates)) {
+        if (!existsSync(manifestCandidate)) {
+            continue;
+        }
+        try {
+            const rawManifestPath = resolve(manifestCandidate);
+            const resolvedManifestPath = realpathSync(manifestCandidate);
+            const packageJson = JSON.parse(readFileSync(resolvedManifestPath, 'utf-8'));
+            if (packageJson.name !== packageName) {
+                continue;
+            }
+            return {
+                packageName,
+                packageDir: dirname(rawManifestPath),
+                manifestPath: resolvedManifestPath,
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function resolveRuntimePackageSelection(packageName, candidateRoots, packageRequire) {
+    const location = resolvePackageManifestLocation(packageName, candidateRoots, packageRequire);
+    if (!location) {
+        return null;
+    }
+    return {
+        packageName,
+        packageDir: location.packageDir,
+        manifestPath: location.manifestPath,
+    };
+}
+function resolvePackageManifestLocation(packageName, candidateRoots, packageRequire) {
+    if (packageRequire) {
+        try {
+            const rawManifestPath = packageRequire.resolve(`${packageName}/package.json`);
+            if (existsSync(rawManifestPath)) {
+                return {
+                    packageDir: dirname(resolve(rawManifestPath)),
+                    manifestPath: realpathSync(rawManifestPath),
+                };
+            }
+        }
+        catch {
+            // Fall back to the candidate-root scan below so workspace shims and
+            // fixture tests can still resolve packages outside the package graph.
+        }
+    }
+    const packageDir = resolvePackageDirectoryPath(packageName, candidateRoots);
+    if (!packageDir) {
+        return null;
+    }
+    const rawManifestPath = join(packageDir, 'package.json');
+    if (!existsSync(rawManifestPath)) {
+        return null;
+    }
+    return {
+        packageDir,
+        manifestPath: realpathSync(rawManifestPath),
+    };
+}
+function readPackageDependencyNames(packageJsonPath) {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    return [
+        ...Object.keys(packageJson.dependencies ?? {}),
+        ...Object.keys(packageJson.optionalDependencies ?? {}),
+    ];
+}
 function dedupeCandidates(candidates) {
     return Array.from(new Set(candidates));
 }
@@ -217,7 +594,7 @@ export function resolveSharedPackageLinkRoots(projectDir) {
     }
     return Array.from(roots);
 }
-function ensureSharedPackageLinkAtRoot(rootDir, source) {
+function ensureSharedPackageLinkAtRoot(rootDir, source, mode) {
     const target = join(rootDir, 'node_modules', '@edge-base', 'shared');
     const markerPath = join(target, '.edgebase-shim');
     const normalizedSource = resolve(source);
@@ -242,7 +619,12 @@ function ensureSharedPackageLinkAtRoot(rootDir, source) {
     mkdirSync(target, { recursive: true });
     writeFileSync(join(target, 'package.json'), buildSharedShimPackageJson(), 'utf-8');
     writeFileSync(markerPath, 'edgebase-shared-shim\n', 'utf-8');
-    ensureDirectorySymlink(join(source, 'src'), join(target, 'src'));
+    if (mode === 'copy') {
+        replaceDirectoryContents(join(source, 'src'), join(target, 'src'));
+    }
+    else {
+        ensureDirectorySymlink(join(source, 'src'), join(target, 'src'));
+    }
 }
 function findWorkspaceRoot(startDir) {
     let currentDir = resolve(startDir);
@@ -288,6 +670,39 @@ function ensureDirectorySymlink(source, target) {
         symlinkSync(normalizedSource, target, process.platform === 'win32' ? 'junction' : 'dir');
     }
 }
+function replaceDirectoryContents(source, target, options = {}) {
+    rmSync(target, { recursive: true, force: true });
+    mkdirSync(dirname(target), { recursive: true });
+    if ((options.dereference ?? true) === false && (options.verbatimSymlinks ?? false) === true) {
+        copyDirectoryTreePreservingSymlinks(source, target);
+        return;
+    }
+    cpSync(source, target, {
+        recursive: true,
+        force: true,
+        dereference: options.dereference ?? true,
+        verbatimSymlinks: options.verbatimSymlinks ?? false,
+    });
+}
+function copyDirectoryTreePreservingSymlinks(source, target) {
+    const stat = lstatSync(source);
+    if (stat.isSymbolicLink()) {
+        rmSync(target, { recursive: true, force: true });
+        mkdirSync(dirname(target), { recursive: true });
+        const linkTarget = readlinkSync(source);
+        symlinkSync(linkTarget, target, process.platform === 'win32' ? 'junction' : 'dir');
+        return;
+    }
+    if (stat.isDirectory()) {
+        mkdirSync(target, { recursive: true });
+        for (const entry of readdirSync(source)) {
+            copyDirectoryTreePreservingSymlinks(join(source, entry), join(target, entry));
+        }
+        return;
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    copyFileSync(source, target);
+}
 function readExistingSymlinkTarget(target) {
     try {
         if (!lstatSync(target).isSymbolicLink()) {
@@ -316,16 +731,16 @@ function buildSharedShimPackageJson() {
         },
     }, null, 2)}\n`;
 }
-function buildRuntimeConfigShimContents(injectedEnv) {
+function buildRuntimeConfigShimContents(injectedEnv, importPath = '../../../../edgebase.config.ts') {
     const normalizedEnv = Object.fromEntries(Object.entries(injectedEnv ?? {}).filter(([, value]) => typeof value === 'string'));
     if (Object.keys(normalizedEnv).length === 0) {
-        return `// Auto-generated by edgebase CLI. Re-export the user project config with a static path so Wrangler can bundle it.
-import config from '../../../../edgebase.config.ts';
+        return `// Auto-generated by edgebase CLI. Re-export the runtime config module with a static path so Wrangler can bundle it.
+import config from '${importPath}';
 
 export default config;
 `;
     }
-    return `// Auto-generated by edgebase CLI. Inject local config env before evaluating the user project config.
+    return `// Auto-generated by edgebase CLI. Inject local config env before evaluating the runtime config module.
 const injectedEnv = ${JSON.stringify(normalizedEnv, null, 2)} as Record<string, string>;
 
 if (typeof process !== 'undefined' && process?.env) {
@@ -336,25 +751,27 @@ if (typeof process !== 'undefined' && process?.env) {
   }
 }
 
-const mod = await import('../../../../edgebase.config.ts');
+const mod = await import('${importPath}');
 const config = (mod as { default?: unknown }).default ?? mod;
 
 export default config;
 `;
 }
-export function writeRuntimeConfigShim(projectDir, injectedEnv) {
+export function writeRuntimeConfigShim(projectDir, injectedEnv, options) {
     const shimPath = join(getRuntimeServerSrcDir(projectDir), 'generated-config.ts');
-    writeFileSync(shimPath, buildRuntimeConfigShimContents(injectedEnv), 'utf-8');
+    writeFileSync(shimPath, buildRuntimeConfigShimContents(injectedEnv, options?.importPath), 'utf-8');
 }
-function writeRuntimeTestConfigShim(projectDir) {
+function writeRuntimeTestConfigShim(projectDir, options) {
     const shimPath = join(getRuntimeRoot(projectDir), 'edgebase.test.config.ts');
-    const tsConfigPath = join(projectDir, 'edgebase.test.config.ts');
-    const jsConfigPath = join(projectDir, 'edgebase.test.config.js');
-    const importPath = existsSync(tsConfigPath)
-        ? '../../../edgebase.test.config.ts'
-        : existsSync(jsConfigPath)
-            ? '../../../edgebase.test.config.js'
-            : './src/generated-config.ts';
+    const importPath = options?.importPath ?? (() => {
+        const tsConfigPath = join(projectDir, 'edgebase.test.config.ts');
+        const jsConfigPath = join(projectDir, 'edgebase.test.config.js');
+        return existsSync(tsConfigPath)
+            ? '../../../edgebase.test.config.ts'
+            : existsSync(jsConfigPath)
+                ? '../../../edgebase.test.config.js'
+                : './src/generated-config.ts';
+    })();
     writeFileSync(shimPath, `// Auto-generated by edgebase CLI. Keep the runtime test-config import resolvable in scaffolded dev environments.
 // If the project does not define a dedicated test config, fall back to the generated runtime config shim.
 import config from '${importPath}';