@open-mercato/cli 0.4.9-develop-db9ecc46fc → 0.4.9-develop-d989387b7a

package/src/lib/__tests__/modules-config.test.ts

@@ -0,0 +1,104 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { ensureModuleRegistration, setModuleRegistrationSource } from '../modules-config'
+
+describe('modules-config', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'modules-config-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('adds a package-backed module without touching conditional pushes', () => {
+    const filePath = path.join(tmpDir, 'modules.ts')
+    fs.writeFileSync(
+      filePath,
+      [
+        "export const enabledModules = [",
+        "  { id: 'auth', from: '@open-mercato/core' },",
+        "]",
+        '',
+        "if (process.env.OM_ENABLE_ENTERPRISE_MODULES === 'true') {",
+        "  enabledModules.push({ id: 'record_locks', from: '@open-mercato/enterprise' })",
+        '}',
+      ].join('\n'),
+    )
+
+    const result = ensureModuleRegistration(filePath, {
+      id: 'test_package',
+      from: '@open-mercato/test-package',
+    })
+
+    expect(result).toEqual({
+      changed: true,
+      registeredAs: '@open-mercato/test-package',
+    })
+
+    const updated = fs.readFileSync(filePath, 'utf8')
+    expect(updated).toContain("{ id: 'test_package', from: '@open-mercato/test-package' }")
+    expect(updated).toContain("enabledModules.push({ id: 'record_locks', from: '@open-mercato/enterprise' })")
+  })
+
+  it('returns no-op when the same registration already exists', () => {
+    const filePath = path.join(tmpDir, 'modules.ts')
+    fs.writeFileSync(
+      filePath,
+      [
+        "export const enabledModules = [",
+        "  { id: 'test_package', from: '@open-mercato/test-package' },",
+        "]",
+      ].join('\n'),
+    )
+
+    const result = ensureModuleRegistration(filePath, {
+      id: 'test_package',
+      from: '@open-mercato/test-package',
+    })
+
+    expect(result).toEqual({
+      changed: false,
+      registeredAs: '@open-mercato/test-package',
+    })
+  })
+
+  it('fails when the module is already registered from another source', () => {
+    const filePath = path.join(tmpDir, 'modules.ts')
+    fs.writeFileSync(
+      filePath,
+      [
+        "export const enabledModules = [",
+        "  { id: 'test_package', from: '@app' },",
+        "]",
+      ].join('\n'),
+    )
+
+    expect(() =>
+      ensureModuleRegistration(filePath, {
+        id: 'test_package',
+        from: '@open-mercato/test-package',
+      }),
+    ).toThrow('already registered from "@app"')
+  })
+
+  it('updates an existing module source to @app', () => {
+    const filePath = path.join(tmpDir, 'modules.ts')
+    fs.writeFileSync(
+      filePath,
+      [
+        "export const enabledModules = [",
+        "  { id: 'test_package', from: '@open-mercato/test-package' },",
+        "]",
+      ].join('\n'),
+    )
+
+    const result = setModuleRegistrationSource(filePath, 'test_package', '@app')
+
+    expect(result).toEqual({ changed: true })
+    expect(fs.readFileSync(filePath, 'utf8')).toContain("{ id: 'test_package', from: '@app' }")
+  })
+})

package/src/lib/__tests__/resolve-environment.test.ts

