zyzz 0.0.7 → 0.0.9

package/src/compiler/Graph.ts

@@ -38,6 +38,8 @@ export declare namespace compile {
 
   /** Source modules available for relative import resolution. */
   type Options = {
+    /** Host entrypoints emit owned stylesheet effects without packed contracts. */
+    readonly [Stylesheets.entry]?: string | undefined
     /** Host syntax from the same immutable source snapshot. */
     readonly [Syntax.cache]?:
       | ReadonlyMap<string, Parser.ParseResult>
@@ -71,6 +73,8 @@ export declare namespace compile {
 
   /** Compiled modules and their direct source dependencies. */
   type ReturnType = {
+    /** Packed resources deduplicated by the host across scoped source outputs. */
+    readonly [Stylesheets.packed]?: readonly Stylesheets.Resource[]
     /** Versioned compiler-only JSON per module; publish beside the compiled entrypoint as <entry>.zyzz.json. */
     readonly contracts: Readonly<Record<string, string>>
     /** Direct static runtime source and library-contract dependencies, keyed by module identity. */
@@ -88,7 +92,7 @@ export declare namespace compile {
   }
 }
 
-/** Creates an isolated compiler that retains only the last successful graph. */
+/** Creates an isolated compiler with bounded extraction reuse across source graphs. */
 export function create(): create.ReturnType {
   let previous: Cache | undefined
 
@@ -112,6 +116,26 @@ export declare namespace create {
   }
 }
 
+type Extraction = {
+  dependencies: readonly string[]
+  extracted: Source.extract.ReturnType
+  inputs: ReadonlyMap<
+    string,
+    Source.extract.ReturnType | ReturnType<typeof Contract.read>
+  >
+  resolution: string
+  source: string
+}
+
+type Transformed = {
+  classes: Readonly<Record<string, string | undefined>>
+  extracted: Source.extract.ReturnType
+  owners: string
+  output: Transform.compile.ReturnType
+  schemes: boolean
+  themes: Readonly<Record<string, Theme.Definition>>
+}
+
 type Cache = {
   compiler: boolean
   composition: Css.compile.Options['composition']
@@ -119,9 +143,12 @@ type Cache = {
 
   contracts: string
   development: boolean
+  entry: string | undefined
   extracted: ReadonlyMap<string, Source.extract.ReturnType>
   libraries: Readonly<Record<string, ReturnType<typeof Contract.read>>>
   reset: string | undefined
+  retained: ReadonlyMap<string, Extraction>
+  transformed: ReadonlyMap<string, Transformed>
   resolutions: Readonly<Record<string, string>>
   native: compile.Options['native']
   result: compile.ReturnType
@@ -195,14 +222,15 @@ function build(options: compile.Options, cache?: Cache): Cache {
       ]),
   )
 
-  // File-set changes can alter extensionless resolution even without source edits.
+  // Host resolutions remain explicit when generated modules enter or leave the graph.
   const previous = (() => {
     if (
       cache &&
       cache.contracts === contracts &&
       cache.development === !!options.development &&
-      ids.length === Object.keys(cache.sources).length &&
-      ids.every((id) => Object.hasOwn(cache.sources, id))
+      (options.imports !== undefined ||
+        (ids.length === Object.keys(cache.sources).length &&
+          ids.every((id) => Object.hasOwn(cache.sources, id))))
     ) {
       return cache
     }
@@ -211,6 +239,8 @@ function build(options: compile.Options, cache?: Cache): Cache {
   })()
   if (
     previous &&
+    previous.entry === options[Stylesheets.entry] &&
+    ids.length === Object.keys(previous.sources).length &&
     Object.keys(resolutions).length ===
       Object.keys(previous.resolutions).length &&
     Object.entries(resolutions).every(
@@ -224,6 +254,8 @@ function build(options: compile.Options, cache?: Cache): Cache {
   )
     return previous
 
+  const retained = new Map(previous?.retained)
+  const transformed = new Map(previous?.transformed)
   const dependencies: Record<string, readonly string[]> = Object.create(null)
   const extracted = new Map<string, Source.extract.ReturnType>()
   const identifiers = new Map<string, Set<string>>()
@@ -365,29 +397,6 @@ function build(options: compile.Options, cache?: Cache): Cache {
     let direct: Ast.Node | undefined
     const stars: string[] = []
     for (const statement of program.body) {
-      if (
-        statement.type === 'ImportDeclaration' &&
-        statement.importKind !== 'type'
-      ) {
-        const target = resolve(moduleId, statement.source.value, statement)
-        if (!target) continue
-        for (const specifier of statement.specifiers) {
-          if (
-            specifier.type === 'ImportNamespaceSpecifier' ||
-            (specifier.type === 'ImportSpecifier' &&
-              specifier.importKind === 'type')
-          )
-            continue
-          const imported =
-            specifier.type === 'ImportDefaultSpecifier'
-              ? 'default'
-              : specifier.imported.type === 'Identifier'
-                ? specifier.imported.name
-                : specifier.imported.value
-          const value = constant(target, imported, next)
-          if (value) imports[specifier.local.name] = relocate(value, specifier)
-        }
-      }
       if (statement.type === 'ExportDefaultDeclaration' && name === 'default') {
         direct = statement.declaration
         exported = true
@@ -436,7 +445,47 @@ function build(options: compile.Options, cache?: Cache): Cache {
             .filter((value) => value !== undefined),
         ),
       ]
-      return candidates.length === 1 ? candidates[0] : undefined
+      const value = candidates.length === 1 ? candidates[0] : undefined
+      if (value || !stars.length) constants.set(key, value)
+      return value
+    }
+    if (
+      direct &&
+      [
+        'FunctionDeclaration',
+        'FunctionExpression',
+        'ArrowFunctionExpression',
+        'ClassDeclaration',
+        'ClassExpression',
+      ].includes(direct.type)
+    ) {
+      constants.set(key, undefined)
+      return undefined
+    }
+    for (const statement of program.body) {
+      if (
+        statement.type === 'ImportDeclaration' &&
+        statement.importKind !== 'type'
+      ) {
+        const target = resolve(moduleId, statement.source.value, statement)
+        if (!target) continue
+        for (const specifier of statement.specifiers) {
+          if (
+            specifier.type === 'ImportNamespaceSpecifier' ||
+            (specifier.type === 'ImportSpecifier' &&
+              specifier.importKind === 'type')
+          )
+            continue
+          const imported =
+            specifier.type === 'ImportDefaultSpecifier'
+              ? 'default'
+              : specifier.imported.type === 'Identifier'
+                ? specifier.imported.name
+                : specifier.imported.value
+          const value = constant(target, imported, next)
+          if (value) imports[specifier.local.name] = relocate(value, specifier)
+        }
+      }
     }
     const scope = new Scope.Tracker({ preserveExitedScopes: true })
     Walker.walk(program, { scopeTracker: scope })
@@ -602,21 +651,34 @@ function build(options: compile.Options, cache?: Cache): Cache {
 
     const source = options.modules[moduleId]!
 
+    const snapshot =
+      previous?.retained.get(moduleId) ??
+      (previous && Object.hasOwn(previous.sources, moduleId)
+        ? {
+            dependencies: previous.result.dependencies[moduleId]!,
+            extracted: previous.extracted.get(moduleId)!,
+            inputs: new Map(
+              previous.result.dependencies[moduleId]!.map((target) => [
+                target,
+                previous.libraries[target] ?? previous.extracted.get(target)!,
+              ]),
+            ),
+            resolution: previous.resolutions[moduleId]!,
+            source: previous.sources[moduleId]!,
+          }
+        : undefined)
     if (
-      previous &&
-      source === previous.sources[moduleId] &&
-      resolutions[moduleId] === previous.resolutions[moduleId] &&
-      previous.result.dependencies[moduleId]!.every(
-        (target) =>
-          Object.hasOwn(libraries, target) ||
-          visit(target) === previous.extracted.get(target),
+      snapshot &&
+      source === snapshot.source &&
+      resolutions[moduleId] === snapshot.resolution &&
+      snapshot.dependencies.every((target) =>
+        Object.hasOwn(libraries, target)
+          ? libraries[target] === snapshot.inputs.get(target)
+          : Object.hasOwn(options.modules, target) &&
+            visit(target) === snapshot.inputs.get(target),
       )
     ) {
-      return retain(
-        moduleId,
-        previous.extracted.get(moduleId)!,
-        previous.result.dependencies[moduleId]!,
-      )
+      return retain(moduleId, snapshot.extracted, snapshot.dependencies)
     }
 
     // Validate identity and syntax through the public source boundary before linking.
@@ -957,6 +1019,20 @@ function build(options: compile.Options, cache?: Cache): Cache {
 
     extracted.set(moduleId, result)
     dependencies[moduleId] = imports
+    retained.delete(moduleId)
+    retained.set(moduleId, {
+      dependencies: imports,
+      extracted: result,
+      inputs: new Map(
+        imports.map((target) => [
+          target,
+          libraries[target] ?? extracted.get(target)!,
+        ]),
+      ),
+      resolution: resolutions[moduleId]!,
+      source: options.modules[moduleId]!,
+    })
+    if (retained.size > 256) retained.delete(retained.keys().next().value!)
 
     for (const call of result.themeCalls)
       for (const name of new Set([
@@ -1072,6 +1148,9 @@ function build(options: compile.Options, cache?: Cache): Cache {
         ...(options.native.units && { units: { ...options.native.units } }),
       },
       reset: options.reset,
+      entry: options[Stylesheets.entry],
+      retained,
+      transformed,
       resolutions: Object.freeze(resolutions),
       result: Object.freeze({
         contracts: Object.freeze(
@@ -1248,16 +1327,58 @@ function build(options: compile.Options, cache?: Cache): Cache {
   }
 
   const sharedVisited = new Set<string>()
+  const packed: Stylesheets.Resource[] = []
 
   const shared = (() => {
     try {
-      const sharedSections = ids.flatMap((id) => reachable(id, sharedVisited))
+      const entry = options[Stylesheets.entry]
+      const packedSections =
+        entry === undefined
+          ? []
+          : (dependencies[entry] ?? [])
+              .filter((id) => Object.hasOwn(libraries, id))
+              .flatMap((id) => reachable(id, sharedVisited))
+      const sharedSections =
+        entry === undefined
+          ? ids.flatMap((id) => reachable(id, sharedVisited))
+          : (sections.get(entry) ?? [])
+      if (packedSections.length) {
+        // Validate combined ownership and ordering before splitting independently loaded resources.
+        Stylesheets.render([...packedSections, ...sharedSections])
+        for (const section of packedSections) {
+          packed.push({
+            id: JSON.stringify([section.owner, section.source, section.key]),
+            ...Stylesheets.render([section]),
+          })
+        }
+      }
       const resetSource =
         (options.reset === undefined ? undefined : 'zyzz/reset.css') ??
         resetOwners[0] ??
         sharedSections.find((section) => section.key === 'optional-reset-order')
           ?.source
 
+      if (packed.length) {
+        const order = Stylesheets.render([
+          ...(resetSource === undefined
+            ? []
+            : [
+                {
+                  source: resetSource,
+                  css: '',
+                  layers: layerNames.length
+                    ? layerNames.map((name) => ['reset', name])
+                    : [['reset']],
+                },
+              ]),
+          ...[...packedSections, ...sharedSections].map((section) => ({
+            ...section,
+            css: '',
+          })),
+        ])
+        if (order.css) packed.unshift({ ...order, id: order.css })
+      }
+
       return Stylesheets.render([
         ...(resetSource === undefined
           ? []
@@ -1406,12 +1527,26 @@ function build(options: compile.Options, cache?: Cache): Cache {
     ),
   )
 
+  const ownerSignature = JSON.stringify(owners)
+
   // Extraction visits dependencies first; their emitted classes must precede consumers.
   for (const moduleId of extracted.keys()) {
-    modules[moduleId] =
-      sameThemes &&
-      previous!.schemes === schemes &&
-      extracted.get(moduleId) === previous!.extracted.get(moduleId)
+    const cached = transformed.get(moduleId)
+    const reusable =
+      cached &&
+      cached.extracted === extracted.get(moduleId) &&
+      cached.schemes === schemes &&
+      Object.keys(cached.themes).length === names.length &&
+      names.every((name) => cached.themes[name] === themes[name]) &&
+      Object.entries(cached.classes).every(
+        ([name, value]) => styleClasses[name] === value,
+      ) &&
+      cached.owners === ownerSignature
+    modules[moduleId] = reusable
+      ? cached.output
+      : sameThemes &&
+          previous!.schemes === schemes &&
+          extracted.get(moduleId) === previous!.extracted.get(moduleId)
         ? previous!.result.modules[moduleId]!
         : Transform.compile({
             compiler: options.compiler,
@@ -1422,6 +1557,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
             schemes,
             source: options.modules[moduleId]!,
             [Themes.context]: {
+              parsed: parse({ moduleId, source: options.modules[moduleId]! }),
               extracted: Object.freeze({
                 ...extracted.get(moduleId)!,
                 vars: sharedThemes,
@@ -1432,13 +1568,39 @@ function build(options: compile.Options, cache?: Cache): Cache {
               styleClasses,
             },
           })
+    transformed.delete(moduleId)
+    transformed.set(moduleId, {
+      classes: Object.fromEntries(
+        extracted
+          .get(moduleId)!
+          .calls.flatMap((call) =>
+            (call.runtimeComposition ?? []).map((input) => [
+              input.name,
+              styleClasses[input.name],
+            ]),
+          ),
+      ),
+      extracted: extracted.get(moduleId)!,
+      owners: ownerSignature,
+      output: modules[moduleId]!,
+      schemes,
+      themes: sharedThemes,
+    })
+    if (transformed.size > 256)
+      transformed.delete(transformed.keys().next().value!)
     // Module-local checks cannot detect truncated ownership hashes colliding across files.
+    const emitted = new Set(
+      Array.from(
+        modules[moduleId]!.css.matchAll(/\.(z-[\w-]+)\{/g),
+        (match) => match[1],
+      ),
+    )
     for (const value of Object.values(modules[moduleId]!.classes))
       for (const name of value.split(' ')) {
         if (
           options.compiler === false ||
           !name.startsWith('z-') ||
-          !modules[moduleId]!.css.includes(`.${name}{`)
+          !emitted.has(name)
         )
           continue
 
@@ -1531,8 +1693,12 @@ function build(options: compile.Options, cache?: Cache): Cache {
     libraries: Object.freeze(libraries),
     native: undefined,
     reset: options.reset,
+    entry: options[Stylesheets.entry],
+    retained,
+    transformed,
     resolutions: Object.freeze(resolutions),
     result: Object.freeze({
+      ...(packed.length ? { [Stylesheets.packed]: packed } : {}),
       ...(sharedCss
         ? {
             sharedCss,
@@ -1543,7 +1709,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
         : {}),
       contracts: Object.freeze(
         Object.fromEntries(
-          ids
+          (options[Stylesheets.entry] === undefined ? ids : [])
             .filter(
               (id) =>
                 Object.keys(extracted.get(id)!.themeExports ?? {}).length ||

package/src/compiler/Transform.ts

@@ -96,7 +96,8 @@ export function compile(options: compile.Options): compile.ReturnType {
   }
 
   const module = new MagicString(options.source)
-  const program = Syntax.parse(options).program
+  const program = (options[Themes.context]?.parsed ?? Syntax.parse(options))
+    .program
 
   for (const call of extracted.contributionCalls ?? [])
     module.overwrite(

package/src/compiler/internal/Stylesheets.ts

@@ -17,6 +17,15 @@ export class ConflictError extends Error {
   override name = 'Stylesheets.ConflictError'
 }
 
+/** Selects module-owned effects when the host loads source dependencies separately. */
+export const entry = Symbol('stylesheet entry')
+
+/** Independently shared packed sections for hosts that load source modules separately. */
+export const packed = Symbol('packed stylesheets')
+
+/** One packed resource with stable source ownership for development updates. */
+export type Resource = ReturnType<typeof render> & { readonly id: string }
+
 /** Ordered CSS owned by one portable source module. */
 export type Section = {
   /** Isolated selector namespaces belonging to the source owner. */

package/src/internal/Value.ts

@@ -29,7 +29,10 @@ export type Accepted<style, properties> = {
 }
 
 type AcceptedValue<value, property extends PropertyKey, properties> =
-  Extract<value, `[${string}]` | `[${string}] !important`> extends never
+  Extract<
+    value,
+    `${string} !custom` | `${string} !custom !important`
+  > extends never
     ? AcceptedMember<Record<property, value>, properties>[property]
     : value extends unknown
       ? AcceptedMember<Record<property, value>, properties>[property]
@@ -37,22 +40,15 @@ type AcceptedValue<value, property extends PropertyKey, properties> =
 
 type AcceptedMember<style, properties> = {
   [property in keyof style]: property extends keyof properties
-    ? style[property] extends `[${infer value}]` | `[${infer value}] !important`
-      ?
-          | (property extends 'gridTemplateColumns' | 'gridTemplateRows'
-              ? style[property] extends LiteralAccepted<
-                  Pick<style, property>,
-                  Literal.Properties
-                >[property]
-                ? style[property]
-                : never
-              : never)
-          | (ScalarValue<value, property> extends LiteralAccepted<
-              Record<property, ScalarValue<value, property>>,
-              Literal.Properties
-            >[property]
-              ? style[property]
-              : never)
+    ? style[property] extends
+        | `${infer value} !custom`
+        | `${infer value} !custom !important`
+      ? ScalarValue<value, property> extends LiteralAccepted<
+          Record<property, ScalarValue<value, property>>,
+          Literal.Properties
+        >[property]
+        ? style[property]
+        : never
       : style[property] extends readonly [unknown, ...unknown[]]
         ? AcceptedArray<style[property], property, properties>
         : LiteralAccepted<Pick<style, property>, properties>[property]
@@ -135,15 +131,11 @@ type Fold<value> = value extends string
 /** Refines concrete scalar spellings; already-broad property contracts need no literal refinement. */
 export type Checked<style, tokens = {}> = {
   [property in keyof style]: style[property] extends
-    | `[${infer value}]`
-    | `[${infer value}] !important`
-    ?
-        | (property extends 'gridTemplateColumns' | 'gridTemplateRows'
-            ? LiteralChecked<Pick<style, property>>[property]
-            : never)
-        | LiteralChecked<
-            Record<property, ScalarValue<value, property>>
-          >[property]
+    | `${infer value} !custom`
+    | `${infer value} !custom !important`
+    ? value extends `${string} !${'custom' | 'important'}`
+      ? never
+      : LiteralChecked<Record<property, ScalarValue<value, property>>>[property]
     : style[property] extends readonly [unknown, ...unknown[]]
       ? CheckedArray<style[property], property, tokens>
       : LiteralChecked<Pick<style, property>, tokens>[property]
@@ -214,8 +206,8 @@ export type Tokens<
             | Token.Reference
             | Token.Variable
             | `${Token.Variable} !important`
-            | `[${string}]`
-            | `[${string}] !important`
+            | `${string} !custom`
+            | `${string} !custom !important`
         ? unknown
         : value extends Atom<Token.Names<tokens, property>>
           ? unknown
@@ -361,7 +353,7 @@ export type Fallbacks<atom> = atom | readonly [atom, ...atom[]]
 /** One declaration or a nonempty ordered sequence of declaration fallbacks. */
 export type Input<value> = Fallbacks<Atom<Exclude<value, undefined>>>
 
-/** Splits a trailing importance marker without interpreting quoted or escaped text. */
+/** Splits trailing custom and importance markers without interpreting quoted or escaped text. */
 export function parse(
   input: unknown,
   property: keyof Literal.Properties,
@@ -383,16 +375,6 @@ export function parse(
 
     const parts = [...input.parts]
     let remaining = text.length - String(parsed.value).length
-    if (parsed.custom) {
-      for (let index = 0; index < parts.length; index++) {
-        const part = parts[index]
-        if (part === '') continue
-        if (typeof part !== 'string') return undefined
-        parts[index] = part.slice(1)
-        break
-      }
-      remaining--
-    }
 
     for (let index = parts.length - 1; remaining > 0 && index >= 0; index--) {
       const part = parts[index]
@@ -434,37 +416,38 @@ export function parse(
       '',
     )
 
-    if (!escaped(marker) && (suffix === '' || suffix === 'important')) break
+    if (
+      !escaped(marker) &&
+      (suffix === '' || suffix === 'important' || suffix === 'custom')
+    )
+      break
 
     marker = marker === 0 ? -1 : input.lastIndexOf('!', marker - 1)
   }
 
-  if (marker < 0) {
-    if (bracketed(input))
-      return {
-        custom: true,
-        important: false,
-        value: scalar(input.slice(1, -1)),
-      }
-    return undefined
-  }
-  if (input.slice(marker - 1) !== ' !important' || escaped(marker - 1))
+  if (marker < 0) return undefined
+  const suffix = input.slice(marker - 1)
+  if (
+    (suffix !== ' !important' && suffix !== ' !custom') ||
+    escaped(marker - 1)
+  )
     return { invalid: true }
 
   let end = marker
-
   while (end > 0 && /[ \t\n\r\f]/.test(input[end - 1]!) && !escaped(end - 1))
     end--
 
   const body = input.slice(0, end)
-  const custom = bracketed(body)
-  const text = custom ? body.slice(1, -1) : body
-  const value = scalar(text)
+  if (!body) return { invalid: true }
+  const nested = parse(body, property)
+  if (nested && 'invalid' in nested) return nested
+  const custom = suffix === ' !custom'
+  if (nested && (custom || nested.important)) return { invalid: true }
 
   return {
-    ...(custom ? { custom: true } : {}),
-    important: true as const,
-    value,
+    ...(custom || nested?.custom ? { custom: true } : {}),
+    important: !custom,
+    value: nested?.value ?? scalar(body),
   }
 
   function scalar(text: string): number | string {
@@ -476,34 +459,3 @@ export function parse(
       : text
   }
 }
-
-/** Recognizes one enclosing pair without consuming native grid line lists. */
-function bracketed(value: string): boolean {
-  if (!value.startsWith('[') || !value.endsWith(']')) return false
-  let depth = 0
-  let quote = ''
-  for (let index = 0; index < value.length; index++) {
-    const character = value[index]!
-    if (character === '\\') {
-      index++
-      continue
-    }
-    if (quote) {
-      if (character === quote) quote = ''
-      continue
-    }
-    if (character === '/' && value[index + 1] === '*') {
-      const end = value.indexOf('*/', index + 2)
-      if (end < 0) return false
-      index = end + 1
-      continue
-    }
-    if (character === '"' || character === "'") {
-      quote = character
-      continue
-    }
-    if (character === '[') depth++
-    if (character === ']' && --depth === 0) return index === value.length - 1
-  }
-  return false
-}

package/src/metro/Graph.ts

@@ -1,7 +1,7 @@
 /** Reads a closed local source graph for native authoring without evaluating modules. @module */
 import * as Fs from 'node:fs'
 import * as Path from 'node:path'
-import * as Parser from 'oxc-parser'
+import * as Snapshot from '../node/internal/Snapshot.js'
 import type * as Graph from '../compiler/Graph.js'
 
 /** Collects relative source imports; package and asset imports remain owned by Metro. */
@@ -10,6 +10,7 @@ export function read(
   source: string,
   platform: string,
   root: string,
+  snapshot = Snapshot.create(),
 ) {
   const files = new Set<string>()
   const modules: Record<string, string> = Object.create(null)
@@ -31,7 +32,8 @@ export function read(
     modules[id] = source
     const resolved: Record<string, string | null> = Object.create(null)
     imports[id] = resolved
-    for (const statement of Parser.parseSync(filename, source).program.body) {
+    for (const statement of snapshot.parse({ moduleId: id, source }).program
+      .body) {
       if (
         !('source' in statement) ||
         !statement.source ||
@@ -62,7 +64,7 @@ export function read(
       )
       if (!target || !/\.[cm]?[jt]sx?$/.test(target)) continue
       resolved[specifier] = identity(target)
-      visit(target, Fs.readFileSync(target, 'utf8'))
+      visit(target, snapshot.readSync(target))
     }
   }
   visit(filename, source)