@exodus/stasis-plugins 1.0.0-beta.12 → 1.0.0-beta.14

package/src/rollup.js

@@ -6,12 +6,12 @@ import { dirname, isAbsolute, resolve as resolvePath } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
 import { Bundle } from '@exodus/stasis-core/bundle'
-import { resolvePluginState } from './plugins.js'
+import { attestedImport, resolvePluginState, unsupportedExtension } from './plugins.js'
 import { State } from '@exodus/stasis-core/state'
 // Pre-patch snapshot, not `import { readFile }`: under --fs=async that builtin is patched, and
 // this plugin loads after, so a direct import would route rollup's reads through the capture hook.
-import { realReadFile } from '@exodus/stasis-core/state-util'
-import { classifyExtension } from '@exodus/stasis-core/util'
+import { inScope, realReadFile } from '@exodus/stasis-core/state-util'
+import { classifyExtension, isPathWithin } from '@exodus/stasis-core/util'
 
 // Rollup chains resolveId/load hooks first-non-null-wins, so put this plugin FIRST in `plugins`:
 // listed later, a sibling resolver (node-resolve, commonjs) answers before stasis sees the edge --
@@ -145,20 +145,13 @@ export class StasisRollup {
   #classifyOrThrow(id) {
     const kind = classifyExtension(id, this.#resources)
     if (kind === 'unknown') {
-      throw new Error(
-        `StasisRollup: unsupported extension for '${id}' -- add its extension or filename to the plugin's resources option or stop importing it`
-      )
+      throw new Error(unsupportedExtension('StasisRollup', `'${id}'`))
     }
     return kind
   }
 
   #inRoot(path) {
-    try {
-      this.#state.relative(path)
-      return true
-    } catch {
-      return false
-    }
+    return isPathWithin(this.#state.root, path)
   }
 
   async #resolveId(ctx, source, importer, opts) {
@@ -191,21 +184,15 @@ export class StasisRollup {
       this.#assertPersistableAttributes(attrs)
       // Forward import attributes (`with { type: 'json' }`) so plugin-capture round-trips to
       // plugin-load, both keyed under `* (with: ...)`.
-      let url, format
-      try {
-        ;({ url, format } = this.#state.getImport(parentURL, source, { importAttributes: attrs }))
-      } catch (err) {
-        // No attested edge -- at a successful capture that's an EXTERNAL (never recorded as an
-        // edge), so hand it back to rollup. File BYTES still fail closed at the load hook.
-        // A non-MODULE_NOT_FOUND error is a real fault -- rethrow.
-        if (err?.code === 'ERR_MODULE_NOT_FOUND') return null
-        throw err
-      }
+      // No attested edge: rollup's. File BYTES still fail closed at the load hook.
+      const attested = attestedImport(this.#state, parentURL, source, { importAttributes: attrs })
+      if (attested === undefined) return null
+      const { url, format } = attested
       const path = fileURLToPath(url)
       // Refuse a resource only when load mode would actually serve it: an out-of-scope workspace
       // resource under node_modules scope comes from disk via the user's asset plugin, exactly
       // like a capture build (the load hook defers it with the same scope gate).
-      if (Bundle.isResourceFormat(format) && (this.#state.config.full || this.#state.inNodeModules(url))) {
+      if (Bundle.isResourceFormat(format) && inScope(this.#state, url)) {
         this.#refuseResourceLoad(path)
       }
       // KNOWN GAP: sibling resolution metadata (moduleSideEffects, syntheticNamedExports, meta)
@@ -253,7 +240,7 @@ export class StasisRollup {
       // a sibling's bare resolve() probe carries isEntry too but never loads, so only genuine
       // roots reach this gate.
       if (this.#state.config.full && ctx.getModuleInfo(id)?.isEntry) this.#state.assertEntry(url)
-      if (!this.#state.config.full && !this.#state.inNodeModules(url)) return null
+      if (!inScope(this.#state, url)) return null
       const { source, format } = this.#state.getFile(url)
       if (Bundle.isResourceFormat(format)) this.#refuseResourceLoad(id)
       // Code is stored as UTF-8 text, exactly what rollup's parser expects.

package/src/webpack.js

@@ -5,9 +5,9 @@ import { createRequire, isBuiltin } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
-import { resolvePluginState } from './plugins.js'
+import { attestedImport, resolvePluginState, unsupportedExtension } from './plugins.js'
 import { State } from '@exodus/stasis-core/state'
-import { realReadFileSync } from '@exodus/stasis-core/state-util'
+import { realReadFileSync, servedByBundle } from '@exodus/stasis-core/state-util'
 import { classifyExtension } from '@exodus/stasis-core/util'
 
 // CJS require anchored here, used only to locate the PROJECT's babel-plugin-module-resolver below.
@@ -95,14 +95,8 @@ export class StasisWebpack {
     const state = this.#state
     const orig = compiler.inputFileSystem
 
-    // True iff `p` is in scope for load mode. state.relative throws outside state.root (treated
-    // as out-of-scope: system files, scratch).
-    const inScope = (p) => {
-      if (typeof p !== 'string') return false
-      try { state.relative(p) } catch { return false }
-      if (state.config.full) return true
-      return state.inNodeModules(pathToFileURL(p).toString())
-    }
+    // True iff `p` is served from the bundle under load (servedByBundle).
+    const served = (p) => typeof p === 'string' && p !== '' && servedByBundle(state, p)
 
     // Family = the sidecar's own app-graph bundle first, then its parent (loaders + resolution-path
     // dirs the ambient preload captured). Both share one lockfile; no parent -> just [state].
@@ -121,7 +115,7 @@ export class StasisWebpack {
     // must keep `this` = orig; we override only readFile and stat.
     const wrappedReadFile = (p, options, callback) => {
       if (typeof options === 'function') { callback = options; options = undefined }
-      if (inScope(p)) {
+      if (served(p)) {
         try {
           const src = serveFromBundle(p)
           const buf = Buffer.isBuffer(src) ? src : Buffer.from(src)
@@ -136,7 +130,7 @@ export class StasisWebpack {
       return orig.readFile(p, options, callback)
     }
     const wrappedStat = (p, callback) => {
-      if (inScope(p)) {
+      if (served(p)) {
         // Directories have no bundle content, so serve a synthetic dir Stats from the family's
         // existence record (getFsStat) -- webpack's resolver stat()s intermediate dirs while walking.
         const url = pathToFileURL(p).toString()
@@ -168,21 +162,14 @@ export class StasisWebpack {
         const issuer = data.contextInfo?.issuer
         if (!issuer) return  // entries: already absolute, inputFileSystem covers them
         // Out-of-scope parents were never the bundle's responsibility -- defer to webpack's resolver.
-        if (!inScope(issuer)) return
+        if (!served(issuer)) return
         // Built-ins are never bundled or recorded as edges; skip up front. SECURITY: never consult
         // getImport for a builtin name, so a tampered bundle can't redirect `fs` to an arbitrary file.
         if (isBuiltin(data.request)) return
         const parentURL = pathToFileURL(issuer).toString()
-        let resolved
-        try {
-          resolved = state.getImport(parentURL, data.request)
-        } catch (err) {
-          // No attested edge -- at a successful capture that's an EXTERNAL (never recorded as an
-          // edge), so defer to webpack. File BYTES still fail closed at the inputFileSystem wrapper.
-          // A non-MODULE_NOT_FOUND error is a real fault -- rethrow.
-          if (err?.code === 'ERR_MODULE_NOT_FOUND') return
-          throw err
-        }
+        // No attested edge: defer to webpack. File BYTES still fail closed at the inputFileSystem wrapper.
+        const resolved = attestedImport(state, parentURL, data.request)
+        if (resolved === undefined) return
         // Redirect the resolver to the absolute bundle path; the stat wrapper then reports it exists.
         data.request = fileURLToPath(resolved.url)
       })
@@ -267,10 +254,7 @@ export class StasisWebpack {
 
         const kind = classifyExtension(filePath, this.#resources)
         if (kind === 'unknown') {
-          throw new Error(
-            `StasisWebpack: unsupported extension for '${filePath}' -- ` +
-            `add its extension or filename to the plugin's resources option or stop importing it`
-          )
+          throw new Error(unsupportedExtension('StasisWebpack', `'${filePath}'`))
         }
 
         const url = pathToFileURL(filePath).toString()