fix(core,sdk): keep sdkScope out of the browser import graph

The previous TriggerClient commit added `import { AsyncLocalStorage }
from "node:async_hooks"` in `sdkScope/index.ts`, which is reachable
from `@trigger.dev/core/v3`. Browser bundles importing from the v3
root (webapp dashboard, ai-chat client components) pulled the node
builtin transitively and failed to compile.

Split storage out so the v3 root stays browser-safe:

- `sdkScope/index.ts` exposes the API plus an `_installSdkScopeStorage`
  hook with a slot pattern. No node imports.
- `sdkScope/storage-node.ts` owns the AsyncLocalStorage and installs
  itself via the slot on import. Only file in the package that touches
  `node:async_hooks`.
- Exported as `@trigger.dev/core/v3/sdk-scope-storage`. Deliberately
  NOT re-exported from the v3 root.
- `@trigger.dev/sdk` modules that need the scope (TriggerClient, auth)
  side-effect-import the sub-path.
- `@trigger.dev/sdk` is marked `"sideEffects": false` so browser
  bundles that don't reach TriggerClient or auth tree-shake them and
  their side-effect imports out entirely.

`apiClientManager.runWithConfig` keeps a fallback to in-place global
mutation when storage isn't installed (browser, Edge, Cloudflare
Workers, or Node consumers that haven't imported TriggerClient/auth).
This preserves the pre-existing concurrency-not-safe-but-functional
semantics in runtimes that can't run AsyncLocalStorage. On Node where
TriggerClient or auth has been imported, the ALS path is used and
parallel scopes don't stomp.

Author: ericallam

packages/core/package.json

@@ -55,7 +55,8 @@
       "./v3/runEngineWorker": "./src/v3/runEngineWorker/index.ts",
       "./v3/machines": "./src/v3/machines/index.ts",
       "./v3/serverOnly": "./src/v3/serverOnly/index.ts",
-      "./v3/isomorphic": "./src/v3/isomorphic/index.ts"
+      "./v3/isomorphic": "./src/v3/isomorphic/index.ts",
+      "./v3/sdk-scope-storage": "./src/v3/sdkScope/storage-node.ts"
     },
     "sourceDialects": [
       "@triggerdotdev/source"
@@ -622,6 +623,17 @@
         "types": "./dist/commonjs/v3/isomorphic/index.d.ts",
         "default": "./dist/commonjs/v3/isomorphic/index.js"
       }
+    },
+    "./v3/sdk-scope-storage": {
+      "import": {
+        "@triggerdotdev/source": "./src/v3/sdkScope/storage-node.ts",
+        "types": "./dist/esm/v3/sdkScope/storage-node.d.ts",
+        "default": "./dist/esm/v3/sdkScope/storage-node.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/v3/sdkScope/storage-node.d.ts",
+        "default": "./dist/commonjs/v3/sdkScope/storage-node.js"
+      }
     }
   },
   "type": "module",

packages/core/src/v3/apiClientManager/index.ts

