veryfront 0.1.1003 → 0.1.1004

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.1003",
+    "version": "0.1.1004",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "minimumDependencyAge": {

package/esm/src/discovery/transpiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/transpiler.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA6IvD;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAwGlB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}
+{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/transpiler.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA4MvD;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAgIlB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}

package/esm/src/discovery/transpiler.js

@@ -27,7 +27,50 @@ import * as evalMod from "../eval/index.js";
 import * as metricsMod from "../metrics/index.js";
 import * as schemasMod from "../schemas/index.js";
 import * as chatUploadsMod from "../chat/upload-handler.js";
+// Keyed by entry file + entry source hash; each entry additionally records the
+// bundled dependency contents it was built from and is only served while those
+// still match (see findCachedModuleWithFreshDeps).
 const transpileCache = new Map();
+const textEncoder = new TextEncoder();
+async function hashSource(source) {
+    const digest = await dntShim.crypto.subtle.digest("SHA-256", textEncoder.encode(source));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * Returns the first cached module whose recorded bundled-dependency contents
+ * still match what the current adapter serves. esbuild inlines relative
+ * imports into the bundle, so an unchanged entry file does not guarantee an
+ * unchanged module: a dependency edited by a new release (or differing between
+ * two projects that share the same entry source) must invalidate the entry.
+ */
+async function findCachedModuleWithFreshDeps(entries, context) {
+    const hashByPath = new Map();
+    for (const entry of entries) {
+        let depsMatch = true;
+        for (const dep of entry.deps) {
+            let hash = hashByPath.get(dep.path);
+            if (!hashByPath.has(dep.path)) {
+                try {
+                    const content = context.fsAdapter
+                        ? await context.fsAdapter.readFile(dep.path)
+                        : await createFileSystem().readTextFile(dep.path);
+                    hash = await hashSource(content);
+                }
+                catch {
+                    hash = undefined;
+                }
+                hashByPath.set(dep.path, hash);
+            }
+            if (hash === undefined || hash !== dep.hash) {
+                depsMatch = false;
+                break;
+            }
+        }
+        if (depsMatch)
+            return entry.module;
+    }
+    return undefined;
+}
 // Setup veryfront modules as globals for compiled binary support
 let veryfrontGlobalsInitialized = false;
 /**
@@ -57,7 +100,7 @@ async function ensureVeryfrontGlobals() {
 /**
  * Create an esbuild plugin for resolving files via fsAdapter
  */
-function createFsAdapterPlugin(fsAdapter) {
+function createFsAdapterPlugin(fsAdapter, onDependencyLoaded) {
     const existsCache = new Map();
     async function checkExists(filePath) {
         const cached = existsCache.get(filePath);
@@ -108,6 +151,7 @@ function createFsAdapterPlugin(fsAdapter) {
             build.onLoad({ filter: /.*/, namespace: "fsadapter" }, wrapWithCurrentContext(async (args) => {
                 try {
                     const content = await fsAdapter.readFile(args.path);
+                    onDependencyLoaded?.(args.path, content);
                     return {
                         contents: content,
                         loader: getEsbuildLoader(args.path),
@@ -131,9 +175,6 @@ function createFsAdapterPlugin(fsAdapter) {
  * Import and transpile a module for discovery
  */
 export async function importModule(file, context) {
-    const cached = transpileCache.get(file);
-    if (cached)
-        return cached;
     // Ensure veryfront modules are available as globals for compiled binaries
     await ensureVeryfrontGlobals();
     const filePath = file.replace("file://", "");
@@ -149,6 +190,20 @@ export async function importModule(file, context) {
             cause: error,
         });
     }
+    // The cache key must include the source content: a shared hosted runtime
+    // process serves many projects and releases, and the same relative path
+    // (e.g. "tools/foo.ts") recurs across them. A path-only key keeps serving
+    // the stale module after a deploy and can hand one project's module to
+    // another project's discovery. The entry hash alone is still not enough —
+    // bundled relative imports are inlined into the module — so cached entries
+    // are only served after their recorded dependency contents re-verify.
+    const cacheKey = `${file} ${await hashSource(source)}`;
+    const cachedEntries = transpileCache.get(cacheKey);
+    if (cachedEntries) {
+        const cached = await findCachedModuleWithFreshDeps(cachedEntries, context);
+        if (cached)
+            return cached;
+    }
     const loader = getEsbuildLoader(filePath);
     await ensureDefaultBundlerContracts();
     const { build } = await import("../extensions/bundler/index.js");
@@ -160,8 +215,16 @@ export async function importModule(file, context) {
     const relativeImports = isDeno && !isDenoCompiled && !hasFsAdapter
         ? [...source.matchAll(/from\s+["'](\.\.[^"']+)["']/g)].map((m) => m[1]).filter(Boolean)
         : [];
-    // Use fsAdapter plugin whenever a VFS adapter is available (regardless of runtime)
-    const plugins = hasFsAdapter ? [createFsAdapterPlugin(context.fsAdapter)] : [];
+    // Use fsAdapter plugin whenever a VFS adapter is available (regardless of
+    // runtime), recording every bundled dependency for cache re-validation.
+    const bundledDeps = [];
+    const plugins = hasFsAdapter
+        ? [
+            createFsAdapterPlugin(context.fsAdapter, (path, content) => {
+                bundledDeps.push({ path, content });
+            }),
+        ]
+        : [];
     const result = await build({
         bundle: true,
         write: false,
@@ -218,7 +281,10 @@ export async function importModule(file, context) {
         const moduleUrl = pathHelper.toFileUrl(tempFile);
         moduleUrl.searchParams.set("v", String(Date.now()));
         const module = await import(moduleUrl.href);
-        transpileCache.set(file, module);
+        const deps = await Promise.all(bundledDeps.map(async ({ path, content }) => ({ path, hash: await hashSource(content) })));
+        const entries = transpileCache.get(cacheKey) ?? [];
+        entries.push({ deps, module });
+        transpileCache.set(cacheKey, entries);
         return module;
     }
     finally {

package/esm/src/utils/version-constant.d.ts

@@ -1,3 +1,3 @@
 /** Shared version value. */
-export declare const VERSION = "0.1.1003";
+export declare const VERSION = "0.1.1004";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.1003";
+export const VERSION = "0.1.1004";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.1003",
+  "version": "0.1.1004",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",