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

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

@@ -1,7 +1,15 @@
 import path from 'node:path'
 import fs from 'node:fs'
 import os from 'node:os'
-import { parseModuleMetadata, copyDirRecursive, rewriteCrossModuleImports, updateModulesTs } from '../eject'
+import {
+  parseModuleMetadata,
+  copyDirRecursive,
+  rewriteCrossModuleImports,
+  updateModulesTs,
+  listEjectableModules,
+  ejectModule,
+} from '../eject'
+import type { PackageResolver } from '../resolver'
 
 describe('eject', () => {
   let tmpDir: string
@@ -84,6 +92,23 @@ describe('eject', () => {
       expect(fs.existsSync(path.join(dest, 'node_modules'))).toBe(false)
       expect(fs.existsSync(path.join(dest, 'keep.ts'))).toBe(true)
     })
+
+    it('skips AppleDouble and Finder metadata files', () => {
+      const src = path.join(tmpDir, 'src')
+      const dest = path.join(tmpDir, 'dest')
+      fs.mkdirSync(path.join(src, 'nested'), { recursive: true })
+      fs.writeFileSync(path.join(src, '._setup.ts'), 'junk')
+      fs.writeFileSync(path.join(src, '.DS_Store'), 'junk')
+      fs.writeFileSync(path.join(src, 'nested', '._page.tsx'), 'junk')
+      fs.writeFileSync(path.join(src, 'setup.ts'), 'export const setup = true')
+
+      copyDirRecursive(src, dest)
+
+      expect(fs.existsSync(path.join(dest, '._setup.ts'))).toBe(false)
+      expect(fs.existsSync(path.join(dest, '.DS_Store'))).toBe(false)
+      expect(fs.existsSync(path.join(dest, 'nested', '._page.tsx'))).toBe(false)
+      expect(fs.existsSync(path.join(dest, 'setup.ts'))).toBe(true)
+    })
   })
 
   describe('updateModulesTs', () => {
@@ -256,4 +281,85 @@ describe('eject', () => {
       expect(rewritten).toContain("import('../../unknown/missing')")
     })
   })
+
+  describe('official module packages', () => {
+    function createOfficialModuleResolver(baseDir: string): PackageResolver {
+      const appDir = path.join(baseDir, 'apps', 'mercato')
+      const modulesTsPath = path.join(appDir, 'src', 'modules.ts')
+      const installedPackageRoot = path.join(baseDir, 'node_modules', '@open-mercato', 'test-package')
+
+      fs.mkdirSync(path.join(appDir, 'src'), { recursive: true })
+      fs.mkdirSync(path.join(installedPackageRoot, 'src', 'modules', 'test_package'), { recursive: true })
+      fs.mkdirSync(path.join(installedPackageRoot, 'dist', 'modules', 'test_package'), { recursive: true })
+
+      fs.writeFileSync(
+        path.join(appDir, 'src', 'modules.ts'),
+        "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n",
+      )
+      fs.writeFileSync(
+        path.join(installedPackageRoot, 'package.json'),
+        JSON.stringify(
+          {
+            name: '@open-mercato/test-package',
+            version: '0.1.0',
+            peerDependencies: {
+              '@open-mercato/core': '>=0.4.7 <0.5.0',
+            },
+          },
+          null,
+          2,
+        ),
+      )
+      fs.writeFileSync(
+        path.join(installedPackageRoot, 'src', 'modules', 'test_package', 'index.ts'),
+        "export const metadata = { title: 'Test Package', description: 'Fixture package', ejectable: true }\n",
+      )
+      fs.writeFileSync(
+        path.join(installedPackageRoot, 'src', 'modules', 'test_package', 'widget.ts'),
+        'export const widget = true\n',
+      )
+      fs.writeFileSync(
+        path.join(installedPackageRoot, 'dist', 'modules', 'test_package', 'index.js'),
+        'export const metadata = {};\n',
+      )
+
+      return {
+        getAppDir: () => appDir,
+        getModulesConfigPath: () => modulesTsPath,
+        loadEnabledModules: () => [{ id: 'test_package', from: '@open-mercato/test-package' }],
+        getModulePaths: () => ({
+          appBase: path.join(appDir, 'src', 'modules', 'test_package'),
+          pkgBase: path.join(baseDir, 'packages', 'test-package', 'src', 'modules', 'test_package'),
+        }),
+        getPackageRoot: () => path.join(baseDir, 'packages', 'test-package'),
+      } as unknown as PackageResolver
+    }
+
+    it('lists module packages as ejectable from module index.ts metadata', () => {
+      const resolver = createOfficialModuleResolver(tmpDir)
+
+      expect(listEjectableModules(resolver)).toEqual([
+        {
+          id: 'test_package',
+          title: 'Test Package',
+          description: 'Fixture package',
+          from: '@open-mercato/test-package',
+        },
+      ])
+    })
+
+    it('ejects module packages using module index.ts ejectable flag', () => {
+      const resolver = createOfficialModuleResolver(tmpDir)
+      const appModuleDir = path.join(tmpDir, 'apps', 'mercato', 'src', 'modules', 'test_package')
+      const modulesTsPath = path.join(tmpDir, 'apps', 'mercato', 'src', 'modules.ts')
+
+      ejectModule(resolver, 'test_package')
+
+      expect(fs.existsSync(path.join(appModuleDir, 'index.ts'))).toBe(true)
+      expect(fs.existsSync(path.join(appModuleDir, 'widget.ts'))).toBe(true)
+      expect(fs.readFileSync(modulesTsPath, 'utf8')).toContain(
+        "{ id: 'test_package', from: '@app' }",
+      )
+    })
+  })
 })

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

