@cedarjs/vite 7.1.0 → 7.1.1-next.468

package/dist/devFeServer.js

@@ -25,7 +25,7 @@ async function createServer() {
   const rwPaths = getPaths();
   const rscEnabled = getConfig().experimental.rsc?.enabled ?? false;
   const serverStorage = createServerStorage();
-  app.use("*", (req, _res, next) => {
+  app.use((req, _res, next) => {
     const fullUrl = getFullUrl(req, rscEnabled);
     const perReqStore = createPerRequestMap({
       // Convert express headers to fetch header
@@ -102,8 +102,8 @@ async function createServer() {
     },
     vite
   );
-  app.get("*", createServerAdapter(routeHandler));
-  app.post("*", handleWithMiddleware());
+  app.get("/{*splat}", createServerAdapter(routeHandler));
+  app.post("/{*splat}", handleWithMiddleware());
   const port = getConfig().web.port;
   console.log(`Started server on http://localhost:${port}`);
   return app.listen(port);

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export { cedarRemoveFromBundle } from './plugins/vite-plugin-cedar-remove-from-b
 export { cedarjsResolveCedarStyleImportsPlugin } from './plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js';
 export { cedarjsJobPathInjectorPlugin } from './plugins/vite-plugin-cedarjs-job-path-injector.js';
 export { cedarMockCellDataPlugin } from './plugins/vite-plugin-cedar-mock-cell-data.js';
+export { cedarParsedScalarsPlugin } from './plugins/vite-plugin-cedar-parsed-scalars.js';
 export { cedarMergedConfig } from './plugins/vite-plugin-merged-config.js';
 export { cedarNetlifySkewProtectionPlugin } from './plugins/vite-plugin-cedar-netlify-skew-protection.js';
 export { cedarSwapApolloProvider } from './plugins/vite-plugin-swap-apollo-provider.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAoCxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,iDAAiD,CAAA;AAC3F,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAA;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAA;AACtF,OAAO,EAAE,gCAAgC,EAAE,MAAM,wDAAwD,CAAA;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAA;AACtF,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,+CAA+C,CAAA;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gDAAgD,CAAA;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,uDAAuD,CAAA;AACvG,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAA;AAC/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,4DAA4D,CAAA;AACzG,OAAO,EAAE,2BAA2B,EAAE,MAAM,mDAAmD,CAAA;AAC/F,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAA;AACzF,OAAO,EAAE,qCAAqC,EAAE,MAAM,8DAA8D,CAAA;AACpH,OAAO,EAAE,4BAA4B,EAAE,MAAM,oDAAoD,CAAA;AACjG,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAA;AACvF,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,EAAE,gCAAgC,EAAE,MAAM,wDAAwD,CAAA;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAA;AACvF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAA;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAA;AAE1F,KAAK,aAAa,GAAG;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;CACjC,CAAA;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,GAAE,aAAkB,GAAG,YAAY,EAAE,CA+CzE;AAED,8DAA8D;AAC9D,eAAe,KAAK,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAqCxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,iDAAiD,CAAA;AAC3F,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAA;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAA;AACtF,OAAO,EAAE,gCAAgC,EAAE,MAAM,wDAAwD,CAAA;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAA;AACtF,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,+CAA+C,CAAA;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gDAAgD,CAAA;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,uDAAuD,CAAA;AACvG,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAA;AAC/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,4DAA4D,CAAA;AACzG,OAAO,EAAE,2BAA2B,EAAE,MAAM,mDAAmD,CAAA;AAC/F,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAA;AACzF,OAAO,EAAE,qCAAqC,EAAE,MAAM,8DAA8D,CAAA;AACpH,OAAO,EAAE,4BAA4B,EAAE,MAAM,oDAAoD,CAAA;AACjG,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAA;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAA;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,EAAE,gCAAgC,EAAE,MAAM,wDAAwD,CAAA;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAA;AACvF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAA;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAA;AAE1F,KAAK,aAAa,GAAG;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;CACjC,CAAA;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,GAAE,aAAkB,GAAG,YAAY,EAAE,CAgDzE;AAED,8DAA8D;AAC9D,eAAe,KAAK,CAAA"}

package/dist/index.js

@@ -20,6 +20,7 @@ import { cedarDataUriShim } from "./plugins/vite-plugin-cedar-data-uri-shim.js";
 import { cedarEntryInjectionPlugin } from "./plugins/vite-plugin-cedar-entry-injection.js";
 import { cedarHtmlEnvPlugin } from "./plugins/vite-plugin-cedar-html-env.js";
 import { cedarMockCellDataPlugin } from "./plugins/vite-plugin-cedar-mock-cell-data.js";
+import { cedarParsedScalarsPlugin } from "./plugins/vite-plugin-cedar-parsed-scalars.js";
 import { cedarRemoveDevFatalErrorPage } from "./plugins/vite-plugin-cedar-remove-dev-fatal-error-page.js";
 import { cedarRemoveFromBundle } from "./plugins/vite-plugin-cedar-remove-from-bundle.js";
 import { cedarRoutesAutoLoaderPlugin } from "./plugins/vite-plugin-cedar-routes-auto-loader.js";
@@ -49,6 +50,7 @@ import { cedarRemoveFromBundle as cedarRemoveFromBundle2 } from "./plugins/vite-
 import { cedarjsResolveCedarStyleImportsPlugin as cedarjsResolveCedarStyleImportsPlugin2 } from "./plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js";
 import { cedarjsJobPathInjectorPlugin } from "./plugins/vite-plugin-cedarjs-job-path-injector.js";
 import { cedarMockCellDataPlugin as cedarMockCellDataPlugin2 } from "./plugins/vite-plugin-cedar-mock-cell-data.js";
+import { cedarParsedScalarsPlugin as cedarParsedScalarsPlugin2 } from "./plugins/vite-plugin-cedar-parsed-scalars.js";
 import { cedarMergedConfig as cedarMergedConfig2 } from "./plugins/vite-plugin-merged-config.js";
 import { cedarNetlifySkewProtectionPlugin } from "./plugins/vite-plugin-cedar-netlify-skew-protection.js";
 import { cedarSwapApolloProvider as cedarSwapApolloProvider2 } from "./plugins/vite-plugin-swap-apollo-provider.js";
@@ -80,6 +82,7 @@ function cedar({ mode, babel } = {}) {
     cedarMergedConfig(),
     cedarjsResolveCedarStyleImportsPlugin(),
     cedarSwapApolloProvider(),
+    cedarParsedScalarsPlugin(),
     cedarCellTransform(),
     cedarRemoveFromBundle(),
     cedarRemoveDevFatalErrorPage(),
@@ -109,6 +112,7 @@ export {
   cedarMockCellDataPlugin2 as cedarMockCellDataPlugin,
   cedarNetlifySkewProtectionPlugin,
   cedarOtelWrappingPlugin,
+  cedarParsedScalarsPlugin2 as cedarParsedScalarsPlugin,
   cedarRemoveDevFatalErrorPage2 as cedarRemoveDevFatalErrorPage,
   cedarRemoveFromBundle2 as cedarRemoveFromBundle,
   cedarRoutesAutoLoaderPlugin2 as cedarRoutesAutoLoaderPlugin,

package/dist/jobsDevMiddleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jobsDevMiddleware.d.ts","sourceRoot":"","sources":["../src/jobsDevMiddleware.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAyEzC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAKD,KAAK,eAAe,GAAG,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,CAAA;AAE3D;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA8FhC"}
+{"version":3,"file":"jobsDevMiddleware.d.ts","sourceRoot":"","sources":["../src/jobsDevMiddleware.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAsGzC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAKD,KAAK,eAAe,GAAG,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,CAAA;AAE3D;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA6GhC"}

package/dist/jobsDevMiddleware.js

@@ -1,8 +1,13 @@
+import fs from "node:fs";
+import { hostname } from "node:os";
+import path from "node:path";
 import { pathToFileURL } from "node:url";
 import ansis from "ansis";
 import {
+  isJobModuleFile,
   JobNotFoundError,
   JobsLibNotFoundError,
+  jobsFromModules,
   setJobLoaderOverrides
 } from "@cedarjs/jobs";
 import { getPaths } from "@cedarjs/project-config";
@@ -40,10 +45,27 @@ async function loadJobViaVite(viteServer, { name: jobName, path: jobPath }) {
   }
   return mod[jobName];
 }
+async function loadAllJobsViaVite(viteServer) {
+  const jobsDir = getPaths().api.jobs;
+  if (!fs.existsSync(jobsDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(jobsDir, { recursive: true, encoding: "utf-8" }).filter(isJobModuleFile).sort();
+  const modules = [];
+  for (const file of files) {
+    modules.push(
+      await viteServer.ssrLoadModule(
+        pathToFileURL(path.join(jobsDir, file)).href
+      )
+    );
+  }
+  return jobsFromModules(modules);
+}
 async function startJobsDevWorkers(viteServer) {
   setJobLoaderOverrides({
     loadJobsManager: () => loadJobsManagerViaVite(viteServer),
-    loadJob: (computedProperties) => loadJobViaVite(viteServer, computedProperties)
+    loadJob: (computedProperties) => loadJobViaVite(viteServer, computedProperties),
+    loadAllJobs: () => loadAllJobsViaVite(viteServer)
   });
   let jobsManager;
   try {
@@ -61,12 +83,17 @@ async function startJobsDevWorkers(viteServer) {
     setJobLoaderOverrides(void 0);
     return null;
   }
+  try {
+    await jobsManager.syncSchedules();
+  } catch (e) {
+    logger.error("[CedarJS Jobs] Could not sync the declared schedules", e);
+  }
   logger.warn(
     `[CedarJS Jobs] Starting ${numWorkers.length} worker(s) in-process (Unified Dev)...`
   );
   const workers = numWorkers.map(([index, id]) => {
     const workerConfig = jobsManager.workers[index];
-    const processName = `ud-jobs.${[workerConfig.queue].flat().join("-")}.${id}`;
+    const processName = `ud-jobs.${[workerConfig.queue].flat().join("-")}.${id} host:${hostname()} pid:${process.pid}`;
     return jobsManager.createWorker({
       index,
       clear: false,

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-cell.d.ts

@@ -16,7 +16,8 @@ import type { Plugin } from 'vite';
  * export const QUERY = gql`...`
  * export const Loading = () => <div>Loading...</div>
  * export const Success = ({ data }) => <div>{data}</div>
- * export default createCell({ QUERY, Loading, Success, displayName: 'MyCell' })
+ * const MyCell = createCell({ QUERY, Loading, Success, displayName: 'MyCell' })
+ * export default MyCell
  * ```
  */
 export declare function cedarCellTransform(): Plugin;

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

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-cedar-cell.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-cell.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAqBlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAsK3C"}
+{"version":3,"file":"vite-plugin-cedar-cell.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-cell.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAqBlC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAsM3C"}

package/dist/plugins/vite-plugin-cedar-cell.js

@@ -23,6 +23,7 @@ function cedarCellTransform() {
       if (!id.match(/Cell\.[jt]sx?$/)) {
         return null;
       }
+      const cellComponentName = parsePath(id).name;
       try {
         const ast = parse(code, {
           sourceType: "module",
@@ -111,20 +112,38 @@ function cedarCellTransform() {
                 computed: false
               }
             ];
+            const cellVariableDeclaration = {
+              type: "VariableDeclaration",
+              kind: "const",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name: cellComponentName
+                  },
+                  init: {
+                    type: "CallExpression",
+                    callee: {
+                      type: "Identifier",
+                      name: createCellHookName
+                    },
+                    arguments: [
+                      {
+                        type: "ObjectExpression",
+                        properties: objectProperties
+                      }
+                    ]
+                  }
+                }
+              ]
+            };
+            path.node.body.push(cellVariableDeclaration);
             const exportDefaultDeclaration = {
               type: "ExportDefaultDeclaration",
               declaration: {
-                type: "CallExpression",
-                callee: {
-                  type: "Identifier",
-                  name: createCellHookName
-                },
-                arguments: [
-                  {
-                    type: "ObjectExpression",
-                    properties: objectProperties
-                  }
-                ]
+                type: "Identifier",
+                name: cellComponentName
               }
             };
             path.node.body.push(exportDefaultDeclaration);

package/dist/plugins/vite-plugin-cedar-parsed-scalars.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+/**
+ * Gives `CedarApolloProvider` the cache config for the scalars in
+ * `graphql.parsedScalars` in `cedar.toml`. Does nothing when no scalar is set
+ * to be parsed.
+ *
+ * The config comes from the project's generated GraphQL schema, so it is built
+ * into the virtual module `virtual:cedar-parsed-scalars` rather than into the
+ * provider, which is a published package that Vite pre-bundles in dev. The
+ * module puts the config on `globalThis.__CEDAR__PARSED_SCALARS`, where the
+ * provider reads it when it creates the cache, and `App` and the web test
+ * setup file import the module so that every entry point that renders the
+ * provider has it. The module is a
+ * dependency of the generated schema file, so a change to the schema reloads
+ * the app. The generated schema is only read, and `graphql` and its schema
+ * loader only imported, when the virtual module is actually resolved, so a
+ * project that doesn't use this setting doesn't pay for loading them.
+ */
+export declare function cedarParsedScalarsPlugin(): Plugin | undefined;
+//# sourceMappingURL=vite-plugin-cedar-parsed-scalars.d.ts.map

package/dist/plugins/vite-plugin-cedar-parsed-scalars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-parsed-scalars.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-parsed-scalars.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAclC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,SAAS,CA4E7D"}

package/dist/plugins/vite-plugin-cedar-parsed-scalars.js

@@ -0,0 +1,60 @@
+import { normalizePath } from "vite";
+import { getParsedScalars, getPaths } from "@cedarjs/project-config";
+const VIRTUAL_MODULE_ID = "virtual:cedar-parsed-scalars";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const APP_FILE_REGEXP = /web[\\/]src[\\/]App\.(ts|tsx|js|jsx)$/;
+const VITEST_WEB_SETUP_FILE_REGEXP = /[\\/]vitest-web\.setup\.(ts|js)$/;
+function cedarParsedScalarsPlugin() {
+  if (Object.keys(getParsedScalars()).length === 0) {
+    return void 0;
+  }
+  return {
+    name: "cedar-parsed-scalars",
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+      return null;
+    },
+    async load(id) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) {
+        return null;
+      }
+      this.addWatchFile(getPaths().generated.schema);
+      const { loadParsedScalarsCacheConfig } = await import("@cedarjs/internal/dist/generate/parsedScalars.js");
+      const config = loadParsedScalarsCacheConfig();
+      return `globalThis.__CEDAR__PARSED_SCALARS = ${JSON.stringify(config)}`;
+    },
+    transform(code, id) {
+      if (!APP_FILE_REGEXP.test(id) && !VITEST_WEB_SETUP_FILE_REGEXP.test(id)) {
+        return null;
+      }
+      return `import '${VIRTUAL_MODULE_ID}'
+${code}`;
+    },
+    // `this.addWatchFile` in `load` only reruns the virtual module for a
+    // change to a file it has already watched. The schema doesn't exist yet
+    // on a clean `cedar dev` (the web server and `cedar-gen-watch` start
+    // concurrently), so its first appearance is a 'create' event on a path
+    // nothing has watched yet, and reaches here without an `addWatchFile`
+    // call ever having registered it. Reload the virtual module for exactly
+    // that file, on every event type, so the app picks up the first schema
+    // once `cedar-gen-watch` writes it, the same way it already does for a
+    // later edit.
+    hotUpdate(options) {
+      if (options.file !== normalizePath(getPaths().generated.schema)) {
+        return;
+      }
+      const moduleGraph = this.environment.moduleGraph;
+      const module = moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
+      if (!module) {
+        return;
+      }
+      moduleGraph.invalidateModule(module);
+      return [module];
+    }
+  };
+}
+export {
+  cedarParsedScalarsPlugin
+};

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/plugins/vite-plugin-handler-als-wrapping.d.ts

@@ -25,9 +25,7 @@ import type { Plugin } from 'vite';
  * This replaces `babel-plugin-handler-als-wrapping` for Vite builds.
  * The babel plugin is still used for Jest and prerender.
  */
-export declare function handlerAlsWrappingPlugin({ projectIsEsm, }?: {
-    projectIsEsm?: boolean;
-}): Plugin;
+export declare function handlerAlsWrappingPlugin(): Plugin;
 /**
  * Wraps the `handler` export of an API function file with an async context
  * store guard. Returns the transformed code, or `null` if the file does not
@@ -38,7 +36,5 @@ export declare function handlerAlsWrappingPlugin({ projectIsEsm, }?: {
  * function so it can be applied from build pipelines that don't go through
  * Vite's plugin pipeline (e.g. the legacy esbuild API build).
  */
-export declare function applyHandlerAlsWrapping(code: string, { projectIsEsm }?: {
-    projectIsEsm?: boolean;
-}): string | null;
+export declare function applyHandlerAlsWrapping(code: string): string | null;
 //# sourceMappingURL=vite-plugin-handler-als-wrapping.d.ts.map

package/dist/plugins/vite-plugin-handler-als-wrapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-handler-als-wrapping.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-handler-als-wrapping.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAKlC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,YAAoB,GACrB,GAAE;IACD,YAAY,CAAC,EAAE,OAAO,CAAA;CAClB,GAAG,MAAM,CAuBd;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,EAAE,YAAoB,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACxD,MAAM,GAAG,IAAI,CAsDf"}
+{"version":3,"file":"vite-plugin-handler-als-wrapping.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-handler-als-wrapping.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAKlC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAuBjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkDnE"}