@cedarjs/cli 5.0.0-canary.2547 → 5.0.0-canary.2548

package/dist/commands/deploy/renderHandler.js

@@ -8,7 +8,11 @@ import {
 } from "@cedarjs/cli-helpers/packageManager/exec";
 import { installPackages } from "@cedarjs/cli-helpers/packageManager/packages";
 import { getPaths } from "@cedarjs/project-config";
-const handler = async ({ side, prisma, dataMigrate }) => {
+const handler = async ({
+  side,
+  prisma,
+  dataMigrate
+}) => {
   recordTelemetryAttributes({
     command: "deploy render",
     side,
@@ -35,7 +39,7 @@ const handler = async ({ side, prisma, dataMigrate }) => {
       const packageJson = JSON.parse(
         fs.readFileSync(path.join(cedarPaths.base, "package.json"), "utf-8")
       );
-      const hasDataMigratePackage = !!packageJson.devDependencies["@cedarjs/cli-data-migrate"];
+      const hasDataMigratePackage = !!packageJson.devDependencies?.["@cedarjs/cli-data-migrate"];
       if (!hasDataMigratePackage) {
         console.error(
           [
@@ -57,8 +61,8 @@ const handler = async ({ side, prisma, dataMigrate }) => {
     if (hasServerFile) {
       runWithNode(serverFilePath, execaConfig);
     } else {
-      const { handler: handler2 } = await import("@cedarjs/api-server/apiCliConfigHandler");
-      handler2();
+      const { handler: apiHandler } = await import("@cedarjs/api-server/apiCliConfigHandler");
+      apiHandler();
     }
   }
   async function runWebCommands() {

package/dist/commands/destroy/page/pageHandler.js

@@ -41,7 +41,7 @@ const handler = async ({ name, path }) => {
   try {
     await t.run();
   } catch (e) {
-    console.log(c.error(e.message));
+    console.log(c.error(e instanceof Error ? e.message : String(e)));
   }
 };
 export {

package/dist/commands/destroy/scaffold/scaffoldHandler.js

@@ -15,7 +15,11 @@ import {
   routes as scaffoldRoutes,
   splitPathAndModel
 } from "../../generate/scaffold/scaffoldHandler.js";
-const removeRoutesWithSet = async ({ model, path, nestScaffoldByModel }) => {
+const removeRoutesWithSet = async ({
+  model,
+  path,
+  nestScaffoldByModel
+}) => {
   const routes = await scaffoldRoutes({ model, path, nestScaffoldByModel });
   const routeNames = routes.map(extractRouteName);
   const pluralPascalName = pascalcase(pluralize(model));
@@ -28,9 +32,13 @@ const removeSetImport = () => {
   if (routesContent.match("<Set")) {
     return "Skipping removal of Set import in Routes.{jsx,tsx}";
   }
-  const [cedarRouterImport] = routesContent.match(
+  const cedarRouterImportMatch = routesContent.match(
     /import {[^]*} from '@cedarjs\/router'/
   );
+  if (!cedarRouterImportMatch) {
+    return "No @cedarjs/router import found in Routes.{jsx,tsx}";
+  }
+  const [cedarRouterImport] = cedarRouterImportMatch;
   const removedSetImport = cedarRouterImport.replace(/,*\s*Set,*/, "");
   const newRoutesContent = routesContent.replace(
     cedarRouterImport,
@@ -39,7 +47,10 @@ const removeSetImport = () => {
   writeFile(routesPath, newRoutesContent, { overwriteExisting: true });
   return "Removed Set import in Routes.{jsx,tsx}";
 };
-const removeLayoutImport = ({ model: name, path: scaffoldPath = "" }) => {
+const removeLayoutImport = ({
+  model: name,
+  path: scaffoldPath = ""
+}) => {
   const pluralPascalName = pascalcase(pluralize(name));
   const pascalScaffoldPath = scaffoldPath === "" ? scaffoldPath : scaffoldPath.split("/").map(pascalcase).join("/") + "/";
   const layoutName = `${pluralPascalName}Layout`;
@@ -53,7 +64,12 @@ const removeLayoutImport = ({ model: name, path: scaffoldPath = "" }) => {
   writeFile(routesPath, newRoutesContent, { overwriteExisting: true });
   return "Removed layout import from Routes.{jsx,tsx}";
 };
-const tasks = ({ model, path, tests, nestScaffoldByModel }) => new Listr(
+const tasks = ({
+  model,
+  path,
+  tests,
+  nestScaffoldByModel
+}) => new Listr(
   [
     {
       title: "Destroying scaffold files...",
@@ -91,12 +107,15 @@ const handler = async ({ model: modelArg }) => {
     const { name } = await verifyModelName({ name: model, isDestroyer: true });
     await tasks({ model: name, path }).run();
   } catch (e) {
-    console.log(c.error(e.message));
+    console.log(c.error(e instanceof Error ? e.message : String(e)));
   }
 };
 const extractRouteName = (route) => {
-  const { groups } = route.match(/.*name="?(?<routeName>\w+)"?/);
-  return groups.routeName;
+  const match = route.match(/.*name="?(?<routeName>\w+)"?/);
+  if (!match?.groups?.routeName) {
+    throw new Error(`Could not extract route name from route: ${route}`);
+  }
+  return match.groups.routeName;
 };
 export {
   handler,

package/dist/commands/setup/server-file/serverFileHandler.js

@@ -5,13 +5,16 @@ import { addApiPackages, colors as c } from "@cedarjs/cli-helpers";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
 import { isTypeScriptProject } from "../../../lib/project.js";
-const { version } = JSON.parse(
+const packageJson = JSON.parse(
   fs.readFileSync(
     path.resolve(import.meta.dirname, "../../../../package.json"),
     "utf-8"
   )
 );
-function setupServerFileTasks({ force = false } = {}) {
+const { version } = packageJson;
+function setupServerFileTasks({
+  force = false
+} = {}) {
   return [
     {
       title: "Adding the server file...",
@@ -36,17 +39,22 @@ function setupServerFileTasks({ force = false } = {}) {
     addApiPackages([`@cedarjs/api-server@${version}`])
   ];
 }
-async function handler({ force, verbose }) {
-  const tasks = new Listr(setupServerFileTasks({ force }), {
+async function handler({
+  force,
+  verbose
+}) {
+  const listr = new Listr(setupServerFileTasks({ force }), {
     rendererOptions: { collapseSubtasks: false, persistentOutput: true },
     renderer: verbose ? "verbose" : "default"
   });
   try {
-    await tasks.run();
+    await listr.run();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    const exitCode = typeof e === "object" && e !== null && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    process.exit(exitCode);
   }
 }
 export {

package/dist/lib/configureStorybook.js

@@ -10,11 +10,11 @@ import {
 } from "./merge/strategy.js";
 import { isTypeScriptProject } from "./project.js";
 import { getPaths, transformTSToJS, writeFile } from "./index.js";
-async function extendStorybookConfiguration(newConfigPath = void 0) {
+async function extendStorybookConfiguration(newConfigPath) {
   const webPaths = getPaths().web;
   const ts = isTypeScriptProject();
   const sbPreviewConfigPath = webPaths.storybookPreviewConfig ?? `${webPaths.storybook}/preview.${ts ? "tsx" : "js"}`;
-  const read = (path2) => fse.readFileSync(path2, { encoding: "utf-8" });
+  const read = (filePath) => fse.readFileSync(filePath, { encoding: "utf-8" });
   if (!fse.existsSync(sbPreviewConfigPath)) {
     const templateContent = read(
       path.resolve(

package/dist/lib/exec.js

@@ -67,11 +67,11 @@ async function runScriptFunction({
           customResolver: (id, importer, _options) => {
             const apiImportBase = importStatementPath(getPaths().api.base);
             const webImportBase = importStatementPath(getPaths().web.base);
-            if (importer.startsWith(apiImportBase)) {
+            if (importer?.startsWith(apiImportBase)) {
               const apiImportSrc = importStatementPath(getPaths().api.src);
               const resolvedId = id.replace("src", apiImportSrc);
               return { id: resolveExtension(resolvedId) };
-            } else if (importer.startsWith(webImportBase)) {
+            } else if (importer?.startsWith(webImportBase)) {
               const webImportSrc = importStatementPath(getPaths().web.src);
               const resolvedId = id.replace("src", webImportSrc);
               return { id: resolveExtension(resolvedId) };
@@ -97,22 +97,23 @@ async function runScriptFunction({
     throw new Error("Vite environment is not runnable.");
   }
   let returnValue;
-  let scriptError = null;
   try {
-    const script = await env.runner.import(scriptPath);
-    returnValue = await script[functionName](args);
-  } catch (error) {
-    scriptError = error;
-  }
-  try {
-    const { db } = await env.runner.import(path.join(getPaths().api.lib, "db"));
-    db.$disconnect();
-  } catch (e) {
-  }
-  await server.close();
-  process.env.NODE_ENV = NODE_ENV;
-  if (scriptError) {
-    throw scriptError;
+    const module = await env.runner.import(scriptPath);
+    const fn = module[functionName];
+    if (typeof fn !== "function") {
+      throw new Error(`Function '${functionName}' not found in script`);
+    }
+    returnValue = await fn(args);
+  } finally {
+    try {
+      const dbModule = await env.runner.import(
+        path.join(getPaths().api.lib, "db")
+      );
+      dbModule.db?.$disconnect?.();
+    } catch {
+    }
+    await server.close();
+    process.env.NODE_ENV = NODE_ENV;
   }
   return returnValue;
 }

package/dist/lib/extendFile.js

@@ -1,8 +1,8 @@
 import fs from "node:fs";
-function fileIncludes(path, str) {
-  return fs.existsSync(path) && fs.readFileSync(path).toString().includes(str);
+function fileIncludes(filePath, str) {
+  return fs.existsSync(filePath) && fs.readFileSync(filePath).toString().includes(str);
 }
-function extendJSXFile(path, {
+function extendJSXFile(filePath, {
   insertComponent: {
     name = void 0,
     props = void 0,
@@ -14,7 +14,7 @@ function extendJSXFile(path, {
   imports = [],
   moduleScopeLines = []
 }) {
-  const content = fs.readFileSync(path).toString().split("\n");
+  const content = fs.readFileSync(filePath).toString().split("\n");
   if (moduleScopeLines?.length) {
     content.splice(
       content.findLastIndex((l) => l.trimStart().startsWith("import")) + 1,
@@ -41,9 +41,16 @@ function extendJSXFile(path, {
       insertAfter
     });
   }
-  fs.writeFileSync(path, content.filter((e) => e !== void 0).join("\n"));
+  fs.writeFileSync(filePath, content.join("\n"));
 }
-function insertComponent(content, { component, props, around, within, insertBefore, insertAfter }) {
+function insertComponent(content, {
+  component,
+  props,
+  around,
+  within,
+  insertBefore,
+  insertAfter
+}) {
   if (around && within || !(around || within)) {
     throw new Error(
       "Exactly one of (around | within) must be defined. Choose one."
@@ -62,16 +69,16 @@ function insertComponent(content, { component, props, around, within, insertBefo
     open++;
     close--;
   }
-  const [, componentDepth] = content[open].match(/([^\S\r\n]*).*/);
+  const depthMatch = content[open].match(/([^\S\r\n]*).*/);
+  const componentDepth = depthMatch?.[1] ?? "";
   content.splice(
     open,
     close - open,
-    // "Delete" the wrapped component contents. We put it back below.
-    insertBefore && componentDepth + insertBefore,
+    ...insertBefore ? [componentDepth + insertBefore] : [],
     componentDepth + buildOpeningTag(component, props),
     ...content.slice(open, close).map((line) => "  " + line),
     componentDepth + `</${component}>`,
-    insertAfter && componentDepth + insertAfter
+    ...insertAfter ? [componentDepth + insertAfter] : []
   );
 }
 function buildOpeningTag(componentName, props) {
@@ -92,11 +99,14 @@ function buildOpeningTag(componentName, props) {
   const possibleSpace = propsString.length ? " " : "";
   return `<${componentName}${possibleSpace}${propsString}>`;
 }
-function objectToComponentProps(obj, options = { exclude: [], raw: false }) {
+function objectToComponentProps(obj, options = {
+  exclude: [],
+  raw: false
+}) {
   const props = [];
   const doRaw = (key) => options.raw === true || Array.isArray(options.raw) && options.raw.includes(key);
   for (const [key, value] of Object.entries(obj)) {
-    if (options.exclude && options.exclude.includes(key)) {
+    if (options.exclude?.includes(key)) {
       continue;
     }
     if (doRaw(key)) {

package/dist/lib/merge/strategy.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import uniqWith from "lodash/uniqWith.js";
 import { nodeIs, sieve } from "./algorithms.js";
-const OPAQUE_UID_TAG = "RW_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
+const OPAQUE_UID_TAG = "CEDAR_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
 function requireSameType(base, ext) {
   if (base.path.type !== ext.path.type) {
     throw new Error(
@@ -17,9 +17,21 @@ function requireStrategyExists(base, _ext, strategy, strategyName) {
   }
 }
 const strictEquality = (lhs, rhs) => lhs === rhs;
-const byName = (lhs, rhs) => lhs.name === rhs.name;
-const byKeyName = (lhs, rhs) => lhs.key.name === rhs.key.name;
-const byValue = (lhs, rhs) => lhs.value === rhs.value;
+function hasName(v) {
+  return typeof v === "object" && v !== null && "name" in v;
+}
+function hasKey(v) {
+  return typeof v === "object" && v !== null && "key" in v;
+}
+function hasKeyName(v) {
+  return hasKey(v) && hasName(v.key);
+}
+function hasValue(v) {
+  return typeof v === "object" && v !== null && "value" in v;
+}
+const byName = (lhs, rhs) => hasName(lhs) && hasName(rhs) && lhs.name === rhs.name;
+const byKeyName = (lhs, rhs) => hasKeyName(lhs) && hasKeyName(rhs) && lhs.key.name === rhs.key.name;
+const byValue = (lhs, rhs) => hasValue(lhs) && hasValue(rhs) && lhs.value === rhs.value;
 function defaultEquality(baseContainer, extContainer) {
   const sample = baseContainer.length && baseContainer[0] || extContainer.length && extContainer[0];
   const defaults = {
@@ -30,14 +42,13 @@ function defaultEquality(baseContainer, extContainer) {
     ObjectProperty: byKeyName,
     StringLiteral: byValue
   };
-  return sample && sample.type in defaults ? defaults[sample.type] : strictEquality;
+  return sample && typeof sample === "object" && "type" in sample && typeof sample.type === "string" && sample.type in defaults ? defaults[sample.type] : strictEquality;
 }
-function opaquely(strategy) {
-  strategy[OPAQUE_UID_TAG] = true;
-  return strategy;
+function opaquely(reducer) {
+  return Object.assign(reducer, { [OPAQUE_UID_TAG]: true });
 }
-function isOpaque(strategy) {
-  return strategy[OPAQUE_UID_TAG] === true;
+function isOpaque(fn) {
+  return OPAQUE_UID_TAG in fn && fn[OPAQUE_UID_TAG] === true;
 }
 const keepBase = opaquely(() => {
 });
@@ -47,20 +58,36 @@ const keepBoth = opaquely((base, ext) => {
 const keepExtension = opaquely((base, ext) => {
   base.path.replaceWith(ext.path);
 });
-const keepBothStatementParents = opaquely((base, ext) => {
-  base.path.getStatementParent().insertAfter(ext.path.getStatementParent().node);
-});
+const keepBothStatementParents = opaquely(
+  (base, ext) => {
+    const extParent = ext.path.getStatementParent();
+    if (extParent) {
+      base.path.getStatementParent()?.insertAfter(extParent.node);
+    }
+  }
+);
 const interleaveStrategy = {
-  ImportDeclaration(baseImport, extImport) {
-    const baseSpecs = baseImport.specifiers;
-    const extSpecs = extImport.specifiers;
-    const importSpecifierEquality = (lhs, rhs) => lhs.type === rhs.type && lhs.imported?.name === rhs.imported?.name && lhs.local?.name == rhs.local?.name;
+  ImportDeclaration(base, ext) {
+    if (!t.isImportDeclaration(base) || !t.isImportDeclaration(ext)) {
+      return;
+    }
+    const baseSpecs = base.specifiers;
+    const extSpecs = ext.specifiers;
+    const importSpecifierEquality = (lhs, rhs) => {
+      if (lhs.type !== rhs.type) {
+        return false;
+      }
+      if (lhs.type === "ImportSpecifier" && rhs.type === "ImportSpecifier") {
+        return lhs.imported.type === "Identifier" && rhs.imported.type === "Identifier" && lhs.imported.name === rhs.imported.name && lhs.local?.name === rhs.local?.name;
+      }
+      return lhs.local?.name === rhs.local?.name;
+    };
     const uniqueSpecifiersOfType = (type) => uniqWith(
       [...baseSpecs, ...extSpecs].filter(nodeIs(type)),
       importSpecifierEquality
     );
     if (!baseSpecs.length !== !extSpecs.length) {
-      return keepBothStatementParents(baseImport, extImport);
+      return keepBothStatementParents(base, ext);
     }
     const defaultPosition = (specs) => specs.some(nodeIs("ImportDefaultSpecifier")) ? -1 : 0;
     const namespacePosition = (specs) => specs.some(nodeIs("ImportNamespaceSpecifier")) || specs.some(nodeIs("ImportSpecifier")) ? -1 : specs.length;
@@ -70,10 +97,10 @@ const interleaveStrategy = {
       [uniqueSpecifiersOfType("ImportNamespaceSpecifier"), namespacePosition],
       [uniqueSpecifiersOfType("ImportSpecifier"), importPosition]
     );
-    baseImport.specifiers = firstSpecifierList;
+    base.specifiers = firstSpecifierList;
     if (rest.length) {
-      baseImport.path.insertAfter(
-        rest.map((specs) => t.importDeclaration(specs, baseImport.source))
+      base.path.insertAfter(
+        rest.map((specs) => t.importDeclaration(specs, base.source))
       );
     }
   }
@@ -81,47 +108,70 @@ const interleaveStrategy = {
 function interleave(base, ext) {
   requireSameType(base, ext);
   requireStrategyExists(base, ext, interleaveStrategy, "interleave");
-  return interleaveStrategy[base.path.type](base, ext);
+  interleaveStrategy[base.path.type]?.(base, ext);
 }
 const concatStrategy = {
   ArrayExpression(base, ext) {
+    if (!t.isArrayExpression(base) || !t.isArrayExpression(ext)) {
+      return;
+    }
     base.elements = [...base.elements, ...ext.elements];
   },
   ObjectExpression(base, ext) {
+    if (!t.isObjectExpression(base) || !t.isObjectExpression(ext)) {
+      return;
+    }
     base.properties = [...base.properties, ...ext.properties];
   },
   StringLiteral(base, ext) {
+    if (!t.isStringLiteral(base) || !t.isStringLiteral(ext)) {
+      return;
+    }
     base.value = base.value.concat(ext.value);
   }
 };
 function concat(base, ext) {
   requireSameType(base, ext);
   requireStrategyExists(base, ext, concatStrategy, "concat");
-  return concatStrategy[base.path.type](base, ext);
+  concatStrategy[base.path.type]?.(base, ext);
 }
 const concatUniqueStrategy = {
   ArrayExpression(base, ext, eq) {
-    eq ||= defaultEquality(base.elements, ext.elements);
-    base.elements = uniqWith([...base.elements, ...ext.elements], eq);
+    if (!t.isArrayExpression(base) || !t.isArrayExpression(ext)) {
+      return;
+    }
+    const equalFn = eq ?? defaultEquality(base.elements, ext.elements);
+    base.elements = uniqWith([...base.elements, ...ext.elements], equalFn);
   },
   ObjectExpression(base, ext, eq) {
-    eq ||= defaultEquality(base.properties, ext.properties);
-    base.properties = uniqWith([...base.properties, ...ext.properties], eq);
+    if (!t.isObjectExpression(base) || !t.isObjectExpression(ext)) {
+      return;
+    }
+    const equalFn = eq ?? defaultEquality(base.properties, ext.properties);
+    base.properties = uniqWith([...base.properties, ...ext.properties], equalFn);
   }
 };
 function concatUnique(baseOrEq, ext) {
-  if (arguments.length === 1) {
-    return (base, ext2) => {
-      requireSameType(base, ext2);
-      requireStrategyExists(base, ext2, concatUniqueStrategy, "concatUnique");
-      return concatUniqueStrategy[base.path.type](base, ext2, baseOrEq);
+  if (typeof baseOrEq === "function") {
+    const eq = baseOrEq;
+    return (base2, innerExt) => {
+      requireSameType(base2, innerExt);
+      requireStrategyExists(
+        base2,
+        innerExt,
+        concatUniqueStrategy,
+        "concatUnique"
+      );
+      concatUniqueStrategy[base2.path.type]?.(base2, innerExt, eq);
     };
   }
-  if (arguments.length === 2) {
-    requireSameType(baseOrEq, ext);
-    requireStrategyExists(baseOrEq, ext, concatUniqueStrategy, "concatUnique");
-    return concatUniqueStrategy[baseOrEq.path.type](baseOrEq, ext);
+  const base = baseOrEq;
+  if (!ext) {
+    return;
   }
+  requireSameType(base, ext);
+  requireStrategyExists(base, ext, concatUniqueStrategy, "concatUnique");
+  concatUniqueStrategy[base.path.type]?.(base, ext);
 }
 export {
   concat,

package/dist/lib/schemaHelpers.js

@@ -9,13 +9,13 @@ const getExistingModelName = async (name) => {
     return void 0;
   }
   const modelName = name.replace(/[_-]/g, "").toLowerCase();
-  for (let model of Object.values(schemaMemo)) {
+  for (const model of Object.values(schemaMemo)) {
     if (model.name.toLowerCase() === modelName) {
       return model.name;
     }
   }
   const schema = (await getSchemaDefinitions()).datamodel;
-  for (let model of schema.models) {
+  for (const model of schema.models) {
     if (model.name.toLowerCase() === modelName) {
       return model.name;
     }
@@ -36,25 +36,24 @@ const getSchema = async (name) => {
   if (schemaMemo[modelName]) {
     return schemaMemo[modelName];
   }
-  const model = schema.models.find((model2) => model2.name === modelName);
+  const model = schema.models.find((m) => m.name === modelName);
   if (!model) {
     return void 0;
   }
-  model.fields.forEach((field) => {
+  const enrichedFields = model.fields.map((field) => {
     const fieldEnum = schema.enums.find((e) => field.type === e.name);
-    if (fieldEnum) {
-      field.enumValues = fieldEnum.values;
-    }
+    return fieldEnum ? { ...field, enumValues: fieldEnum.values } : { ...field };
   });
-  schemaMemo[modelName] = model;
-  return model;
+  const enrichedModel = { ...model, fields: enrichedFields };
+  schemaMemo[modelName] = enrichedModel;
+  return enrichedModel;
 };
 const getEnum = async (name) => {
   const schema = await getSchemaDefinitions();
   if (!name) {
     return schema.metadata.datamodel.enums;
   }
-  const model = schema.datamodel.enums.find((model2) => model2.name === name);
+  const model = schema.datamodel.enums.find((e) => e.name === name);
   if (!model) {
     throw new Error(
       `No enum schema definition found for \`${name}\` in schema.prisma file`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/cli",
-  "version": "5.0.0-canary.2547",
+  "version": "5.0.0-canary.2548",
   "description": "The CedarJS Command Line",
   "repository": {
     "type": "git",
@@ -33,17 +33,17 @@
   "dependencies": {
     "@babel/parser": "7.29.7",
     "@babel/preset-typescript": "7.29.7",
-    "@cedarjs/api-server": "5.0.0-canary.2547",
-    "@cedarjs/cli-helpers": "5.0.0-canary.2547",
-    "@cedarjs/fastify-web": "5.0.0-canary.2547",
-    "@cedarjs/internal": "5.0.0-canary.2547",
-    "@cedarjs/prerender": "5.0.0-canary.2547",
-    "@cedarjs/project-config": "5.0.0-canary.2547",
-    "@cedarjs/structure": "5.0.0-canary.2547",
-    "@cedarjs/telemetry": "5.0.0-canary.2547",
-    "@cedarjs/utils": "5.0.0-canary.2547",
-    "@cedarjs/vite": "5.0.0-canary.2547",
-    "@cedarjs/web-server": "5.0.0-canary.2547",
+    "@cedarjs/api-server": "5.0.0-canary.2548",
+    "@cedarjs/cli-helpers": "5.0.0-canary.2548",
+    "@cedarjs/fastify-web": "5.0.0-canary.2548",
+    "@cedarjs/internal": "5.0.0-canary.2548",
+    "@cedarjs/prerender": "5.0.0-canary.2548",
+    "@cedarjs/project-config": "5.0.0-canary.2548",
+    "@cedarjs/structure": "5.0.0-canary.2548",
+    "@cedarjs/telemetry": "5.0.0-canary.2548",
+    "@cedarjs/utils": "5.0.0-canary.2548",
+    "@cedarjs/vite": "5.0.0-canary.2548",
+    "@cedarjs/web-server": "5.0.0-canary.2548",
     "@listr2/prompt-adapter-enquirer": "4.2.1",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/core": "1.30.1",