veryfront 0.1.1237 → 0.1.1239

package/esm/src/rendering/orchestrator/module-loader/index.d.ts

@@ -22,7 +22,7 @@ export { fetchEsmModule, rewriteEsmPaths } from "./esm-rewriter.js";
  * @param useLocalAdapter - Whether to use local adapter for reading
  * @returns Path to the transformed module file
  */
-export declare function transformModuleWithDeps(filePath: string, tmpDir: string, localAdapter: RuntimeAdapter, config: ModuleLoaderConfig, useLocalAdapter?: boolean, lineage?: ReadonlySet<string>, cycleTargets?: Set<string>): Promise<string>;
+export declare function transformModuleWithDeps(filePath: string, tmpDir: string, localAdapter: RuntimeAdapter, config: ModuleLoaderConfig, useLocalAdapter?: boolean, lineage?: ReadonlySet<string>, cycleTargets?: Set<string>, unresolvedSpecifiers?: Set<string>): Promise<string>;
 export interface ModuleLoaderConfig {
     projectDir: string;
     projectId?: string;
@@ -53,6 +53,7 @@ export interface ModuleLoaderConfig {
  * message variants the runtimes surface for a missing `import()` target.
  */
 export declare function isMissingModuleError(error: unknown): boolean;
+export declare function isUnresolvedTenantImport(error: unknown, unresolvedSpecifiers: ReadonlySet<string>, rebuiltArtifactPath?: string): boolean;
 /**
  * Load a module by path, transforming it and its dependencies.
  *

package/esm/src/rendering/orchestrator/module-loader/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAmBzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAC;AAEhG,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAsBpD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAOpE;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,cAAc,EAC5B,MAAM,EAAE,kBAAkB,EAC1B,eAAe,UAAQ,EACvB,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,EAKxC,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,GACpC,OAAO,CAAC,MAAM,CAAC,CA6JjB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mEAAmE;IACnE,6BAA6B,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjE,yEAAyE;IACzE,uBAAuB,CAAC,EAAE,4BAA4B,CAAC;IACvD,0DAA0D;IAC1D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,yEAAyE;IACzE,UAAU,CAAC,EAAE,yBAAyB,CAAC;CACxC;AAyBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI5D;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAuGlC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAsBzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAC;AAKhG,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AA6CpD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAOpE;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,cAAc,EAC5B,MAAM,EAAE,kBAAkB,EAC1B,eAAe,UAAQ,EACvB,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,EAKxC,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,EAarC,oBAAoB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC5C,OAAO,CAAC,MAAM,CAAC,CAyLjB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mEAAmE;IACnE,6BAA6B,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjE,yEAAyE;IACzE,uBAAuB,CAAC,EAAE,4BAA4B,CAAC;IACvD,0DAA0D;IAC1D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,yEAAyE;IACzE,UAAU,CAAC,EAAE,yBAAyB,CAAC;CACxC;AAyBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI5D;AAkED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAC,EACzC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,OAAO,CAwBT;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA0JlC"}

package/esm/src/rendering/orchestrator/module-loader/index.js

@@ -13,12 +13,36 @@ import { getHttpBundleCacheDir, getMdxEsmCacheDir } from "../../../utils/cache-d
 import { join, toFileUrl } from "../../../platform/compat/path/index.js";
 import { invalidateMdxEsmModule } from "../../../transforms/mdx/esm-module-loader/cache/index.js";
 import { resolveModuleDependencies, rewriteResolvedDependencyImports, } from "./dependency-resolver.js";
-import { persistTransformedModule } from "./module-persistence.js";
+import { persistTransformedModule, readPersistedUnresolvedSpecifiers, } from "./module-persistence.js";
 import { transformModuleCodeWithCache } from "./module-transform-cache.js";
 import { buildModuleTransformCacheVariant, getModuleCacheKey, resolveCachedModulePath, } from "./module-cache-lookup.js";
-import { markBuildFailure } from "./build-failure.js";
+import { markBuildFailure, markTenantBuildFailure } from "./build-failure.js";
+import { MODULE_CACHE_MAX_ENTRIES } from "../../../utils/constants/cache.js";
+import { isTenantSourceBuildError } from "../../../errors/tenant-classification.js";
+import { rewriteSsrProjectAliasSpecifier } from "../../../transforms/import-rewriter/strategies/alias-strategy.js";
 export { isBuildFailure } from "./build-failure.js";
 const logger = rendererLogger.component("module-loader");
+/**
+ * Specifiers each transformed module subtree left as authored, keyed by the
+ * root module's transform cache key.
+ *
+ * The transform cache lets a module skip dependency resolution entirely, so the
+ * evidence has to outlive the resolution that produced it — otherwise a
+ * dependency's dangling tenant import is only ever visible on the very first
+ * transform. The memo uses the module cache's entry bound and refreshes access
+ * order on reads, while holding only specifier strings.
+ */
+const unresolvedSpecifiersByCacheKey = new Map();
+function cacheUnresolvedSpecifiers(cacheKey, specifiers) {
+    unresolvedSpecifiersByCacheKey.delete(cacheKey);
+    unresolvedSpecifiersByCacheKey.set(cacheKey, specifiers);
+    while (unresolvedSpecifiersByCacheKey.size > MODULE_CACHE_MAX_ENTRIES) {
+        const oldestKey = unresolvedSpecifiersByCacheKey.keys().next().value;
+        if (oldestKey === undefined)
+            break;
+        unresolvedSpecifiersByCacheKey.delete(oldestKey);
+    }
+}
 function throwIfModuleLoadAborted(config) {
     config.signal?.throwIfAborted();
 }
@@ -54,7 +78,20 @@ export async function transformModuleWithDeps(filePath, tmpDir, localAdapter, co
 // is copied per level): a descendant records a cycle target here, and the
 // ancestor that eventually persists that target reads it to write a stable
 // alias the left-as-authored cycle edge can resolve to.
-cycleTargets = new Set()) {
+cycleTargets = new Set(), 
+// Also shared by reference across the whole transform tree: every specifier
+// the dependency resolver could not resolve and therefore left as authored.
+// Those are the only specifiers that can survive into the built module and
+// fail at `import()` time, so this is the evidence that tells a tenant typo
+// apart from a framework artifact going missing. See `loadModule`.
+//
+// A module served from the cache below returns before
+// `resolveModuleDependencies` runs, so it cannot re-derive its own evidence.
+// That matters because the retry path invalidates only the *root* module's
+// cache entry: without a memo, a typo living in a dependency would go
+// unrecorded on every rebuild and never be attributed to the tenant. The
+// cache-hit branch therefore replays what the first resolution found.
+unresolvedSpecifiers = new Set()) {
     throwIfModuleLoadAborted(config);
     const { moduleCache, projectDir, projectId, contentSourceId, adapter, mode } = config;
     const cacheKey = getModuleCacheKey(filePath, projectId, projectDir, contentSourceId, config.reactVersion, mode, config.dependencyPinningCacheKey, config.moduleServerOrigin);
@@ -70,9 +107,24 @@ cycleTargets = new Set()) {
         moduleServerOrigin: config.moduleServerOrigin,
     });
     if (cachedPath) {
+        // Replay the evidence this module produced when it was last resolved. A
+        // cache hit skips `resolveModuleDependencies`, so without this a dependency
+        // that was already transformed contributes nothing and its tenant-authored
+        // dangling import silently loses attribution.
+        const memoizedUnresolvedSpecifiers = unresolvedSpecifiersByCacheKey.get(cacheKey);
+        const cachedUnresolvedSpecifiers = memoizedUnresolvedSpecifiers ??
+            await readPersistedUnresolvedSpecifiers(cachedPath, localAdapter);
+        cacheUnresolvedSpecifiers(cacheKey, cachedUnresolvedSpecifiers);
+        for (const specifier of cachedUnresolvedSpecifiers) {
+            unresolvedSpecifiers.add(specifier);
+        }
         markModuleLoadProgress(config, "module:cache-hit", filePath);
         return cachedPath;
     }
+    // Collect this module and every recursively transformed descendant into an
+    // isolated set. Once persistence succeeds, cache that complete subtree and
+    // merge it into the caller's aggregate evidence.
+    const moduleUnresolvedSpecifiers = new Set();
     const readAdapter = useLocalAdapter ? localAdapter : adapter;
     let fileContent = decodeFileContent(await readAdapter.fs.readFile(filePath));
     markModuleLoadProgress(config, "module:source-read", filePath);
@@ -115,7 +167,7 @@ cycleTargets = new Set()) {
             isLocalLib: dep.isLocalLib,
         });
         try {
-            const depTempPath = await transformModuleWithDeps(dep.depFilePath, tmpDir, localAdapter, config, dep.isLocalLib, nextLineage, cycleTargets);
+            const depTempPath = await transformModuleWithDeps(dep.depFilePath, tmpDir, localAdapter, config, dep.isLocalLib, nextLineage, cycleTargets, moduleUnresolvedSpecifiers);
             return { ...dep, depTempPath };
         }
         catch (error) {
@@ -124,6 +176,13 @@ cycleTargets = new Set()) {
             // branch must not fail the page that merely mentions it.
             if (!dep.isDynamic)
                 throw error;
+            // A tenant-source compile failure is deliberately non-fatal until this
+            // dynamic edge executes. The importer remains authored, so retain that
+            // provenance for the retry classification seam. Infrastructure errors
+            // stay framework-owned even if the resulting edge is later missing.
+            if (isTenantSourceBuildError(error)) {
+                moduleUnresolvedSpecifiers.add(dep.path);
+            }
             logger.warn("Leaving an unresolvable dynamic dependency as authored:", {
                 path: dep.path,
                 depFilePath: dep.depFilePath,
@@ -143,6 +202,7 @@ cycleTargets = new Set()) {
     for (const dep of resolvedDeps) {
         if (dep.depFilePath)
             continue;
+        moduleUnresolvedSpecifiers.add(dep.path);
         logger.warn("Could not find dependency:", {
             path: dep.path,
             relativePath: dep.relativePath,
@@ -179,7 +239,11 @@ cycleTargets = new Set()) {
         moduleServerOrigin: config.moduleServerOrigin,
         dependencyPinningCacheKey: config.dependencyPinningCacheKey,
         isCycleTarget: cycleTargets.has(filePath),
+        unresolvedSpecifiers: [...moduleUnresolvedSpecifiers],
     });
+    cacheUnresolvedSpecifiers(cacheKey, [...moduleUnresolvedSpecifiers]);
+    for (const specifier of moduleUnresolvedSpecifiers)
+        unresolvedSpecifiers.add(specifier);
     markModuleLoadProgress(config, "module:persisted", filePath);
     return persistedPath;
 }
@@ -214,6 +278,94 @@ export function isMissingModuleError(error) {
         return true;
     return /cannot find module|module not found/i.test(error.message);
 }
+/**
+ * Whether a module-not-found failure is a specifier the project authored that
+ * points at nothing, as opposed to framework infrastructure going missing.
+ *
+ * `isMissingModuleError` alone cannot answer this: an `ERR_MODULE_NOT_FOUND`
+ * is raised the same way for a tenant typo, an HTTP bundle miss, a cycle-break
+ * alias that did not resolve, and a rebuilt artifact the runtime failed to
+ * persist. Only the first is the tenant's fault, and only the first may be
+ * downgraded to a warning in observability.
+ *
+ * The discriminator is evidence rather than a guess: `resolveModuleDependencies`
+ * resolves only `@/` aliases and relative imports, and `transformModuleWithDeps`
+ * records every specifier it had to leave as authored. If it left none anywhere
+ * in this module's transform tree, then nothing tenant-authored survived
+ * unrewritten and whatever is missing here is framework-owned.
+ *
+ * Note the runtime reports the *resolved* path, which for a dropped relative
+ * specifier lands inside the build's own temp directory — so a "is this path
+ * ours?" test on the message would reject exactly the case this identifies.
+ */
+/**
+ * The specifier a module-not-found error names as missing.
+ *
+ * Runtimes report it as the first quoted token and then name the importer, so
+ * only the first quote pair identifies what is actually absent. The quote style
+ * differs by runtime and both reach this seam, since `isMissingModuleError`
+ * matches Node's phrasing as well as Deno's:
+ *
+ * - Deno:  `Module not found "file:///…/missing".`
+ * - Node:  `Cannot find module '/…/missing' imported from /…/page.js`
+ *
+ * Note Node leaves the importer unquoted, so a double-quote-only match would
+ * return `""` there and silently disable every check built on this.
+ */
+function missingModuleTarget(message) {
+    const match = message.match(/"([^"]*)"|'([^']*)'/);
+    return match?.[1] ?? match?.[2] ?? "";
+}
+function normalizeMissingModuleTarget(message) {
+    const target = missingModuleTarget(message).replace(/[?#].*$/, "");
+    if (target.startsWith("file://")) {
+        try {
+            return decodeURIComponent(new URL(target).pathname);
+        }
+        catch {
+            return target.replace(/^file:\/+/, "/");
+        }
+    }
+    return target;
+}
+function normalizeUnresolvedSpecifier(specifier) {
+    const withoutSuffix = specifier.replace(/[?#].*$/, "");
+    return (rewriteSsrProjectAliasSpecifier(withoutSuffix) ?? withoutSuffix)
+        .replace(/^(\.\/|\.\.\/)+/, "")
+        .replace(/^\/+/, "");
+}
+function missingTargetMatchesSpecifier(target, specifier) {
+    const normalizedSpecifier = normalizeUnresolvedSpecifier(specifier);
+    if (!normalizedSpecifier)
+        return false;
+    return target === normalizedSpecifier || target.endsWith(`/${normalizedSpecifier}`);
+}
+export function isUnresolvedTenantImport(error, unresolvedSpecifiers, rebuiltArtifactPath) {
+    if (!isMissingModuleError(error))
+        return false;
+    if (unresolvedSpecifiers.size === 0)
+        return false;
+    const message = error instanceof Error ? error.message : String(error);
+    // An HTTP bundle is framework infrastructure with dedicated recovery on the
+    // outer branch. A miss on one is not the tenant's doing even when the tenant
+    // separately has an unresolved import.
+    if (/veryfront-http-bundle\/http-[a-f0-9]+\.mjs/.test(message))
+        return false;
+    // The missing module can be the rebuilt artifact *itself* rather than one of
+    // its dependencies — a racing cache sweep or a failing cache volume can evict
+    // it between persist and import. That is repeated cache eviction, which must
+    // stay at error severity however the tenant's own imports look.
+    //
+    // Only the *missing target* may be compared, never the whole message: the
+    // runtime appends the importer's location, and at this seam the importer is
+    // always the rebuilt artifact, so scanning the full message would exclude
+    // every case including the tenant typo this predicate exists to catch.
+    if (rebuiltArtifactPath && missingModuleTarget(message).includes(rebuiltArtifactPath)) {
+        return false;
+    }
+    const missingTarget = normalizeMissingModuleTarget(message);
+    return [...unresolvedSpecifiers].some((specifier) => missingTargetMatchesSpecifier(missingTarget, specifier));
+}
 /**
  * Load a module by path, transforming it and its dependencies.
  *
@@ -228,9 +380,13 @@ export async function loadModule(filePath, config) {
     markModuleLoadProgress(config, "module:cache-ready", filePath);
     // Everything up to here compiles and resolves source, so a failure is a build
     // failure. Everything after it is the module running.
+    // Every specifier the resolver had to leave as authored, across this module's
+    // whole transform tree. Read back at the retry seam below to tell a tenant
+    // typo apart from framework infrastructure going missing.
+    const unresolvedSpecifiers = new Set();
     let tempFilePath;
     try {
-        tempFilePath = await transformModuleWithDeps(filePath, tmpDir, localAdapter, config);
+        tempFilePath = await transformModuleWithDeps(filePath, tmpDir, localAdapter, config, false, undefined, undefined, unresolvedSpecifiers);
     }
     catch (error) {
         throw markBuildFailure(error);
@@ -280,14 +436,41 @@ export async function loadModule(filePath, config) {
             // invalidation stays scoped to this tenant (the path-cache key is not
             // project-scoped — see invalidateMdxEsmModule).
             invalidateMdxEsmModule(tmpDir, filePath, config.projectDir, config.reactVersion, buildModuleTransformCacheVariant(config.dependencyPinningCacheKey, config.moduleServerOrigin));
+            // Classification at the retry seam must describe the rebuilt graph, not
+            // the artifact that just failed. A dependency may appear between the two
+            // transforms, so retaining its earlier dropped-specifier evidence can
+            // misattribute an unrelated retry failure to the tenant.
+            unresolvedSpecifiers.clear();
             let rebuiltPath;
             try {
-                rebuiltPath = await transformModuleWithDeps(filePath, tmpDir, localAdapter, config);
+                rebuiltPath = await transformModuleWithDeps(filePath, tmpDir, localAdapter, config, false, undefined, undefined, unresolvedSpecifiers);
             }
             catch (rebuildError) {
                 throw markBuildFailure(rebuildError);
             }
-            return await import(`${toFileUrl(rebuiltPath).href}?t=${Date.now()}&rebuilt=1`);
+            try {
+                return await import(`${toFileUrl(rebuiltPath).href}?t=${Date.now()}&rebuilt=1`);
+            }
+            catch (retryError) {
+                // The module was found and ran, so it threw at module scope. That is an
+                // ordinary application error the project's own error page should
+                // present, not a build failure — leave it untagged.
+                if (!isMissingModuleError(retryError))
+                    throw retryError;
+                // Still unresolved after a full rebuild from source, and the resolver
+                // recorded leaving a specifier as authored: a path the project wrote
+                // that points at nothing. Classify it explicitly, because
+                // `ERR_MODULE_NOT_FOUND` is not a VeryfrontError and slug-based
+                // classification cannot see it.
+                if (isUnresolvedTenantImport(retryError, unresolvedSpecifiers, rebuiltPath)) {
+                    throw markTenantBuildFailure(retryError);
+                }
+                // A resolution failure the tenant did not cause: an HTTP bundle miss, a
+                // cycle-break alias that did not resolve, or an artifact the rebuild
+                // failed to persist. Still a build failure, but a framework-owned one,
+                // so it keeps error-level severity.
+                throw markBuildFailure(retryError);
+            }
         }
         logger.error("Failed to import module:", {
             filePath,

package/esm/src/rendering/orchestrator/module-loader/module-persistence.d.ts

@@ -16,6 +16,8 @@ export interface PersistTransformedModuleInput {
     reactVersion?: string;
     dependencyPinningCacheKey?: string;
     moduleServerOrigin?: string;
+    /** Tenant-authored imports left unresolved in this module subtree. */
+    unresolvedSpecifiers?: readonly string[];
     /**
      * True when a dynamic import elsewhere closes a cycle back onto this module.
      * Such an edge is left as authored (`import("../app/page.js")`), so it needs a
@@ -23,6 +25,8 @@ export interface PersistTransformedModuleInput {
      */
     isCycleTarget?: boolean;
 }
+/** Read unresolved-import evidence stored beside a transformed artifact. */
+export declare function readPersistedUnresolvedSpecifiers(modulePath: string, localAdapter: RuntimeAdapter): Promise<readonly string[]>;
 /** Write a transformed module artifact and register cache pointers. */
 export declare function persistTransformedModule(input: PersistTransformedModuleInput): Promise<string>;
 //# sourceMappingURL=module-persistence.d.ts.map

package/esm/src/rendering/orchestrator/module-loader/module-persistence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-persistence.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/module-persistence.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAwDzE,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,cAAc,CAAC;IAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAqDD,uEAAuE;AACvE,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,MAAM,CAAC,CAmFjB"}
+{"version":3,"file":"module-persistence.d.ts","sourceRoot":"","sources":["../../../../../src/src/rendering/orchestrator/module-loader/module-persistence.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AA6DzE,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,cAAc,CAAC;IAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sEAAsE;IACtE,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,4EAA4E;AAC5E,wBAAsB,iCAAiC,CACrD,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,cAAc,GAC3B,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAmB5B;AA4ZD,uEAAuE;AACvE,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,MAAM,CAAC,CAgHjB"}