@astrale-os/sdk 0.4.19 → 0.5.0-beta.2

package/src/linter/index.ts

@@ -1,15 +0,0 @@
-export { ruleCatalog, ruleId, ruleInfo } from './rules/catalog.js'
-export type { ImplementedRuleSlug, RuleInfo, RuleOwner } from './rules/catalog.js'
-export type {
-  DiagnosticLocation,
-  DiagnosticSeverity,
-  LintDiagnostic,
-  LintResult,
-  LinterToolErrorCode,
-} from './diagnostic.js'
-export { LinterToolError } from './diagnostic.js'
-export { lintDomain } from './lint.js'
-export type { LintDomainOptions } from './lint.js'
-export { domainOxlintConfig } from './oxlint/config.js'
-export { formatLintResult } from './report.js'
-export type { LintReportFormat } from './report.js'

package/src/linter/lint.ts

@@ -1,34 +0,0 @@
-import { resolve } from 'node:path'
-import { performance } from 'node:perf_hooks'
-
-import { analyzeProject } from './analyze.js'
-import { dedupeDiagnostics, type LintResult } from './diagnostic.js'
-import { runOxlint } from './oxlint/run.js'
-import { assertSingleTypeUniverse } from './preflight.js'
-import { discoverProject } from './project.js'
-
-export type LintDomainOptions = {
-  root?: string
-  fix?: boolean
-  preflight?: boolean
-  /** Cancels the external Oxlint process and rejects the lint operation. */
-  signal?: AbortSignal
-}
-
-export async function lintDomain(options: LintDomainOptions = {}): Promise<LintResult> {
-  const started = performance.now()
-  const root = resolve(options.root ?? process.cwd())
-  if (options.preflight !== false) await assertSingleTypeUniverse(root)
-  const [project, oxlint] = await Promise.all([
-    discoverProject(root),
-    runOxlint(root, options.fix ?? false, { signal: options.signal }),
-  ])
-  const diagnostics = dedupeDiagnostics([...oxlint.diagnostics, ...analyzeProject(project)])
-  return {
-    root: project.root,
-    diagnostics,
-    files: Math.max(project.files.length, oxlint.files),
-    durationMs: Math.max(0, Math.round(performance.now() - started)),
-    exitCode: diagnostics.some((diagnostic) => diagnostic.severity === 'error') ? 1 : 0,
-  }
-}

package/src/linter/oxlint/astrale-ox.d.ts

@@ -1,5 +0,0 @@
-declare module '@astrale-os/ox/lint' {
-  // oxlint-disable-next-line consistent-type-imports -- ambient modules cannot import this type
-  const config: import('oxlint').OxlintConfig
-  export default config
-}

package/src/linter/oxlint/config.ts

@@ -1,24 +0,0 @@
-import base from '@astrale-os/ox/lint'
-import { defineConfig } from 'oxlint'
-
-export const domainOxlintConfig = defineConfig({
-  extends: [base],
-  // Oxlint resolves ignore patterns relative to the config object that declares
-  // them. Lift the shared preset's traversal boundary onto the project config;
-  // leaving it only inside `extends` roots it in the installed preset package
-  // and allows a project's dependency tree into discovery.
-  ignorePatterns: base.ignorePatterns,
-  jsPlugins: [
-    {
-      name: 'astrale',
-      specifier: '@astrale-os/sdk/linter/oxlint-plugin',
-    },
-  ],
-  rules: {
-    'astrale/core-has-no-async': 'error',
-    'astrale/no-nested-steps': 'error',
-    'astrale/no-read-inside-mutate': 'error',
-  },
-})
-
-export default domainOxlintConfig

package/src/linter/oxlint/ignore-patterns.ts

@@ -1,17 +0,0 @@
-/**
- * The domain linter's process-level project-discovery boundary.
- *
- * Oxlint roots config-file ignores at that config's directory. The SDK also
- * uses an internal fallback config outside the target project, so invocation
- * must enforce these patterns relative to its working directory as well.
- */
-export const DOMAIN_OXLINT_IGNORE_PATTERNS = [
-  '**/dist/**',
-  '**/node_modules/**',
-  '**/coverage/**',
-  '**/*.js',
-  '**/*.mjs',
-  '**/*.cjs',
-  '**/*.gen.ts',
-  '**/*.gen.tsx',
-] as const