@@ -0,0 +1,141 @@
+import os from 'node:os'
+import path from 'node:path'
+import { realpathSync } from 'node:fs'
+import { mkdtemp, mkdir, rm, symlink } from 'node:fs/promises'
+import { resolveEnvironment } from '../resolver'
+
+const normalizePath = (p: string) => p.replace(/\\/g, '/')
+
+async function makeDir(root: string, ...segments: string[]): Promise<string> {
+  const dir = path.join(root, ...segments)
+  await mkdir(dir, { recursive: true })
+  return dir
+}
+
+describe('resolveEnvironment', () => {
+  let tempRoot = ''
+
+  beforeEach(async () => {
+    // realpathSync resolves macOS /var -> /private/var symlink so comparisons are stable
+    tempRoot = realpathSync(await mkdtemp(path.join(os.tmpdir(), 'om-resolve-env-')))
+  })
+
+  afterEach(async () => {
+    if (tempRoot) {
+      await rm(tempRoot, { recursive: true, force: true })
+    }
+  })
+
+  describe('standalone — local node_modules', () => {
+    it('returns standalone mode with rootDir = cwd when @open-mercato/core is a real directory at cwd', async () => {
+      await makeDir(tempRoot, 'node_modules', '@open-mercato', 'core')
+
+      const env = resolveEnvironment(tempRoot)
+
+      expect(env.mode).toBe('standalone')
+      expect(normalizePath(env.rootDir)).toBe(normalizePath(tempRoot))
+      expect(normalizePath(env.appDir)).toBe(normalizePath(tempRoot))
+    })
+
+    it('resolves packageRoot under node_modules in standalone mode', async () => {
+      await makeDir(tempRoot, 'node_modules', '@open-mercato', 'core')
+
+      const env = resolveEnvironment(tempRoot)
+
+      expect(normalizePath(env.packageRoot('@open-mercato/core'))).toBe(
+        normalizePath(path.join(tempRoot, 'node_modules', '@open-mercato', 'core')),
+      )
+    })
+
+    // In local mode (cwd === nodeModulesRoot), appDir === cwd.
+    // apps/ subdirectory detection only fires in the hoisted case — see hoisted tests below.
+    it('sets appDir to cwd even when apps/mercato subdirectory exists', async () => {
+      await makeDir(tempRoot, 'node_modules', '@open-mercato', 'core')
+      await makeDir(tempRoot, 'apps', 'mercato')
+
+      const env = resolveEnvironment(tempRoot)
+
+      expect(env.mode).toBe('standalone')
+      expect(normalizePath(env.appDir)).toBe(normalizePath(tempRoot))
+    })
+  })
+
+  describe('standalone — hoisted node_modules', () => {
+    it('returns standalone mode with rootDir set to parent when @open-mercato/core is hoisted', async () => {
+      // Structure: tempRoot/node_modules/@open-mercato/core (real dir)
+      //            tempRoot/myapp/ (the cwd)
+      await makeDir(tempRoot, 'node_modules', '@open-mercato', 'core')
+      const childDir = await makeDir(tempRoot, 'myapp')
+
+      const env = resolveEnvironment(childDir)
+
+      expect(env.mode).toBe('standalone')
+      expect(normalizePath(env.rootDir)).toBe(normalizePath(tempRoot))
+      // appDir falls back to childDir since no apps/ found at rootDir
+      expect(normalizePath(env.appDir)).toBe(normalizePath(childDir))
+    })
+
+    it('detects apps/mercato as appDir when hoisted and apps/mercato exists at rootDir', async () => {
+      // Structure: tempRoot/node_modules/@open-mercato/core (real dir)
+      //            tempRoot/apps/mercato/ (app directory)
+      //            tempRoot/myapp/ (the cwd — simulates running CLI from a sub-directory)
+      await makeDir(tempRoot, 'node_modules', '@open-mercato', 'core')
+      await makeDir(tempRoot, 'apps', 'mercato')
+      const childDir = await makeDir(tempRoot, 'myapp')
+
+      const env = resolveEnvironment(childDir)
+
+      expect(env.mode).toBe('standalone')
+      expect(normalizePath(env.rootDir)).toBe(normalizePath(tempRoot))
+      expect(normalizePath(env.appDir)).toBe(normalizePath(path.join(tempRoot, 'apps', 'mercato')))
+    })
+
+    it('resolves packageRoot under hoisted node_modules', async () => {
+      await makeDir(tempRoot, 'node_modules', '@open-mercato', 'core')
+      const childDir = await makeDir(tempRoot, 'myapp')
+
+      const env = resolveEnvironment(childDir)
+
+      expect(normalizePath(env.packageRoot('@open-mercato/core'))).toBe(
+        normalizePath(path.join(tempRoot, 'node_modules', '@open-mercato', 'core')),
+      )
+    })
+  })
+
+  describe('monorepo — symlinked node_modules', () => {
+    it('returns monorepo mode when @open-mercato/core is a symlink', async () => {
+      // Structure: tempRoot/packages/core (real source)
+      //            tempRoot/node_modules/@open-mercato/core -> ../../packages/core (symlink)
+      const packagesCore = await makeDir(tempRoot, 'packages', 'core')
+      const nmOpen = await makeDir(tempRoot, 'node_modules', '@open-mercato')
+      await symlink(packagesCore, path.join(nmOpen, 'core'))
+
+      const env = resolveEnvironment(tempRoot)
+
+      expect(env.mode).toBe('monorepo')
+      expect(normalizePath(env.rootDir)).toBe(normalizePath(tempRoot))
+    })
+
+    it('resolves packageRoot under packages/ in monorepo mode', async () => {
+      const packagesCore = await makeDir(tempRoot, 'packages', 'core')
+      const nmOpen = await makeDir(tempRoot, 'node_modules', '@open-mercato')
+      await symlink(packagesCore, path.join(nmOpen, 'core'))
+
+      const env = resolveEnvironment(tempRoot)
+
+      expect(normalizePath(env.packageRoot('@open-mercato/core'))).toBe(
+        normalizePath(path.join(tempRoot, 'packages', 'core')),
+      )
+    })
+  })
+
+  describe('no @open-mercato packages present', () => {
+    it('falls back to standalone mode with rootDir = cwd', async () => {
+      const env = resolveEnvironment(tempRoot)
+
+      expect(env.mode).toBe('standalone')
+      expect(normalizePath(env.rootDir)).toBe(normalizePath(tempRoot))
+      expect(normalizePath(env.appDir)).toBe(normalizePath(tempRoot))
+    })
+  })
+})

