@cedarjs/vite 8.0.0-canary.3417 → 8.0.0-canary.3418

package/dist/buildApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildApp.d.ts","sourceRoot":"","sources":["../src/buildApp.ts"],"names":[],"mappings":"AAiEA,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,EAAE,CAAC,EAAE,OAAO,CAAA;CACb;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,EAClC,OAAe,EACf,SAA0B,EAC1B,EAAU,GACX,GAAE,oBAAyB,iBA4b3B"}
+{"version":3,"file":"buildApp.d.ts","sourceRoot":"","sources":["../src/buildApp.ts"],"names":[],"mappings":"AAuEA,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,EAAE,CAAC,EAAE,OAAO,CAAA;CACb;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,EAClC,OAAe,EACf,SAA0B,EAC1B,EAAU,GACX,GAAE,oBAAyB,iBAyd3B"}

package/dist/buildApp.js

@@ -26,6 +26,11 @@ import {
   getPaths
 } from "@cedarjs/project-config";
 import { generateDiffSourceMap } from "./lib/generateDiffSourceMap.js";
+import {
+  copySandboxChildrenIntoVercelFunctions,
+  findSandboxChildScripts,
+  SANDBOX_CHILDREN_DIR
+} from "./lib/sandboxChildren.js";
 import { getWorkspacePackageAliases } from "./lib/workspacePackageAliases.js";
 import { cedarAutoImportsPlugin } from "./plugins/vite-plugin-cedar-auto-import.js";
 import { cedarDirectoryNamedImportPlugin } from "./plugins/vite-plugin-cedar-directory-named-import.js";
@@ -34,6 +39,7 @@ import { cedarGraphqlOptionsExtractPlugin } from "./plugins/vite-plugin-cedar-gr
 import { cedarImportDirPlugin } from "./plugins/vite-plugin-cedar-import-dir.js";
 import { cedarMockCellDataPlugin } from "./plugins/vite-plugin-cedar-mock-cell-data.js";
 import { cedarOtelWrappingPlugin } from "./plugins/vite-plugin-cedar-otel-wrapping.js";