package/src/linter/oxlint/plugin.js

@@ -1,16 +0,0 @@
-// @ts-check
-
-import { coreHasNoAsync } from '../rules/core-has-no-async.js'
-import { noNestedSteps } from '../rules/no-nested-steps.js'
-import { noReadInsideMutate } from '../rules/no-read-inside-mutate.js'
-
-const astraleOxlintPlugin = {
-  meta: { name: 'astrale', version: '0.1.0' },
-  rules: {
-    'core-has-no-async': coreHasNoAsync,
-    'no-nested-steps': noNestedSteps,
-    'no-read-inside-mutate': noReadInsideMutate,
-  },
-}
-
-export default astraleOxlintPlugin

package/src/linter/oxlint/process.ts

@@ -1,219 +0,0 @@
-import { spawn } from 'node:child_process'
-
-import { LinterToolError } from '../diagnostic.js'
-
-const DEFAULT_TIMEOUT_MS = 60_000
-const DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024 * 1024
-const DEFAULT_TERMINATION_GRACE_MS = 1_000
-
-export type OxlintProcessOptions = {
-  signal?: AbortSignal
-  timeoutMs?: number
-  outputLimitBytes?: number
-  terminationGraceMs?: number
-}
-
-export type OxlintProcessResult = {
-  status: number | null
-  signal: NodeJS.Signals | null
-  stdout: string
-  stderr: string
-}
-
-type TerminationReason =
-  | { kind: 'cancelled'; cause: unknown }
-  | { kind: 'output-limit'; limitBytes: number }
-  | { kind: 'timeout'; timeoutMs: number }
-
-/**
- * Run Oxlint under the runtime it declares, independent of the SDK CLI's
- * parent runtime. The published CLI intentionally runs under Bun, while
- * Oxlint's executable is a Node program.
- */
-export async function runOxlintProcess(
-  bin: string,
-  args: readonly string[],
-  cwd: string,
-  options: OxlintProcessOptions = {},
-): Promise<OxlintProcessResult> {
-  const timeoutMs = positiveInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, 'timeoutMs')
-  const outputLimitBytes = positiveInteger(
-    options.outputLimitBytes,
-    DEFAULT_OUTPUT_LIMIT_BYTES,
-    'outputLimitBytes',
-  )
-  const terminationGraceMs = nonNegativeInteger(
-    options.terminationGraceMs,
-    DEFAULT_TERMINATION_GRACE_MS,
-    'terminationGraceMs',
-  )
-
-  if (options.signal?.aborted) throw cancelledError(options.signal.reason)
-
-  let child: ReturnType<typeof spawn>
-  try {
-    child = spawn('node', [bin, ...args], {
-      cwd,
-      env: process.env,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      windowsHide: true,
-    })
-  } catch (cause) {
-    throw startError(bin, cause)
-  }
-
-  return await new Promise<OxlintProcessResult>((resolve, reject) => {
-    const stdout: Buffer[] = []
-    const stderr: Buffer[] = []
-    let capturedBytes = 0
-    let settled = false
-    let processError: unknown
-    let terminationReason: TerminationReason | undefined
-    let forceKillTimer: NodeJS.Timeout | undefined
-
-    const timeout = setTimeout(() => {
-      terminate({ kind: 'timeout', timeoutMs })
-    }, timeoutMs)
-    timeout.unref?.()
-
-    const onAbort = () => terminate({ kind: 'cancelled', cause: options.signal?.reason })
-    options.signal?.addEventListener('abort', onAbort, { once: true })
-
-    const onStdout = (chunk: Buffer | string) => capture(stdout, chunk)
-    const onStderr = (chunk: Buffer | string) => capture(stderr, chunk)
-    child.stdout?.on('data', onStdout)
-    child.stderr?.on('data', onStderr)
-
-    // `close` follows both normal exit and spawn errors. Record an error here
-    // but settle only after `close`, so the process handle and stdio are always
-    // reaped before the caller continues.
-    child.once('error', (cause) => {
-      processError = cause
-      clearTimeout(timeout)
-    })
-    child.once('close', (status, signal) => {
-      finish(() => {
-        if (terminationReason) {
-          reject(terminationError(terminationReason))
-          return
-        }
-        if (processError) {
-          reject(startError(bin, processError))
-          return
-        }
-        resolve({
-          status,
-          signal,
-          stdout: Buffer.concat(stdout).toString('utf8'),
-          stderr: Buffer.concat(stderr).toString('utf8'),
-        })
-      })
-    })
-
-    // Close the race between the pre-spawn check and listener registration.
-    if (options.signal?.aborted) onAbort()
-
-    function capture(target: Buffer[], chunk: Buffer | string): void {
-      if (terminationReason) return
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
-      const remaining = outputLimitBytes - capturedBytes
-      if (remaining > 0) {
-        const accepted = Math.min(remaining, buffer.byteLength)
-        target.push(buffer.subarray(0, accepted))
-        capturedBytes += accepted
-      }
-      if (buffer.byteLength > remaining) {
-        terminate({ kind: 'output-limit', limitBytes: outputLimitBytes })
-      }
-    }
-
-    function terminate(reason: TerminationReason): void {
-      if (settled || terminationReason) return
-      terminationReason = reason
-      try {
-        child.kill('SIGTERM')
-      } catch {
-        forceKill()
-        return
-      }
-      forceKillTimer = setTimeout(forceKill, terminationGraceMs)
-      forceKillTimer.unref?.()
-    }
-
-    function forceKill(): void {
-      if (settled || child.exitCode !== null || child.signalCode !== null) return
-      try {
-        child.kill('SIGKILL')
-      } catch {
-        // The close/error event remains the authoritative process outcome.
-      }
-    }
-
-    function finish(settle: () => void): void {
-      if (settled) return
-      settled = true
-      clearTimeout(timeout)
-      if (forceKillTimer) clearTimeout(forceKillTimer)
-      options.signal?.removeEventListener('abort', onAbort)
-      child.stdout?.off('data', onStdout)
-      child.stderr?.off('data', onStderr)
-      settle()
-    }
-  })
-}
-
-function startError(bin: string, cause: unknown): LinterToolError {
-  return new LinterToolError(`Could not start Oxlint with Node at ${bin}.`, {
-    code: 'OXLINT_START_FAILED',
-    cause,
-  })
-}
-
-function cancelledError(cause: unknown): LinterToolError {
-  return new LinterToolError('Oxlint was cancelled and its process was terminated.', {
-    code: 'OXLINT_CANCELLED',
-    cause,
-  })
-}
-
-function terminationError(reason: TerminationReason): LinterToolError {
-  switch (reason.kind) {
-    case 'cancelled':
-      return cancelledError(reason.cause)
-    case 'output-limit':
-      return new LinterToolError(
-        `Oxlint exceeded the ${formatBytes(reason.limitBytes)} output limit and was terminated.`,
-        { code: 'OXLINT_OUTPUT_LIMIT' },
-      )
-    case 'timeout':
-      return new LinterToolError(
-        `Oxlint exceeded the ${formatDuration(reason.timeoutMs)} timeout and was terminated.`,
-        { code: 'OXLINT_TIMEOUT' },
-      )
-  }
-}
-
-function positiveInteger(value: number | undefined, fallback: number, name: string): number {
-  const result = value ?? fallback
-  if (!Number.isSafeInteger(result) || result <= 0) {
-    throw new TypeError(`${name} must be a positive integer.`)
-  }
-  return result
-}
-
-function nonNegativeInteger(value: number | undefined, fallback: number, name: string): number {
-  const result = value ?? fallback
-  if (!Number.isSafeInteger(result) || result < 0) {
-    throw new TypeError(`${name} must be a non-negative integer.`)
-  }
-  return result
-}
-
-function formatDuration(milliseconds: number): string {
-  return milliseconds % 1_000 === 0 ? `${milliseconds / 1_000}s` : `${milliseconds}ms`
-}
-
-function formatBytes(bytes: number): string {
-  const mib = 1024 * 1024
-  return bytes % mib === 0 ? `${bytes / mib} MiB` : `${bytes} bytes`
-}

