@animus-ui/extract 0.1.0 → 0.1.1

package/crates/extract-v2/index.d.ts

@@ -0,0 +1,104 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class ExtractEngine {
+  constructor(options?: EngineOptions | undefined | null)
+  /**
+   * Parse-once fact extraction over the file set; facts and sources are
+   * RETAINED on the handle for subsequent per-file calls. Returns the
+   * fact manifest (files + parseCount) as JSON.
+   */
+  analyze(fileEntriesJson: string): string
+  /** Reset all retained build state. */
+  clearCache(): void
+  get parseCount(): number
+  /**
+   * Per-file transformation from retained source + facts (no-config
+   * subset: variants/compounds/states; system/custom payloads need the
+   * row-07 config inputs and FAIL LOUD). Returns {code, hasComponents}
+   * JSON. Import decisions come from surviving chain/payload metadata;
+   * consumed-import stripping and directive handling are the ported v1
+   * semantics.
+   */
+  transformFile(path: string): string
+}
+
+/**
+ * Chain discovery over a file set: parse once per file (parallel), walk
+ * every stored AST, return owned facts. The v2 spine's first real surface;
+ * consumed by the parity comparison tooling.
+ */
+export declare function discoverChains(fileEntriesJson: string): string
+
+/**
+ * Engine options (row 07 Task 07.3 — replaces the RF-53 hardcodes).
+ * All fields optional; absent = v1 defaults.
+ */
+export interface EngineOptions {
+  /** Class-identity prefix (v1 default "animus"). */
+  prefix?: string
+  /** Runtime import source (v1 default "@animus-ui/system"). */
+  runtimeImport?: string
+  /** CSS virtual module id (v1 default "virtual:animus/styles.css"). */
+  cssModuleId?: string
+  /**
+   * System-props virtual module id (v1 EmitterConfig default
+   * "virtual:animus/system-props").
+   */
+  systemPropsModuleId?: string
+  /** Flat theme scales JSON (v1 analyzeProject `theme_json`). */
+  themeJson?: string
+  /** Token-alias variable map JSON (v1 `variable_map_json`). */
+  variableMapJson?: string
+  /** Contextual vars JSON (v1 `contextual_vars_json`). */
+  contextualVarsJson?: string
+  /** Prop config map JSON (v1 `config_json`). */
+  configJson?: string
+  /** Group registry JSON (v1 `group_registry_json`). */
+  groupRegistryJson?: string
+  /** Selector aliases JSON (v1 `selector_aliases_json`). */
+  selectorAliasesJson?: string
+  /** Global style blocks JSON (v1 `global_style_blocks_json`). */
+  globalStyleBlocksJson?: string
+  /**
+   * Keyframes blocks JSON (v1 `keyframes_blocks_json` — feeds BOTH the
+   * global sheet and the static keyframes registry, v1 Phase 2a).
+   */
+  keyframesJson?: string
+  /** Package resolution JSON (v1 `package_resolution_json`). */
+  packageResolutionJson?: string
+  /** Path aliases JSON (`{aliases: [...]}` wrapper, v1 shape). */
+  pathAliasesJson?: string
+  /** v1 `dev_mode`: retain all components (skip reconciliation pruning). */
+  devMode?: boolean
+}
+
+/**
+ * Build/probe identity: proves the v2 binary loads and its oxc linkage
+ * parses. Consumed by the dual-build verification and the parity harness
+ * engine registry.
+ */
+export declare function engineVersion(): string
+
+/**
+ * Full per-file fact extraction (increment 11): chains + eagerly evaluated
+ * stages + statics + raw usage facts + compose families — one parse per
+ * file. The store (and every AST) is dropped when this call returns; the
+ * D4-relevant invariant is that no program() read happens after
+ * cross-file facts resolve.
+ */
+export declare function extractFacts(fileEntriesJson: string): string
+
+export declare function loadSystemModule(systemPath: string, rootDir: string, exportName?: string | undefined | null): NapiSystemConfig
+
+export interface NapiSystemConfig {
+  propConfig: string
+  groupRegistry: string
+  scalesJson: string
+  variableMapJson: string
+  variableCss: string
+  contextualVarsJson: string
+  selectorAliases?: string
+  selectorOrder?: string
+  globalStyleBlocks?: string
+  keyframesBlocks?: string
+}