@@ -0,0 +1,35 @@
+import { parseModuleInstallArgs } from '../module-install-args'
+
+describe('parseModuleInstallArgs', () => {
+  it('defaults to package-backed install without ejecting source', () => {
+    expect(parseModuleInstallArgs(['@open-mercato/test-package'])).toMatchObject({
+      packageSpec: '@open-mercato/test-package',
+      eject: false,
+    })
+  })
+
+  it('accepts --eject as a boolean flag', () => {
+    expect(parseModuleInstallArgs(['@open-mercato/test-package', '--eject'])).toMatchObject({
+      eject: true,
+    })
+    expect(parseModuleInstallArgs(['--eject', '@open-mercato/test-package'])).toMatchObject({
+      packageSpec: '@open-mercato/test-package',
+      eject: true,
+    })
+  })
+
+  it('rejects --eject values', () => {
+    expect(() => parseModuleInstallArgs(['@open-mercato/test-package', '--eject=true'])).toThrow(
+      '--eject does not accept a value',
+    )
+  })
+
+  it('rejects unsupported options', () => {
+    expect(() => parseModuleInstallArgs(['@open-mercato/test-package', '--unknown'])).toThrow(
+      'Unsupported option: --unknown',
+    )
+    expect(() => parseModuleInstallArgs(['@open-mercato/test-package', '--installed'])).toThrow(
+      'Unsupported option: --installed',
+    )
+  })
+})

package/src/lib/__tests__/module-install.test.ts

