@agent-native/core 0.187.0 → 0.187.1-nightly-20260925003003

package/dist/db/embedded-runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Embedded host duty: the process-local claim that a real host product
+ * (`createAgentNativeEmbeddedPlugin()`) explicitly configured this process's
+ * database, including a legitimate `pglite:` URL for a packaged/desktop
+ * install.
+ *
+ * That install can set `NODE_ENV=production` and boots a real H3 app the
+ * same way a deployed Node/Docker server does (see `db/server-runtime.js`),
+ * so `assertHostedRuntimeDatabase()` cannot otherwise tell "the embedding
+ * host chose this database on purpose" apart from "a deploy silently fell
+ * back to it because nobody configured `DATABASE_URL`." Claimed with
+ * {@link markEmbeddedRuntimeAuthorized}.
+ *
+ * Its own module, mirroring `./migration-runtime.js`: `client.js` reads it,
+ * and keeping it dependency-free avoids adding one more stub to every
+ * `vi.mock("../db/client.js")` in the codebase.
+ */
+/** True once an embedding host has explicitly configured this process's database. */
+export declare function isEmbeddedRuntimeAuthorized(): boolean;
+/** Claim embedded-host duty. Idempotent; never unset for the life of the process. */
+export declare function markEmbeddedRuntimeAuthorized(): void;

package/dist/db/embedded-runtime.js

@@ -0,0 +1,27 @@
+/**
+ * Embedded host duty: the process-local claim that a real host product
+ * (`createAgentNativeEmbeddedPlugin()`) explicitly configured this process's
+ * database, including a legitimate `pglite:` URL for a packaged/desktop
+ * install.
+ *
+ * That install can set `NODE_ENV=production` and boots a real H3 app the
+ * same way a deployed Node/Docker server does (see `db/server-runtime.js`),
+ * so `assertHostedRuntimeDatabase()` cannot otherwise tell "the embedding
+ * host chose this database on purpose" apart from "a deploy silently fell
+ * back to it because nobody configured `DATABASE_URL`." Claimed with
+ * {@link markEmbeddedRuntimeAuthorized}.
+ *
+ * Its own module, mirroring `./migration-runtime.js`: `client.js` reads it,
+ * and keeping it dependency-free avoids adding one more stub to every
+ * `vi.mock("../db/client.js")` in the codebase.
+ */
+/** True once an embedding host has explicitly configured this process's database. */
+export function isEmbeddedRuntimeAuthorized() {
+    return (globalThis.__AGENT_NATIVE_EMBEDDED_RUNTIME__ ===
+        true);
+}
+/** Claim embedded-host duty. Idempotent; never unset for the life of the process. */
+export function markEmbeddedRuntimeAuthorized() {
+    globalThis.__AGENT_NATIVE_EMBEDDED_RUNTIME__ =
+        true;
+}

package/dist/db/migrations.js