@@ -111,7 +111,22 @@ export class APIClientManagerAPI {
     fn: R
   ): Promise<ReturnType<R>> {
     const merged: ApiClientConfiguration = { ...this.#getConfig(), ...config };
-    return sdkScope.withScope({ apiClientConfig: merged, inheritContext: true }, fn);
+
+    // Use the AsyncLocalStorage scope when installed (Node-side code
+    // that has loaded TriggerClient or auth) — concurrency-safe.
+    if (sdkScope.hasStorage()) {
+      return sdkScope.withScope({ apiClientConfig: merged, inheritContext: true }, fn);
+    }
+
+    // Fallback: in-place global mutation. Matches pre-existing behavior
+    // and works in any runtime (browser, Edge, Workers, Node without
+    // the storage installed). Not concurrency-safe — parallel callers
+    // with different configs will stomp on each other.
+    const original = this.#getConfig();
+    registerGlobal(API_NAME, merged, true);
+    return fn().finally(() => {
+      registerGlobal(API_NAME, original, true);
+    });
   }
 
   public setGlobalAPIClientConfiguration(config: ApiClientConfiguration): boolean {

packages/core/src/v3/sdkScope/index.ts

@@ -1,18 +1,29 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { ApiClientConfiguration } from "../apiClientManager/types.js";
+import type { SdkScope, SdkScopeStorage } from "./types.js";
 
-export type SdkScope = {
-  apiClientConfig: ApiClientConfiguration;
-  inheritContext: boolean;
-};
+export type { SdkScope, SdkScopeStorage } from "./types.js";
+
+// Storage slot. Filled at runtime by a Node-only module
+// (`@trigger.dev/core/v3/sdk-scope-storage`) that owns the
+// AsyncLocalStorage instance. Left undefined in environments that
+// never import that module (browsers, edge runtimes), where
+// `sdkScope.withScope` falls through to invoking the callback
+// directly. `sdkScope/index.ts` deliberately does not statically
+// import `node:async_hooks` or `storage-node.ts` so it is safe to
+// include in any browser-side bundle that reaches `@trigger.dev/core/v3`.
+let installedStorage: SdkScopeStorage | undefined;
 
-const storage = new AsyncLocalStorage<SdkScope>();
+export function _installSdkScopeStorage(storage: SdkScopeStorage): void {
+  installedStorage = storage;
+}
 
 export const sdkScope = {
+  hasStorage(): boolean {
+    return installedStorage !== undefined;
+  },
   getStore(): SdkScope | undefined {
-    return storage.getStore();
+    return installedStorage?.getStore();
   },
   withScope<R>(scope: SdkScope, fn: () => R): R {
-    return storage.run(scope, fn);
+    return installedStorage ? installedStorage.run(scope, fn) : fn();
   },
 };

packages/core/src/v3/sdkScope/storage-node.ts

@@ -0,0 +1,15 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { _installSdkScopeStorage } from "./index.js";
+import type { SdkScope } from "./types.js";
+
+// Importing this module installs an AsyncLocalStorage-backed
+// `SdkScopeStorage` into the slot exposed by `sdkScope/index.ts`. The
+// SDK side-effect-imports this from server-only modules
+// (TriggerClient, auth) so that browser-bundled code that never
+// touches those modules never pulls `node:async_hooks` either.
+const als = new AsyncLocalStorage<SdkScope>();
+
+_installSdkScopeStorage({
+  getStore: () => als.getStore(),
+  run: (scope, fn) => als.run(scope, fn),
+});

packages/core/src/v3/sdkScope/types.ts

@@ -0,0 +1,11 @@
+import type { ApiClientConfiguration } from "../apiClientManager/types.js";
+
+export type SdkScope = {
+  apiClientConfig: ApiClientConfiguration;
+  inheritContext: boolean;
+};
+
+export type SdkScopeStorage = {
+  getStore(): SdkScope | undefined;
+  run<R>(scope: SdkScope, fn: () => R): R;
+};

packages/trigger-sdk/package.json

@@ -12,6 +12,7 @@
     "directory": "packages/trigger-sdk"
   },
   "type": "module",
+  "sideEffects": false,
   "files": [
     "dist"
   ],

packages/trigger-sdk/src/v3/auth.ts

@@ -5,6 +5,11 @@ import {
 } from "@trigger.dev/core/v3";
 import { generateJWT as internal_generateJWT } from "@trigger.dev/core/v3";
 
+// Install the Node AsyncLocalStorage-backed storage so `auth.withAuth`
+// (and the public-token helpers that route through it) actually scope
+// API client config. See `triggerClient.ts` for the same import.
+import "@trigger.dev/core/v3/sdk-scope-storage";
+
 /**
  * Register the global API client configuration. Alternatively, you can set the `TRIGGER_SECRET_KEY` and `TRIGGER_API_URL` environment variables.
  * @param options The API client configuration.

packages/trigger-sdk/src/v3/triggerClient.ts

@@ -3,6 +3,14 @@ import {
   sdkScope,
   type SdkScope,
 } from "@trigger.dev/core/v3";
+
+// Install the Node AsyncLocalStorage-backed storage. Kept as a
+// side-effect import so it is never reached from browser bundles
+// that don't transitively import TriggerClient (relies on
+// `sideEffects: false` in this package + the v3 root not importing
+// storage-node statically).
+import "@trigger.dev/core/v3/sdk-scope-storage";
+
 import { auth } from "./auth.js";
 import { batch } from "./batch.js";
 import { deployments } from "./deployments.js";