package/src/lib/eject.ts

@@ -1,6 +1,8 @@
 import path from 'node:path'
 import fs from 'node:fs'
+import { setModuleRegistrationSource } from './modules-config'
 import type { PackageResolver, ModuleEntry } from './resolver'
+import { resolveInstalledOfficialModulePackage } from './module-package'
 
 type ModuleMetadata = {
   ejectable?: boolean
@@ -11,11 +13,15 @@ type ModuleMetadata = {
 const SKIP_DIRS = new Set(['__tests__', '__mocks__', 'node_modules'])
 const SOURCE_FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']
 
+function shouldSkipEntryName(name: string): boolean {
+  return SKIP_DIRS.has(name) || name === '.DS_Store' || name.startsWith('._')
+}
+
 function collectSourceFiles(dir: string): string[] {
   const files: string[] = []
   const entries = fs.readdirSync(dir, { withFileTypes: true })
   for (const entry of entries) {
-    if (SKIP_DIRS.has(entry.name)) continue
+    if (shouldSkipEntryName(entry.name)) continue
     const fullPath = path.join(dir, entry.name)
     if (entry.isDirectory()) {
       files.push(...collectSourceFiles(fullPath))
@@ -159,7 +165,7 @@ export function copyDirRecursive(src: string, dest: string): void {
 
   const entries = fs.readdirSync(src, { withFileTypes: true })
   for (const entry of entries) {
-    if (SKIP_DIRS.has(entry.name)) continue
+    if (shouldSkipEntryName(entry.name)) continue
 
     const srcPath = path.join(src, entry.name)
     const destPath = path.join(dest, entry.name)
@@ -173,58 +179,47 @@ export function copyDirRecursive(src: string, dest: string): void {
 }
 
 export function updateModulesTs(modulesPath: string, moduleId: string): void {
-  if (!fs.existsSync(modulesPath)) {
-    throw new Error(`modules.ts not found at ${modulesPath}`)
-  }
-
-  const source = fs.readFileSync(modulesPath, 'utf8')
-  const objectPattern = /\{[^{}]*\}/g
-
-  let match: RegExpExecArray | null
-  let updatedSource: string | null = null
-
-  while ((match = objectPattern.exec(source)) !== null) {
-    const objectLiteral = match[0]
-    const idMatch = objectLiteral.match(/\bid\s*:\s*(['"])([^'"]+)\1/)
-    if (!idMatch || idMatch[2] !== moduleId) {
-      continue
-    }
-
-    const updatedObject = upsertModuleSource(objectLiteral)
-    updatedSource =
-      source.slice(0, match.index) +
-      updatedObject +
-      source.slice(match.index + objectLiteral.length)
-    break
-  }
+  setModuleRegistrationSource(modulesPath, moduleId, '@app')
+}
 
-  if (!updatedSource) {
-    throw new Error(
-      `Could not find module entry for "${moduleId}" in ${modulesPath}. ` +
-      `Expected a pattern like: { id: '${moduleId}', from: '...' } or { id: '${moduleId}' }`,
-    )
-  }
+export type EjectableModule = {
+  id: string
+  title?: string
+  description?: string
+  from: string
+}
 
-  fs.writeFileSync(modulesPath, updatedSource)
+type ResolvedModuleSource = {
+  pkgBase: string
+  metadata: ModuleMetadata
 }
 
-function upsertModuleSource(objectLiteral: string): string {
-  if (/from\s*:\s*'[^']*'/.test(objectLiteral)) {
-    return objectLiteral.replace(/from\s*:\s*'[^']*'/, "from: '@app'")
-  }
+function resolveModuleSource(
+  resolver: PackageResolver,
+  entry: ModuleEntry,
+): ResolvedModuleSource {
+  const { pkgBase } = resolver.getModulePaths(entry)
+  const fallbackMetadata = parseModuleMetadata(path.join(pkgBase, 'index.ts'))
+  const from = entry.from || '@open-mercato/core'
 
-  if (/from\s*:\s*"[^"]*"/.test(objectLiteral)) {
-    return objectLiteral.replace(/from\s*:\s*"[^"]*"/, 'from: "@app"')
+  if (from === '@app' || from === '@open-mercato/core') {
+    return { pkgBase, metadata: fallbackMetadata }
   }
 
-  return objectLiteral.replace(/\}\s*$/, ", from: '@app' }")
-}
+  try {
+    const modulePackage = resolveInstalledOfficialModulePackage(resolver, from, entry.id)
 
-export type EjectableModule = {
-  id: string
-  title?: string
-  description?: string
-  from: string
+    return {
+      pkgBase: modulePackage.sourceModuleDir,
+      metadata: {
+        ejectable: modulePackage.metadata.ejectable,
+        title: modulePackage.moduleInfo.title ?? modulePackage.metadata.moduleId,
+        description: modulePackage.moduleInfo.description,
+      },
+    }
+  } catch {
+    return { pkgBase, metadata: fallbackMetadata }
+  }
 }
 
 export function listEjectableModules(resolver: PackageResolver): EjectableModule[] {
@@ -234,9 +229,7 @@ export function listEjectableModules(resolver: PackageResolver): EjectableModule
   for (const entry of modules) {
     if (entry.from === '@app') continue
 
-    const { pkgBase } = resolver.getModulePaths(entry)
-    const indexPath = path.join(pkgBase, 'index.ts')
-    const metadata = parseModuleMetadata(indexPath)
+    const { metadata } = resolveModuleSource(resolver, entry)
 
     if (metadata.ejectable) {
       ejectable.push({
@@ -268,7 +261,8 @@ export function ejectModule(resolver: PackageResolver, moduleId: string): void {
     )
   }
 
-  const { pkgBase, appBase } = resolver.getModulePaths(entry)
+  const { appBase } = resolver.getModulePaths(entry)
+  const { pkgBase, metadata } = resolveModuleSource(resolver, entry)
 
   if (!fs.existsSync(pkgBase)) {
     throw new Error(
@@ -277,13 +271,9 @@ export function ejectModule(resolver: PackageResolver, moduleId: string): void {
     )
   }
 
-  const indexPath = path.join(pkgBase, 'index.ts')
-  const metadata = parseModuleMetadata(indexPath)
-
   if (!metadata.ejectable) {
     throw new Error(
-      `Module "${moduleId}" is not marked as ejectable. ` +
-      `Only modules with \`ejectable: true\` in their metadata can be ejected.`,
+      `Module "${moduleId}" is not marked as ejectable. Only modules with \`ejectable: true\` in their metadata can be ejected.`,
     )
   }
 

package/src/lib/generators/__tests__/generators.test.ts

@@ -26,6 +26,11 @@ describe('generators', () => {
       expect(typeof module.generateModuleDi).toBe('function')
     })
 
+    it('should export generateModulePackageSources', async () => {
+      const module = await import('../module-package-sources')
+      expect(typeof module.generateModulePackageSources).toBe('function')
+    })
+
     // Note: api-client uses openapi-typescript which is ESM-only
     // and doesn't work with Jest's CommonJS environment
     it.skip('should export generateApiClient', async () => {
@@ -172,6 +177,12 @@ describe('generator file output patterns', () => {
       expect(expectedPath).toContain('injection-widgets.generated.ts')
     })
 
+    it('should output module package CSS sources', () => {
+      const outputDir = '/project/generated'
+      const expectedPath = `${outputDir}/module-package-sources.css`
+      expect(expectedPath).toContain('module-package-sources.css')
+    })
+
     it('should output search config', () => {
       const outputDir = '/project/generated'
       const expectedPath = `${outputDir}/search.generated.ts`

package/src/lib/generators/__tests__/module-package-sources.test.ts

@@ -0,0 +1,121 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { generateModulePackageSources } from '../module-package-sources'
+import type { PackageResolver } from '../../resolver'
+
+const fixturePackageRoot = path.resolve(
+  __dirname,
+  '..',
+  '..',
+  '__fixtures__',
+  'official-module-package',
+)
+
+function copyDir(src: string, dest: string): void {
+  fs.mkdirSync(dest, { recursive: true })
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath)
+    } else {
+      fs.copyFileSync(srcPath, destPath)
+    }
+  }
+}
+
+function createResolver(tmpDir: string, packageRoot: string, from: string): PackageResolver {
+  const appDir = path.join(tmpDir, 'app')
+  const outputDir = path.join(appDir, '.mercato', 'generated')
+  fs.mkdirSync(outputDir, { recursive: true })
+
+  return {
+    isMonorepo: () => false,
+    getRootDir: () => appDir,
+    getAppDir: () => appDir,
+    getOutputDir: () => outputDir,
+    getModulesConfigPath: () => path.join(appDir, 'src', 'modules.ts'),
+    discoverPackages: () => [],
+    loadEnabledModules: () => [{ id: 'test_package', from }],
+    getModulePaths: () => ({
+      appBase: path.join(appDir, 'src', 'modules', 'test_package'),
+      pkgBase: path.join(packageRoot, 'src', 'modules', 'test_package'),
+    }),
+    getModuleImportBase: () => ({
+      appBase: '@/modules/test_package',
+      pkgBase: `${from}/modules/test_package`,
+    }),
+    getPackageOutputDir: () => outputDir,
+    getPackageRoot: () => packageRoot,
+  }
+}
+
+describe('generateModulePackageSources', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'module-package-sources-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('writes @source entries for official package-backed modules', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    copyDir(fixturePackageRoot, packageRoot)
+    const resolver = createResolver(tmpDir, packageRoot, '@open-mercato/test-package')
+
+    const result = await generateModulePackageSources({ resolver, quiet: true })
+    expect(result.errors).toEqual([])
+
+    const output = fs.readFileSync(path.join(resolver.getOutputDir(), 'module-package-sources.css'), 'utf8')
+    expect(output).toContain('@source')
+    expect(output).toContain('node_modules/@open-mercato/test-package/src/**/*.{ts,tsx}')
+  })
+
+  it('skips app-backed modules', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    copyDir(fixturePackageRoot, packageRoot)
+    const resolver = createResolver(tmpDir, packageRoot, '@app')
+
+    await generateModulePackageSources({ resolver, quiet: true })
+
+    const output = fs.readFileSync(path.join(resolver.getOutputDir(), 'module-package-sources.css'), 'utf8')
+    expect(output).toBe('')
+  })
+
+  it('resolves hoisted package-backed modules for monorepo apps', async () => {
+    const appDir = path.join(tmpDir, 'apps', 'mercato')
+    const outputDir = path.join(appDir, '.mercato', 'generated')
+    const installedPackageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    copyDir(fixturePackageRoot, installedPackageRoot)
+    fs.mkdirSync(outputDir, { recursive: true })
+
+    const resolver = {
+      isMonorepo: () => true,
+      getRootDir: () => tmpDir,
+      getAppDir: () => appDir,
+      getOutputDir: () => outputDir,
+      getModulesConfigPath: () => path.join(appDir, 'src', 'modules.ts'),
+      discoverPackages: () => [],
+      loadEnabledModules: () => [{ id: 'test_package', from: '@open-mercato/test-package' }],
+      getModulePaths: () => ({
+        appBase: path.join(appDir, 'src', 'modules', 'test_package'),
+        pkgBase: path.join(installedPackageRoot, 'src', 'modules', 'test_package'),
+      }),
+      getModuleImportBase: () => ({
+        appBase: '@/modules/test_package',
+        pkgBase: '@open-mercato/test-package/modules/test_package',
+      }),
+      getPackageOutputDir: () => outputDir,
+      getPackageRoot: () => installedPackageRoot,
+    } as PackageResolver
+
+    await generateModulePackageSources({ resolver, quiet: true })
+
+    const output = fs.readFileSync(path.join(outputDir, 'module-package-sources.css'), 'utf8')
+    expect(output).toContain('node_modules/@open-mercato/test-package/src/**/*.{ts,tsx}')
+  })
+})

package/src/lib/generators/index.ts

@@ -2,4 +2,5 @@ export { generateEntityIds, type EntityIdsOptions } from './entity-ids'
 export { generateModuleRegistry, generateModuleRegistryCli, type ModuleRegistryOptions } from './module-registry'
 export { generateModuleEntities, type ModuleEntitiesOptions } from './module-entities'
 export { generateModuleDi, type ModuleDiOptions } from './module-di'
+export { generateModulePackageSources, type ModulePackageSourcesOptions } from './module-package-sources'
 export { generateOpenApi, type GenerateOpenApiOptions } from './openapi'

package/src/lib/generators/module-package-sources.ts

@@ -0,0 +1,59 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { readOfficialModulePackageFromRoot, resolveInstalledPackageRoot } from '../module-package'
+import type { PackageResolver } from '../resolver'
+import { calculateStructureChecksum, createGeneratorResult, type GeneratorResult, writeGeneratedFile } from '../utils'
+
+export interface ModulePackageSourcesOptions {
+  resolver: PackageResolver
+  quiet?: boolean
+}
+
+function normalizeCssSourcePath(value: string): string {
+  const normalized = value.split(path.sep).join('/')
+  return normalized.startsWith('.') ? normalized : `./${normalized}`
+}
+
+export async function generateModulePackageSources(
+  options: ModulePackageSourcesOptions,
+): Promise<GeneratorResult> {
+  const { resolver, quiet } = options
+  const result = createGeneratorResult()
+  const outputDir = resolver.getOutputDir()
+  const outFile = path.join(outputDir, 'module-package-sources.css')
+  const checksumFile = path.join(outputDir, 'module-package-sources.checksum')
+  const sourcePaths = new Set<string>()
+  const checksumTargets: string[] = []
+
+  for (const entry of resolver.loadEnabledModules()) {
+    if (!entry.from || entry.from === '@app' || entry.from === '@open-mercato/core') continue
+
+    const packageRoot = resolveInstalledPackageRoot(resolver, entry.from)
+    checksumTargets.push(packageRoot)
+
+    let modulePackage
+    try {
+      modulePackage = readOfficialModulePackageFromRoot(packageRoot, entry.from, entry.id)
+    } catch {
+      continue
+    }
+
+    const packageSourceRoot = path.join(modulePackage.packageRoot, 'src')
+    const relativeSourcePath = normalizeCssSourcePath(path.relative(path.dirname(outFile), packageSourceRoot))
+    sourcePaths.add(`@source "${relativeSourcePath}/**/*.{ts,tsx}";`)
+  }
+
+  const content = `${Array.from(sourcePaths).sort((left, right) => left.localeCompare(right)).join('\n')}${sourcePaths.size > 0 ? '\n' : ''}`
+  const structureChecksum = calculateStructureChecksum(checksumTargets)
+
+  writeGeneratedFile({
+    outFile,
+    checksumFile,
+    content,
+    structureChecksum,
+    result,
+    quiet,
+  })
+
+  return result
+}

package/src/lib/module-install-args.ts

@@ -0,0 +1,50 @@
+export type ParsedModuleInstallArgs = {
+  packageSpec: string | null
+  eject: boolean
+  moduleId: string | null
+}
+
+export function parseModuleInstallArgs(args: string[]): ParsedModuleInstallArgs {
+  let packageSpec: string | null = null
+  let eject = false
+  let moduleId: string | null = null
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (!arg) continue
+
+    if (arg === '--eject') {
+      eject = true
+      continue
+    }
+
+    if (arg.startsWith('--eject=')) {
+      throw new Error('--eject does not accept a value')
+    }
+
+    if (arg === '--module') {
+      const next = args[index + 1]
+      if (next && !next.startsWith('-')) {
+        moduleId = next
+        index += 1
+        continue
+      }
+      throw new Error(`--module requires a moduleId value`)
+    }
+
+    if (arg.startsWith('--module=')) {
+      moduleId = arg.slice('--module='.length) || null
+      continue
+    }
+
+    if (arg.startsWith('-')) {
+      throw new Error(`Unsupported option: ${arg}`)
+    }
+
+    if (!arg.startsWith('-') && !packageSpec) {
+      packageSpec = arg
+    }
+  }
+
+  return { packageSpec, eject, moduleId }
+}