@@ -0,0 +1,217 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { PackageResolver } from '../resolver'
+import { enableOfficialModule } from '../module-install'
+
+function buildPackageFixture(
+  packageRoot: string,
+  moduleId: string,
+  options?: {
+    ejectable?: boolean
+    extraSourceFiles?: Array<{ relativePath: string; content: string }>
+  },
+): void {
+  const ejectable = options?.ejectable ?? false
+  for (const base of ['src', 'dist']) {
+    fs.mkdirSync(path.join(packageRoot, base, 'modules', moduleId), { recursive: true })
+  }
+  fs.writeFileSync(
+    path.join(packageRoot, 'package.json'),
+    JSON.stringify({ name: '@open-mercato/test-package', version: '0.1.0' }),
+  )
+  fs.writeFileSync(
+    path.join(packageRoot, 'src', 'modules', moduleId, 'index.ts'),
+    `export const metadata = { title: 'Test', ejectable: ${ejectable ? 'true' : 'false'} }\n`,
+  )
+  fs.writeFileSync(
+    path.join(packageRoot, 'dist', 'modules', moduleId, 'index.js'),
+    `exports.metadata = {};\n`,
+  )
+
+  for (const file of options?.extraSourceFiles ?? []) {
+    const targetPath = path.join(packageRoot, 'src', 'modules', moduleId, file.relativePath)
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true })
+    fs.writeFileSync(targetPath, file.content)
+  }
+}
+
+function buildResolver(
+  appDir: string,
+  packageRoot: string,
+  modulesTsContent: string,
+): PackageResolver {
+  const modulesTsPath = path.join(appDir, 'src', 'modules.ts')
+  fs.mkdirSync(path.join(appDir, 'src'), { recursive: true })
+  fs.writeFileSync(modulesTsPath, modulesTsContent)
+
+  return {
+    getAppDir: () => appDir,
+    getModulesConfigPath: () => modulesTsPath,
+    getPackageRoot: () => packageRoot,
+    isMonorepo: () => false,
+    getRootDir: () => appDir,
+    loadEnabledModules: () => [],
+    getModulePaths: () => ({ appBase: '', pkgBase: '' }),
+    getOutputDir: () => path.join(appDir, '.mercato', 'generated'),
+  } as unknown as PackageResolver
+}
+
+describe('enableOfficialModule', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'module-install-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('throws when module is already enabled in modules.ts with the same source', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    const appDir = path.join(tmpDir, 'app')
+    buildPackageFixture(packageRoot, 'test_package')
+
+    const resolver = buildResolver(
+      appDir,
+      packageRoot,
+      "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n",
+    )
+
+    await expect(
+      enableOfficialModule(resolver, '@open-mercato/test-package'),
+    ).rejects.toThrow('already enabled in modules.ts')
+  })
+
+  it('throws when module is already enabled with different casing in the source field', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    const appDir = path.join(tmpDir, 'app')
+    buildPackageFixture(packageRoot, 'test_package')
+
+    // registered without explicit from (defaults to @open-mercato/core internally) — different from what enable would write
+    // This triggers the "already registered from different source" error from ensureModuleRegistration
+    const resolver = buildResolver(
+      appDir,
+      packageRoot,
+      "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/other' }]\n",
+    )
+
+    await expect(
+      enableOfficialModule(resolver, '@open-mercato/test-package'),
+    ).rejects.toThrow('already registered from')
+  })
+
+  it('error message includes the module id and package name', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    const appDir = path.join(tmpDir, 'app')
+    buildPackageFixture(packageRoot, 'test_package')
+
+    const resolver = buildResolver(
+      appDir,
+      packageRoot,
+      "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n",
+    )
+
+    await expect(
+      enableOfficialModule(resolver, '@open-mercato/test-package'),
+    ).rejects.toThrow('"test_package"')
+
+    await expect(
+      enableOfficialModule(resolver, '@open-mercato/test-package'),
+    ).rejects.toThrow('"@open-mercato/test-package"')
+  })
+
+  it('throws when the specific module is already enabled in a multi-module package', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'multi')
+    const appDir = path.join(tmpDir, 'app')
+
+    // package with two modules
+    for (const moduleId of ['alpha', 'beta']) {
+      fs.mkdirSync(path.join(packageRoot, 'src', 'modules', moduleId), { recursive: true })
+      fs.mkdirSync(path.join(packageRoot, 'dist', 'modules', moduleId), { recursive: true })
+      fs.writeFileSync(
+        path.join(packageRoot, 'src', 'modules', moduleId, 'index.ts'),
+        `export const metadata = { ejectable: false }\n`,
+      )
+      fs.writeFileSync(
+        path.join(packageRoot, 'dist', 'modules', moduleId, 'index.js'),
+        `exports.metadata = {};\n`,
+      )
+    }
+    fs.writeFileSync(
+      path.join(packageRoot, 'package.json'),
+      JSON.stringify({ name: '@open-mercato/multi', version: '0.1.0' }),
+    )
+
+    // alpha is already enabled, beta is not
+    const resolver = buildResolver(
+      appDir,
+      packageRoot,
+      "export const enabledModules = [{ id: 'alpha', from: '@open-mercato/multi' }]\n",
+    )
+
+    await expect(
+      enableOfficialModule(resolver, '@open-mercato/multi', 'alpha'),
+    ).rejects.toThrow('already enabled in modules.ts')
+
+    // beta is not yet enabled — must not throw "already enabled", even if generators fail afterwards
+    try {
+      await enableOfficialModule(resolver, '@open-mercato/multi', 'beta')
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      expect(message).not.toContain('already enabled in modules.ts')
+    }
+  })
+
+  it('copies module source into the app when enabling with --eject', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    const appDir = path.join(tmpDir, 'app')
+    buildPackageFixture(packageRoot, 'test_package', {
+      ejectable: true,
+      extraSourceFiles: [
+        {
+          relativePath: path.join('backend', 'page.tsx'),
+          content: 'export default function TestPage() { return null }\n',
+        },
+      ],
+    })
+
+    const resolver = buildResolver(
+      appDir,
+      packageRoot,
+      "export const enabledModules = []\n",
+    )
+
+    await expect(
+      enableOfficialModule(
+        resolver,
+        '@open-mercato/test-package',
+        undefined,
+        true,
+      ),
+    ).rejects.toThrow('generated artifacts are stale')
+
+    expect(fs.existsSync(path.join(appDir, 'src', 'modules', 'test_package', 'index.ts'))).toBe(true)
+    expect(fs.existsSync(path.join(appDir, 'src', 'modules', 'test_package', 'backend', 'page.tsx'))).toBe(true)
+    expect(fs.readFileSync(path.join(appDir, 'src', 'modules.ts'), 'utf8')).toContain(
+      "{ id: 'test_package', from: '@app' }",
+    )
+  })
+
+  it('rejects enabling with --eject when the package is not ejectable', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    const appDir = path.join(tmpDir, 'app')
+    buildPackageFixture(packageRoot, 'test_package')
+
+    const resolver = buildResolver(
+      appDir,
+      packageRoot,
+      "export const enabledModules = []\n",
+    )
+
+    await expect(
+      enableOfficialModule(resolver, '@open-mercato/test-package', undefined, true),
+    ).rejects.toThrow('--eject requires open-mercato.ejectable === true')
+  })
+})

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

