@tamagui/static 2.7.7 → 3.0.0-beta.1093.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/static",
-  "version": "2.7.7",
+  "version": "3.0.0-beta.1093.1",
   "gitHead": "a49cc7ea6b93ba384e77a4880ae48ac4a5635c14",
   "license": "MIT",
   "source": "src/index.ts",
@@ -9,87 +9,78 @@
     "types",
     "dist"
   ],
-  "type": "commonjs",
-  "main": "dist",
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
   "types": "./types/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "types": "./types/index.d.ts",
-      "default": "./dist/index.cjs"
-    },
-    "./worker": {
-      "types": "./types/worker.d.ts",
-      "default": "./dist/worker.cjs"
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.mjs"
     },
     "./checkDeps": {
       "types": "./types/checkDeps.d.ts",
-      "default": "./dist/checkDeps.cjs"
+      "import": "./dist/esm/checkDeps.mjs",
+      "require": "./dist/cjs/checkDeps.cjs",
+      "default": "./dist/esm/checkDeps.mjs"
     },
     "./loadTamagui": {
       "types": "./types/extractor/loadTamagui.d.ts",
-      "default": "./dist/extractor/loadTamagui.cjs"
+      "import": "./dist/esm/extractor/loadTamagui.mjs",
+      "require": "./dist/cjs/extractor/loadTamagui.cjs",
+      "default": "./dist/esm/extractor/loadTamagui.mjs"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tamagui-build --skip-native",
-    "watch": "tamagui-build --skip-native --watch",
+    "build": "tamagui-build --skip-native --keep-env-target",
+    "watch": "tamagui-build --skip-native --keep-env-target --watch",
     "clean": "tamagui-build clean",
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@babel/core": "^7.25.2",
-    "@babel/generator": "^7.25.5",
-    "@babel/helper-plugin-utils": "^7.24.8",
-    "@babel/parser": "^7.25.4",
-    "@babel/plugin-transform-react-jsx": "^7.25.2",
-    "@babel/runtime": "^7.25.4",
-    "@babel/template": "^7.25.0",
-    "@babel/traverse": "^7.25.4",
-    "@babel/types": "^7.25.4",
-    "@tamagui/cli-color": "2.7.7",
-    "@tamagui/config-default": "2.7.7",
-    "@tamagui/core": "2.7.7",
-    "@tamagui/fake-react-native": "2.7.7",
-    "@tamagui/generate-themes": "2.7.7",
-    "@tamagui/helpers": "2.7.7",
-    "@tamagui/helpers-node": "2.7.7",
-    "@tamagui/proxy-worm": "2.7.7",
-    "@tamagui/react-native-web-internals": "2.7.7",
-    "@tamagui/react-native-web-lite": "2.7.7",
-    "@tamagui/shorthands": "2.7.7",
-    "@tamagui/types": "2.7.7",
-    "@tamagui/web": "2.7.7",
-    "babel-literal-to-ast": "^2.1.0",
+    "@tamagui/animation-helpers": "3.0.0-beta.1093.1",
+    "@tamagui/cli-color": "3.0.0-beta.1093.1",
+    "@tamagui/compiler-core": "3.0.0-beta.1093.1",
+    "@tamagui/config-default": "3.0.0-beta.1093.1",
+    "@tamagui/core": "3.0.0-beta.1093.1",
+    "@tamagui/dom": "3.0.0-beta.1093.1",
+    "@tamagui/fake-react-native": "3.0.0-beta.1093.1",
+    "@tamagui/generate-themes": "3.0.0-beta.1093.1",
+    "@tamagui/helpers": "3.0.0-beta.1093.1",
+    "@tamagui/helpers-node": "3.0.0-beta.1093.1",
+    "@tamagui/react-native-web-internals": "3.0.0-beta.1093.1",
+    "@tamagui/react-native-web-lite": "3.0.0-beta.1093.1",
+    "@tamagui/shorthands": "3.0.0-beta.1093.1",
+    "@tamagui/style-grammar": "3.0.0-beta.1093.1",
+    "@tamagui/types": "3.0.0-beta.1093.1",
+    "@tamagui/web": "3.0.0-beta.1093.1",
     "browserslist": "^4.28.1",
     "check-dependency-version-consistency": "^4.1.0",
-    "esbuild": "^0.27.2",
+    "esbuild": "0.28.1",
     "esbuild-register": "^3.6.0",
-    "esbuild-wasm": "^0.27.2",
     "fast-glob": "^3.2.11",
-    "find-cache-dir": "^3.3.2",
     "find-root": "^1.1.0",
     "fs-extra": "^11.2.0",
-    "invariant": "^2.2.4",
     "js-yaml": "^4.1.0",
-    "react-native-web": "^0.21.0"
+    "react-native-web": "~0.21.0"
   },
   "devDependencies": {
-    "@babel/plugin-syntax-typescript": "^7.25.4",
-    "@tamagui/build": "2.7.7",
-    "@types/babel__core": "^7.20.5",
+    "@tamagui/build": "3.0.0-beta.1093.1",
     "@types/find-root": "^1.1.2",
     "@types/node": "^22.1.0",
     "@types/webpack": "^4.41.26",
-    "babel-loader": "^9.1.3",
     "esbuild-loader": "^4.2.2",
     "null-loader": "^4.0.1",
-    "react": ">=19",
-    "react-native": "0.83.2",
-    "typescript": "~5.9.2"
+    "react": "19.2.3",
+    "react-native": "0.86.2",
+    "typescript": "~6.0.3"
   },
   "peerDependencies": {
     "react": ">=19"

package/src/check-dep-versions.ts

@@ -3,7 +3,7 @@
   "author": "Bryan Mishkin",
  */
 
-import { globSync } from 'fast-glob'
+import FastGlob from 'fast-glob'
 import { load } from 'js-yaml'
 import { existsSync, readFileSync } from 'node:fs'
 import { join, relative } from 'node:path'
@@ -399,7 +399,7 @@ function expandWorkspaces(
     }
     // Use cwd instead of passing join()'d paths to globby for Windows support: https://github.com/micromatch/micromatch/blob/34f44b4f57eacbdbcc74f64252e0845cf44bbdbd/README.md?plain=1#L822
     // Ignore any node_modules that may be present due to the use of nohoist.
-    return globSync(workspace, {
+    return FastGlob.globSync(workspace, {
       onlyDirectories: true,
       cwd: root,
       ignore: ['**/node_modules'],

package/src/checkDeps.ts

@@ -359,7 +359,7 @@ export async function checkDeps(root: string) {
 
   if (issues.length === 0) {
     console.info(`Tamagui dependencies look good ✅`)
-    process.exit(0)
+    return
   }
 
   for (let i = 0; i < issues.length; i++) {
@@ -367,5 +367,6 @@ export async function checkDeps(root: string) {
     console.error(issues[i])
   }
 
-  process.exit(1)
+  // the caller owns the exit; `tamagui check` still has the style half to run
+  process.exitCode = 1
 }

package/src/compiler.ts

@@ -0,0 +1,506 @@
+import {
+  CompilerSession,
+  LOWERED_MODULE_PLAN_VERSION,
+  ModulePlanCache,
+  PLAN_CACHE_SCHEMA_VERSION,
+  contentHash,
+  defaultPlanCacheRoot,
+  resolvedModuleId,
+  stableStringify,
+  yukuFactory,
+  type AppliedLoweredModule,
+  type CompilerTarget,
+  type HostModuleInput,
+  type LoweredModulePlan,
+  type ResolvedModuleId,
+} from '@tamagui/compiler-core'
+import type { TamaguiOptions } from '@tamagui/types'
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+
+import { ComponentDiscovery, type ComponentModuleEvaluator } from './componentDiscovery'
+import { createComponentRegistry, createTamaguiCompilerHost } from './compilerHost'
+import { domStructuralPass } from './domStructuralPass'
+import type { TamaguiProjectInfo } from './extractor/bundleConfig'
+import { loadTamagui } from './extractor/loadTamagui'
+import { resolveZeroRuntimeSync } from './zero/options'
+
+export interface CompilerProjectComponentModule {
+  moduleName: string
+  id: string
+}
+
+export interface CompilerProject {
+  projectInfo: TamaguiProjectInfo
+  componentModules: CompilerProjectComponentModule[]
+  generation: string
+  /** Keep elements with dynamic style props fully on the runtime path. */
+  disablePartialExtraction?: boolean
+  /** emit native theme-token mappings for the native style engine */
+  experimentalNativeFastPath?: boolean
+  /** Zero-runtime mode, which makes the host's diagnostics mode-aware. */
+  zeroRuntime?: boolean
+  /**
+   * Content identity of everything a lowering plan depends on that is not a
+   * module: the compiler build, the evaluated config and component registry,
+   * the platform, and the modes. Null when the project could not name the files
+   * that determine it, in which case nothing is cached to disk.
+   */
+  cacheStamp: string | null
+}
+
+export interface LoadCompilerProjectInput {
+  root: string
+  target: CompilerTarget
+  options: Partial<TamaguiOptions>
+  generation:
+    | string
+    | ((
+        projectInfo: TamaguiProjectInfo,
+        componentModules: CompilerProjectComponentModule[],
+        options: TamaguiOptions
+      ) => string)
+  rebuild?: boolean
+  /**
+   * `name@version` for the host integration package, folded into the cache
+   * stamp so a plugin upgrade cannot reuse plans built by the previous one.
+   */
+  hostVersions?: readonly string[]
+  missingProjectMessage?: string
+  load?: (options: TamaguiOptions, rebuild: boolean) => Promise<TamaguiProjectInfo | null>
+  resolveComponents?: (
+    moduleNames: readonly string[],
+    projectInfo: TamaguiProjectInfo,
+    options: TamaguiOptions
+  ) => Promise<CompilerProjectComponentModule[]>
+}
+
+/**
+ * normalize and load the compiler-owned project contract. module resolution and
+ * evaluation stay with the adapter through the two callbacks.
+ */
+export async function loadCompilerProject({
+  root,
+  target,
+  options: optionsIn,
+  generation,
+  rebuild = false,
+  hostVersions = [],
+  missingProjectMessage = 'Unable to load the Tamagui compiler project',
+  load = loadTamagui,
+  resolveComponents,
+}: LoadCompilerProjectInput): Promise<CompilerProject> {
+  const components = [
+    ...new Set(['@tamagui/core', ...(optionsIn.components || ['tamagui'])]),
+  ]
+  const options = {
+    ...optionsIn,
+    root,
+    platform: target,
+    components,
+  } as TamaguiOptions
+  const zeroRuntime = resolveZeroRuntimeSync(options, root).mode
+  if (zeroRuntime === 'enforce') options.outputCSS = undefined
+
+  const projectInfo = await load(options, rebuild)
+  if (!projectInfo?.tamaguiConfig || !projectInfo.components) {
+    throw new Error(missingProjectMessage)
+  }
+
+  const componentModules = resolveComponents
+    ? await resolveComponents(components, projectInfo, options)
+    : []
+
+  const disablePartialExtraction = !!options.disablePartialExtraction
+  const experimentalNativeFastPath =
+    target === 'native' && options.experimental?.nativeFastPath === true
+
+  return {
+    projectInfo,
+    componentModules,
+    generation:
+      typeof generation === 'function'
+        ? generation(projectInfo, componentModules, options)
+        : generation,
+    disablePartialExtraction,
+    experimentalNativeFastPath,
+    zeroRuntime: zeroRuntime !== 'off',
+    cacheStamp: compilerProjectStamp({
+      stampSources: projectInfo.stampSources ?? [],
+      hostVersions,
+      target,
+      componentModules,
+      disablePartialExtraction,
+      experimentalNativeFastPath,
+      zeroRuntime: zeroRuntime !== 'off',
+      development: process.env.NODE_ENV === 'development',
+    }),
+  }
+}
+
+const requireFromCompiler = createRequire(
+  typeof __filename === 'string' ? __filename : import.meta.url
+)
+
+// upgrading the compiler must invalidate cached plans even when nothing about
+// the project changed
+const compilerPackageVersions = ['@tamagui/compiler-core', '@tamagui/static'].map(
+  (name) =>
+    `${name}@${(requireFromCompiler(`${name}/package.json`) as { version: string }).version}`
+)
+
+/**
+ * The non-module half of every plan cache key. Null when the project named no
+ * stamp sources: a stamp that cannot see a config change is worse than no
+ * cache, so that project simply does not cache.
+ */
+export function compilerProjectStamp(input: {
+  stampSources: readonly string[]
+  hostVersions: readonly string[]
+  target: CompilerTarget
+  componentModules: readonly CompilerProjectComponentModule[]
+  disablePartialExtraction: boolean
+  experimentalNativeFastPath: boolean
+  zeroRuntime: boolean
+  /**
+   * `process.env.NODE_ENV === 'development'` in the process that builds plans.
+   * The host emits debug-receipt edits into `plan.edits` only in development
+   * (compilerHost.ts's developmentDebugInstrumentation), so a development plan
+   * is not a plan a production build may reuse. This is the ONLY ambient input
+   * to a plan, and it lives in the stamp so every host inherits it rather than
+   * each one remembering to add it to its own key.
+   */
+  development: boolean
+}): string | null {
+  if (!input.stampSources.length) return null
+  const sources: [string, string][] = []
+  for (const file of [...new Set(input.stampSources)].sort()) {
+    try {
+      sources.push([file, contentHash(readFileSync(file))])
+    } catch {
+      // a source the project named but that is not readable makes the stamp
+      // incomplete, and an incomplete stamp is what ships stale styles
+      return null
+    }
+  }
+  return contentHash(
+    stableStringify({
+      schema: PLAN_CACHE_SCHEMA_VERSION,
+      plan: LOWERED_MODULE_PLAN_VERSION,
+      packages: [...compilerPackageVersions, ...input.hostVersions].sort(),
+      target: input.target,
+      development: input.development,
+      componentModules: input.componentModules.map(({ moduleName, id }) => [
+        moduleName,
+        cleanId(id),
+      ]),
+      disablePartialExtraction: input.disablePartialExtraction,
+      experimentalNativeFastPath: input.experimentalNativeFastPath,
+      zeroRuntime: input.zeroRuntime,
+      sources,
+    })
+  )
+}
+
+export interface CompilerResolution {
+  id: string
+  external?: boolean
+}
+
+export interface CompilerInput {
+  id: string
+  source: string
+  root: string
+  target: CompilerTarget
+  /** Host environment whose resolver produced this module graph. */
+  environment?: string
+  project: CompilerProject
+  resolve(specifier: string, importer: string): Promise<CompilerResolution | null>
+  load(id: string): Promise<string | null>
+  /**
+   * Evaluate a host-resolved module and return its exports. The frontend asks
+   * for every package a JSX element or styled() base imports from that is not
+   * in the configured `components` list, once per module per project, and
+   * lowers against the static configs it finds. Return null (or throw) when
+   * the host cannot evaluate the module; those elements stay on the runtime
+   * path exactly as before.
+   */
+  evaluate?: ComponentModuleEvaluator
+}
+
+export type CompilerUpdateInput = CompilerInput
+
+export interface CompilerResult {
+  plan: LoweredModulePlan
+  output: AppliedLoweredModule
+  invalidatedIds: ResolvedModuleId[]
+}
+
+function cleanId(id: string): string {
+  return id.split(/[?#]/, 1)[0]
+}
+
+function externalId(specifier: string): ResolvedModuleId {
+  return resolvedModuleId(`external://${encodeURIComponent(specifier)}`)
+}
+
+function compilerContext(input: CompilerInput): string {
+  return `${input.root}\0${input.target}\0${input.environment ?? ''}\0${input.project.generation}`
+}
+
+function sourceCanBeLinked(root: string, id: string): boolean {
+  const clean = cleanId(id)
+  const normalized = clean.replace(/\\/g, '/')
+  if (!path.isAbsolute(clean) || normalized.includes('/node_modules/')) return false
+  const relative = path.relative(root, clean)
+  return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`))
+}
+
+/**
+ * Long-lived host-resolved graph frontend. The adapter supplies every identity and
+ * load result; compiler-core never guesses package, alias, or workspace resolution.
+ */
+export class CompilerFrontend {
+  private readonly session = new CompilerSession()
+  private queue: Promise<unknown> = Promise.resolve()
+  private readonly planCaches = new Map<string, ModulePlanCache>()
+  private readonly moduleRecords = new Map<ResolvedModuleId, HostModuleInput>()
+  private moduleContext: string | null = null
+  private readonly discovery = new ComponentDiscovery()
+
+  /**
+   * One cache per project root and platform. Absent when the project produced
+   * no content stamp, in which case plans are never persisted rather than
+   * persisted under an identity that cannot see a config change.
+   */
+  private planCacheFor(
+    input: CompilerInput
+  ): { store: ModulePlanCache; stamp: string } | undefined {
+    const stamp = input.project.cacheStamp
+    if (!stamp) return undefined
+    const root = defaultPlanCacheRoot(input.root, input.target)
+    let store = this.planCaches.get(root)
+    if (!store) {
+      store = new ModulePlanCache(root)
+      this.planCaches.set(root, store)
+    }
+    return { store, stamp }
+  }
+
+  /** Hits, misses and writes across every plan cache this frontend has used. */
+  get planCacheStats(): { hits: number; misses: number; writes: number } {
+    const total = { hits: 0, misses: 0, writes: 0 }
+    for (const store of this.planCaches.values()) {
+      total.hits += store.stats.hits
+      total.misses += store.stats.misses
+      total.writes += store.stats.writes
+    }
+    return total
+  }
+
+  compile(input: CompilerInput): Promise<CompilerResult> {
+    // compiling must not leak process-global state: internal stages set
+    // TAMAGUI_TARGET / IS_STATIC while evaluating modules for a platform, and
+    // an embedder (or a test that renders at runtime after compiling) must see
+    // its own environment unchanged afterward
+    const operation = this.queue.then(async () => {
+      const previousTarget = process.env.TAMAGUI_TARGET
+      const previousStatic = process.env.IS_STATIC
+      try {
+        return await this.compileNow(input)
+      } finally {
+        if (previousTarget === undefined) delete process.env.TAMAGUI_TARGET
+        else process.env.TAMAGUI_TARGET = previousTarget
+        if (previousStatic === undefined) delete process.env.IS_STATIC
+        else process.env.IS_STATIC = previousStatic
+      }
+    })
+    this.queue = operation.catch(() => undefined)
+    return operation
+  }
+
+  update(input: CompilerUpdateInput): Promise<ResolvedModuleId[]> {
+    const operation = this.queue.then(async () => {
+      const { modules } = await this.buildTree(input)
+      const invalidated = new Set<ResolvedModuleId>()
+      for (const module of modules.values()) {
+        for (const id of await this.session.update(module)) invalidated.add(id)
+        this.moduleRecords.set(module.id, module)
+      }
+      return [...invalidated].sort()
+    })
+    this.queue = operation.catch(() => undefined)
+    return operation
+  }
+
+  has(id: string): boolean {
+    return this.session.has(resolvedModuleId(cleanId(id)))
+  }
+
+  dependentsOf(id: string): ResolvedModuleId[] {
+    return this.session.dependentsOf(resolvedModuleId(cleanId(id)))
+  }
+
+  remove(id: string) {
+    const operation = this.queue.then(async () => {
+      const result = await this.session.remove(resolvedModuleId(cleanId(id)))
+      for (const invalidatedId of result.invalidatedIds) {
+        this.moduleRecords.delete(invalidatedId)
+      }
+      return result
+    })
+    this.queue = operation.catch(() => undefined)
+    return operation
+  }
+
+  parseCount(id: string): number {
+    return this.session.parseCount(resolvedModuleId(cleanId(id)))
+  }
+
+  private async compileNow(input: CompilerInput): Promise<CompilerResult> {
+    const { rootModule, modules } = await this.buildTree(input)
+    const invalidated = new Set<ResolvedModuleId>()
+    for (const module of modules.values()) {
+      for (const id of await this.session.update(module)) invalidated.add(id)
+      this.moduleRecords.set(module.id, module)
+    }
+    const projectInfo = input.project.projectInfo
+    if (!projectInfo.tamaguiConfig || !projectInfo.components) {
+      throw new Error('The compiler requires evaluated Tamagui config and components')
+    }
+    const componentModules = input.project.componentModules.map((component) => ({
+      moduleName: component.moduleName,
+      resolvedId: cleanId(component.id),
+    }))
+    const registry = createComponentRegistry(projectInfo.components, componentModules)
+    this.discovery.seed(registry)
+    const host = createTamaguiCompilerHost({
+      target: input.target,
+      tamaguiConfig: projectInfo.tamaguiConfig,
+      components: projectInfo.components,
+      componentModules,
+      registry,
+      disablePartialExtraction: input.project.disablePartialExtraction,
+      experimentalNativeFastPath: input.project.experimentalNativeFastPath,
+      zeroRuntime: input.project.zeroRuntime,
+    })
+    const result = await this.session.compile({
+      module: rootModule,
+      adapter: {
+        target: input.target,
+        projectGeneration: input.project.generation,
+        host,
+        planCache: this.planCacheFor(input),
+        async load(id) {
+          return modules.get(id) ?? null
+        },
+        prepare: (module) => this.discovery.prepare(module, registry, input.evaluate),
+      },
+      structuralPass: domStructuralPass,
+    })
+    for (const id of result.invalidatedIds) invalidated.add(id)
+    return {
+      plan: result.plan,
+      output: result.output,
+      invalidatedIds: [...invalidated].sort(),
+    }
+  }
+
+  /** host-resolved ids of every module discovery found components in */
+  discoveredModuleIds(): string[] {
+    return this.discovery.ids()
+  }
+
+  private async buildTree(input: CompilerUpdateInput): Promise<{
+    rootModule: HostModuleInput
+    modules: Map<ResolvedModuleId, HostModuleInput>
+  }> {
+    const moduleContext = compilerContext(input)
+    if (this.moduleContext !== moduleContext) {
+      this.moduleRecords.clear()
+      this.discovery.clear()
+      this.moduleContext = moduleContext
+    }
+
+    const componentBySpecifier = new Map(
+      input.project.componentModules.map((component) => [
+        component.moduleName,
+        resolvedModuleId(cleanId(component.id)),
+      ])
+    )
+    const modules = new Map<ResolvedModuleId, HostModuleInput>()
+    const loading = new Set<ResolvedModuleId>()
+
+    const addInstalledClosure = (module: HostModuleInput): void => {
+      if (modules.has(module.id) || loading.has(module.id)) return
+      loading.add(module.id)
+      for (const dependency of module.imports) {
+        if (dependency.external) continue
+        const installedDependency = this.moduleRecords.get(dependency.resolvedId)
+        if (installedDependency && this.session.has(dependency.resolvedId)) {
+          addInstalledClosure(installedDependency)
+        }
+      }
+      modules.set(module.id, module)
+      loading.delete(module.id)
+    }
+
+    const loadModule = async (
+      rawId: string,
+      source: string
+    ): Promise<HostModuleInput> => {
+      const id = resolvedModuleId(cleanId(rawId))
+      const existing = modules.get(id)
+      if (existing) return existing
+      const installed = this.moduleRecords.get(id)
+      if (installed?.source === source && this.session.has(id)) {
+        addInstalledClosure(installed)
+        return installed
+      }
+      if (loading.has(id)) {
+        return { id, source, imports: [] }
+      }
+      loading.add(id)
+
+      const imports: HostModuleInput['imports'][number][] = []
+      for (const specifier of yukuFactory.scanImports(id, source)) {
+        const configuredComponent = componentBySpecifier.get(specifier)
+        if (configuredComponent) {
+          imports.push({ specifier, resolvedId: configuredComponent, external: true })
+          continue
+        }
+
+        const resolution = await input.resolve(specifier, id)
+        if (!resolution) continue
+        const canLink =
+          !resolution.external && sourceCanBeLinked(input.root, resolution.id)
+        const resolvedId = canLink
+          ? resolvedModuleId(cleanId(resolution.id))
+          : path.isAbsolute(cleanId(resolution.id))
+            ? resolvedModuleId(cleanId(resolution.id))
+            : externalId(specifier)
+        imports.push({ specifier, resolvedId, external: !canLink })
+        if (canLink && !modules.has(resolvedId) && !loading.has(resolvedId)) {
+          const installedDependency = this.moduleRecords.get(resolvedId)
+          if (installedDependency && this.session.has(resolvedId)) {
+            addInstalledClosure(installedDependency)
+          } else {
+            const dependencySource = await input.load(resolution.id)
+            if (dependencySource !== null) {
+              await loadModule(resolution.id, dependencySource)
+            }
+          }
+        }
+      }
+
+      const module = { id, source, imports }
+      modules.set(id, module)
+      loading.delete(id)
+      return module
+    }
+
+    const rootModule = await loadModule(input.id, input.source)
+    return { rootModule, modules }
+  }
+}