package/src/linter/oxlint/run.ts

@@ -1,175 +0,0 @@
-import { existsSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { dirname, join, relative, resolve, sep } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { LinterToolError, type DiagnosticSeverity, type LintDiagnostic } from '../diagnostic.js'
-import { ruleInfo } from '../rules/catalog.js'
-import { DOMAIN_OXLINT_IGNORE_PATTERNS } from './ignore-patterns.js'
-import { runOxlintProcess, type OxlintProcessOptions } from './process.js'
-
-type OxlintOutput = {
-  diagnostics?: OxlintDiagnostic[]
-  number_of_files?: number
-}
-
-type OxlintDiagnostic = {
-  message?: string
-  code?: string
-  severity?: string
-  url?: string
-  help?: string
-  filename?: string
-  labels?: Array<{
-    span?: { offset?: number; length?: number; line?: number; column?: number }
-  }>
-}
-
-export type OxlintResult = {
-  diagnostics: LintDiagnostic[]
-  files: number
-}
-
-export async function runOxlint(
-  root: string,
-  fix: boolean,
-  options: OxlintProcessOptions = {},
-): Promise<OxlintResult> {
-  const packageJson = join(root, 'package.json')
-  const projectRequire = createRequire(packageJson)
-  const sdkRequire = createRequire(import.meta.url)
-  const oxlintPackage = resolvePackage('oxlint/package.json', projectRequire, sdkRequire)
-  const bin = join(dirname(oxlintPackage), 'bin', 'oxlint')
-  const config = projectConfig(root) ?? internalConfigPath()
-  const args = ['.', '--format=json', '--no-error-on-unmatched-pattern', '--config', config]
-  // Config-file ignores are rooted at the config's own directory. Enforce the
-  // SDK's traversal boundary at the target process as well so the internal
-  // fallback config and imported presets cannot discover dependency/build trees.
-  for (const pattern of DOMAIN_OXLINT_IGNORE_PATTERNS) args.push('--ignore-pattern', pattern)
-  if (fix) args.push('--fix')
-
-  const { status, signal, stdout, stderr } = await runOxlintProcess(bin, args, root, options)
-
-  if (status !== 0 && status !== 1) {
-    const outcome = signal ? `signal ${signal}` : `status ${status ?? 'unknown'}`
-    const detail = failureDetail(stderr, stdout)
-    throw new LinterToolError(`Oxlint failed with ${outcome}.${detail ? `\n${detail}` : ''}`, {
-      code: 'OXLINT_FAILED',
-    })
-  }
-
-  let output: OxlintOutput
-  try {
-    const parsed: unknown = JSON.parse(stdout)
-    if (!isOxlintOutput(parsed)) throw new TypeError('Unexpected Oxlint report shape.')
-    output = parsed
-  } catch (error) {
-    const detail = failureDetail(stderr, stdout) || `Oxlint exited with status ${status}`
-    throw new LinterToolError(`Oxlint did not produce a diagnostic report.\n${detail}`, {
-      code: 'OXLINT_INVALID_OUTPUT',
-      cause: error,
-    })
-  }
-
-  return {
-    diagnostics: (output.diagnostics ?? []).map((diagnostic) =>
-      normalizeDiagnostic(root, diagnostic),
-    ),
-    files: output.number_of_files ?? 0,
-  }
-}
-
-function resolvePackage(
-  id: string,
-  projectRequire: NodeJS.Require,
-  sdkRequire: NodeJS.Require,
-): string {
-  try {
-    return projectRequire.resolve(id)
-  } catch (projectError) {
-    try {
-      return sdkRequire.resolve(id)
-    } catch {
-      throw new LinterToolError(
-        'Oxlint is not installed. Add the scaffolded Oxlint dev dependency and run your package manager install.',
-        { code: 'OXLINT_NOT_INSTALLED', cause: projectError },
-      )
-    }
-  }
-}
-
-function isOxlintOutput(value: unknown): value is OxlintOutput {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
-  const output = value as OxlintOutput
-  return (
-    (output.diagnostics === undefined || Array.isArray(output.diagnostics)) &&
-    (output.number_of_files === undefined || typeof output.number_of_files === 'number')
-  )
-}
-
-function failureDetail(stderr: string, stdout: string): string {
-  const detail = stderr.trim() || stdout.trim()
-  const limit = 4_000
-  return detail.length <= limit ? detail : `…${detail.slice(-limit)}`
-}
-
-function projectConfig(root: string): string | undefined {
-  for (const name of [
-    'oxlint.config.ts',
-    'oxlint.config.js',
-    'oxlint.config.mjs',
-    'oxlint.config.cjs',
-    '.oxlintrc.json',
-    '.oxlintrc.jsonc',
-  ]) {
-    const path = join(root, name)
-    if (existsSync(path)) return path
-  }
-  return undefined
-}
-
-function internalConfigPath(): string {
-  const current = fileURLToPath(import.meta.url)
-  const extension = current.endsWith('.ts') ? '.ts' : '.js'
-  return join(dirname(current), `config${extension}`)
-}
-
-function normalizeDiagnostic(root: string, diagnostic: OxlintDiagnostic): LintDiagnostic {
-  const id = normalizeCode(diagnostic.code ?? 'oxlint/unknown')
-  const info = ruleInfo(id)
-  const span = diagnostic.labels?.[0]?.span
-  return {
-    id,
-    severity: normalizeSeverity(diagnostic.severity),
-    message: diagnostic.message ?? info?.message ?? 'Oxlint reported a violation.',
-    ...(diagnostic.help || info?.help ? { help: diagnostic.help ?? info?.help } : {}),
-    ...(diagnostic.url || info?.url ? { url: diagnostic.url ?? info?.url } : {}),
-    owner: info?.owner ?? 'generic',
-    ...(diagnostic.filename
-      ? {
-          location: {
-            path: relativePath(root, diagnostic.filename),
-            line: span?.line ?? 1,
-            column: span?.column ?? 1,
-            ...(span?.offset !== undefined ? { offset: span.offset } : {}),
-            ...(span?.length !== undefined ? { length: span.length } : {}),
-          },
-        }
-      : {}),
-  }
-}
-
-function normalizeCode(code: string): string {
-  const match = /^([^()]+)\(([^()]+)\)$/.exec(code)
-  return match ? `${match[1]}/${match[2]}` : code
-}
-
-function normalizeSeverity(severity: string | undefined): DiagnosticSeverity {
-  return severity === 'error' ? 'error' : 'warning'
-}
-
-function relativePath(root: string, filename: string): string {
-  const absolute = resolve(root, filename)
-  const path = relative(root, absolute)
-  return sep === '/' ? path : path.split(sep).join('/')
-}

package/src/linter/preflight.ts

@@ -1,182 +0,0 @@
-import { existsSync } from 'node:fs'
-import { readFile, realpath } from 'node:fs/promises'
-import { createRequire } from 'node:module'
-import { dirname, join, relative, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { LinterToolError } from './diagnostic.js'
-
-const brandedPackages = [
-  '@astrale-os/kernel-client',
-  '@astrale-os/kernel-core',
-  '@astrale-os/kernel-dsl',
-] as const
-
-const conventionalMembers = ['client', 'frontend', 'schema', 'worker'] as const
-
-type Resolution = {
-  consumer: string
-  path: string
-}
-
-type ConsumerPackageJson = {
-  name?: string
-  dependencies?: Record<string, string>
-  optionalDependencies?: Record<string, string>
-  workspaces?: string[] | { packages?: string[] }
-}
-
-export async function assertSingleTypeUniverse(root: string): Promise<void> {
-  const manifests = await collectConsumerManifests(root)
-  const consumers = [
-    ...manifests.map((path) => ({ label: relative(root, dirname(path)) || '.', path })),
-    { label: '@astrale-os/sdk/linter', path: fileURLPackageJson() },
-  ]
-
-  for (const packageName of brandedPackages) {
-    const resolutions: Resolution[] = []
-    for (const consumer of consumers) {
-      const resolved = await resolvePackageRoot(packageName, consumer.path)
-      if (resolved) resolutions.push({ consumer: consumer.label, path: resolved })
-    }
-    const paths = new Set(resolutions.map((resolution) => resolution.path))
-    if (paths.size <= 1) continue
-    const detail = formatResolutions(resolutions)
-    throw new LinterToolError(
-      `Multiple physical installations of ${packageName} would create incompatible Astrale types.\n` +
-        `${detail}\nReinstall the workspace so every member resolves one compatible package instance.`,
-      { code: 'LINTER_PREFLIGHT_FAILED' },
-    )
-  }
-}
-
-function formatResolutions(resolutions: readonly Resolution[]): string {
-  const byPath = new Map<string, string[]>()
-  for (const resolution of resolutions) {
-    const consumers = byPath.get(resolution.path) ?? []
-    consumers.push(resolution.consumer)
-    byPath.set(resolution.path, consumers)
-  }
-  return [...byPath]
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([path, consumers]) => {
-      const sorted = [...new Set(consumers)].sort()
-      const shown = sorted.slice(0, 4).join(', ')
-      const omitted = sorted.length > 4 ? ` (+${sorted.length - 4} more)` : ''
-      return `  ${path}\n    from: ${shown}${omitted}`
-    })
-    .join('\n')
-}
-
-async function collectConsumerManifests(root: string): Promise<string[]> {
-  const rootManifest = join(root, 'package.json')
-  if (!existsSync(rootManifest)) return []
-
-  const manifests = new Set([rootManifest])
-  const packageJson = await readPackageJson(rootManifest)
-  const workspaces = Array.isArray(packageJson?.workspaces)
-    ? packageJson.workspaces
-    : packageJson?.workspaces?.packages
-
-  for (const workspace of workspaces ?? []) {
-    if (typeof workspace !== 'string' || hasGlob(workspace)) continue
-    addManifestWithinRoot(manifests, root, workspace)
-  }
-
-  for (const member of conventionalMembers) addManifestWithinRoot(manifests, root, member)
-  await addDomainContractDependencyManifests(manifests)
-  return [...manifests].sort()
-}
-
-async function readPackageJson(manifest: string): Promise<ConsumerPackageJson | undefined> {
-  try {
-    return JSON.parse(await readFile(manifest, 'utf8'))
-  } catch {
-    return undefined
-  }
-}
-
-async function addDomainContractDependencyManifests(manifests: Set<string>): Promise<void> {
-  const pending = [...manifests]
-  for (let index = 0; index < pending.length; index++) {
-    const consumer = pending[index]!
-    const packageJson = await readPackageJson(consumer)
-    const dependencies = {
-      ...packageJson?.optionalDependencies,
-      ...packageJson?.dependencies,
-    }
-    for (const packageName of Object.keys(dependencies).sort()) {
-      if (!isDomainContractPackage(packageName)) continue
-      const manifest = await resolveDependencyManifest(packageName, consumer)
-      if (!manifest || manifests.has(manifest)) continue
-      manifests.add(manifest)
-      pending.push(manifest)
-    }
-  }
-}
-
-async function resolveDependencyManifest(
-  packageName: string,
-  consumerManifest: string,
-): Promise<string | undefined> {
-  const require = createRequire(consumerManifest)
-  try {
-    return await realpath(require.resolve(`${packageName}/package.json`))
-  } catch {
-    try {
-      let directory = dirname(await realpath(require.resolve(packageName)))
-      for (;;) {
-        const manifest = join(directory, 'package.json')
-        if (existsSync(manifest)) {
-          const packageJson = await readPackageJson(manifest)
-          if (packageJson?.name === packageName) return await realpath(manifest)
-        }
-        const parent = dirname(directory)
-        if (parent === directory) return undefined
-        directory = parent
-      }
-    } catch {
-      return undefined
-    }
-  }
-}
-
-function addManifestWithinRoot(manifests: Set<string>, root: string, member: string): void {
-  const manifest = resolve(root, member, 'package.json')
-  const parent = relative(root, manifest)
-  if (parent.startsWith('..') || parent === '') return
-  if (existsSync(manifest)) manifests.add(manifest)
-}
-
-function hasGlob(path: string): boolean {
-  return /[*?[\]{}!]/u.test(path)
-}
-
-function isDomainContractPackage(packageName: string): boolean {
-  return packageName.startsWith('@astrale-domains/')
-}
-
-async function resolvePackageRoot(
-  packageName: (typeof brandedPackages)[number],
-  manifest: string,
-): Promise<string | undefined> {
-  if (!existsSync(manifest)) return undefined
-  try {
-    const resolved = createRequire(manifest).resolve(`${packageName}/package.json`)
-    return await realpath(dirname(resolved))
-  } catch {
-    return undefined
-  }
-}
-
-function fileURLPackageJson(): string {
-  let directory = dirname(fileURLToPath(import.meta.url))
-  for (;;) {
-    const candidate = join(directory, 'package.json')
-    if (existsSync(candidate)) return candidate
-    const parent = dirname(directory)
-    if (parent === directory) break
-    directory = parent
-  }
-  return join(directory, 'package.json')
-}