@@ -0,0 +1,215 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { PackageResolver } from '../resolver'
+import {
+  discoverModulesInPackage,
+  parsePackageNameFromSpec,
+  readOfficialModulePackageFromRoot,
+  resolveInstalledOfficialModulePackage,
+  validateEjectBoundaries,
+} from '../module-package'
+
+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)
+    }
+  }
+}
+
+describe('module-package', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'module-package-test-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('parses official package names from package specs', () => {
+    expect(parsePackageNameFromSpec('@open-mercato/test-package')).toBe('@open-mercato/test-package')
+    expect(parsePackageNameFromSpec('@open-mercato/test-package@preview')).toBe('@open-mercato/test-package')
+    expect(parsePackageNameFromSpec('@open-mercato/test-package@file:/tmp/pkg')).toBe('@open-mercato/test-package')
+  })
+
+  it('reads and validates an official module package manifest', () => {
+    const modulePackage = readOfficialModulePackageFromRoot(fixturePackageRoot, '@open-mercato/test-package')
+
+    expect(modulePackage.packageName).toBe('@open-mercato/test-package')
+    expect(modulePackage.metadata.moduleId).toBe('test_package')
+    expect(modulePackage.metadata.ejectable).toBe(true)
+    expect(modulePackage.sourceModuleDir).toContain(path.join('src', 'modules', 'test_package'))
+    expect(modulePackage.distModuleDir).toContain(path.join('dist', 'modules', 'test_package'))
+  })
+
+  it('resolves a hoisted installed module package from a monorepo app', () => {
+    const appDir = path.join(tmpDir, 'apps', 'mercato')
+    const installedPackageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    fs.mkdirSync(appDir, { recursive: true })
+    copyDir(fixturePackageRoot, installedPackageRoot)
+
+    const resolver = {
+      getAppDir: () => appDir,
+      getPackageRoot: () => installedPackageRoot,
+    } as unknown as PackageResolver
+
+    const modulePackage = resolveInstalledOfficialModulePackage(
+      resolver,
+      '@open-mercato/test-package',
+    )
+
+    expect(fs.realpathSync(modulePackage.packageRoot)).toBe(fs.realpathSync(installedPackageRoot))
+    expect(modulePackage.metadata.moduleId).toBe('test_package')
+  })
+
+  it('discovers all modules in a multi-module package', () => {
+    const packageRoot = path.join(tmpDir, 'multi-module-package')
+    fs.mkdirSync(path.join(packageRoot, 'src', 'modules', 'alpha'), { recursive: true })
+    fs.mkdirSync(path.join(packageRoot, 'src', 'modules', 'beta'), { recursive: true })
+    fs.writeFileSync(
+      path.join(packageRoot, 'src', 'modules', 'alpha', 'index.ts'),
+      "export const metadata = { ejectable: true }\n",
+    )
+    fs.writeFileSync(
+      path.join(packageRoot, 'src', 'modules', 'beta', 'index.ts'),
+      "export const metadata = { ejectable: false }\n",
+    )
+
+    const modules = discoverModulesInPackage(packageRoot)
+    expect(modules).toHaveLength(2)
+    expect(modules.find((m) => m.moduleId === 'alpha')?.ejectable).toBe(true)
+    expect(modules.find((m) => m.moduleId === 'beta')?.ejectable).toBe(false)
+  })
+
+  it('selects a specific module from a multi-module package via targetModuleId', () => {
+    const packageRoot = path.join(tmpDir, 'multi-module-pkg')
+    for (const moduleId of ['customers', 'sales']) {
+      fs.mkdirSync(path.join(packageRoot, 'src', 'modules', moduleId), { recursive: true })
+      fs.mkdirSync(path.join(packageRoot, 'dist', 'modules', moduleId), { recursive: true })
+      fs.writeFileSync(
+        path.join(packageRoot, 'src', 'modules', moduleId, 'index.ts'),
+        `export const metadata = { ejectable: false }\n`,
+      )
+      fs.writeFileSync(
+        path.join(packageRoot, 'dist', 'modules', moduleId, 'index.js'),
+        `exports.metadata = {};\n`,
+      )
+    }
+    fs.writeFileSync(
+      path.join(packageRoot, 'package.json'),
+      JSON.stringify({ name: '@open-mercato/core' }),
+    )
+
+    const result = readOfficialModulePackageFromRoot(packageRoot, undefined, 'sales')
+    expect(result.metadata.moduleId).toBe('sales')
+    expect(result.sourceModuleDir).toContain(path.join('modules', 'sales'))
+  })
+
+  it('throws when targetModuleId is not found in package', () => {
+    const packageRoot = path.join(tmpDir, 'single-module-pkg')
+    fs.mkdirSync(path.join(packageRoot, 'src', 'modules', 'customers'), { recursive: true })
+    fs.mkdirSync(path.join(packageRoot, 'dist', 'modules', 'customers'), { recursive: true })
+    fs.writeFileSync(
+      path.join(packageRoot, 'src', 'modules', 'customers', 'index.ts'),
+      `export const metadata = { ejectable: false }\n`,
+    )
+    fs.writeFileSync(
+      path.join(packageRoot, 'dist', 'modules', 'customers', 'index.js'),
+      `exports.metadata = {};\n`,
+    )
+    fs.writeFileSync(
+      path.join(packageRoot, 'package.json'),
+      JSON.stringify({ name: '@open-mercato/core' }),
+    )
+
+    expect(() =>
+      readOfficialModulePackageFromRoot(packageRoot, undefined, 'nonexistent'),
+    ).toThrow('does not contain module "nonexistent"')
+  })
+
+  it('throws when a multi-module package is used without specifying a module', () => {
+    const packageRoot = path.join(tmpDir, 'ambiguous-pkg')
+    for (const moduleId of ['alpha', 'beta']) {
+      fs.mkdirSync(path.join(packageRoot, 'src', 'modules', moduleId), { recursive: true })
+      fs.mkdirSync(path.join(packageRoot, 'dist', 'modules', moduleId), { recursive: true })
+      fs.writeFileSync(
+        path.join(packageRoot, 'src', 'modules', moduleId, 'index.ts'),
+        `export const metadata = {}\n`,
+      )
+      fs.writeFileSync(
+        path.join(packageRoot, 'dist', 'modules', moduleId, 'index.js'),
+        `exports.metadata = {};\n`,
+      )
+    }
+    fs.writeFileSync(
+      path.join(packageRoot, 'package.json'),
+      JSON.stringify({ name: '@open-mercato/multi' }),
+    )
+
+    expect(() =>
+      readOfficialModulePackageFromRoot(packageRoot),
+    ).toThrow('contains multiple modules')
+  })
+
+  it('rejects --eject when a module imports files outside its module directory', () => {
+    const invalidPackageRoot = path.join(tmpDir, 'invalid-package')
+    copyDir(fixturePackageRoot, invalidPackageRoot)
+
+    fs.mkdirSync(path.join(invalidPackageRoot, 'src', 'lib'), { recursive: true })
+    fs.writeFileSync(
+      path.join(invalidPackageRoot, 'src', 'lib', 'shared.ts'),
+      'export const sharedValue = 1\n',
+    )
+    fs.mkdirSync(path.join(invalidPackageRoot, 'src', 'modules', 'test_package', 'lib'), {
+      recursive: true,
+    })
+    fs.writeFileSync(
+      path.join(invalidPackageRoot, 'src', 'modules', 'test_package', 'lib', 'broken.ts'),
+      "import { sharedValue } from '../../../lib/shared'\nexport const brokenValue = sharedValue\n",
+    )
+
+    expect(() =>
+      validateEjectBoundaries(
+        readOfficialModulePackageFromRoot(invalidPackageRoot, '@open-mercato/test-package'),
+      ),
+    ).toThrow('cannot be added with --eject')
+  })
+
+  it('ignores AppleDouble metadata files when validating --eject boundaries', () => {
+    const packageRoot = path.join(tmpDir, 'package-with-sidecars')
+    copyDir(fixturePackageRoot, packageRoot)
+
+    fs.writeFileSync(
+      path.join(packageRoot, 'src', 'modules', 'test_package', '._setup.ts'),
+      "import { sharedValue } from '../../../lib/shared'\n",
+    )
+    fs.mkdirSync(path.join(packageRoot, 'src', 'modules', 'test_package', 'backend', 'test-packag'), {
+      recursive: true,
+    })
+    fs.writeFileSync(
+      path.join(packageRoot, 'src', 'modules', 'test_package', 'backend', 'test-packag', '._page.tsx'),
+      "import { sharedValue } from '../../../../lib/shared'\n",
+    )
+
+    expect(() =>
+      validateEjectBoundaries(
+        readOfficialModulePackageFromRoot(packageRoot, '@open-mercato/test-package'),
+      ),
+    ).not.toThrow()
+  })
+})