@cedarjs/project-config 8.0.0-canary.3364 → 8.0.0-canary.3366

package/dist/index.js

@@ -415,6 +415,7 @@ var isTypeScriptProject = () => {
 import fs6 from "node:fs";
 import path5 from "node:path";
 import { pathToFileURL } from "node:url";
+import { Worker } from "node:worker_threads";
 
 // src/packageManager.ts
 import fs5 from "node:fs";
@@ -519,6 +520,55 @@ async function getDataMigrationsPath(prismaConfigPath) {
   const migrationsDir = path5.dirname(migrationsPath);
   return path5.join(migrationsDir, "dataMigrations");
 }
+async function getPrismaClientOutputDirs() {
+  try {
+    const mod = await import("@prisma/internals");
+    const { getConfig: getConfig3 } = mod.default || mod;
+    const { schemas, schemaRootDir } = await getPrismaSchemas();
+    const config = await getConfig3({ datamodel: schemas });
+    return config.generators.filter(
+      (generator) => ["prisma-client", "prisma-client-js"].includes(
+        generator.provider.value ?? ""
+      )
+    ).map((generator) => generator.output?.value).filter((output) => Boolean(output)).map(
+      (output) => path5.isAbsolute(output) ? output : path5.resolve(schemaRootDir, output)
+    );
+  } catch {
+    return [];
+  }
+}
+async function getPrismaClientOutputDirsIsolated() {
+  const { prismaClientOutputDirsWorkerUrl } = await import("./prismaClientOutputDirsWorkerUrl.js");
+  return new Promise((resolve) => {
+    const worker = new Worker(prismaClientOutputDirsWorkerUrl);
+    worker.once("message", (outputDirs) => {
+      resolve(
+        Array.isArray(outputDirs) ? outputDirs.filter((dir) => typeof dir === "string") : []
+      );
+      void worker.terminate();
+    });
+    worker.once("error", () => resolve([]));
+    worker.once("exit", () => resolve([]));
+  });
+}
+function createPrismaClientFileMatcher(resolveOutputDirs = getPrismaClientOutputDirsIsolated) {
+  let outputDirs;
+  const getOutputDirs = () => {
+    outputDirs ??= resolveOutputDirs();
+    return outputDirs;
+  };
+  return {
+    load: async () => {
+      await getOutputDirs();
+    },
+    matches: async (filePath) => {
+      return (await getOutputDirs()).some((dir) => {
+        const relativePath = path5.relative(dir, filePath);
+        return relativePath !== "" && !relativePath.startsWith("..") && !path5.isAbsolute(relativePath);
+      });
+    }
+  };
+}
 async function resolveGeneratedPrismaClient() {
   let generatorOutputPath;
   let ext = "ts";
@@ -600,6 +650,7 @@ function getEnvVarDefinitions() {
 export {
   DEFAULT_CONFIG,
   TargetEnum,
+  createPrismaClientFileMatcher,
   ensurePosixPath,
   findUp,
   getAppRouteHook,
@@ -616,6 +667,8 @@ export {
   getMigrationsPath,
   getParsedScalars,
   getPaths,
+  getPrismaClientOutputDirs,
+  getPrismaClientOutputDirsIsolated,
   getPrismaDatasourceProvider,
   getPrismaSchemas,
   getRawConfig,

package/dist/prisma.d.ts

@@ -51,6 +51,42 @@ export declare function getDbDir(prismaConfigPath: string): Promise<string>;
  * @returns Absolute path to the data migrations directory
  */
 export declare function getDataMigrationsPath(prismaConfigPath: string): Promise<string>;
+/**
+ * Gets the absolute output directories of the project's Prisma client
+ * generators (`prisma-client` and `prisma-client-js`).
+ *
+ * Other generators are not included: third-party generators (e.g. Zod schema
+ * generators) can emit source that relies on Cedar's import transforms.
+ *
+ * Returns an empty array if the schema can't be read or no client generator
+ * has an output path.
+ */
+export declare function getPrismaClientOutputDirs(): Promise<string[]>;
+/**
+ * Same as `getPrismaClientOutputDirs()`, but resolved in a worker thread.
+ *
+ * Loading `@prisma/internals` has process-wide side effects that slow down a
+ * Vite build running in the same process by several seconds on large
+ * projects. A worker has its own module registry, so those side effects stay
+ * contained.
+ */
+export declare function getPrismaClientOutputDirsIsolated(): Promise<string[]>;
+/**
+ * Creates a matcher that reports whether a file is part of the project's
+ * generated Prisma client. Build pipelines use it to skip Cedar's source
+ * transforms for that code.
+ *
+ * The output directories are resolved once and reused for the lifetime of the
+ * matcher, so create a new one per build. Call `load()` from a build start
+ * hook: resolving them lazily from the first transform makes the lookup
+ * compete with module transforms, which stalls every transform waiting on it.
+ *
+ * @param resolveOutputDirs - Resolves the Prisma client output directories
+ */
+export declare function createPrismaClientFileMatcher(resolveOutputDirs?: () => Promise<string[]>): {
+    load: () => Promise<void>;
+    matches: (filePath: string) => Promise<boolean>;
+};
 type ResolveReturnType = {
     clientPath: string;
     error: undefined;

package/dist/prisma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../src/prisma.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAQ1C;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,yBA8B9D;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,gBAAgB,EAAE,MAAM,mBAY3D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,mEAgBrC;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,MAAM,CAAC,CAWnE;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,CAiBjB;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQxE;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,KAAK,iBAAiB,GAClB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACxC;IAAE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAwD/E"}
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../src/prisma.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAQ1C;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,yBA8B9D;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,gBAAgB,EAAE,MAAM,mBAY3D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,mEAgBrC;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,MAAM,CAAC,CAWnE;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,CAiBjB;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQxE;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAyBnE;AAED;;;;;;;GAOG;AACH,wBAAsB,iCAAiC,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAkB3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAC3C,iBAAiB,GAAE,MAAM,OAAO,CAC9B,MAAM,EAAE,CAC2B;;wBAcT,MAAM;EAYnC;AAED,KAAK,iBAAiB,GAClB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACxC;IAAE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAwD/E"}

package/dist/prismaClientOutputDirsWorker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prismaClientOutputDirsWorker.d.ts.map

package/dist/prismaClientOutputDirsWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prismaClientOutputDirsWorker.d.ts","sourceRoot":"","sources":["../src/prismaClientOutputDirsWorker.ts"],"names":[],"mappings":""}

package/dist/prismaClientOutputDirsWorker.js

@@ -0,0 +1,344 @@
+// src/prismaClientOutputDirsWorker.ts
+import { parentPort } from "node:worker_threads";
+
+// src/prisma.ts
+import fs5 from "node:fs";
+import path4 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/paths.ts
+import fs4 from "node:fs";
+import path3 from "path";
+import fg from "fast-glob";
+
+// src/config.ts
+import fs2 from "node:fs";
+import merge from "deepmerge";
+import * as toml from "smol-toml";
+import { env as envInterpolation } from "string-env-interpolation";
+
+// src/findUp.ts
+import fs from "node:fs";
+import path from "path";
+function findUp(file, startingDirectory = process.cwd()) {
+  const possibleFilepath = path.join(startingDirectory, file);
+  if (fs.existsSync(possibleFilepath)) {
+    return possibleFilepath;
+  }
+  const parentDirectory = path.dirname(startingDirectory);
+  if (parentDirectory === startingDirectory) {
+    return null;
+  }
+  return findUp(file, parentDirectory);
+}
+
+// src/configPath.ts
+var CONFIG_FILE_NAMES = ["cedar.toml", "redwood.toml"];
+var getConfigPathCache = /* @__PURE__ */ new Map();
+var getConfigPath = (cwd = process.env.CEDAR_CWD ?? process.env.RWJS_CWD ?? process.cwd()) => {
+  const cachedPath = getConfigPathCache.get(cwd);
+  if (cachedPath) {
+    return cachedPath;
+  }
+  const configPath = findUp("cedar.toml", cwd) || findUp("redwood.toml", cwd);
+  if (!configPath) {
+    throw new Error(
+      `Could not find a "${CONFIG_FILE_NAMES.join('" or "')}" file, are you sure you're in a Cedar project?`
+    );
+  }
+  getConfigPathCache.set(cwd, configPath);
+  return configPath;
+};
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  web: {
+    title: "Cedar App",
+    port: 8910,
+    path: "./web",
+    target: "browser" /* BROWSER */,
+    includeEnvironmentVariables: [],
+    apiUrl: "/.api/functions",
+    fastRefresh: true,
+    a11y: true,
+    sourceMap: false
+  },
+  api: {
+    title: "Cedar App",
+    port: 8911,
+    path: "./api",
+    target: "node" /* NODE */,
+    prismaConfig: "./api/prisma.config.cjs",
+    prismaGenerateArgs: [],
+    serverConfig: "./api/server.config.js",
+    debugPort: void 0
+  },
+  graphql: {
+    fragments: false,
+    trustedDocuments: false,
+    includeScalars: { File: true },
+    parsedScalars: {}
+  },
+  browser: {
+    open: false
+  },
+  generate: {
+    tests: true,
+    stories: true,
+    nestScaffoldByModel: true
+  },
+  notifications: {
+    versionUpdates: []
+  },
+  studio: {
+    basePort: 4318,
+    graphiql: {
+      authImpersonation: {
+        authProvider: void 0,
+        userId: void 0,
+        email: void 0,
+        jwtSecret: "secret"
+      }
+    }
+  },
+  test: {
+    autoConsentToDbReset: false
+  },
+  experimental: {
+    opentelemetry: {
+      enabled: false,
+      wrapApi: true
+    },
+    cli: {
+      autoInstall: true,
+      plugins: [
+        {
+          package: "@cedarjs/cli-storybook-vite"
+        },
+        {
+          package: "@cedarjs/cli-data-migrate"
+        }
+      ]
+    },
+    useSDLCodeGenForGraphQLTypes: false,
+    streamingSsr: {
+      enabled: false
+    },
+    rsc: {
+      enabled: false
+    },
+    realtime: {
+      enabled: false
+    },
+    reactCompiler: {
+      enabled: false,
+      lintOnly: false
+    },
+    packagesWorkspace: {
+      enabled: false
+    },
+    gqlorm: {
+      enabled: false,
+      organizationModel: "Organization",
+      membershipModel: "Membership",
+      membershipUserField: "userId",
+      membershipOrganizationField: "organizationId"
+    }
+  }
+};
+function getConfig(configPath) {
+  const config = merge(DEFAULT_CONFIG, getRawConfig(configPath));
+  return config;
+}
+function getRawConfig(configPath = getConfigPath()) {
+  try {
+    return toml.parse(envInterpolation(fs2.readFileSync(configPath, "utf8")));
+  } catch (e) {
+    throw new Error(`Could not parse "${configPath}": ${e}`);
+  }
+}
+
+// src/generatedDataDir.ts
+import fs3 from "node:fs";
+import path2 from "node:path";
+function getGeneratedDataDirPath(cwd = process.env.CEDAR_CWD ?? process.env.RWJS_CWD ?? process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  const projectRoot = path2.dirname(configPath);
+  const rootDotCedarDir = path2.join(projectRoot, ".cedar");
+  const rootDotRedwoodDir = path2.join(projectRoot, ".redwood");
+  const generatedDirPath = fs3.existsSync(rootDotCedarDir) ? rootDotCedarDir : fs3.existsSync(rootDotRedwoodDir) ? rootDotRedwoodDir : rootDotCedarDir;
+  return generatedDirPath;
+}
+
+// src/paths.ts
+var getBaseDir = (configPath = getConfigPath()) => {
+  return path3.dirname(configPath);
+};
+var resolveFile = (filePath, extensions = [".js", ".tsx", ".ts", ".jsx", ".mjs", ".mts", ".cjs"]) => {
+  for (const extension of extensions) {
+    const p = `${filePath}${extension}`;
+    if (fs4.existsSync(p)) {
+      return p;
+    }
+  }
+  return null;
+};
+var getPathsCache = /* @__PURE__ */ new Map();
+function getPaths(BASE_DIR = getBaseDir()) {
+  if (getPathsCache.has(BASE_DIR)) {
+    return getPathsCache.get(BASE_DIR);
+  }
+  const routes = resolveFile(path3.join(BASE_DIR, "web/src/Routes"));
+  const { prismaConfig: prismaConfigFromConfig } = getConfig(
+    getConfigPath(BASE_DIR)
+  ).api;
+  const prismaConfigBase = path3.join(
+    BASE_DIR,
+    prismaConfigFromConfig.replace(/\.[^.]+$/, "")
+  );
+  const prismaConfig = resolveFile(prismaConfigBase) || path3.join(BASE_DIR, prismaConfigFromConfig);
+  const viteConfig = resolveFile(
+    path3.join(BASE_DIR, "web/vite.config")
+  );
+  const generatedBase = getGeneratedDataDirPath(BASE_DIR);
+  const paths = {
+    base: BASE_DIR,
+    generated: {
+      base: generatedBase,
+      schema: path3.join(generatedBase, "schema.graphql"),
+      types: {
+        includes: path3.join(generatedBase, "types/includes"),
+        mirror: path3.join(generatedBase, "types/mirror")
+      },
+      prebuild: path3.join(generatedBase, "prebuild")
+    },
+    scripts: path3.join(BASE_DIR, "scripts"),
+    packages: path3.join(BASE_DIR, "packages"),
+    generatorTemplates: path3.join(BASE_DIR, "generatorTemplates"),
+    api: {
+      base: path3.join(BASE_DIR, "api"),
+      prismaConfig,
+      functions: path3.join(BASE_DIR, "api/src/functions"),
+      graphql: path3.join(BASE_DIR, "api/src/graphql"),
+      lib: path3.join(BASE_DIR, "api/src/lib"),
+      config: path3.join(BASE_DIR, "api/src/config"),
+      services: path3.join(BASE_DIR, "api/src/services"),
+      directives: path3.join(BASE_DIR, "api/src/directives"),
+      subscriptions: path3.join(BASE_DIR, "api/src/subscriptions"),
+      src: path3.join(BASE_DIR, "api/src"),
+      dist: path3.join(BASE_DIR, "api/dist"),
+      types: path3.join(BASE_DIR, "api/types"),
+      models: path3.join(BASE_DIR, "api/src/models"),
+      mail: path3.join(BASE_DIR, "api/src", "mail"),
+      jobs: path3.join(BASE_DIR, "api/src/jobs"),
+      distJobs: path3.join(BASE_DIR, "api/dist/jobs"),
+      jobsConfig: resolveFile(path3.join(BASE_DIR, "api/src/lib", "jobs")),
+      distJobsConfig: resolveFile(
+        path3.join(BASE_DIR, "api/dist", "lib", "jobs")
+      ),
+      logger: resolveFile(path3.join(BASE_DIR, "api/src/lib", "logger"))
+    },
+    web: {
+      routes,
+      base: path3.join(BASE_DIR, "web"),
+      pages: path3.join(BASE_DIR, "web/src/pages/"),
+      components: path3.join(BASE_DIR, "web/src/components"),
+      layouts: path3.join(BASE_DIR, "web/src/layouts/"),
+      src: path3.join(BASE_DIR, "web/src"),
+      storybook: path3.join(BASE_DIR, "web/.storybook"),
+      app: resolveFile(path3.join(BASE_DIR, "web/src/App")),
+      document: resolveFile(path3.join(BASE_DIR, "web/src/Document")),
+      html: path3.join(BASE_DIR, "web/index.html"),
+      config: path3.join(BASE_DIR, "web/config"),
+      viteConfig,
+      postcss: path3.join(BASE_DIR, "web/config/postcss.config.cjs"),
+      storybookConfig: path3.join(BASE_DIR, "web/.storybook/main.js"),
+      storybookPreviewConfig: resolveFile(
+        path3.join(BASE_DIR, "web/.storybook/preview")
+      ),
+      storybookManagerConfig: path3.join(BASE_DIR, "web/.storybook/manager.js"),
+      dist: path3.join(BASE_DIR, "web/dist"),
+      distBrowser: path3.join(BASE_DIR, "web/dist/browser"),
+      distRsc: path3.join(BASE_DIR, "web/dist/rsc"),
+      distSsr: path3.join(BASE_DIR, "web/dist/ssr"),
+      distSsrDocument: path3.join(BASE_DIR, "web/dist/ssr/Document"),
+      distSsrEntryServer: path3.join(BASE_DIR, "web/dist/ssr/entry.server"),
+      distRouteHooks: path3.join(BASE_DIR, "web/dist/ssr/routeHooks"),
+      distRscEntries: path3.join(BASE_DIR, "web/dist/rsc/entries.mjs"),
+      routeManifest: path3.join(BASE_DIR, "web/dist/ssr/route-manifest.json"),
+      types: path3.join(BASE_DIR, "web/types"),
+      entryClient: resolveFile(path3.join(BASE_DIR, "web/src/entry.client")),
+      // new vite/stream entry point for client
+      entryServer: resolveFile(path3.join(BASE_DIR, "web/src/entry.server")),
+      graphql: path3.join(BASE_DIR, "web/src/graphql")
+    }
+  };
+  fs4.mkdirSync(paths.generated.types.includes, { recursive: true });
+  fs4.mkdirSync(paths.generated.types.mirror, { recursive: true });
+  getPathsCache.set(BASE_DIR, paths);
+  return paths;
+}
+
+// src/prisma.ts
+var configCache = /* @__PURE__ */ new Map();
+async function loadPrismaConfig(prismaConfigPath) {
+  if (!fs5.existsSync(prismaConfigPath)) {
+    throw new Error(`Prisma config file not found at: ${prismaConfigPath}`);
+  }
+  if (configCache.has(prismaConfigPath)) {
+    return configCache.get(prismaConfigPath);
+  }
+  const configUrl = pathToFileURL(prismaConfigPath).href;
+  let config;
+  try {
+    const mod = await import(configUrl);
+    config = mod.default || mod;
+    if (!config) {
+      throw new Error("Prisma config must have a default export");
+    }
+    configCache.set(prismaConfigPath, config);
+  } catch (error) {
+    throw new Error(
+      `Failed to load Prisma config from ${prismaConfigPath}: ${error}`
+    );
+  }
+  return config;
+}
+async function getSchemaPath(prismaConfigPath) {
+  const config = await loadPrismaConfig(prismaConfigPath);
+  const configDir = path4.dirname(prismaConfigPath);
+  if (config.schema) {
+    return path4.isAbsolute(config.schema) ? config.schema : path4.resolve(configDir, config.schema);
+  }
+  return path4.join(configDir, "schema.prisma");
+}
+async function getPrismaSchemas() {
+  const mod = await import("@prisma/internals");
+  const { createSchemaPathInput, getSchemaWithPath } = mod.default || mod;
+  const schemaPath = await getSchemaPath(getPaths().api.prismaConfig);
+  const schemaPathInput = createSchemaPathInput({
+    baseDir: fs5.lstatSync(schemaPath).isDirectory() ? schemaPath : path4.dirname(schemaPath),
+    schemaPathFromConfig: schemaPath
+  });
+  return getSchemaWithPath({ schemaPath: schemaPathInput });
+}
+async function getPrismaClientOutputDirs() {
+  try {
+    const mod = await import("@prisma/internals");
+    const { getConfig: getConfig2 } = mod.default || mod;
+    const { schemas, schemaRootDir } = await getPrismaSchemas();
+    const config = await getConfig2({ datamodel: schemas });
+    return config.generators.filter(
+      (generator) => ["prisma-client", "prisma-client-js"].includes(
+        generator.provider.value ?? ""
+      )
+    ).map((generator) => generator.output?.value).filter((output) => Boolean(output)).map(
+      (output) => path4.isAbsolute(output) ? output : path4.resolve(schemaRootDir, output)
+    );
+  } catch {
+    return [];
+  }
+}
+
+// src/prismaClientOutputDirsWorker.ts
+parentPort?.postMessage(await getPrismaClientOutputDirs());

package/dist/prismaClientOutputDirsWorkerUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const prismaClientOutputDirsWorkerUrl: URL;
+//# sourceMappingURL=prismaClientOutputDirsWorkerUrl.d.ts.map

package/dist/prismaClientOutputDirsWorkerUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prismaClientOutputDirsWorkerUrl.d.ts","sourceRoot":"","sources":["../src/prismaClientOutputDirsWorkerUrl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,+BAA+B,KAG3C,CAAA"}

package/dist/prismaClientOutputDirsWorkerUrl.js

@@ -0,0 +1,8 @@
+// src/prismaClientOutputDirsWorkerUrl.ts
+var prismaClientOutputDirsWorkerUrl = new URL(
+  "./prismaClientOutputDirsWorker.js",
+  import.meta.url
+);
+export {
+  prismaClientOutputDirsWorkerUrl
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/project-config",
-  "version": "8.0.0-canary.3364",
+  "version": "8.0.0-canary.3366",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -46,7 +46,7 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.5",
-    "@cedarjs/framework-tools": "8.0.0-canary.3364",
+    "@cedarjs/framework-tools": "8.0.0-canary.3366",
     "concurrently": "9.2.4",
     "prisma": "7.10.0",
     "publint": "0.3.25",