package/crates/extract-v2/index.js

@@ -0,0 +1,594 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./animus-extract-v2.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-android-arm64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./animus-extract-v2.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-android-arm-eabi')
+        const bindingPackageVersion = require('animus-extract-v2-binding-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+        return require('./animus-extract-v2.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-win32-x64-gnu')
+        const bindingPackageVersion = require('animus-extract-v2-binding-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./animus-extract-v2.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-win32-x64-msvc')
+        const bindingPackageVersion = require('animus-extract-v2-binding-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./animus-extract-v2.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-win32-ia32-msvc')
+        const bindingPackageVersion = require('animus-extract-v2-binding-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./animus-extract-v2.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-win32-arm64-msvc')
+        const bindingPackageVersion = require('animus-extract-v2-binding-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./animus-extract-v2.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('animus-extract-v2-binding-darwin-universal')
+      const bindingPackageVersion = require('animus-extract-v2-binding-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./animus-extract-v2.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-darwin-x64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./animus-extract-v2.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-darwin-arm64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./animus-extract-v2.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-freebsd-x64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./animus-extract-v2.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-freebsd-arm64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./animus-extract-v2.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-x64-musl')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./animus-extract-v2.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-x64-gnu')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./animus-extract-v2.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-arm64-musl')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./animus-extract-v2.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-arm64-gnu')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./animus-extract-v2.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-arm-musleabihf')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./animus-extract-v2.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./animus-extract-v2.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-loong64-musl')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./animus-extract-v2.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-loong64-gnu')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./animus-extract-v2.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-riscv64-musl')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./animus-extract-v2.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('animus-extract-v2-binding-linux-riscv64-gnu')
+          const bindingPackageVersion = require('animus-extract-v2-binding-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./animus-extract-v2.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-linux-ppc64-gnu')
+        const bindingPackageVersion = require('animus-extract-v2-binding-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./animus-extract-v2.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-linux-s390x-gnu')
+        const bindingPackageVersion = require('animus-extract-v2-binding-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./animus-extract-v2.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-openharmony-arm64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./animus-extract-v2.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-openharmony-x64')
+        const bindingPackageVersion = require('animus-extract-v2-binding-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./animus-extract-v2.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('animus-extract-v2-binding-openharmony-arm')
+        const bindingPackageVersion = require('animus-extract-v2-binding-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.0.1' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → force WASI fallback even if native loaded
+//   'error'                  → force WASI and throw if no WASI binding is found
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' || process.env.NAPI_RS_FORCE_WASI === 'error'
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./animus-extract-v2.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (forceWasi) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding || forceWasi) {
+    try {
+      wasiBinding = require('animus-extract-v2-binding-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (forceWasi) {
+        if (!wasiBindingError) {
+          wasiBindingError = err
+        } else {
+          wasiBindingError.cause = err
+        }
+        loadErrors.push(err)
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
+    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
+    error.cause = wasiBindingError
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = loadErrors.reduce((err, cur) => {
+      cur.cause = err
+      return cur
+    })
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.ExtractEngine = nativeBinding.ExtractEngine
+module.exports.discoverChains = nativeBinding.discoverChains
+module.exports.engineVersion = nativeBinding.engineVersion
+module.exports.extractFacts = nativeBinding.extractFacts
+module.exports.loadSystemModule = nativeBinding.loadSystemModule

package/dist/index.cjs

@@ -0,0 +1,393 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let fs = require("fs");
+let _animus_ui_properties = require("@animus-ui/properties");
+//#region pipeline/assemble-stylesheet.ts
+/**
+* The 7 Animus cascade layers. Always prefixed with `anm-` to avoid
+* collision with other frameworks' layer names (e.g., Tailwind's `base`).
+*/
+const ANIMUS_LAYERS = [
+	"anm-global",
+	"anm-base",
+	"anm-variants",
+	"anm-compounds",
+	"anm-states",
+	"anm-system",
+	"anm-custom"
+];
+/**
+* Build the `@layer` declaration line.
+*
+* When `isCustom` is false (default layers), uses ANIMUS_LAYERS directly.
+* When `isCustom` is true, passes names through as-is — the consumer already
+* wrote the final names including the `anm-` prefixed entries.
+*/
+function buildLayerDeclaration(layers, isCustom) {
+	return `@layer ${(isCustom ? layers : [...ANIMUS_LAYERS]).join(", ")};\n`;
+}
+/**
+* Validate that a consumer `layers` array contains all 7 Animus layers
+* in the correct relative order. Consumer layers may be interleaved.
+*
+* @throws Error with descriptive message on violation
+*/
+function validateLayerOrder(layers) {
+	const expected = [...ANIMUS_LAYERS];
+	let cursor = 0;
+	for (const layer of layers) if (cursor < expected.length && layer === expected[cursor]) cursor++;
+	if (cursor < expected.length) {
+		const missing = expected.slice(cursor);
+		const found = expected.slice(0, cursor);
+		if (!expected.every((l) => layers.includes(l))) {
+			const absent = expected.filter((l) => !layers.includes(l));
+			throw new Error(`[animus-extract] Custom layers missing required layers: ${absent.join(", ")}. All 7 Animus layers must be present: ${expected.join(", ")}`);
+		}
+		throw new Error(`[animus-extract] Custom layers have wrong order. Found ${found.join(", ")} but then expected ${missing[0]}. Required order: (${expected.join(" < ")}). You may interleave custom layers but must preserve this subsequence.`);
+	}
+}
+/**
+* Strip a leading `@layer ...;` declaration line from CSS if present.
+* The Rust crate embeds this in prod-mode output; we strip it so the
+* shared assembler controls placement.
+*/
+function stripLeadingLayerDeclaration(css) {
+	return css.replace(/^@layer\s+[^;{]+;\s*\n?/, "");
+}
+function assembleStylesheet(options) {
+	const hasCustomLayers = !!options.layers;
+	const layers = options.layers ?? ANIMUS_LAYERS;
+	if (options.layers) validateLayerOrder(options.layers);
+	const declaration = buildLayerDeclaration(layers, hasCustomLayers);
+	const variables = options.variableCss || "";
+	const componentCss = options.componentCss ? stripLeadingLayerDeclaration(options.componentCss) : "";
+	const body = [options.globalCss || "", componentCss].filter(Boolean).join("\n");
+	if (options.split) return {
+		declaration,
+		variables,
+		body
+	};
+	return [
+		declaration,
+		variables,
+		body
+	].filter(Boolean).join("\n");
+}
+//#endregion
+//#region pipeline/discover-packages.ts
+/**
+* Extract external DS package names from `includes` declarations in the system file.
+*
+* Supports two forms:
+*   - Primary (1.0+):  `createSystem({ includes: [identifier, ...] })` constructor arg
+*   - Legacy:          `.includes([identifier, ...])` chain method (RC migration fallback)
+*
+* For each identifier found, traces back to its import declaration and returns
+* the import specifier. Only packages explicitly declared via `includes` are treated
+* as external DS dependencies.
+*
+* Falls back to empty array if no `includes` declaration is found.
+*/
+function extractSystemFilePackages(systemFilePath) {
+	let source;
+	try {
+		source = (0, fs.readFileSync)(systemFilePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const identifiers = /* @__PURE__ */ new Set();
+	const constructorRegex = /createSystem\s*\(\s*\{[^}]*?\bincludes\s*:\s*\[([^\]]*)\]/gs;
+	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
+	const collectIdentifiers = (regex) => {
+		let match;
+		while ((match = regex.exec(source)) !== null) {
+			const inner = match[1];
+			for (const token of inner.split(",")) {
+				const id = token.trim();
+				if (id && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(id)) identifiers.add(id);
+			}
+		}
+	};
+	collectIdentifiers(constructorRegex);
+	collectIdentifiers(chainRegex);
+	if (identifiers.size === 0) return [];
+	const importMap = /* @__PURE__ */ new Map();
+	const importRegex = /^\s*import\s+(?:([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*)?(?:\{([^}]*)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from\s+['"]([^'"]+)['"]/gm;
+	let importMatch;
+	while ((importMatch = importRegex.exec(source)) !== null) {
+		const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
+		if (comboDefault) importMap.set(comboDefault, specifier);
+		if (defaultImport) importMap.set(defaultImport, specifier);
+		if (namedImports) for (const binding of namedImports.split(",")) {
+			const parts = binding.trim().split(/\s+as\s+/);
+			const localName = (parts[1] || parts[0]).trim();
+			if (localName) importMap.set(localName, specifier);
+		}
+	}
+	const packages = /* @__PURE__ */ new Set();
+	for (const id of identifiers) {
+		const specifier = importMap.get(id);
+		if (specifier && !specifier.startsWith(".")) {
+			const pkgName = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+			packages.add(pkgName);
+		}
+	}
+	return Array.from(packages);
+}
+//#endregion
+//#region pipeline/mdx-preprocessor.ts
+/**
+* MDX source preprocessor for the extraction pipeline.
+*
+* MDX files are first-class consumers of ds-built components but are not
+* directly parseable by OXC (which the scanner uses for .tsx/.jsx). This
+* module compiles MDX sources to scanner-consumable JSX using @mdx-js/mdx.
+*
+* @mdx-js/mdx is declared as `peerDependenciesMeta.optional` on the
+* plugin packages that import this module. The dynamic import with
+* .catch() ensures non-MDX consumers (who configure `extensions` to
+* exclude .mdx) never trigger the resolution — zero install-footprint
+* cost for them.
+*
+* The `DEFAULT_EXTENSIONS` constant is the shared source of truth for
+* both `@animus-ui/vite-plugin` and `@animus-ui/next-plugin`. Each plugin
+* imports it directly; independent redeclaration of default extensions
+* is considered a regression.
+*/
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mdx"
+];
+/**
+* Preprocess an MDX source string into scanner-consumable JSX.
+*
+* - Returns `{ kind: 'ok', source }` with JSX-compiled output on success.
+* - Returns `{ kind: 'missing-dep' }` if @mdx-js/mdx is not resolvable
+*   (consumer needs to install it).
+* - Returns `{ kind: 'error', error }` on compile failure (e.g. malformed
+*   MDX syntax). Plugins SHALL warn + skip affected files; the build
+*   continues with remaining files.
+*/
+async function preprocessMdx(source, filename) {
+	const mdxMod = await import("@mdx-js/mdx").catch(() => null);
+	if (mdxMod === null) return { kind: "missing-dep" };
+	try {
+		const vfile = await mdxMod.compile(source, {
+			outputFormat: "program",
+			development: false,
+			jsx: true
+		});
+		return {
+			kind: "ok",
+			source: `/* @mdx-source: ${filename} */\n${String(vfile)}`
+		};
+	} catch (err) {
+		return {
+			kind: "error",
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
+//#region pipeline/prefix.ts
+/**
+* Apply namespace prefix to a variable map, CSS variable declarations, and theme JSON.
+*
+* Variable map: `{ "colors.ember": "--color-ember" }` -> `{ "colors.ember": "--prefix-color-ember" }`
+* Variable CSS: `--color-ember: #FF2800` -> `--prefix-color-ember: #FF2800`
+*               `var(--color-ember)` -> `var(--prefix-color-ember)`
+* Theme JSON:   `{ "colors.ember": "var(--color-ember)" }` -> `{ "colors.ember": "var(--prefix-color-ember)" }`
+*/
+function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextualVarsJson) {
+	if (!prefix) return {
+		variableMapJson,
+		variableCss,
+		themeJson,
+		contextualVarsJson
+	};
+	const varRefRe = /var\(--([a-zA-Z][\w-]*)\)/g;
+	const map = JSON.parse(variableMapJson);
+	const prefixed = {};
+	for (const [key, varName] of Object.entries(map)) prefixed[key] = varName.startsWith("--") ? `--${prefix}-${varName.slice(2)}` : varName;
+	let css = variableCss;
+	css = css.replace(/--([a-zA-Z][\w-]*)\s*:/g, `--${prefix}-$1:`);
+	css = css.replace(varRefRe, `var(--${prefix}-$1)`);
+	const result = {
+		variableMapJson: JSON.stringify(prefixed),
+		variableCss: css
+	};
+	if (themeJson) result.themeJson = themeJson.replace(varRefRe, `var(--${prefix}-$1)`);
+	if (contextualVarsJson) {
+		const ctxVars = JSON.parse(contextualVarsJson);
+		const prefixedCtx = {};
+		for (const [scale, names] of Object.entries(ctxVars)) prefixedCtx[scale] = names.map((name) => `${prefix}-${name}`);
+		result.contextualVarsJson = JSON.stringify(prefixedCtx);
+	}
+	return result;
+}
+//#endregion
+//#region pipeline/utils.ts
+/** Convert camelCase CSS property names to kebab-case. */
+function camelToKebab(str) {
+	return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+//#endregion
+//#region pipeline/resolve-global-styles.ts
+/**
+* Resolve {scale.path} and {scale.path/alpha} token aliases in a CSS value string.
+* Mirrors the Rust theme_resolver's resolve_token_aliases logic.
+*/
+function resolveTokenAliases(value, flat, variableMap) {
+	if (!value.includes("{")) return value;
+	return value.replace(/\{([^}]+)\}/g, (_match, content) => {
+		const slashIdx = content.indexOf("/");
+		const tokenPath = slashIdx >= 0 ? content.slice(0, slashIdx) : content;
+		const alpha = slashIdx >= 0 ? Number.parseInt(content.slice(slashIdx + 1), 10) : null;
+		const flatKey = tokenPath;
+		let resolved;
+		if (variableMap[flatKey]) resolved = `var(${variableMap[flatKey]})`;
+		else if (flat[flatKey] != null) resolved = flat[flatKey];
+		else return `{${content}}`;
+		if (alpha === 0) return "transparent";
+		if (alpha != null && alpha !== 100) return `color-mix(in srgb, ${resolved} ${alpha}%, transparent)`;
+		return resolved;
+	});
+}
+/**
+* Resolve a single CSS value through prop config: scale lookup, transform, token aliases.
+*/
+function resolveValue(raw, config, flat, variableMap, transforms) {
+	let resolved = String(raw);
+	if (config?.scale) {
+		const key = config.scale + "." + raw;
+		if (flat[key] != null) resolved = flat[key];
+	}
+	if (config?.transform && transforms[config.transform]) {
+		const fn = transforms[config.transform];
+		const input = typeof resolved === "string" && !Number.isNaN(Number(resolved)) ? Number(resolved) : resolved;
+		resolved = String(fn(input));
+	}
+	return resolveTokenAliases(resolved, flat, variableMap);
+}
+/**
+* Resolve a block of selectors -> style objects using prop config + theme.
+* @keyframes selectors are resolved with full prop config support.
+*/
+function resolveBlock(selectors, propConfig, flat, variableMap, transforms) {
+	const rules = [];
+	for (const [selector, styleObj] of Object.entries(selectors)) {
+		if (selector.startsWith("@keyframes")) {
+			const frames = [];
+			for (const [pct, frameStyles] of Object.entries(styleObj)) if (typeof frameStyles === "object" && frameStyles !== null) {
+				const decls = [];
+				for (const [prop, raw] of Object.entries(frameStyles)) {
+					const cfg = propConfig[prop];
+					const cssProps = cfg?.properties?.length ? cfg.properties : cfg ? [cfg.property] : [prop];
+					const resolved = resolveValue(raw, cfg, flat, variableMap, transforms);
+					for (const cssProp of cssProps) decls.push(`    ${camelToKebab(cssProp)}: ${resolved};`);
+				}
+				frames.push(`  ${pct} {\n${decls.join("\n")}\n  }`);
+			}
+			rules.push(`${selector} {\n${frames.join("\n")}\n}`);
+			continue;
+		}
+		const decls = [];
+		for (const [prop, raw] of Object.entries(styleObj)) {
+			const config = propConfig[prop];
+			const cssProps = config?.properties?.length ? config.properties : config ? [config.property] : [prop];
+			const resolved = resolveValue(raw, config, flat, variableMap, transforms);
+			for (const cssProp of cssProps) decls.push(`  ${camelToKebab(cssProp)}: ${resolved};`);
+		}
+		if (decls.length) rules.push(`${selector} {\n${decls.join("\n")}\n}`);
+	}
+	return rules.join("\n\n");
+}
+/**
+* Resolve global style blocks into CSS strings.
+*
+* Takes the global style map (block name -> selectors -> props -> values),
+* resolves prop shorthand, scale lookups, transforms, and token aliases,
+* and returns a map of block name -> resolved CSS string.
+*/
+function resolveGlobalStyles(globalStyles, propConfig, flat, variableMap, transforms) {
+	const result = {};
+	for (const [name, block] of Object.entries(globalStyles)) {
+		const resolved = resolveBlock(block, propConfig, flat, variableMap, transforms);
+		if (resolved) result[name] = resolved;
+	}
+	return result;
+}
+//#endregion
+//#region pipeline/resolve-transforms.ts
+/**
+* Resolve __TRANSFORM__ placeholders in extracted CSS.
+*
+* Pattern: `__TRANSFORM__name__rawValue__` -> transform function result.
+* The Rust crate emits these placeholders for CSS values that require
+* JS transform functions (e.g., size, grid) which can't be evaluated in Rust.
+*/
+function resolveTransformPlaceholders(css, transforms) {
+	return css.replace(/__TRANSFORM__(\w+)__(.+?)__/g, (_, name, rawValue) => {
+		const fn = transforms[name];
+		if (!fn) return rawValue;
+		const result = fn(rawValue !== "" && !Number.isNaN(Number(rawValue)) ? Number(rawValue) : rawValue);
+		return typeof result === "object" ? JSON.stringify(result) : String(result);
+	});
+}
+//#endregion
+//#region pipeline/unit-fallback.ts
+/**
+* Append `px` to bare numeric values in CSS declarations for properties
+* that expect length units. Unitless properties are preserved as-is.
+* Numbers inside CSS function calls (cubic-bezier, rgb, calc, etc.) are skipped.
+*/
+function applyUnitFallback(css) {
+	return css.replace(/([a-z-]+)\s*:\s*([^;{}]+);/g, (match, prop, value) => {
+		if (_animus_ui_properties.UNITLESS_PROPERTIES.has(prop)) return match;
+		let depth = 0;
+		let fixed = "";
+		let i = 0;
+		while (i < value.length) if (value[i] === "(") {
+			depth++;
+			fixed += value[i];
+			i++;
+		} else if (value[i] === ")") {
+			depth--;
+			fixed += value[i];
+			i++;
+		} else if (depth > 0) {
+			fixed += value[i];
+			i++;
+		} else {
+			const numMatch = value.slice(i).match(/^(-?\d+\.?\d*)/);
+			if (numMatch) {
+				const num = numMatch[1];
+				const after = value[i + num.length];
+				if (after && /[a-z%]/i.test(after)) fixed += num;
+				else fixed += num + "px";
+				i += num.length;
+			} else {
+				fixed += value[i];
+				i++;
+			}
+		}
+		return fixed !== value ? `${prop}:${fixed};` : match;
+	});
+}
+//#endregion
+exports.ANIMUS_LAYERS = ANIMUS_LAYERS;
+exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
+exports.applyPrefix = applyPrefix;
+exports.applyUnitFallback = applyUnitFallback;
+exports.assembleStylesheet = assembleStylesheet;
+exports.camelToKebab = camelToKebab;
+exports.extractSystemFilePackages = extractSystemFilePackages;
+exports.preprocessMdx = preprocessMdx;
+exports.resolveGlobalStyles = resolveGlobalStyles;
+exports.resolveTokenAliases = resolveTokenAliases;
+exports.resolveTransformPlaceholders = resolveTransformPlaceholders;
+exports.resolveValue = resolveValue;
+exports.stripLeadingLayerDeclaration = stripLeadingLayerDeclaration;
+exports.validateLayerOrder = validateLayerOrder;

package/index-v2.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Type surface for the `@animus-ui/extract/engine-v2` subpath.
+ *
+ * The runtime entry (`index-v2.js`) is a hand-written CJS loader that assigns
+ * the whole napi binary to `module.exports` (`module.exports = loadNative()`)
+ * so it can fail loud with an actionable message when the binary is absent
+ * (extraction-diagnostics §V2 boundary error reporting). Because that whole-
+ * object assignment is opaque to `cjs-module-lexer`, the *value* has no
+ * statically-detectable named exports — so the value is typed opaquely here
+ * (`unknown`). Declaring the napi functions/class as named value exports would
+ * make `attw` report every one as missing at runtime ("Named exports").
+ *
+ * The napi-generated declarations at `crates/extract-v2/index.d.ts` describe
+ * the real shape; they are re-exposed as *type-only* members so consumers can
+ * still name the engine's types. The subpath is consumed via CJS `require`
+ * (see vite-plugin's `requireEngine`), which returns the full binding object.
+ *
+ * No `types` export condition is used for `./engine-v2` (root CLAUDE.md § Key
+ * Rules: bun's createRequire matches `types` as a runtime target and loads
+ * `.d.ts` as JS); TypeScript sibling-declaration substitution supplies these
+ * types from the `.js` entry instead.
+ */
+import type * as ExtractV2 from './crates/extract-v2/index';
+
+declare namespace engineV2 {
+  export type ExtractEngine = ExtractV2.ExtractEngine;
+  export type EngineOptions = ExtractV2.EngineOptions;
+  export type NapiSystemConfig = ExtractV2.NapiSystemConfig;
+}
+
+declare const engineV2: unknown;
+
+export = engineV2;

package/index-v2.js

@@ -0,0 +1,33 @@
+/**
+ * v2 engine loader. The npm surface stays @animus-ui/extract — one
+ * package, two engines; plugins select via the `engine` option.
+ *
+ * Fail-loud contract: a missing binary must produce an actionable
+ * error, never a silent fallback to the other engine
+ * (extraction-diagnostics §V2 boundary error reporting).
+ */
+const { existsSync } = require('fs');
+const { join } = require('path');
+
+function loadNative() {
+  const { platform, arch } = process;
+  const candidates = [
+    `animus-extract-v2.${platform}-${arch}.node`,
+    `animus-extract-v2.${platform}-${arch}-gnu.node`,
+    `animus-extract-v2.${platform}-${arch}-msvc.node`,
+  ];
+  for (const name of candidates) {
+    const p = join(__dirname, 'crates/extract-v2', name);
+    if (existsSync(p)) return require(p);
+  }
+  throw new Error(
+    `@animus-ui/extract engine v2: native binary not found for ${platform}-${arch} ` +
+      `(looked for ${candidates.join(', ')} under crates/extract-v2/). ` +
+      `Published releases ship this binary for darwin-arm64, linux-x64-gnu and ` +
+      `linux-arm64-gnu — reinstall the package, or set engine: 'v1' in the plugin ` +
+      `options as the escape hatch (this workspace's fixtures honor ANIMUS_ENGINE=v1). ` +
+      `In the animus workspace, build it with: vp run build:extract-v2.`
+  );
+}
+
+module.exports = loadNative();

package/index.js

@@ -3,7 +3,7 @@
 // @ts-nocheck
 /* auto-generated by NAPI-RS */
 
-const { readFileSync } = require('node:fs')
+const { readFileSync } = require('fs')
 let nativeBinding = null
 const loadErrors = []
 
@@ -33,7 +33,7 @@ const isMuslFromFilesystem = () => {
 
 const isMuslFromReport = () => {
   let report = null
-  if (typeof process.report?.getReport === 'function') {
+  if (process.report && typeof process.report.getReport === 'function') {
     process.report.excludeNetwork = true
     report = process.report.getReport()
   }
@@ -105,7 +105,7 @@ function requireNative() {
     }
   } else if (process.platform === 'win32') {
     if (process.arch === 'x64') {
-      if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
         try {
         return require('./animus-extract.win32-x64-gnu.node')
       } catch (e) {
@@ -525,23 +525,33 @@ function requireNative() {
 
 nativeBinding = requireNative()
 
-if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → force WASI fallback even if native loaded
+//   'error'                  → force WASI and throw if no WASI binding is found
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' || process.env.NAPI_RS_FORCE_WASI === 'error'
+
+if (!nativeBinding || forceWasi) {
   let wasiBinding = null
   let wasiBindingError = null
   try {
     wasiBinding = require('./animus-extract.wasi.cjs')
     nativeBinding = wasiBinding
   } catch (err) {
-    if (process.env.NAPI_RS_FORCE_WASI) {
+    if (forceWasi) {
       wasiBindingError = err
     }
   }
-  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  if (!nativeBinding || forceWasi) {
     try {
       wasiBinding = require('@animus-ui/extract-wasm32-wasi')
       nativeBinding = wasiBinding
     } catch (err) {
-      if (process.env.NAPI_RS_FORCE_WASI) {
+      if (forceWasi) {
         if (!wasiBindingError) {
           wasiBindingError = err
         } else {
@@ -560,17 +570,18 @@ if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
 
 if (!nativeBinding) {
   if (loadErrors.length > 0) {
-    throw new Error(
+    const error = new Error(
       `Cannot find native binding. ` +
         `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
         'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
-      {
-        cause: loadErrors.reduce((err, cur) => {
-          cur.cause = err
-          return cur
-        }),
-      },
     )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = loadErrors.reduce((err, cur) => {
+      cur.cause = err
+      return cur
+    })
+    throw error
   }
   throw new Error(`Failed to load native binding`)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animus-ui/extract",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Animus static CSS extraction pipeline (Rust/NAPI)",
   "keywords": [
     "animus",
@@ -24,7 +24,11 @@
     "index.js",
     "index.d.ts",
     "*.node",
-    "dist"
+    "dist",
+    "index-v2.js",
+    "index-v2.d.ts",
+    "crates/extract-v2/*.node",
+    "crates/extract-v2/index.d.ts"
   ],
   "main": "index.js",
   "types": "index.d.ts",
@@ -36,27 +40,33 @@
     },
     "./pipeline": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.mjs",
-      "default": "./dist/index.mjs"
+      "default": "./dist/index.cjs"
+    },
+    "./engine-v2": {
+      "import": "./index-v2.js",
+      "require": "./index-v2.js",
+      "default": "./index-v2.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "napi build --platform --release && bun run build:ts",
+    "build": "napi build --platform --release && bun run build:v2 && bun run build:ts",
+    "build:v1": "napi build --platform --release",
     "build:ts": "tsdown && tsgo -p tsconfig.build.json",
     "build:debug": "napi build --platform",
-    "compile": "tsgo -p tsconfig.build.json --noEmit"
+    "compile": "tsgo -p tsconfig.build.json --noEmit",
+    "build:v2": "cd crates/extract-v2 && bunx napi build --platform --release",
+    "build:v2:debug": "cd crates/extract-v2 && bunx napi build --platform"
   },
   "dependencies": {
-    "@animus-ui/properties": "0.1.0"
+    "@animus-ui/properties": "0.1.1"
   },
   "devDependencies": {
     "@animus-ui/system": "workspace:*",
     "@mdx-js/mdx": "^3.0.0",
-    "@napi-rs/cli": "^3.0.0"
+    "@napi-rs/cli": "^3.7.3"
   },
   "peerDependencies": {
     "@mdx-js/mdx": "^3.0.0"
@@ -67,9 +77,9 @@
     }
   },
   "optionalDependencies": {
-    "@animus-ui/extract-darwin-arm64": "0.1.0",
-    "@animus-ui/extract-linux-arm64-gnu": "0.1.0",
-    "@animus-ui/extract-linux-x64-gnu": "0.1.0"
+    "@animus-ui/extract-darwin-arm64": "0.1.1",
+    "@animus-ui/extract-linux-arm64-gnu": "0.1.1",
+    "@animus-ui/extract-linux-x64-gnu": "0.1.1"
   },
   "napi": {
     "binaryName": "animus-extract",