@hyperfrontend/builder§

import { build } from '@hyperfrontend/builder'
import { byPrefix } from '@hyperfrontend/builder/presets'

const result = await build({
  projectRoot: '/abs/libs/foo',
  workspaceRoot: '/abs/repo',
  isWorkspacePackage: byPrefix('@hyperfrontend/'),
  esm: { bundleWorkspaceDeps: false },
  cjs: { bundleWorkspaceDeps: false },
})
result.formatCounts.esm // => number of ESM entries emitted

const isWorkspacePackage = byNames(['@hyperfrontend/logging', 'internal-utils'])
isWorkspacePackage('internal-utils')         // => true
isWorkspacePackage('rollup')                 // => false

const isWorkspacePackage = byPrefix('@hyperfrontend/')
isWorkspacePackage('@hyperfrontend/logging') // => true
isWorkspacePackage('rollup')                 // => false

const context = createBuildContext({ projectRoot, workspaceRoot })
await runBundlePhase(context, config)

const monitor = createMemoryMonitor({ warningMB: 256, criticalMB: 512, growthMB: 32 })
monitor.check('bundle:start')
await runBundlePhase(ctx, config)
monitor.check('bundle:end')
monitor.logSummary()

await runBundlePhase(ctx, config)
await recover()
await runPackagePhase(ctx, config)

const binOutputs = await runBinPhase(context, config.bin ?? [])

const formatOutputs = await runBundlePhase(context, config)

await runPackagePhase(context, config, formatOutputs)

const binOutputs = await runBinPhase(context, config.bin ?? [])

applyCodesign({ binary: '/abs/dist/libs/builder/bin/hf-build.darwin-arm64' })

const outputs = await buildNativeBin({
  bin: { name: 'hf-build', format: 'cjs', sea: { platforms: ['linux-x64'] } },
  ctx: context,
  cjsOutputPath: '/abs/dist/libs/builder/bin/hf-build.js',
})

if (!currentPlatformMatches(bin.sea?.platforms ?? [])) {
  log.info(`skipping native build for ${bin.name} on ${currentPlatformTarget()}`)
  return []
}

const target = currentPlatformTarget() // 'linux-x64'

const report = await dispatchInjectWorker(
  { hostBinary, outputBinary, blobPath, resourceName, machoSegmentName, sentinelFuse, reportPath: '' },
  { workerPath: '/abs/dist/.../worker.cjs.js', label: 'hf-build' }
)

const result = generateSeaBlob({
  seaConfigPath: '/abs/dist/libs/builder/bin/hf-build.sea-config.json',
  outputBlobPath: '/abs/dist/libs/builder/bin/hf-build.sea-prep.blob',
})

const config = generateSeaConfig({
  mainPath: '/abs/dist/libs/builder/bin/hf-build.cjs.js',
  outputPath: '/abs/dist/libs/builder/bin/hf-build.sea-prep.blob',
})

await injectBlob({
  hostBinary: process.execPath,
  outputBinary: '/abs/dist/libs/builder/bin/hf-build.linux-x64',
  blobPath: '/abs/dist/libs/builder/bin/hf-build.sea-prep.blob',
})

removeCodesign({ binary: '/abs/dist/libs/builder/bin/hf-build.darwin-arm64' })

const invocation = resolveDefaultInjectWorkerPath('/abs/repo')
if (!invocation) throw new Error('builder inject worker artifact not found')

const host = resolveHostBinary({ platform: 'linux-x64' }) // process.execPath

const report = await runInjectWorkerJob({
  hostBinary: '/opt/node',
  outputBinary: '/tmp/out',
  blobPath: '/tmp/sea.blob',
  resourceName: 'NODE_SEA_BLOB',
  machoSegmentName: 'NODE_SEA',
  sentinelFuse: 'NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2',
  reportPath: '/tmp/report.json',
})

const outputs = await buildJsBin({ name: 'cz', format: 'cjs', runner: 'runCz' }, context)

const outputs = await buildJsBin({ name: 'hf-build', format: ['cjs', 'esm'] }, context)

const footer = defaultBootstrap({ runner: 'default', format: 'esm' })

const footer = defaultBootstrap({ runner: 'runCz', format: 'cjs' })

const formatOutputs = await runBundlePhase(context, config)

collectEntryRefs("import { A } from '..';")
// => [{ specifier: '..', names: ['A'] }]

collectExportedNames('export type { A } from "./a";\nexport declare const b: number;')
// => Set { 'A', 'b' }

computeSiblingSpecifier(
  '/abs/dist/libs/foo/bundle/index.d.ts',
  { srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }
) // => '../models'

const plugin = createSiblingExternalizePlugin({
  selfSrcPath: 'bundle',
  selfDtsPath: '/abs/dist/libs/foo/bundle/index.d.ts',
  siblings: [{ srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }],
})

dtsPathFor('/abs/dist/libs/foo', 'models') // => '/abs/dist/libs/foo/models/index.d.ts'

const siblings = filterSiblings('bundle', allEntries)

const dangling = findDanglingEntryRefs(context)

const owner = findOwningSibling('/abs/dist/libs/foo/models/index.d.ts', siblings)

flattenDeclarationPaths(context)

const result = await generateDeclarations(context)
console.log(result.stdout)

const removed = pruneOrphanDeclarations(context)

await runDtsPerEntry(context)

await runDtsPrePass(context)

verifyEntryTypeRefs(context)

const byModule = attribute(parseEntry(source, 'esm'), owners)

baseName('Store$1') // => 'Store'

chunkFileName('cjs') // => 'index.cjs.js'

const files = collectReachableSources(['/abs/libs/foo/src/index.ts'], '/abs/libs/foo/src')

fingerprintOf(statement, sourceFile) // 'const x = index_cjs_js.getType();' for both `$1` and `$2` copies

const report = hoistSharedFirstParty(context, monitor)

const owners = indexOwners('/abs/libs/foo/src', ['/abs/libs/foo/src/index.ts'])

const parsed = parseEntry("import { x } from './_dependencies/a/index.esm.js'\nclass C {}", 'esm')

const plan = planHoists(entries, owners)

const source = renderChunk({ decls, crossImports: [], depImports: [] }, 'esm')

const resolution = resolveModuleRefs(decls, owners, parsed.importBindings, parsed.declNames, 'events/events')

const rewritten = rewriteEntry(parseEntry(source, 'esm'), [{ decls, specifier: './_shared/state/index.esm.js' }], 'esm')

sharedDirFor('events/events') // => '_shared/events/events'

const routes = buildWorkspaceRoutes(context.workspaceBundledDeps)
createExternalizeBundledDepsPlugin({ deps, entryOutDir, format, depsRoot, workspaceRoutes: routes })

const plugin = createExternalizeBundledDepsPlugin({
  deps: ['rollup'],
  entryOutDir: '/abs/dist/libs/foo/bundle/rollup',
  format: 'esm',
  depsRoot: '/abs/dist/libs/foo/_dependencies',
})

const paths = loadWorkspacePathMappings('/abs/repo')
paths.get('@hyperfrontend/logging') // => ['/abs/repo/libs/logging/src/index.ts']

relativeImport('/abs/dist/libs/foo/bundle/rollup', '/abs/dist/libs/foo/_dependencies/rollup/index.esm.js')
// => '../../_dependencies/rollup/index.esm.js'

const deps = resolveBundledDeps('/abs/libs/foo/package.json', {
  isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
})

const invocation = resolveDefaultWorkerPath()
if (!invocation) throw new Error('builder worker artifact not found')