+import { cedarSandboxChildrenPlugin } from "./plugins/vite-plugin-cedar-sandbox-children.js";
 import { cedarjsJobPathInjectorPlugin } from "./plugins/vite-plugin-cedarjs-job-path-injector.js";
 import { handlerAlsWrappingPlugin } from "./plugins/vite-plugin-handler-als-wrapping.js";
 function resolveWithExtensions(id) {
@@ -56,6 +62,7 @@ async function buildCedarApp({
   const cedarPaths = getPaths();
   const cedarConfig = getConfig();
   const environments = {};
+  let sandboxChildren = {};
   if (workspace.includes("web")) {
     environments.client = {
       build: {
@@ -97,15 +104,16 @@ async function buildCedarApp({
       }
     };
     if (ud) {
+      sandboxChildren = findSandboxChildScripts(cedarPaths.api.src);
       environments["ssr"] = {
         build: {
           ssr: true,
           outDir: path.join(cedarPaths.api.dist, "ud"),
           emptyOutDir: true,
           rollupOptions: {
-            input: catchAllEntry,
+            input: { index: catchAllEntry, ...sandboxChildren },
             output: {
-              entryFileNames: "index.js"
+              entryFileNames: "[name].js"
             },
             external: (id) => {
               if (id.startsWith("virtual:")) {
@@ -201,6 +209,12 @@ async function buildCedarApp({
   ];
   if (ud) {
     plugins.push(catchAll());
+    plugins.push(
+      cedarSandboxChildrenPlugin({
+        environment: "ssr",
+        children: sandboxChildren
+      })
+    );
     plugins.push({
       name: "cedar-ud-verify-routes",
       configResolved() {
@@ -341,7 +355,19 @@ async function buildCedarApp({
     },
     plugins
   });
-  return builder.buildApp();
+  await builder.buildApp();
+  const vercelNode = builder.environments["vercel_node"];
+  if (ud && vercelNode && Object.keys(sandboxChildren).length > 0) {
+    const outDir = path.resolve(
+      vercelNode.config.root,
+      vercelNode.config.build.outDir
+    );
+    copySandboxChildrenIntoVercelFunctions({
+      appRoot: cedarPaths.base,
+      childrenDir: path.join(cedarPaths.api.dist, "ud", SANDBOX_CHILDREN_DIR),
+      functionsDir: path.join(outDir, "functions")
+    });
+  }
 }
 export {
   buildCedarApp

package/dist/lib/sandboxChildren.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The folder in `api/dist/ud` a bundled API build puts every sandboxed
+ * child script in, as `<name>.child.js`, with a `node_modules` holding the
+ * packages they import. `findChildScript()` in `@cedarjs/api/sandbox`
+ * looks for `api/dist/ud/sandbox-children` from its caller's folder up.
+ */
+export declare const SANDBOX_CHILDREN_DIR = "sandbox-children";
+/**
+ * Every sandboxed child script in `apiSrc` (`**\/*.child.{ts,js,mts,mjs}`),
+ * as `{ 'sandbox-children/<name>.child': file }`, for a bundled build's
+ * `input`. Throws when two have the same name: in a bundle they all go in
+ * one folder, and `findChildScript()` finds them by name.
+ */
+export declare function findSandboxChildScripts(apiSrc: string): Record<string, string>;
+export interface SandboxChildImports {
+    /** The child script's source file, which its imports resolve from */
+    source: string;
+    /** What it imports: package names and Node builtins */
+    imports: string[];
+}
+/**
+ * Copies the packages the child scripts import, and everything those
+ * depend on, into `<childrenDir>/node_modules`, so the folder runs on its
+ * own wherever it's deployed: a serverless function's file tracing doesn't
+ * follow a child script (nothing imports it), and it would miss what
+ * native packages load at run time anyway (sharp's libvips).
+ *
+ * Follows each package's `dependencies`, and the `optionalDependencies`
+ * and `peerDependencies` that are installed, which is how native packages
+ * ship their platform's binaries (`@img/sharp-linux-x64`,
+ * `@img/sharp-libvips-linux-x64`).
+ *
+ * The copy keeps each package's choices, so it finds the same versions
+ * it does in the app: a dependency nested in a package's own
+ * `node_modules` is copied into the copy's `node_modules`; one beside it
+ * in a `node_modules` (pnpm's layout), or shadowed in the copy by another
+ * version, goes next to the dependent's copy; one in the app's own
+ * `node_modules` folders goes at the top. A package already reachable from
+ * the dependent's copy is reused. When two versions would still need the
+ * same place, it throws instead of letting one overwrite the other. So
+ * does a package or regular dependency that isn't installed: the child
+ * couldn't import it either.
+ */
+export declare function vendorSandboxChildPackages(childrenDir: string, children: SandboxChildImports[]): void;
+/**
+ * Copies the bundled build's sandboxed children (and their `node_modules`)
+ * into every Node function in a Vercel Build Output API folder
+ * (`.vercel/output/functions/*.func`), at the same path as in the app
+ * (`api/dist/ud/sandbox-children`). Each Vercel function is a single
+ * bundled file with nothing else from the app, and `findChildScript()`
+ * looks for the children from the function's folder up.
+ */
+export declare function copySandboxChildrenIntoVercelFunctions({ appRoot, childrenDir, functionsDir, }: {
+    appRoot: string;
+    childrenDir: string;
+    functionsDir: string;
+}): string[];
+//# sourceMappingURL=sandboxChildren.d.ts.map

package/dist/lib/sandboxChildren.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxChildren.d.ts","sourceRoot":"","sources":["../../src/lib/sandboxChildren.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,qBAAqB,CAAA;AAEtD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAyBxB;AA6CD,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,mBAAmB,EAAE,QA+GhC;AAgBD;;;;;;;GAOG;AACH,wBAAgB,sCAAsC,CAAC,EACrD,OAAO,EACP,WAAW,EACX,YAAY,GACb,EAAE;IACD,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;CACrB,YAgCA"}

package/dist/lib/sandboxChildren.js

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import { isBuiltin } from "node:module";
+import path from "node:path";
+import fg from "fast-glob";
+const SANDBOX_CHILDREN_DIR = "sandbox-children";
+function findSandboxChildScripts(apiSrc) {
+  const files = fg.sync("**/*.child.{ts,js,mts,mjs}", {
+    cwd: apiSrc,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/__tests__/**"]
+  }).sort();
+  const entries = {};
+  for (const file of files) {
+    const name = path.basename(file).replace(/\.(ts|js|mts|mjs)$/, "");
+    const key = `${SANDBOX_CHILDREN_DIR}/${name}`;
+    if (entries[key]) {
+      throw new Error(
+        `Two sandboxed child scripts are named ${name}: ${path.relative(apiSrc, entries[key])} and ${path.relative(apiSrc, file)}. A bundled build puts every child script in one folder, so their names must be unique.`
+      );
+    }
+    entries[key] = path.normalize(file);
+  }
+  return entries;
+}
+const packageName = (specifier) => {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+};
+const readPackageJson = (dir) => {
+  const parsed = JSON.parse(
+    fs.readFileSync(path.join(dir, "package.json"), "utf8")
+  );
+  return parsed && typeof parsed === "object" ? parsed : {};
+};
+const findPackage = (name, dir) => {
+  let current = dir;
+  for (; ; ) {
+    const candidate = path.join(current, "node_modules", name);
+    if (fs.existsSync(path.join(candidate, "package.json"))) {
+      return { realDir: fs.realpathSync(candidate), foundIn: current };
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+};
+function vendorSandboxChildPackages(childrenDir, children) {
+  const copyOf = /* @__PURE__ */ new Map();
+  const occupied = /* @__PURE__ */ new Map();
+  const inNodeModules = (dir) => dir.split(path.sep).includes("node_modules");
+  const reachableFrom = (copy, name) => {
+    let dir = copy;
+    for (; ; ) {
+      const there = occupied.get(path.join(dir, "node_modules", name));
+      if (there || dir === childrenDir) {
+        return there?.realDir;
+      }
+      dir = path.dirname(dir);
+    }
+  };
+  const visit = (name, fromDir, dependentCopy, required, dependent) => {
+    const found = findPackage(name, fromDir);
+    if (!found) {
+      if (required) {
+        throw new Error(
+          `Can't find package "${name}", which ${dependent} imports, in a node_modules folder above ${fromDir}`
+        );
+      }
+      return;
+    }
+    const { realDir, foundIn } = found;
+    const reachable = reachableFrom(dependentCopy, name);
+    if (reachable === realDir) {
+      return;
+    }
+    const copiedFolder = copyOf.get(foundIn);
+    const besideDependent = path.join(dependentCopy, "node_modules", name);
+    const target = copiedFolder ? path.join(copiedFolder, "node_modules", name) : inNodeModules(foundIn) || reachable ? besideDependent : path.join(childrenDir, "node_modules", name);
+    const there = occupied.get(target);
+    if (there) {
+      throw new Error(
+        `Sandboxed child scripts need two versions of "${name}" in one place: ${there.realDir} (for ${there.neededBy}) and ${realDir} (for ${dependent}). Install a single version of it, or move the children so their imports resolve the same way.`
+      );
+    }
+    occupied.set(target, { realDir, neededBy: dependent });
+    if (!copyOf.has(realDir)) {
+      copyOf.set(realDir, target);
+    }
+    fs.cpSync(realDir, target, {
+      recursive: true,
+      dereference: true,
+      // Its own node_modules are copied as dependencies, when they're needed
+      filter: (src) => src !== path.join(realDir, "node_modules")
+    });
+    const pkg = readPackageJson(realDir);
+    const optional = /* @__PURE__ */ new Set([
+      ...Object.keys(pkg.optionalDependencies ?? {}),
+      ...Object.keys(pkg.peerDependencies ?? {})
+    ]);
+    for (const dep of Object.keys(pkg.dependencies ?? {})) {
+      visit(dep, realDir, target, !optional.has(dep), name);
+    }
+    for (const dep of optional) {
+      visit(dep, realDir, target, false, name);
+    }
+  };
+  for (const { source, imports } of children) {
+    for (const specifier of imports) {
+      if (isBuiltin(specifier) || specifier.startsWith("#")) {
+        continue;
+      }
+      visit(
+        packageName(specifier),
+        fs.realpathSync(path.dirname(source)),
+        childrenDir,
+        true,
+        path.basename(source)
+      );
+    }
+  }
+}
+const findVercelFunctionDirs = (dir) => fs.existsSync(dir) ? fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+  const entryPath = path.join(dir, entry.name);
+  return entry.name.endsWith(".func") ? [entryPath] : findVercelFunctionDirs(entryPath);
+}) : [];
+function copySandboxChildrenIntoVercelFunctions({
+  appRoot,
+  childrenDir,
+  functionsDir
+}) {
+  const childrenDirInApp = path.relative(appRoot, childrenDir);
+  if (!fs.existsSync(childrenDir)) {
+    return [];
+  }
+  const functionDirs = findVercelFunctionDirs(functionsDir).filter((dir) => {
+    const config = path.join(dir, ".vc-config.json");
+    if (!fs.existsSync(config)) {
+      return false;
+    }
+    const parsed = JSON.parse(fs.readFileSync(config, "utf8"));
+    return !!parsed && typeof parsed === "object" && "runtime" in parsed && typeof parsed.runtime === "string" && parsed.runtime.startsWith("nodejs");
+  });
+  for (const dir of functionDirs) {
+    fs.cpSync(childrenDir, path.join(dir, childrenDirInApp), {
+      recursive: true
+    });
+  }
+  return functionDirs;
+}
+export {
+  SANDBOX_CHILDREN_DIR,
+  copySandboxChildrenIntoVercelFunctions,
+  findSandboxChildScripts,
+  vendorSandboxChildPackages
+};

package/dist/plugins/vite-plugin-cedar-sandbox-children.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+/**
+ * For the bundled API build (`cedar build --ud`): the sandboxed child
+ * scripts in api/src are extra entries of the build (see
+ * `findSandboxChildScripts()`), so each comes out as
+ * `sandbox-children/<name>.child.js`. This plugin checks that each child
+ * stands alone, importing only packages and Node builtins (it can read
+ * nothing of the app), and then copies the packages they import into
+ * `sandbox-children/node_modules`.
+ *
+ * `findChildScript()` from `@cedarjs/api/sandbox` finds the children there
+ * from code in the bundle.
+ */
+export declare function cedarSandboxChildrenPlugin({ environment, children, }: {
+    /** The bundled build's environment */
+    environment: string;
+    /** The child scripts' entries: `{ 'sandbox-children/x.child': file }` */
+    children: Record<string, string>;
+}): Plugin;
+//# sourceMappingURL=vite-plugin-cedar-sandbox-children.d.ts.map

package/dist/plugins/vite-plugin-cedar-sandbox-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-sandbox-children.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-sandbox-children.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AASlC;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,WAAW,EACX,QAAQ,GACT,EAAE;IACD,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,GAAG,MAAM,CAmDT"}

package/dist/plugins/vite-plugin-cedar-sandbox-children.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { normalizePath } from "vite";
+import {
+  SANDBOX_CHILDREN_DIR,
+  vendorSandboxChildPackages
+} from "../lib/sandboxChildren.js";
+function cedarSandboxChildrenPlugin({
+  environment,
+  children
+}) {
+  const sources = new Set(
+    Object.values(children).map((file) => normalizePath(file))
+  );
+  let imports = [];
+  return {
+    name: "cedar-sandbox-children",
+    apply: "build",
+    applyToEnvironment(env) {
+      return env.name === environment;
+    },
+    generateBundle(_options, bundle) {
+      imports = [];
+      for (const chunk of Object.values(bundle)) {
+        if (chunk.type !== "chunk" || !chunk.facadeModuleId) {
+          continue;
+        }
+        const source = normalizePath(chunk.facadeModuleId);
+        if (!sources.has(source)) {
+          continue;
+        }
+        const bundled = [...chunk.imports, ...chunk.dynamicImports].filter(
+          (id) => id in bundle
+        );
+        if (bundled.length > 0) {
+          this.error(
+            `${path.basename(source)} imports your app's own code (${bundled.join(", ")}). A sandboxed child script may import only packages and Node builtins: it runs in a process that can't read the rest of your app.`
+          );
+        }
+        imports.push({
+          source,
+          imports: [...chunk.imports, ...chunk.dynamicImports]
+        });
+      }
+    },
+    writeBundle(options) {
+      if (imports.length === 0 || !options.dir) {
+        return;
+      }
+      vendorSandboxChildPackages(
+        path.join(options.dir, SANDBOX_CHILDREN_DIR),
+        imports
+      );
+    }
+  };
+}
+export {
+  cedarSandboxChildrenPlugin
+};

package/dist/rsc/rscBuildClient.d.ts

@@ -3,5 +3,5 @@
  * buildFeServer -> buildRscFeServer -> rscBuildClient
  * Generate the client bundle
  */
-export declare function rscBuildClient(clientEntryFiles: Record<string, string>): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]>;
+export declare function rscBuildClient(clientEntryFiles: Record<string, string>): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputAsset | import("rollup").OutputChunk)[]]>;
 //# sourceMappingURL=rscBuildClient.d.ts.map

package/dist/rsc/rscBuildForServer.d.ts

@@ -3,5 +3,5 @@
  * buildFeServer -> buildRscFeServer -> rscBuildForServer
  * Generate the output to be used by the rsc worker (not the actual server!)
  */
-export declare function rscBuildForServer(clientEntryFiles: Record<string, string>, serverEntryFiles: Record<string, string>, customModules: Record<string, string>): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]>;
+export declare function rscBuildForServer(clientEntryFiles: Record<string, string>, serverEntryFiles: Record<string, string>, customModules: Record<string, string>): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputAsset | import("rollup").OutputChunk)[]]>;
 //# sourceMappingURL=rscBuildForServer.d.ts.map

package/dist/rsc/rscBuildForSsr.d.ts

@@ -5,5 +5,5 @@
 export declare function rscBuildForSsr({ clientEntryFiles, verbose, }: {
     clientEntryFiles: Record<string, string>;
     verbose?: boolean;
-}): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]>;
+}): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputAsset | import("rollup").OutputChunk)[]]>;
 //# sourceMappingURL=rscBuildForSsr.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/vite",
-  "version": "8.0.0-canary.3417",
+  "version": "8.0.0-canary.3418",
   "description": "Vite configuration package for CedarJS",
   "repository": {
     "type": "git",
@@ -54,17 +54,17 @@
     "@babel/preset-typescript": "7.29.7",
     "@babel/traverse": "7.29.10",
     "@babel/types": "7.29.8",
-    "@cedarjs/api": "8.0.0-canary.3417",
-    "@cedarjs/api-server": "8.0.0-canary.3417",
-    "@cedarjs/babel-config": "8.0.0-canary.3417",
-    "@cedarjs/context": "8.0.0-canary.3417",
-    "@cedarjs/graphql-server": "8.0.0-canary.3417",
-    "@cedarjs/internal": "8.0.0-canary.3417",
-    "@cedarjs/jobs": "8.0.0-canary.3417",
-    "@cedarjs/project-config": "8.0.0-canary.3417",
-    "@cedarjs/server-store": "8.0.0-canary.3417",
-    "@cedarjs/structure": "8.0.0-canary.3417",
-    "@cedarjs/testing": "8.0.0-canary.3417",
+    "@cedarjs/api": "8.0.0-canary.3418",
+    "@cedarjs/api-server": "8.0.0-canary.3418",
+    "@cedarjs/babel-config": "8.0.0-canary.3418",
+    "@cedarjs/context": "8.0.0-canary.3418",
+    "@cedarjs/graphql-server": "8.0.0-canary.3418",
+    "@cedarjs/internal": "8.0.0-canary.3418",
+    "@cedarjs/jobs": "8.0.0-canary.3418",
+    "@cedarjs/project-config": "8.0.0-canary.3418",
+    "@cedarjs/server-store": "8.0.0-canary.3418",
+    "@cedarjs/structure": "8.0.0-canary.3418",
+    "@cedarjs/testing": "8.0.0-canary.3418",
     "@swc/core": "1.16.13",
     "@universal-deploy/store": "^0.3.0",
     "@universal-deploy/vite": "^0.2.0",
@@ -94,10 +94,10 @@
     "yargs-parser": "21.1.1"
   },
   "devDependencies": {
-    "@cedarjs/auth": "8.0.0-canary.3417",
-    "@cedarjs/framework-tools": "8.0.0-canary.3417",
-    "@cedarjs/router": "8.0.0-canary.3417",
-    "@cedarjs/web": "8.0.0-canary.3417",
+    "@cedarjs/auth": "8.0.0-canary.3418",
+    "@cedarjs/framework-tools": "8.0.0-canary.3418",
+    "@cedarjs/router": "8.0.0-canary.3418",
+    "@cedarjs/web": "8.0.0-canary.3418",
     "@dr.pogodin/react-helmet": "2.0.4",
     "@hyrious/esbuild-plugin-commonjs": "0.2.6",
     "@jridgewell/trace-mapping": "0.3.31",
@@ -119,9 +119,9 @@
     "vitest": "4.1.11"
   },
   "peerDependencies": {
-    "@cedarjs/auth": "8.0.0-canary.3417",
-    "@cedarjs/router": "8.0.0-canary.3417",
-    "@cedarjs/web": "8.0.0-canary.3417",
+    "@cedarjs/auth": "8.0.0-canary.3418",
+    "@cedarjs/router": "8.0.0-canary.3418",
+    "@cedarjs/web": "8.0.0-canary.3418",
     "react": "19.3.0",
     "react-dom": "19.3.0"
   },