@@ -301,6 +301,8 @@ export function runMigrations(migrationSource, options) {
                     }
                     catch (err) {
                         if (isPermissionError(err)) {
+                            if (isMigrationAuthorizedRuntime())
+                                throw err;
                             console.warn(`[db] Migration ${label} skipped - insufficient privilege: ${err.message}. ` +
                                 "Apply it with a database role that owns the table. Halting further migrations.", "\nStatement:", currentStatement);
                             break;

package/dist/db/server-runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Server-serving duty: the process-local claim that a real Nitro server
+ * instance has booted and is wiring its H3 app for real requests.
+ *
+ * Netlify/Lambda/Vercel each hand the process a platform env var that is only
+ * ever set during a real function invocation, never during a build. Bare
+ * Node/Docker has no such var — `NODE_ENV=production` alone is set by build
+ * and prerender steps too (see the Cloudflare Pages static-shell script in
+ * deploy/build.ts), so it cannot stand in for one. This flag is set from
+ * {@link import("../server/framework-request-handler.js").getH3App}, the one
+ * choke point every plugin — default or app-authored, on every preset —
+ * calls to register routes, the first time any nitroApp instance actually
+ * boots. A build never constructs a real nitroApp, so this never fires there.
+ *
+ * Its own module, mirroring `./migration-runtime.js`: `client.js` reads it,
+ * and keeping it dependency-free avoids adding one more stub to every
+ * `vi.mock("../db/client.js")` in the codebase.
+ */
+/** True once a real Nitro server instance has started wiring its H3 app. */
+export declare function isServerRuntimeStarted(): boolean;
+/** Claim server-serving duty. Idempotent; never unset for the life of the process. */
+export declare function markServerRuntimeStarted(): void;

package/dist/db/server-runtime.js

@@ -0,0 +1,26 @@
+/**
+ * Server-serving duty: the process-local claim that a real Nitro server
+ * instance has booted and is wiring its H3 app for real requests.
+ *
+ * Netlify/Lambda/Vercel each hand the process a platform env var that is only
+ * ever set during a real function invocation, never during a build. Bare
+ * Node/Docker has no such var — `NODE_ENV=production` alone is set by build
+ * and prerender steps too (see the Cloudflare Pages static-shell script in
+ * deploy/build.ts), so it cannot stand in for one. This flag is set from
+ * {@link import("../server/framework-request-handler.js").getH3App}, the one
+ * choke point every plugin — default or app-authored, on every preset —
+ * calls to register routes, the first time any nitroApp instance actually
+ * boots. A build never constructs a real nitroApp, so this never fires there.
+ *
+ * Its own module, mirroring `./migration-runtime.js`: `client.js` reads it,
+ * and keeping it dependency-free avoids adding one more stub to every
+ * `vi.mock("../db/client.js")` in the codebase.
+ */
+/** True once a real Nitro server instance has started wiring its H3 app. */
+export function isServerRuntimeStarted() {
+    return (globalThis.__AGENT_NATIVE_SERVER_RUNTIME__ === true);
+}
+/** Claim server-serving duty. Idempotent; never unset for the life of the process. */
+export function markServerRuntimeStarted() {
+    globalThis.__AGENT_NATIVE_SERVER_RUNTIME__ = true;
+}

package/dist/deploy/build.d.ts

@@ -33,6 +33,27 @@ export declare const CLOUDFLARE_MODULE_WORKER_ENTRY = "worker.mjs";
  */
 export declare function configureAwsAmplifyRuntimeOutput(serverDir: string, appDir: string, env?: NodeJS.ProcessEnv): void;
 export declare function configureAwsLambdaRuntimeOutput(serverDir: string, appDir: string, env?: NodeJS.ProcessEnv): void;
+/**
+ * Shims one already-read Cloudflare Pages output file's module-scope
+ * `setInterval` calls, sharing the Module preset's globalThis-keyed capture
+ * (`cloudflareModuleTimerShimPrefix` / `CF_MODULE_ORIG_SET_INTERVAL_KEY`)
+ * instead of a disconnected per-file mechanism.
+ *
+ * Pages used to prepend its own shim keyed on a per-file `var
+ * __origSetInterval`, captured independently by every chunk. Since the
+ * generated entry statically imports routes, actions, and plugins (they
+ * evaluate before the entry's own top-level code runs, same as any ES
+ * module's imports), a dependency chunk's shim neutered
+ * `globalThis.setInterval` before the entry's own `var` ever captured
+ * it — so the entry's "original" was already the neutered stub, and its
+ * restore call restored nothing. Sharing this capture with the Module
+ * preset's `__cfRestoreModuleTimers()` (already emitted into the generated
+ * entry by `cloudflareModuleTimerRestoreScript` — see `generateWorkerEntry`)
+ * fixes both: whichever chunk evaluates first captures the one true
+ * original, and every later chunk (including the entry) sees it's already
+ * captured and skips straight to neutering.
+ */
+export declare function shimCloudflarePagesModuleTimers(code: string): string;
 export declare function generateCloudflareModuleWorkerEntry(): string;
 export declare function patchCloudflareModuleNitroEntry(code: string): string;
 export declare function configureCloudflareModuleWorkerOutput(serverDir: string): void;
@@ -255,6 +276,14 @@ export declare function emitSingleTemplateNetlifyBackgroundFunction(projectCwd:
  */
 export declare function assertEmittedBackgroundFunctionOnDisk(destDir: string, functionName: string): void;
 export declare function emitSingleTemplateNetlifyIntegrationRecoveryFunction(projectCwd: string): void;
+/**
+ * Post-build patches for `cloudflare_module` server output. Recurses (via
+ * `walkServerJavaScriptFiles`) because esbuild/Nitro can emit a dependency at
+ * a nested path (e.g. `_libs/@agent-native/core.mjs`) — a flat `readdirSync`
+ * silently skips it, leaving its module-scope `setInterval` call unpatched,
+ * which Cloudflare rejects with error 10021.
+ */
+export declare function patchCloudflareModuleServerOutput(serverDir: string): void;
 /**
  * Nitro receives the React Router SSR build as prebuilt chunks, so its normal
  * dependency resolver cannot reliably fold the preserved bare `yjs` imports

package/dist/deploy/build.js

@@ -275,17 +275,21 @@ export function configureAwsAmplifyRuntimeOutput(serverDir, appDir, env = proces
 export function configureAwsLambdaRuntimeOutput(serverDir, appDir, env = process.env) {
     configureAwsRuntimeOutput(serverDir, appDir, "aws_lambda", env);
 }
-export function generateCloudflareModuleWorkerEntry() {
-    return `let handler;
-
-export * from "./index.mjs";
-
-async function loadHandler() {
-  handler ??= (await import("./index.mjs")).default;
-  return handler;
-}
-
-function initializeBindings(env) {
+/**
+ * JS source for a generated Cloudflare Worker entry's `initializeBindings(env)`
+ * helper, shared between the Module (`generateCloudflareModuleWorkerEntry`) and
+ * Pages (`generateWorkerEntry`) entries so they cannot drift apart.
+ *
+ * Setting `globalThis.__env__` is not optional decoration: it is the
+ * framework's canonical "this is a real Cloudflare invocation" signal
+ * (`hasCloudflareRuntime()` in db/client.ts, also read by `isNodeRuntime()` /
+ * `isCloudflareRuntime()` in shared/runtime.ts). The Pages entry used to copy
+ * bindings into `process.env` without ever setting `__env__`, which silently
+ * defeated every one of those checks on every Pages deploy — including the
+ * hosted-database guard, which never refused to open PGlite there.
+ */
+function cloudflareBindingsInitScript() {
+    return `function initializeBindings(env) {
   if (!env) return;
   globalThis.__env__ = env;
   globalThis.process = globalThis.process || { env: {} };
@@ -293,35 +297,127 @@ function initializeBindings(env) {
   for (const [key, value] of Object.entries(env)) {
     if (typeof value === "string") globalThis.process.env[key] = value;
   }
+}`;
+}
+/**
+ * Global-scope key Module's timer shim (see `cloudflareModuleTimerShimPrefix`
+ * in `buildWithNitro`'s post-build patch) uses to stash the real
+ * `setInterval` before neutering it. Cloudflare Workers loads each server
+ * chunk as its own ES module, so a chunk's own top-level `var` can't be read
+ * back from `worker.mjs` — the original has to be captured on `globalThis`
+ * instead, and only once, since `worker.mjs` always loads (and shims) first.
+ */
+const CF_MODULE_ORIG_SET_INTERVAL_KEY = "__cfModuleOrigSetInterval";
+const CF_MODULE_TIMER_SHIM_MARKER = "__cf_module_timer_shim__";
+/**
+ * Restores the real `setInterval`, captured by
+ * `cloudflareModuleTimerShimPrefix`. Callers must invoke this only after the
+ * shimmed dependency graph has actually been evaluated (e.g. after `await
+ * loadHandler()` in the Module entry, or unconditionally in the Pages entry,
+ * whose dependencies are all statically imported and so are already
+ * evaluated by the time any handler body runs) — calling it any earlier is a
+ * no-op on a cold isolate, since nothing has captured the original yet, and
+ * the shim then immediately re-neuters it during that later evaluation with
+ * nothing left to restore it again.
+ */
+function cloudflareModuleTimerRestoreScript() {
+    return `function __cfRestoreModuleTimers() {
+  if (typeof globalThis.${CF_MODULE_ORIG_SET_INTERVAL_KEY} !== "undefined") {
+    globalThis.setInterval = globalThis.${CF_MODULE_ORIG_SET_INTERVAL_KEY};
+  }
+}`;
+}
+/**
+ * Prepended (in `buildWithNitro`'s post-build patch) to every server chunk
+ * that calls `setInterval` at module scope — Cloudflare Workers disallows
+ * timer creation outside a request/handler context. Neuters the call and,
+ * the first time any chunk runs this, stashes the real `setInterval` on
+ * `globalThis` for `__cfRestoreModuleTimers` (see
+ * `cloudflareModuleTimerRestoreScript`) to hand back once a handler runs.
+ */
+function cloudflareModuleTimerShimPrefix() {
+    return (`/* ${CF_MODULE_TIMER_SHIM_MARKER} */` +
+        `if(typeof globalThis.${CF_MODULE_ORIG_SET_INTERVAL_KEY}==="undefined"){globalThis.${CF_MODULE_ORIG_SET_INTERVAL_KEY}=globalThis.setInterval;}` +
+        `globalThis.setInterval=function(){return{unref(){},ref(){},close(){}}};`);
+}
+/**
+ * Shims one already-read Cloudflare Pages output file's module-scope
+ * `setInterval` calls, sharing the Module preset's globalThis-keyed capture
+ * (`cloudflareModuleTimerShimPrefix` / `CF_MODULE_ORIG_SET_INTERVAL_KEY`)
+ * instead of a disconnected per-file mechanism.
+ *
+ * Pages used to prepend its own shim keyed on a per-file `var
+ * __origSetInterval`, captured independently by every chunk. Since the
+ * generated entry statically imports routes, actions, and plugins (they
+ * evaluate before the entry's own top-level code runs, same as any ES
+ * module's imports), a dependency chunk's shim neutered
+ * `globalThis.setInterval` before the entry's own `var` ever captured
+ * it — so the entry's "original" was already the neutered stub, and its
+ * restore call restored nothing. Sharing this capture with the Module
+ * preset's `__cfRestoreModuleTimers()` (already emitted into the generated
+ * entry by `cloudflareModuleTimerRestoreScript` — see `generateWorkerEntry`)
+ * fixes both: whichever chunk evaluates first captures the one true
+ * original, and every later chunk (including the entry) sees it's already
+ * captured and skips straight to neutering.
+ */
+export function shimCloudflarePagesModuleTimers(code) {
+    if (code.includes("setInterval") &&
+        !code.includes(CF_MODULE_TIMER_SHIM_MARKER)) {
+        return cloudflareModuleTimerShimPrefix() + code;
+    }
+    return code;
+}
+export function generateCloudflareModuleWorkerEntry() {
+    return `let handler;
+
+async function loadHandler() {
+  handler ??= (await import("./index.mjs")).default;
+  return handler;
 }
 
+${cloudflareBindingsInitScript()}
+
+${cloudflareModuleTimerRestoreScript()}
+
 export default {
   async fetch(request, env, ctx) {
     if (typeof ctx?.waitUntil === "function") {
       request.waitUntil = ctx.waitUntil.bind(ctx);
     }
     initializeBindings(env);
-    return (await loadHandler()).fetch(request, env, ctx);
+    const h = await loadHandler();
+    __cfRestoreModuleTimers();
+    return h.fetch(request, env, ctx);
   },
   async scheduled(controller, env, ctx) {
     initializeBindings(env);
-    return (await loadHandler()).scheduled?.(controller, env, ctx);
+    const h = await loadHandler();
+    __cfRestoreModuleTimers();
+    return h.scheduled?.(controller, env, ctx);
   },
   async email(message, env, ctx) {
     initializeBindings(env);
-    return (await loadHandler()).email?.(message, env, ctx);
+    const h = await loadHandler();
+    __cfRestoreModuleTimers();
+    return h.email?.(message, env, ctx);
   },
   async queue(batch, env, ctx) {
     initializeBindings(env);
-    return (await loadHandler()).queue?.(batch, env, ctx);
+    const h = await loadHandler();
+    __cfRestoreModuleTimers();
+    return h.queue?.(batch, env, ctx);
   },
   async tail(traces, env, ctx) {
     initializeBindings(env);
-    return (await loadHandler()).tail?.(traces, env, ctx);
+    const h = await loadHandler();
+    __cfRestoreModuleTimers();
+    return h.tail?.(traces, env, ctx);
   },
   async trace(traces, env, ctx) {
     initializeBindings(env);
-    return (await loadHandler()).trace?.(traces, env, ctx);
+    const h = await loadHandler();
+    __cfRestoreModuleTimers();
+    return h.trace?.(traces, env, ctx);
   },
 };
 `;
@@ -1899,21 +1995,23 @@ ${includeReactRouterSsr
   return _handler;
 }
 
+${cloudflareBindingsInitScript()}
+
+${cloudflareModuleTimerRestoreScript()}
+
 export default {
   async fetch(request, env, ctx) {
     // Attach the request-scoped continuation hook before any URL rewrite.
     if (typeof ctx?.waitUntil === "function") {
       request.waitUntil = ctx.waitUntil.bind(ctx);
     }
-    if (env) {
-      globalThis.process = globalThis.process || { env: {} };
-      globalThis.process.env = globalThis.process.env || {};
-      for (const [key, value] of Object.entries(env)) {
-        if (typeof value === "string") {
-          globalThis.process.env[key] = value;
-        }
-      }
-    }
+    initializeBindings(env);
+    // Unlike the Module entry, every dependency here is statically imported
+    // (see routeImports/actionImports above), so patchCloudflareModuleServerOutput's
+    // shim has already run — and already re-neutered setInterval — by the
+    // time this handler body executes. No loadHandler()-style deferred
+    // import to wait on: restoring here is always safe and always needed.
+    __cfRestoreModuleTimers();
 
     // Try serving static assets first (CF Pages advanced mode).
     // Only attempt this for GET/HEAD — the ASSETS binding is a static file
@@ -2492,7 +2590,6 @@ async function buildCloudflarePages() {
     const allJsFiles = getAllJsFiles(workerOutDir);
     for (const jsFile of allJsFiles) {
         let code = fs.readFileSync(jsFile, "utf-8");
-        const isEntry = path.basename(jsFile) === "index.js";
         // Strip "node:" prefix from all imports/requires. Cloudflare Pages
         // Functions runs under nodejs_compat v1, which exposes builtins as
         // bare names ("fs") and rejects "node:fs" at worker init:
@@ -2527,20 +2624,7 @@ async function buildCloudflarePages() {
         // prefix preserved (for nodejs_compat_v2), the latter is what esbuild now emits.
         code = code.replace(/\bimport\s*\{\s*createRequire\s+as\s+([\w$]+)\s*\}\s*from\s*["'](?:node:)?module["']\s*;/g, "var $1 = function() { return typeof require !== 'undefined' ? require : function(m) { throw new Error('require not supported: ' + m); }; };");
         // Patch setInterval/setTimeout at module scope — CF Workers disallows timers in global scope.
-        // Some dependencies (e.g. Anthropic SDK rate limiter) call setInterval at module init.
-        // With code splitting, chunks evaluate before the entry, so the shim must be in every file.
-        // The restore only happens in the entry's fetch() handler.
-        if (!code.includes("__origSetInterval")) {
-            const timerShim = [
-                "var __origSetInterval=globalThis.setInterval;",
-                "globalThis.setInterval=function(){return{unref(){},ref(){},close(){}}};",
-            ].join("");
-            code = timerShim + code;
-        }
-        if (isEntry) {
-            const timerRestore = "if(__origSetInterval)globalThis.setInterval=__origSetInterval;";
-            code = code.replace(/async fetch\(request,\s*env,\s*ctx\)\s*\{/, (match) => match + timerRestore);
-        }
+        code = shimCloudflarePagesModuleTimers(code);
         assertNoCloudflareWorkerStubDynamicImports(code, jsFile);
         fs.writeFileSync(jsFile, code);
     }
@@ -3827,6 +3911,82 @@ function walkServerJavaScriptFiles(dir, onFile) {
             onFile(entryPath);
     }
 }
+const CF_MODULE_NODE_BUILTINS = [
+    "fs",
+    "path",
+    "os",
+    "crypto",
+    "http",
+    "https",
+    "stream",
+    "url",
+    "util",
+    "events",
+    "buffer",
+    "console",
+    "querystring",
+    "zlib",
+    "net",
+    "tls",
+    "assert",
+    "timers",
+    "child_process",
+    "module",
+    "process",
+    "worker_threads",
+    "string_decoder",
+    "diagnostics_channel",
+    "async_hooks",
+    "perf_hooks",
+    "inspector",
+    "vm",
+];
+/**
+ * Post-build patches for `cloudflare_module` server output. Recurses (via
+ * `walkServerJavaScriptFiles`) because esbuild/Nitro can emit a dependency at
+ * a nested path (e.g. `_libs/@agent-native/core.mjs`) — a flat `readdirSync`
+ * silently skips it, leaving its module-scope `setInterval` call unpatched,
+ * which Cloudflare rejects with error 10021.
+ */
+export function patchCloudflareModuleServerOutput(serverDir) {
+    if (!fs.existsSync(serverDir))
+        return;
+    walkServerJavaScriptFiles(serverDir, (filePath) => {
+        let code = fs.readFileSync(filePath, "utf-8");
+        let changed = false;
+        // 1. Rewrite bare Node.js imports to node: prefixed.
+        // CF Workers requires the node: prefix for built-in modules.
+        for (const mod of CF_MODULE_NODE_BUILTINS) {
+            // Match: from"fs" or from "fs" (but not from"node:fs")
+            const re = new RegExp(`from\\s*["']${mod}["']`, "g");
+            if (re.test(code)) {
+                code = code.replace(re, `from"node:${mod}"`);
+                changed = true;
+            }
+        }
+        // 2. Patch import.meta.url for createRequire().
+        // React Router's server build uses createRequire(import.meta.url)
+        // but import.meta.url is undefined on CF Workers.
+        if (code.includes("import.meta.url")) {
+            code = code.replace(/import\.meta\.url/g, '"file:///worker.mjs"');
+            changed = true;
+        }
+        // 3. Patch setInterval/setTimeout at global scope.
+        // CF Workers disallows timers in global scope. Shim every matching
+        // chunk; only worker.mjs restores the real function, from inside its
+        // own handlers (baked into generateCloudflareModuleWorkerEntry), never
+        // via an immediate per-chunk restore — a chunk loaded ahead of
+        // worker.mjs's handlers running would otherwise leave setInterval
+        // neutered for the rest of the request.
+        if (code.includes("setInterval") &&
+            !code.includes(CF_MODULE_TIMER_SHIM_MARKER)) {
+            code = cloudflareModuleTimerShimPrefix() + code;
+            changed = true;
+        }
+        if (changed)
+            fs.writeFileSync(filePath, code);
+    });
+}
 /**
  * Nitro receives the React Router SSR build as prebuilt chunks, so its normal
  * dependency resolver cannot reliably fold the preserved bare `yjs` imports
@@ -5212,86 +5372,9 @@ export default bundle;
     // Cloudflare-specific post-build patches
     if (preset.startsWith("cloudflare")) {
         const serverDir2 = nitro.options.output.serverDir;
-        const scanDirs = [serverDir2];
-        if (serverDir2) {
-            const chunksDir = path.join(serverDir2, "_chunks");
-            const libsDir = path.join(serverDir2, "_libs");
-            if (fs.existsSync(chunksDir))
-                scanDirs.push(chunksDir);
-            if (fs.existsSync(libsDir))
-                scanDirs.push(libsDir);
-        }
-        for (const scanDir of scanDirs) {
-            if (!scanDir || !fs.existsSync(scanDir))
-                continue;
-            for (const file of fs.readdirSync(scanDir)) {
-                if (!file.endsWith(".mjs") && !file.endsWith(".js"))
-                    continue;
-                const filePath = path.join(scanDir, file);
-                let code = fs.readFileSync(filePath, "utf-8");
-                let changed = false;
-                // 1. Rewrite bare Node.js imports to node: prefixed.
-                // CF Workers requires the node: prefix for built-in modules.
-                const NODE_BUILTINS = [
-                    "fs",
-                    "path",
-                    "os",
-                    "crypto",
-                    "http",
-                    "https",
-                    "stream",
-                    "url",
-                    "util",
-                    "events",
-                    "buffer",
-                    "console",
-                    "querystring",
-                    "zlib",
-                    "net",
-                    "tls",
-                    "assert",
-                    "timers",
-                    "child_process",
-                    "module",
-                    "process",
-                    "worker_threads",
-                    "string_decoder",
-                    "diagnostics_channel",
-                    "async_hooks",
-                    "perf_hooks",
-                    "inspector",
-                    "vm",
-                ];
-                for (const mod of NODE_BUILTINS) {
-                    // Match: from"fs" or from "fs" (but not from"node:fs")
-                    const re = new RegExp(`from\\s*["']${mod}["']`, "g");
-                    if (re.test(code)) {
-                        code = code.replace(re, `from"node:${mod}"`);
-                        changed = true;
-                    }
-                }
-                // 2. Patch import.meta.url for createRequire().
-                // React Router's server build uses createRequire(import.meta.url)
-                // but import.meta.url is undefined on CF Workers.
-                if (code.includes("import.meta.url")) {
-                    code = code.replace(/import\.meta\.url/g, '"file:///worker.mjs"');
-                    changed = true;
-                }
-                // 3. Patch setInterval/setTimeout at global scope.
-                // CF Workers disallows timers in global scope.
-                if (code.includes("setInterval") && !code.includes("__timer_shim__")) {
-                    const shim = "/* __timer_shim__ */" +
-                        "var __origSetInterval=globalThis.setInterval;" +
-                        "globalThis.setInterval=function(){return{unref(){},ref(){},close(){}}};";
-                    const restore = ";(function(){if(typeof __origSetInterval!=='undefined')globalThis.setInterval=__origSetInterval})();";
-                    code = shim + code + "\n" + restore;
-                    changed = true;
-                }
-                if (changed)
-                    fs.writeFileSync(filePath, code);
-            }
-        }
-        // 3. Create stub modules in _libs/ for native deps that Nitro's rolldown
+        if (serverDir2)
+            patchCloudflareModuleServerOutput(serverDir2);
+        // Create stub modules in _libs/ for native deps that Nitro's rolldown
         // bundler references but can't resolve on CF Workers, and rewrite
         // bare imports to point to the stub files.
         const libsDir2 = path.join(serverDir2 || path.join(cwd, "dist", "_worker.js"), "_libs");

package/dist/feature-flags/index.d.ts

@@ -1,2 +1,2 @@
-export { CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, } from "./registry.js";
+export { BUILDER_CREDIT_USAGE_REPORTING_FLAG, CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, } from "./registry.js";
 export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./store.js";

package/dist/feature-flags/index.js

@@ -1,4 +1,4 @@
-export { CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, } from "./registry.js";
+export { BUILDER_CREDIT_USAGE_REPORTING_FLAG, CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, } from "./registry.js";
 export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, } from "./store.js";
 // Plugin and A2A auth stay on `./server` and `@agent-native/core/server`.
 // Re-exporting them here pulls HMAC Node builtins into any Vite client that

package/dist/feature-flags/registry.d.ts

@@ -10,6 +10,7 @@ export interface FeatureFlagDefinition {
 export declare function defineFeatureFlag(definition: FeatureFlagDefinition): FeatureFlagDefinition;
 /** Framework-owned labs flag available to every app's feature-flag plugin. */
 export declare const CONNECT_APPS_FLAG: FeatureFlagDefinition;
+export declare const BUILDER_CREDIT_USAGE_REPORTING_FLAG: FeatureFlagDefinition;
 /** Define a small app-owned feature-flag registry. */
 export declare function defineFeatureFlags(definitions: readonly FeatureFlagDefinition[]): readonly FeatureFlagDefinition[];
 /** Register definitions once at Nitro startup. Re-registering identical data is safe for HMR. */

package/dist/feature-flags/registry.js

@@ -25,6 +25,11 @@ export const CONNECT_APPS_FLAG = defineFeatureFlag({
     displayName: "Connect apps",
     description: "Show the experimental app connection surface.",
 });
+export const BUILDER_CREDIT_USAGE_REPORTING_FLAG = defineFeatureFlag({
+    key: "billing.builder-credit-usage-reporting",
+    displayName: "Builder credit usage reporting",
+    description: "Use the Builder gateway's reported credit charges in usage reports.",
+});
 /** Define a small app-owned feature-flag registry. */
 export function defineFeatureFlags(definitions) {
     const seen = new Set();

package/dist/file-upload/actions/upload-image.d.ts

@@ -44,9 +44,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
+    error?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { createDevScriptRegistry } from "./scripts/dev/index.js";
 export { createAgentChatPlugin, defaultAgentChatPlugin, createAgentNativeEmbeddedPlugin, mountAgentNativeEmbedded, createServer, createSSEHandler, defineNitroPlugin, autoMountAuth, getSession, type AgentChatPluginOptions, type AgentNativeEmbeddedPluginOptions, type AuthSession, type AuthOptions, type CreateServerOptions, type SSEHandlerOptions, } from "./root-server-compat.js";
 export { BUILT_IN_INTEGRATION_CATALOG, INTEGRATION_CATEGORIES, getIntegrationCatalogEntry, listBuiltInChannelIntegrations, listIntegrationCatalog, type AutomationCapabilities, type BuiltInChannelId, type ChannelCapabilities, type IntegrationAvailability, type IntegrationCatalogEntry, type IntegrationCategory, type IntegrationCredentialRequirement, type IntegrationIconKey, type IntegrationSupportMaturity, } from "./integrations/catalog.js";
 export { AutomationConnectorError, createAutomationCallbackHandler, createAutomationRuntime, createInvokeAutomationWorkflowAction, type AutomationCallbackAuthentication, type AutomationCallbackInput, type AutomationCallbackResult, type AutomationInboundDefinition, type AutomationInvocation, type AutomationInvocationResult, type AutomationInvocationStatus, type AutomationOutboundDefinition, type AutomationResponseMode, type AutomationRetryPolicy, type AutomationRuntime, type AutomationRuntimeOptions, type AutomationWorkflowCapabilities, type AutomationWorkflowDefinition, type JsonSchema, } from "./automation/index.js";
-export { CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./feature-flags/index.js";
+export { BUILDER_CREDIT_USAGE_REPORTING_FLAG, CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./feature-flags/index.js";
 export { createFeatureFlagA2AActionRouteAuth, createFeatureFlagsPlugin, } from "./feature-flags/server.js";
 export { defineLab, defineLabs, getLabDefinition, listLabs, registerLabs, type LabDefinition, } from "./labs/index.js";
 export { createLabsPlugin } from "./labs/server.js";

package/dist/index.js

@@ -16,7 +16,7 @@ export { createDevScriptRegistry } from "./scripts/dev/index.js";
 export { createAgentChatPlugin, defaultAgentChatPlugin, createAgentNativeEmbeddedPlugin, mountAgentNativeEmbedded, createServer, createSSEHandler, defineNitroPlugin, autoMountAuth, getSession, } from "./root-server-compat.js";
 export { BUILT_IN_INTEGRATION_CATALOG, INTEGRATION_CATEGORIES, getIntegrationCatalogEntry, listBuiltInChannelIntegrations, listIntegrationCatalog, } from "./integrations/catalog.js";
 export { AutomationConnectorError, createAutomationCallbackHandler, createAutomationRuntime, createInvokeAutomationWorkflowAction, } from "./automation/index.js";
-export { CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, } from "./feature-flags/index.js";
+export { BUILDER_CREDIT_USAGE_REPORTING_FLAG, CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, } from "./feature-flags/index.js";
 export { createFeatureFlagA2AActionRouteAuth, createFeatureFlagsPlugin, } from "./feature-flags/server.js";
 export { defineLab, defineLabs, getLabDefinition, listLabs, registerLabs, } from "./labs/index.js";
 export { createLabsPlugin } from "./labs/server.js";

package/dist/integrations/webhook-handler.js

@@ -1448,7 +1448,8 @@ async function recordIntegrationUsage(options) {
         (usage.inputTokens <= 0 &&
             usage.outputTokens <= 0 &&
             usage.cacheReadTokens <= 0 &&
-            usage.cacheWriteTokens <= 0)) {
+            usage.cacheWriteTokens <= 0 &&
+            usage.builderCreditsUsed == null)) {
         return;
     }
     try {
@@ -1459,6 +1460,8 @@ async function recordIntegrationUsage(options) {
             outputTokens: usage.outputTokens,
             cacheReadTokens: usage.cacheReadTokens,
             cacheWriteTokens: usage.cacheWriteTokens,
+            builderCreditsUsed: usage.builderCreditsUsed,
+            engineName: usage.engineName,
             model: usage.model,
             label: `integration:${options.incoming.platform}`,
             app: options.appId,