zyzz 0.0.6 → 0.0.8

package/src/next/loader.ts

@@ -1,33 +1,26 @@
 /** Loads a physical source graph through Next.js resolution and emits cache-owned CSS. @module */
+import * as AtRules from '../compiler/internal/AtRules.js'
 import * as Crypto from 'node:crypto'
 import * as Fs from 'node:fs/promises'
 import * as Path from 'node:path'
-import * as Parser from 'oxc-parser'
-import * as Graph from '../compiler/Graph.js'
-import * as Reset from '../node/Reset.js'
-import * as AtRules from '../compiler/internal/AtRules.js'
-import * as Contract from '../compiler/internal/Contract.js'
+import * as Stylesheets from '../compiler/internal/Stylesheets.js'
+import * as Project from './internal/Project.js'
 
-type Context = {
-  addContextDependency(directory: string): void
-  addDependency(file: string): void
+type Context = Project.Context & {
   async(): (error: Error | null, code?: string, map?: object) => void
   getOptions(): {
     bundler: string
-    mode: 'shared' | 'source' | 'style'
+    development?: boolean | undefined
+    mode?: 'style' | undefined
     reset?: boolean | undefined
     root: string
   }
-  getResolve(
-    options: object,
-  ): (
-    directory: string,
-    specifier: string,
-    callback: (error: Error | null, file?: string | false) => void,
-  ) => void
-  resourcePath: string
+  resourceQuery?: string | undefined
 }
 
+// Next owns loader worker lifetimes. Each project retains only its latest graph in that worker.
+const projects = new Map<string, ReturnType<typeof Project.create>>()
+
 /** Loader-runner boundary used by Webpack and Turbopack. */
 export default function loader(this: Context, source: string): void {
   const callback = this.async()
@@ -42,14 +35,15 @@ async function compile(context: Context, source: string) {
   const options = context.getOptions()
   const root = options.root
   const directory = Path.resolve(root, '.zyzz', 'next')
-  const modules: Record<string, string> = Object.create(null)
-  const imports: Record<string, Record<string, string | null>> = Object.create(
-    null,
-  )
-  const contracts: Record<string, string> = Object.create(null)
-  const resolve = context.getResolve({})
-  const id = (file: string) =>
-    `app/${Path.relative(root, file).split(Path.sep).join('/')}`
+  if (options.mode) {
+    const hash = new URLSearchParams(context.resourceQuery).get('zyzz')
+    if (!hash || !/^[a-f0-9]{64}$/.test(hash))
+      throw new Error('Invalid generated stylesheet request.')
+    const file = Path.join(directory, `${hash}.css`)
+    context.addDependency(file)
+    return { code: await Fs.readFile(file, 'utf8'), map: undefined }
+  }
+
   const eligible = (file: string) =>
     /\.[cm]?[jt]sx?$/.test(file) &&
     !/\.(?:d|test|test-d|bench|bench-d)\.[cm]?[jt]sx?$/.test(file) &&
@@ -68,221 +62,25 @@ async function compile(context: Context, source: string) {
   )
     return { code: source, map: undefined }
 
-  if (options.mode !== 'shared' && !eligible(context.resourcePath))
-    return { code: source, map: undefined }
-
-  async function visit(file: string, text?: string): Promise<void> {
-    const name = id(file)
-    if (Object.hasOwn(modules, name)) return
-
-    context.addDependency(file)
-    modules[name] = text ?? (await Fs.readFile(file, 'utf8'))
-    const links: Record<string, string | null> = Object.create(null)
-    imports[name] = links
-    const parsed = Parser.parseSync(file, modules[name]!, {
-      sourceType: 'module',
-    })
-
-    for (const node of parsed.program.body) {
-      if (
-        (node.type !== 'ImportDeclaration' &&
-          node.type !== 'ExportNamedDeclaration' &&
-          node.type !== 'ExportAllDeclaration') ||
-        !node.source
-      )
-        continue
-      if (
-        node.type === 'ImportDeclaration'
-          ? node.importKind === 'type'
-          : node.exportKind === 'type'
-      )
-        continue
-
-      const specifier = node.source.value
-      links[specifier] = null
-      // Next owns this virtual module, which has no physical stylesheet contract.
-      if (specifier === 'next/root-params') continue
-      if (
-        specifier === 'zyzz' ||
-        (specifier.startsWith('zyzz/') && specifier !== 'zyzz/default') ||
-        specifier.startsWith('node:')
-      )
-        continue
-
-      const resolved = await new Promise<string | false | undefined>(
-        (accept, reject) => {
-          resolve(Path.dirname(file), specifier, (error, value) =>
-            error ? reject(error) : accept(value),
-          )
-        },
-      )
-      if (!resolved || !/\.[cm]?[jt]sx?$/.test(resolved)) continue
-      if (eligible(resolved)) {
-        links[specifier] = id(resolved)
-        await visit(resolved)
-        continue
-      }
-
-      const sidecar = `${resolved}.zyzz.json`
-      try {
-        contracts[resolved] = await Fs.readFile(sidecar, 'utf8')
-        context.addDependency(sidecar)
-        links[specifier] = resolved
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
-      }
-    }
-  }
-
-  async function discover(directory: string): Promise<void> {
-    const items = await Fs.readdir(directory, { withFileTypes: true })
-
-    // Recursive tracking of a package root follows every installed dependency.
-    // A dependency symlink back to an ancestor, as a package linked from its
-    // own repository, is rejected as a loop, so such a root is tracked through
-    // its files and subdirectories instead.
-    if (
-      !items.some((item) => item.name === 'node_modules') ||
-      !(await loops(directory))
-    )
-      context.addContextDependency(directory)
+  if (!eligible(context.resourcePath)) return { code: source, map: undefined }
 
-    for (const item of items) {
-      if (
-        item.name.startsWith('.') ||
-        [
-          'node_modules',
-          'dist',
-          'build',
-          'coverage',
-          'test',
-          'tests',
-          '__tests__',
-        ].includes(item.name)
-      )
-        continue
-      const file = Path.join(directory, item.name)
-      if (item.isDirectory()) await discover(file)
-      else if (item.isFile() && eligible(file)) await visit(file)
-    }
-  }
-
-  if (options.mode !== 'shared') await visit(context.resourcePath, source)
-  await discover(root)
-  const loaded = new Set<string>()
-  async function dependencies(file: string): Promise<void> {
-    if (loaded.has(file)) return
-    loaded.add(file)
-
-    const metadata = Contract.read(contracts[file]!, new Map(), file)
-    for (const section of metadata.stylesheets) {
-      let owner = file
-      for (const specifier of section.dependency ?? []) {
-        const target = await new Promise<string | false | undefined>(
-          (accept, reject) => {
-            resolve(Path.dirname(owner), specifier, (error, value) =>
-              error ? reject(error) : accept(value),
-            )
-          },
-        )
-        if (!target || !Path.isAbsolute(target))
-          throw new Error('Unable to resolve packed stylesheet dependency.')
-
-        const links = (imports[owner] ??= Object.create(null))
-        links[specifier] = target
-        if (!Object.hasOwn(contracts, target)) {
-          const sidecar = `${target}.zyzz.json`
-          contracts[target] = await Fs.readFile(sidecar, 'utf8')
-          context.addDependency(sidecar)
-        }
-        await dependencies(target)
-        owner = target
-      }
-    }
-  }
-  for (const file of Object.keys(contracts)) await dependencies(file)
-
-  const graph = Graph.compile({
-    contracts,
-    imports,
-    modules,
-    reset: options.reset ? Reset.read() : undefined,
-  })
-  const output = graph.modules[id(context.resourcePath)]
-
-  const assets = new Map<string, string>()
-  for (const [placeholder, target] of Object.entries(
-    graph.sharedAssets ?? {},
-  )) {
-    const raw = target.split(/[?#]/)[0]!
-    const file = await Fs.realpath(
-      target.startsWith('app/')
-        ? Path.join(root, decodeURIComponent(raw.slice(4)))
-        : decodeURIComponent(raw),
-    )
-    const identity = graph.sharedAssetOwners?.[placeholder]
-    let owner = root
-    if (identity && Path.isAbsolute(identity)) {
-      owner = Path.dirname(identity)
-      for (;;) {
-        try {
-          await Fs.access(Path.join(owner, 'package.json'))
-          break
-        } catch (error) {
-          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
-          const parent = Path.dirname(owner)
-          if (parent === owner)
-            throw new Error('Packed assets require an owning package.json.')
-          owner = parent
-        }
-      }
-    }
-
-    const relative = Path.relative(await Fs.realpath(owner), file)
-    if (
-      !identity ||
-      relative === '..' ||
-      relative.startsWith(`..${Path.sep}`) ||
-      Path.isAbsolute(relative)
-    )
-      throw new Error('Asset path escapes its owning package.')
-
-    context.addDependency(file)
-    assets.set(
-      placeholder,
-      Path.relative(
-        options.bundler === 'turbopack'
-          ? Path.dirname(context.resourcePath)
-          : directory,
-        file,
-      )
-        .split(Path.sep)
-        .map(encodeURIComponent)
-        .join('/') + target.slice(raw.length),
-    )
+  const key = JSON.stringify([
+    root,
+    options.bundler,
+    options.reset ?? false,
+    options.development ?? false,
+  ])
+  let project = projects.get(key)
+  if (!project) {
+    project = Project.create(options)
+    projects.set(key, project)
   }
+  const graph = await project.compile(context, source)
+  const output =
+    graph.modules[
+      `app/${Path.relative(root, context.resourcePath).split(Path.sep).join('/')}`
+    ]
 
-  const shared = graph.sharedCss
-    ? AtRules.transform({
-        code: Buffer.from(graph.sharedCss),
-        filename: 'shared.css',
-        inputSourceMap: JSON.stringify(graph.sharedCssMap),
-        sourceMap: true,
-        visitor: {
-          Url: (url) =>
-            assets.has(url.url)
-              ? { ...url, url: assets.get(url.url)! }
-              : undefined,
-        },
-      })
-    : undefined
-  if (options.mode === 'shared')
-    return {
-      code: shared?.code.toString() ?? '',
-      map: shared?.map
-        ? (JSON.parse(shared.map.toString()) as object)
-        : undefined,
-    }
   if (!output) throw new Error('Missing Next.js source compilation.')
   // Bundlers resolve map sources relative to the loader resource, not graph identities.
   const sources = (names: readonly (string | null)[]) =>
@@ -295,63 +93,180 @@ async function compile(context: Context, source: string) {
     sources: sources(output.map.sources),
   }
   const cssMap = { ...output.cssMap, sources: sources(output.cssMap.sources) }
-  if (options.mode === 'style') return { code: output.css, map: cssMap }
 
-  if (options.bundler === 'turbopack') {
-    const sharedFile = Path.relative(
-      Path.dirname(context.resourcePath),
-      Path.join(directory, 'shared.css'),
-    )
-      .split(Path.sep)
-      .join('/')
-    // Turbopack appends the output extension to loader-transformed resource paths.
-    const resource = await Fs.stat(context.resourcePath).then(
-      () => context.resourcePath,
-      async (error: NodeJS.ErrnoException) => {
-        if (error.code !== 'ENOENT') throw error
-        const original = context.resourcePath.slice(
-          0,
-          -Path.extname(context.resourcePath).length,
-        )
-        await Fs.access(original)
-        return original
-      },
-    )
-    const requests = [
-      ...(graph.sharedCss
-        ? [
-            `import ${JSON.stringify(sharedFile.startsWith('../') ? sharedFile : `./${sharedFile}`)};`,
-          ]
-        : []),
-      ...(output.css
-        ? [
-            `import ${JSON.stringify(`./${Path.basename(resource)}?zyzz-style`)};`,
-          ]
-        : []),
-    ]
-    return { code: `${output.code}\n${requests.join('\n')}`, map }
+  if (
+    output.code === source &&
+    !output.css &&
+    !/(?:^|[/\\])(?:layout|_app)\.[cm]?[jt]sx?$/.test(context.resourcePath) &&
+    !graph.sharedCssMap?.sources.some((name) => name !== 'zyzz/reset.css') &&
+    !graph[Stylesheets.packed]?.length
+  )
+    return { code: source, map }
+
+  const shared = await compileShared({
+    css: graph.sharedCss ?? '',
+    map: graph.sharedCssMap!,
+    assets: graph.sharedAssets ?? {},
+    owners: graph.sharedAssetOwners ?? {},
+  })
+
+  async function compileShared(
+    stylesheet: ReturnType<typeof Stylesheets.render>,
+  ) {
+    const assets = new Map<string, string>()
+    for (const [placeholder, target] of Object.entries(stylesheet.assets)) {
+      const raw = target.split(/[?#]/)[0]!
+      const file = await Fs.realpath(
+        target.startsWith('app/')
+          ? Path.join(root, decodeURIComponent(raw.slice(4)))
+          : decodeURIComponent(raw),
+      )
+      const identity = stylesheet.owners[placeholder]
+      let owner = root
+      if (identity && Path.isAbsolute(identity)) {
+        owner = Path.dirname(identity)
+        for (;;) {
+          try {
+            await Fs.access(Path.join(owner, 'package.json'))
+            break
+          } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+            const parent = Path.dirname(owner)
+            if (parent === owner)
+              throw new Error('Packed assets require an owning package.json.')
+            owner = parent
+          }
+        }
+      }
+
+      const relative = Path.relative(await Fs.realpath(owner), file)
+      if (
+        !identity ||
+        relative === '..' ||
+        relative.startsWith(`..${Path.sep}`) ||
+        Path.isAbsolute(relative)
+      )
+        throw new Error('Asset path escapes its owning package.')
+
+      context.addDependency(file)
+      assets.set(
+        placeholder,
+        Path.relative(directory, file)
+          .split(Path.sep)
+          .map(encodeURIComponent)
+          .join('/') + target.slice(raw.length),
+      )
+    }
+
+    return stylesheet.css
+      ? AtRules.transform({
+          code: Buffer.from(stylesheet.css),
+          filename: 'shared.css',
+          inputSourceMap: JSON.stringify({
+            ...stylesheet.map,
+            sources: sources(stylesheet.map.sources),
+          }),
+          sourceMap: true,
+          visitor: {
+            Url: (url) =>
+              assets.has(url.url)
+                ? { ...url, url: assets.get(url.url)! }
+                : undefined,
+          },
+        })
+      : undefined
   }
+
   const styles = [
-    { css: shared?.code.toString(), map: shared?.map?.toString() },
-    { css: output.css, map: JSON.stringify(cssMap) },
+    ...(await Promise.all(
+      (graph[Stylesheets.packed] ?? []).map(async (resource) => {
+        const output = await compileShared(resource)
+        return {
+          css: output?.code.toString(),
+          map: output?.map?.toString(),
+          id: resource.id,
+        }
+      }),
+    )),
+    {
+      id: undefined,
+      css: shared?.code.toString(),
+      map: shared?.map?.toString(),
+    },
+    { id: undefined, css: output.css, map: JSON.stringify(cssMap) },
   ]
   const requests: string[] = []
   await Fs.mkdir(directory, { recursive: true })
-  for (const stylesheet of styles) {
+  try {
+    await Fs.writeFile(
+      Path.join(directory, 'package.json'),
+      JSON.stringify({ sideEffects: true, type: 'module' }),
+      { flag: 'wx' },
+    )
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error
+  }
+  for (const [index, stylesheet] of styles.entries()) {
     if (!stylesheet.css) continue
     const css =
       stylesheet.css +
       (stylesheet.map
         ? `\n/*# sourceMappingURL=data:application/json;base64,${Buffer.from(stylesheet.map).toString('base64')} */`
         : '')
-    const hash = Crypto.createHash('sha256').update(css).digest('hex')
+    const hash = Crypto.createHash('sha256')
+      .update(
+        options.development &&
+          !(
+            index === (graph[Stylesheets.packed]?.length ?? 0) &&
+            graph.sharedCssMap?.sources.every(
+              (name) => name === 'zyzz/reset.css',
+            )
+          )
+          ? (stylesheet.id ??
+              JSON.stringify([context.resourcePath, index, graph.dependencies]))
+          : css,
+      )
+      .digest('hex')
     const file = Path.join(directory, `${hash}.css`)
-    try {
-      await Fs.writeFile(file, css, { flag: 'wx' })
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error
+    if (options.development) {
+      const previous = await Fs.readFile(file, 'utf8').catch(
+        (error: NodeJS.ErrnoException) => {
+          if (error.code !== 'ENOENT') throw error
+          return undefined
+        },
+      )
+      if (previous !== css) {
+        const temporary = `${file}.${Crypto.randomUUID()}.tmp`
+        await Fs.writeFile(temporary, css)
+        await Fs.rename(temporary, file)
+      }
+    } else {
+      try {
+        await Fs.writeFile(file, css, { flag: 'wx' })
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error
+      }
+    }
+    let request = file
+    if (options.development) {
+      // Server-component CSS needs a client graph edge for Next's native CSS HMR.
+      request = `${file}.js`
+      const stylesheet =
+        options.bundler === 'turbopack'
+          ? `./style.css?zyzz=${hash}`
+          : `./${hash}.css`
+      const code = `'use client';import ${JSON.stringify(stylesheet)};`
+      const existing = await Fs.readFile(request, 'utf8').catch(
+        (error: NodeJS.ErrnoException) => {
+          if (error.code !== 'ENOENT') throw error
+          return undefined
+        },
+      )
+      if (existing !== code) await Fs.writeFile(request, code)
+    } else if (options.bundler === 'turbopack') {
+      request = Path.join(directory, 'style.css') + `?zyzz=${hash}`
     }
-    const relative = Path.relative(Path.dirname(context.resourcePath), file)
+    const relative = Path.relative(Path.dirname(context.resourcePath), request)
       .split(Path.sep)
       .join('/')
     requests.push(
@@ -361,38 +276,3 @@ async function compile(context: Context, source: string) {
 
   return { code: `${output.code}\n${requests.join('\n')}`, map }
 }
-
-/** Whether an installed dependency links back to the directory or one of its ancestors. */
-async function loops(directory: string): Promise<boolean> {
-  const installed = Path.join(directory, 'node_modules')
-  const entries = await Fs.readdir(installed, { withFileTypes: true }).catch(
-    () => [],
-  )
-  const candidates = (
-    await Promise.all(
-      entries.map(async (entry) => {
-        if (!entry.name.startsWith('@'))
-          return [Path.join(installed, entry.name)]
-
-        const scoped = Path.join(installed, entry.name)
-
-        return (await Fs.readdir(scoped).catch(() => [])).map((name) =>
-          Path.join(scoped, name),
-        )
-      }),
-    )
-  ).flat()
-
-  for (const candidate of candidates) {
-    const stat = await Fs.lstat(candidate).catch(() => undefined)
-    if (!stat?.isSymbolicLink()) continue
-
-    const target = await Fs.realpath(candidate).catch(() => undefined)
-    if (target === undefined) continue
-
-    const relative = Path.relative(target, directory)
-    if (!relative.startsWith('..') && !Path.isAbsolute(relative)) return true
-  }
-
-  return false
-}

package/src/node/Host.ts

@@ -13,6 +13,7 @@ import * as Graph from '../compiler/Graph.js'
 import * as AtRules from '../compiler/internal/AtRules.js'
 import * as Catalogs from '../compiler/internal/Catalogs.js'
 import * as Relative from '../compiler/internal/Relative.js'
+import * as Snapshot from './internal/Snapshot.js'
 import * as Syntax from '../compiler/internal/Syntax.js'
 import * as Source from '../compiler/Source.js'
 import * as Transform from '../compiler/Transform.js'
@@ -124,6 +125,7 @@ export async function create(options: create.Options): Promise<Runtime> {
   const manifestPath = Path.join(outDir, '.zyzz.json')
 
   const compiler = Graph.create()
+  const snapshot = Snapshot.create()
   const stylesheets = new WeakMap<Transform.compile.ReturnType, Stylesheet>()
   let closed = false
   let closing: Promise<void> | undefined
@@ -250,7 +252,7 @@ export async function create(options: create.Options): Promise<Runtime> {
           `Source path conflicts with host control files: ${name}`,
         )
 
-      sources[name] = await Fs.readFile(input, 'utf8')
+      sources[name] = await snapshot.read(input)
     }
 
     const modules = Object.fromEntries(
@@ -306,7 +308,7 @@ export async function create(options: create.Options): Promise<Runtime> {
 
       observe(`${file}.zyzz.json`)
       try {
-        contracts[file] = await Fs.readFile(`${file}.zyzz.json`, 'utf8')
+        contracts[file] = await snapshot.read(`${file}.zyzz.json`)
       } catch (error) {
         if (
           !required &&
@@ -363,7 +365,7 @@ export async function create(options: create.Options): Promise<Runtime> {
       const file = Path.join(root, name)
       const resolutions = (imports[moduleId] = Object.create(null))
 
-      for (const node of Syntax.parse({ moduleId, source }).program.body) {
+      for (const node of snapshot.parse({ moduleId, source }).program.body) {
         if (
           (node.type !== 'ImportDeclaration' &&
             node.type !== 'ExportNamedDeclaration' &&
@@ -439,6 +441,7 @@ export async function create(options: create.Options): Promise<Runtime> {
     }
 
     const graph = compiler.compile({
+      [Syntax.cache]: snapshot.programs(modules),
       compiler: options.compiler,
       native,
       modules,
@@ -446,6 +449,14 @@ export async function create(options: create.Options): Promise<Runtime> {
       imports,
     })
 
+    snapshot.retain(
+      new Set([
+        ...inputs,
+        ...Object.keys(contracts).map((file) => `${file}.zyzz.json`),
+      ]),
+      modules,
+    )
+
     const artifactNames = [
       'zyzz.css',
       'zyzz.css.map',
@@ -818,6 +829,7 @@ export async function create(options: create.Options): Promise<Runtime> {
 
     closing = (async () => {
       await tail
+      snapshot.clear()
       await lock.close()
       await Fs.rm(lockPath)
     })()