@fluojs/cli 1.0.0-beta.1

package/dist/generators/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function toKebabCase(value: string): string;
+export declare function toPascalCase(value: string): string;
+export declare function toPlural(value: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/generators/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/generators/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAa9C"}

package/dist/generators/utils.js

@@ -0,0 +1,18 @@
+export function toKebabCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[_\s]+/g, '-').replace(/-+/g, '-').toLowerCase();
+}
+export function toPascalCase(value) {
+  return toKebabCase(value).split('-').filter(Boolean).map(segment => segment[0].toUpperCase() + segment.slice(1)).join('');
+}
+export function toPlural(value) {
+  if (value.endsWith('s') || value.endsWith('x') || value.endsWith('z') || value.endsWith('ch') || value.endsWith('sh')) {
+    return `${value}es`;
+  }
+  if (value.endsWith('y') && value.length > 1) {
+    const beforeY = value[value.length - 2];
+    if (!'aeiou'.includes(beforeY)) {
+      return `${value.slice(0, -1)}ies`;
+    }
+  }
+  return `${value}s`;
+}

package/dist/help.d.ts

@@ -0,0 +1,8 @@
+type HelpTableColumn<Row> = {
+    header: string;
+    render: (row: Row) => string;
+};
+export declare function renderAliasList(aliases: string[]): string;
+export declare function renderHelpTable<Row>(rows: Row[], columns: HelpTableColumn<Row>[]): string;
+export {};
+//# sourceMappingURL=help.d.ts.map

package/dist/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../src/help.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,CAAC,GAAG,IAAI;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;CAC9B,CAAC;AAUF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAEzD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAazF"}

package/dist/help.js

@@ -0,0 +1,16 @@
+function border(widths) {
+  return `+${widths.map(width => '-'.repeat(width + 2)).join('+')}+`;
+}
+function renderRow(values, widths) {
+  return `| ${values.map((value, index) => value.padEnd(widths[index] ?? 0)).join(' | ')} |`;
+}
+export function renderAliasList(aliases) {
+  return aliases.length === 0 ? '-' : aliases.join(', ');
+}
+export function renderHelpTable(rows, columns) {
+  const widths = columns.map(column => {
+    const values = rows.map(row => column.render(row));
+    return Math.max(column.header.length, ...values.map(value => value.length));
+  });
+  return [border(widths), renderRow(columns.map(column => column.header), widths), border(widths), ...rows.map(row => renderRow(columns.map(column => column.render(row)), widths)), border(widths)].join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { runCli, type CliRuntimeOptions } from './cli.js';
+export { newUsage, runNewCommand, type NewCommandRuntimeOptions } from './commands/new.js';
+export type { GenerateOptions, GeneratedFile, GeneratorKind, ModuleRegistration } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC3F,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { runCli } from './cli.js';
+export { newUsage, runNewCommand } from './commands/new.js';

package/dist/new/install.d.ts

@@ -0,0 +1,51 @@
+import type { PackageManager } from './types.js';
+/** Concrete command invocation used for dependency installation. */
+export interface InstallCommand {
+    args: string[];
+    command: string;
+}
+/** Runtime overrides for resolving install commands in tests. */
+export interface ResolveInstallCommandOptions {
+    isCorepackAvailable?: boolean;
+}
+/** Runtime overrides for git initialization in tests. */
+export interface InitializeGitRepositoryOptions {
+    command?: string;
+}
+type WritableStream = {
+    write(message: string): unknown;
+};
+type InstallStdioMode = 'capture' | 'inherit';
+type InstallDependenciesOptions = {
+    env?: NodeJS.ProcessEnv;
+    isCorepackAvailable?: boolean;
+    stderr?: WritableStream;
+    stdio?: InstallStdioMode;
+};
+/**
+ * Resolves the concrete install command for a chosen package manager.
+ *
+ * @param packageManager Package manager selected for the generated starter.
+ * @param options Runtime overrides for command detection in tests.
+ * @returns The command and argument list to execute.
+ */
+export declare function resolveInstallCommand(packageManager: PackageManager, options?: ResolveInstallCommandOptions): InstallCommand;
+/**
+ * Installs starter dependencies in the generated project directory.
+ *
+ * @param targetDirectory Generated project directory.
+ * @param packageManager Package manager selected for the generated starter.
+ * @param options Runtime overrides for install execution and diagnostics.
+ * @returns A promise that resolves when installation succeeds.
+ */
+export declare function installDependencies(targetDirectory: string, packageManager: PackageManager, options?: InstallDependenciesOptions): Promise<void>;
+/**
+ * Initializes a git repository in the generated project directory.
+ *
+ * @param targetDirectory Generated project directory.
+ * @param options Runtime overrides for invoking git in tests.
+ * @returns A promise that resolves when repository initialization succeeds.
+ */
+export declare function initializeGitRepository(targetDirectory: string, options?: InitializeGitRepositoryOptions): Promise<void>;
+export {};
+//# sourceMappingURL=install.d.ts.map

package/dist/new/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/new/install.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iEAAiE;AACjE,MAAM,WAAW,4BAA4B;IAC3C,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,yDAAyD;AACzD,MAAM,WAAW,8BAA8B;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,KAAK,cAAc,GAAG;IACpB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAEF,KAAK,gBAAgB,GAAG,SAAS,GAAG,SAAS,CAAC;AAE9C,KAAK,0BAA0B,GAAG;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAmDF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,cAAc,EAC9B,OAAO,GAAE,4BAAiC,GACzC,cAAc,CA4BhB;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,cAAc,EAC9B,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,IAAI,CAAC,CAmCf;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dist/new/install.js

@@ -0,0 +1,140 @@
+import { spawn, spawnSync } from 'node:child_process';
+
+/** Concrete command invocation used for dependency installation. */
+
+/** Runtime overrides for resolving install commands in tests. */
+
+/** Runtime overrides for git initialization in tests. */
+
+const COREPACK_DOCS_URL = 'https://nodejs.org/api/corepack.html';
+class DependencyInstallationError extends Error {
+  output;
+  constructor(exitCode, output) {
+    super(exitCode === null ? 'Dependency installation failed without an exit code.' : `Dependency installation failed with exit code ${exitCode}.`);
+    this.name = 'DependencyInstallationError';
+    this.output = output;
+  }
+}
+function appendStreamOutput(stream, output) {
+  stream?.on('data', chunk => {
+    output.push(typeof chunk === 'string' ? chunk : chunk.toString());
+  });
+}
+function waitForChildProcess(child, capturedOutput) {
+  return new Promise((resolve, reject) => {
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new DependencyInstallationError(code, capturedOutput?.join('') ?? ''));
+    });
+  });
+}
+function checkCommandAvailability(command) {
+  const checker = process.platform === 'win32' ? 'where' : 'which';
+  const result = spawnSync(checker, [command], {
+    stdio: 'ignore'
+  });
+  return result.status === 0;
+}
+
+/**
+ * Resolves the concrete install command for a chosen package manager.
+ *
+ * @param packageManager Package manager selected for the generated starter.
+ * @param options Runtime overrides for command detection in tests.
+ * @returns The command and argument list to execute.
+ */
+export function resolveInstallCommand(packageManager, options = {}) {
+  if (packageManager === 'bun') {
+    return {
+      args: ['install'],
+      command: 'bun'
+    };
+  }
+  if (packageManager === 'yarn') {
+    const isCorepackAvailable = options.isCorepackAvailable ?? checkCommandAvailability('corepack');
+    if (!isCorepackAvailable) {
+      return {
+        args: ['install'],
+        command: 'yarn'
+      };
+    }
+    return {
+      args: ['yarn', 'install'],
+      command: 'corepack'
+    };
+  }
+  return {
+    args: ['install'],
+    command: packageManager
+  };
+}
+
+/**
+ * Installs starter dependencies in the generated project directory.
+ *
+ * @param targetDirectory Generated project directory.
+ * @param packageManager Package manager selected for the generated starter.
+ * @param options Runtime overrides for install execution and diagnostics.
+ * @returns A promise that resolves when installation succeeds.
+ */
+export async function installDependencies(targetDirectory, packageManager, options = {}) {
+  const hasCorepack = packageManager === 'yarn' ? options.isCorepackAvailable ?? checkCommandAvailability('corepack') : undefined;
+  const {
+    args,
+    command
+  } = resolveInstallCommand(packageManager, {
+    isCorepackAvailable: hasCorepack
+  });
+  if (packageManager === 'yarn' && hasCorepack === false) {
+    const message = `[fluo] corepack was not found in PATH, falling back to "yarn install". See ${COREPACK_DOCS_URL}\n`;
+    (options.stderr ?? process.stderr).write(message);
+  }
+  const stdio = options.stdio ?? 'inherit';
+  if (stdio === 'capture') {
+    const capturedOutput = [];
+    const child = spawn(command, args, {
+      cwd: targetDirectory,
+      env: options.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    appendStreamOutput(child.stdout, capturedOutput);
+    appendStreamOutput(child.stderr, capturedOutput);
+    await waitForChildProcess(child, capturedOutput);
+    return;
+  }
+  const child = spawn(command, args, {
+    cwd: targetDirectory,
+    env: options.env,
+    stdio: 'inherit'
+  });
+  await waitForChildProcess(child);
+}
+
+/**
+ * Initializes a git repository in the generated project directory.
+ *
+ * @param targetDirectory Generated project directory.
+ * @param options Runtime overrides for invoking git in tests.
+ * @returns A promise that resolves when repository initialization succeeds.
+ */
+export async function initializeGitRepository(targetDirectory, options = {}) {
+  const command = options.command ?? 'git';
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, ['init'], {
+      cwd: targetDirectory,
+      stdio: 'inherit'
+    });
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Git initialization failed with exit code ${code}.`));
+    });
+  });
+}

package/dist/new/package-spec-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedBootstrapPlan } from './resolver.js';
+import type { BootstrapOptions } from './types.js';
+export declare function resolvePackageSpecs(options: BootstrapOptions, bootstrapPlan: ResolvedBootstrapPlan): Promise<Record<string, string>>;
+//# sourceMappingURL=package-spec-resolver.d.ts.map

package/dist/new/package-spec-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-spec-resolver.d.ts","sourceRoot":"","sources":["../../src/new/package-spec-resolver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAkhBnD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,qBAAqB,GACnC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgCjC"}

package/dist/new/package-spec-resolver.js

@@ -0,0 +1,397 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+const PACKAGE_DIRECTORY_BY_NAME = {
+  '@fluojs/platform-bun': 'platform-bun',
+  '@fluojs/cli': 'cli',
+  '@fluojs/config': 'config',
+  '@fluojs/core': 'core',
+  '@fluojs/di': 'di',
+  '@fluojs/http': 'http',
+  '@fluojs/platform-cloudflare-workers': 'platform-cloudflare-workers',
+  '@fluojs/platform-deno': 'platform-deno',
+  '@fluojs/microservices': 'microservices',
+  '@fluojs/platform-express': 'platform-express',
+  '@fluojs/platform-fastify': 'platform-fastify',
+  '@fluojs/platform-nodejs': 'platform-nodejs',
+  '@fluojs/runtime': 'runtime',
+  '@fluojs/testing': 'testing',
+  '@fluojs/validation': 'validation'
+};
+const LOCAL_PACKAGE_CACHE_DIR = join(tmpdir(), 'fluo-cli-local-packages');
+const LOCAL_PACKAGE_CACHE_STAMP_FILE = 'cache-stamp.json';
+const LOCAL_PACKAGE_CACHE_FORMAT_VERSION = 2;
+function expectedTarballName(packageName, version) {
+  return `${packageName.replace(/^@/, '').replace(/\//g, '-')}-${version}.tgz`;
+}
+function readLocalPackageVersion(repoRoot, packageName) {
+  const packageDirectory = PACKAGE_DIRECTORY_BY_NAME[packageName];
+  const packageJson = JSON.parse(readFileSync(join(repoRoot, 'packages', packageDirectory, 'package.json'), 'utf8'));
+  return packageJson.version;
+}
+function readLocalPackageManifest(repoRoot, packageName) {
+  const packageDirectory = PACKAGE_DIRECTORY_BY_NAME[packageName];
+  return JSON.parse(readFileSync(join(repoRoot, 'packages', packageDirectory, 'package.json'), 'utf8'));
+}
+function collectRequiredLocalPackages(repoRoot, bootstrapPlan) {
+  const pending = [...bootstrapPlan.dependencies.dependencies, ...bootstrapPlan.dependencies.devDependencies].filter(packageName => packageName in PACKAGE_DIRECTORY_BY_NAME);
+  const selected = new Set();
+  while (pending.length > 0) {
+    const packageName = pending.pop();
+    if (!packageName || selected.has(packageName)) {
+      continue;
+    }
+    selected.add(packageName);
+    const manifest = readLocalPackageManifest(repoRoot, packageName);
+    for (const section of ['dependencies', 'optionalDependencies', 'peerDependencies']) {
+      const dependencies = manifest[section];
+      if (!dependencies) {
+        continue;
+      }
+      for (const dependencyName of Object.keys(dependencies)) {
+        if (dependencyName in PACKAGE_DIRECTORY_BY_NAME) {
+          pending.push(dependencyName);
+        }
+      }
+    }
+  }
+  return Array.from(selected);
+}
+function collectLocalPackageVersions(repoRoot, packageNames) {
+  const packageVersions = new Map();
+  for (const packageName of packageNames) {
+    packageVersions.set(packageName, readLocalPackageVersion(repoRoot, packageName));
+  }
+  return packageVersions;
+}
+function getPackageVersionOrThrow(packageVersions, packageName) {
+  const packageVersion = packageVersions.get(packageName);
+  if (!packageVersion) {
+    throw new Error(`Unable to determine version for ${packageName}.`);
+  }
+  return packageVersion;
+}
+function toPackageVersionRecord(packageVersions) {
+  const packageVersionRecord = {};
+  for (const [packageName, packageVersion] of packageVersions.entries()) {
+    packageVersionRecord[packageName] = packageVersion;
+  }
+  return packageVersionRecord;
+}
+function runGitCommand(repoRoot, args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+  } catch {
+    return undefined;
+  }
+}
+function createPackagePathArguments(packageNames) {
+  const packagePaths = new Set();
+  for (const packageName of packageNames) {
+    const packageDirectory = PACKAGE_DIRECTORY_BY_NAME[packageName];
+    const packageRoot = join('packages', packageDirectory);
+    packagePaths.add(packageRoot);
+    packagePaths.add(join(packageRoot, 'src'));
+    packagePaths.add(join(packageRoot, 'package.json'));
+    packagePaths.add(join(packageRoot, 'tsconfig.json'));
+    packagePaths.add(join(packageRoot, 'tsconfig.build.json'));
+  }
+  return Array.from(packagePaths);
+}
+function copyIfExists(sourcePath, destinationPath) {
+  if (!existsSync(sourcePath)) {
+    return;
+  }
+  cpSync(sourcePath, destinationPath, {
+    recursive: true
+  });
+}
+function collectPackageStagePaths(packageRoot, manifest) {
+  const stagePaths = new Set();
+  for (const fixedPath of ['README.md', 'README.ko.md', 'LICENSE', 'LICENSE.md', 'LICENSE.txt']) {
+    if (existsSync(join(packageRoot, fixedPath))) {
+      stagePaths.add(fixedPath);
+    }
+  }
+  for (const fileEntry of manifest.files ?? []) {
+    if (existsSync(join(packageRoot, fileEntry))) {
+      stagePaths.add(fileEntry);
+    }
+  }
+  if (typeof manifest.bin === 'string') {
+    stagePaths.add(manifest.bin);
+  } else if (manifest.bin) {
+    for (const binPath of Object.values(manifest.bin)) {
+      stagePaths.add(binPath);
+    }
+  }
+  if (manifest.main) {
+    stagePaths.add(manifest.main);
+  }
+  if (manifest.types) {
+    stagePaths.add(manifest.types);
+  }
+  return Array.from(stagePaths);
+}
+function stagePackageForPacking(repoRoot, packageName, packageVersions, outputDirectory) {
+  const packageDirectory = PACKAGE_DIRECTORY_BY_NAME[packageName];
+  const packageRoot = join(repoRoot, 'packages', packageDirectory);
+  const stageDirectory = join(outputDirectory, `.stage-${packageDirectory}`);
+  const manifest = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+  rmSync(stageDirectory, {
+    force: true,
+    recursive: true
+  });
+  mkdirSync(stageDirectory, {
+    recursive: true
+  });
+  for (const relativePath of collectPackageStagePaths(packageRoot, manifest)) {
+    copyIfExists(join(packageRoot, relativePath), join(stageDirectory, relativePath));
+  }
+  rewriteWorkspaceProtocolDependencies(manifest, packageVersions);
+  writeFileSync(join(stageDirectory, 'package.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+  return stageDirectory;
+}
+function computeLocalPackageCacheStamp(repoRoot, packageNames, packageVersions) {
+  const headCommit = runGitCommand(repoRoot, ['rev-parse', 'HEAD']);
+  if (!headCommit) {
+    return undefined;
+  }
+  const packagePaths = createPackagePathArguments(packageNames);
+  const dirtyFingerprint = runGitCommand(repoRoot, ['status', '--porcelain', '--', ...packagePaths]);
+  if (dirtyFingerprint === undefined) {
+    return undefined;
+  }
+  return {
+    cacheFormatVersion: LOCAL_PACKAGE_CACHE_FORMAT_VERSION,
+    dirtyFingerprint,
+    headCommit,
+    packageVersions: toPackageVersionRecord(packageVersions)
+  };
+}
+function readLocalPackageCacheStamp(stampPath) {
+  if (!existsSync(stampPath)) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(readFileSync(stampPath, 'utf8'));
+  } catch {
+    return undefined;
+  }
+}
+function cacheStampMatches(expected, actual) {
+  if (!actual) {
+    return false;
+  }
+  if (actual.cacheFormatVersion !== LOCAL_PACKAGE_CACHE_FORMAT_VERSION) {
+    return false;
+  }
+  if (actual.headCommit !== expected.headCommit || actual.dirtyFingerprint !== expected.dirtyFingerprint) {
+    return false;
+  }
+  for (const [packageName, packageVersion] of Object.entries(expected.packageVersions)) {
+    if (actual.packageVersions[packageName] !== packageVersion) {
+      return false;
+    }
+  }
+  return true;
+}
+function cacheContainsTarballs(outputDirectory, packageNames, packageVersions) {
+  const packedFiles = new Set(readdirSync(outputDirectory));
+  return packageNames.every(packageName => {
+    const packageVersion = getPackageVersionOrThrow(packageVersions, packageName);
+    const tarball = expectedTarballName(packageName, packageVersion);
+    return packedFiles.has(tarball);
+  });
+}
+function clearLocalPackageCacheArtifacts(outputDirectory) {
+  if (!existsSync(outputDirectory)) {
+    return;
+  }
+  for (const entry of readdirSync(outputDirectory, {
+    withFileTypes: true
+  })) {
+    if (entry.name === LOCAL_PACKAGE_CACHE_STAMP_FILE) {
+      continue;
+    }
+    if (entry.isDirectory() || entry.name.endsWith('.tgz')) {
+      rmSync(join(outputDirectory, entry.name), {
+        force: true,
+        recursive: true
+      });
+    }
+  }
+}
+function createLocalPackageCachePath(repoRoot) {
+  const repoCacheKey = createHash('sha1').update(resolve(repoRoot)).digest('hex').slice(0, 12);
+  return join(LOCAL_PACKAGE_CACHE_DIR, repoCacheKey);
+}
+function latestModifiedTimeMs(path) {
+  const stats = statSync(path);
+  if (!stats.isDirectory()) {
+    return stats.mtimeMs;
+  }
+  let latest = stats.mtimeMs;
+  for (const entry of readdirSync(path, {
+    withFileTypes: true
+  })) {
+    const entryPath = join(path, entry.name);
+    latest = Math.max(latest, latestModifiedTimeMs(entryPath));
+  }
+  return latest;
+}
+function packageHasOutdatedBuildOutput(repoRoot, packageName) {
+  const packageDirectory = PACKAGE_DIRECTORY_BY_NAME[packageName];
+  const packageRoot = join(repoRoot, 'packages', packageDirectory);
+  const distDirectory = join(packageRoot, 'dist');
+  if (!existsSync(distDirectory)) {
+    return true;
+  }
+  const sourceCandidates = [join(packageRoot, 'src'), join(packageRoot, 'package.json'), join(packageRoot, 'tsconfig.json'), join(packageRoot, 'tsconfig.build.json')];
+  let latestSource = 0;
+  for (const sourceCandidate of sourceCandidates) {
+    if (!existsSync(sourceCandidate)) {
+      continue;
+    }
+    latestSource = Math.max(latestSource, latestModifiedTimeMs(sourceCandidate));
+  }
+  const latestDist = latestModifiedTimeMs(distDirectory);
+  return latestDist < latestSource;
+}
+function shouldRunWorkspaceBuild(repoRoot, packageNames) {
+  return packageNames.some(packageName => packageHasOutdatedBuildOutput(repoRoot, packageName));
+}
+function runPackCommand(packageDirectory, outputDirectory) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn('npm', ['pack', '--pack-destination', outputDirectory], {
+      cwd: packageDirectory,
+      stdio: 'inherit'
+    });
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      reject(new Error(`Failed to pack ${packageDirectory} with exit code ${code}.`));
+    });
+  });
+}
+function runWorkspaceBuild(repoRoot) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn('pnpm', ['build'], {
+      cwd: repoRoot,
+      stdio: 'inherit'
+    });
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      reject(new Error(`Failed to build workspace with exit code ${code}.`));
+    });
+  });
+}
+async function ensureWorkspaceBuildOutput(repoRoot, packageNames) {
+  if (shouldRunWorkspaceBuild(repoRoot, packageNames)) {
+    await runWorkspaceBuild(repoRoot);
+  }
+}
+async function packLocalPackages(repoRoot, outputDirectory, packageNames, packageVersions) {
+  for (const packageName of packageNames) {
+    const packageVersion = getPackageVersionOrThrow(packageVersions, packageName);
+    const tarballName = expectedTarballName(packageName, packageVersion);
+    const stageDirectory = stagePackageForPacking(repoRoot, packageName, packageVersions, outputDirectory);
+    try {
+      await runPackCommand(stageDirectory, outputDirectory);
+    } finally {
+      rmSync(stageDirectory, {
+        force: true,
+        recursive: true
+      });
+    }
+    if (!existsSync(join(outputDirectory, tarballName))) {
+      throw new Error(`Unable to locate packed tarball for ${packageName}.`);
+    }
+  }
+}
+function createLocalTarballSpecs(outputDirectory, packageNames, packageVersions) {
+  const packedFiles = new Set(readdirSync(outputDirectory));
+  const tarballs = new Map();
+  for (const packageName of packageNames) {
+    const packageVersion = getPackageVersionOrThrow(packageVersions, packageName);
+    const tarball = expectedTarballName(packageName, packageVersion);
+    if (!packedFiles.has(tarball)) {
+      throw new Error(`Unable to locate packed tarball for ${packageName}.`);
+    }
+    tarballs.set(packageName, `file:${join(outputDirectory, tarball)}`);
+  }
+  return Object.fromEntries(tarballs);
+}
+function rewriteWorkspaceProtocolSpecifier(specifier, version) {
+  const workspaceRange = specifier.slice('workspace:'.length);
+  if (workspaceRange === '^') {
+    return `^${version}`;
+  }
+  if (workspaceRange === '~') {
+    return `~${version}`;
+  }
+  if (workspaceRange === '*' || workspaceRange.length === 0) {
+    return version;
+  }
+  return workspaceRange;
+}
+function rewriteWorkspaceProtocolDependencies(manifest, packageVersions) {
+  for (const section of ['dependencies', 'optionalDependencies', 'peerDependencies']) {
+    const dependencies = manifest[section];
+    if (!dependencies) {
+      continue;
+    }
+    for (const [packageName, specifier] of Object.entries(dependencies)) {
+      if (!specifier.startsWith('workspace:')) {
+        continue;
+      }
+      const version = packageVersions.get(packageName);
+      if (!version) {
+        continue;
+      }
+      dependencies[packageName] = rewriteWorkspaceProtocolSpecifier(specifier, version);
+    }
+  }
+}
+export async function resolvePackageSpecs(options, bootstrapPlan) {
+  if (options.dependencySource !== 'local' || !options.repoRoot) {
+    return {};
+  }
+  const repoRoot = resolve(options.repoRoot);
+  const outputDirectory = createLocalPackageCachePath(repoRoot);
+  const cacheStampPath = join(outputDirectory, LOCAL_PACKAGE_CACHE_STAMP_FILE);
+  mkdirSync(outputDirectory, {
+    recursive: true
+  });
+  const packageNames = collectRequiredLocalPackages(repoRoot, bootstrapPlan);
+  const packageVersions = collectLocalPackageVersions(repoRoot, packageNames);
+  const expectedCacheStamp = computeLocalPackageCacheStamp(repoRoot, packageNames, packageVersions);
+  const currentCacheStamp = readLocalPackageCacheStamp(cacheStampPath);
+  const canReuseCachedTarballs = expectedCacheStamp ? cacheStampMatches(expectedCacheStamp, currentCacheStamp) && cacheContainsTarballs(outputDirectory, packageNames, packageVersions) : false;
+  if (!canReuseCachedTarballs) {
+    await ensureWorkspaceBuildOutput(repoRoot, packageNames);
+    clearLocalPackageCacheArtifacts(outputDirectory);
+    await packLocalPackages(repoRoot, outputDirectory, packageNames, packageVersions);
+    if (expectedCacheStamp) {
+      writeFileSync(cacheStampPath, `${JSON.stringify(expectedCacheStamp, null, 2)}\n`, 'utf8');
+    } else {
+      rmSync(cacheStampPath, {
+        force: true
+      });
+    }
+  }
+  return createLocalTarballSpecs(outputDirectory, packageNames, packageVersions);
+}