@cedarjs/vite 9.0.0-canary.1784 → 9.0.0-canary.3124

package/bins/cedar-unified-dev.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startUnifiedDevServer } from '../dist/cedar-unified-dev.js'
+
+startUnifiedDevServer().catch((err) => {
+  console.error('Failed to start unified dev server:', err)
+  process.exit(1)
+})

package/bins/{rw-vite-dev.mjs → cedar-vite-dev.mjs}

@@ -16,15 +16,28 @@ const startDevServer = async () => {
   // Tries to maintain the same options as vite's dev cli
   // See here: https://github.com/vitejs/vite/blob/main/packages/vite/src/node/cli.ts#L103
   // e.g. yarn cedar dev web --fwd="--force"
+  //
+  // `force` and `debug` aren't Vite server options, so pull those out.
+  // Everything else yargs-parser picks out of argv (e.g. `open`, `port`,
+  // `https`, `strictPort`, `cors`) is a forwarded server option and gets
+  // passed straight through to Vite's `server` config.
   const {
     force: forceOptimize,
-    forwardedServerArgs,
     debug,
+    _: _positional,
+    ...forwardedServerArgs
   } = yargsParser(process.argv.slice(2), {
     boolean: ['https', 'open', 'strictPort', 'force', 'cors', 'debug'],
     number: ['port'],
   })
 
+  // Default to not auto-opening a browser when there's no interactive
+  // terminal attached (CI, AI coding agents, etc.), unless the user
+  // explicitly forwarded --open.
+  if (forwardedServerArgs.open === undefined && !process.stdout.isTTY) {
+    forwardedServerArgs.open = false
+  }
+
   const devServer = await createServer({
     configFile,
     envFile: false, // env file is handled by plugins in the redwood-vite plugin

package/dist/api/vite-plugin-cedar-vitest-api-preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-cedar-vitest-api-preset.d.ts","sourceRoot":"","sources":["../../src/api/vite-plugin-cedar-vitest-api-preset.ts"],"names":[],"mappings":"AAQA,wBAAgB,iBAAiB,kEAOhC"}
+{"version":3,"file":"vite-plugin-cedar-vitest-api-preset.d.ts","sourceRoot":"","sources":["../../src/api/vite-plugin-cedar-vitest-api-preset.ts"],"names":[],"mappings":"AAUA,wBAAgB,iBAAiB,kEAShC"}

package/dist/api/vite-plugin-cedar-vitest-api-preset.js

@@ -3,12 +3,16 @@ import {
   cedarVitestApiConfigPlugin,
   trackDbImportsPlugin
 } from "@cedarjs/testing/api/vitest";
-import { cedarjsDirectoryNamedImportPlugin } from "../plugins/vite-plugin-cedarjs-directory-named-import.js";
+import { cedarImportDirPlugin } from "../plugins/vite-plugin-cedar-import-dir.js";
+import { cedarjsJobPathInjectorPlugin } from "../plugins/vite-plugin-cedarjs-job-path-injector.js";
+import { cedarjsResolveCedarStyleImportsPlugin } from "../plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js";
 function cedarVitestPreset() {
   return [
+    cedarImportDirPlugin(),
+    cedarjsJobPathInjectorPlugin(),
     cedarVitestApiConfigPlugin(),
     autoImportsPlugin(),
-    cedarjsDirectoryNamedImportPlugin(),
+    cedarjsResolveCedarStyleImportsPlugin(),
     trackDbImportsPlugin()
   ];
 }

package/dist/apiDevMiddleware.d.ts

@@ -0,0 +1,15 @@
+import type { ViteDevServer } from 'vite';
+export declare function loadApiFunctions(viteServer: ViteDevServer): Promise<void>;
+export declare function createApiViteServer(): Promise<ViteDevServer>;
+export declare function setupHmrHandlers(viteServer: ViteDevServer): void;
+/**
+ * Creates a fetch-native handler for API requests.
+ * Routes GraphQL to Yoga and Lambda functions to their handlers.
+ */
+export declare function createApiFetchHandler(): (request: Request) => Promise<Response>;
+export declare function startApiDevMiddleware(): Promise<{
+    viteServer: ViteDevServer;
+    close: () => Promise<void>;
+    handler: (request: Request) => Promise<Response>;
+}>;
+//# sourceMappingURL=apiDevMiddleware.d.ts.map

package/dist/apiDevMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDevMiddleware.d.ts","sourceRoot":"","sources":["../src/apiDevMiddleware.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAsB,aAAa,EAAE,MAAM,MAAM,CAAA;AAoE7D,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,aAAa,iBAe/D;AA8GD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,aAAa,CAAC,CAyMlE;AA0BD,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,aAAa,GAAG,IAAI,CA0EhE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,KAIrB,SAAS,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC,CAiGnD;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC;IACrD,UAAU,EAAE,aAAa,CAAA;IACzB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjD,CAAC,CAcD"}

package/dist/apiDevMiddleware.js

@@ -0,0 +1,435 @@
+import fs from "node:fs";
+import { glob } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import ansis from "ansis";
+import { normalizePath } from "vite";
+import { gqlPlugin as gqlTagPlugin } from "vite-plugin-graphql-tag";
+import tsPathsMod from "vite-tsconfig-paths";
+const tsconfigPaths = (
+  // @ts-expect-error – .default only exists at runtime in CJS double-wrap
+  // interop
+  tsPathsMod.default?.default || tsPathsMod.default || tsPathsMod
+);
+import { buildCedarContext, wrapLegacyHandler } from "@cedarjs/api/runtime";
+import {
+  getApiSideBabelConfigPath,
+  getApiSideBabelPluginsForVite,
+  transformWithBabel
+} from "@cedarjs/babel-config";
+import { getAsyncStoreInstance } from "@cedarjs/context/dist/store";
+import { createGraphQLYoga } from "@cedarjs/graphql-server";
+import { applyGqlormInject } from "@cedarjs/internal/dist/build/api-graphql-transforms.js";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { generateDiffSourceMap } from "./lib/generateDiffSourceMap.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";
+import { applyGraphqlOptionsExtract } from "./plugins/vite-plugin-cedar-graphql-options-extract.js";
+import { cedarImportDirPlugin } from "./plugins/vite-plugin-cedar-import-dir.js";
+import { cedarApiLogFormatterDevPlugin } from "./plugins/vite-plugin-cedar-log-formatter-dev.js";
+import { applyOtelWrapping } from "./plugins/vite-plugin-cedar-otel-wrapping.js";
+import { cedarjsJobPathInjectorPlugin } from "./plugins/vite-plugin-cedarjs-job-path-injector.js";
+function resolveWithExtensions(id) {
+  if (fs.existsSync(id) && fs.statSync(id).isFile()) {
+    return id;
+  }
+  for (const ext of [".js", ".ts", ".jsx", ".tsx", ".mjs", ".mts"]) {
+    const withExt = id + ext;
+    if (fs.existsSync(withExt)) {
+      return withExt;
+    }
+  }
+  return id;
+}
+const LAMBDA_FUNCTIONS = {};
+let loadedGraphqlServer = null;
+let loadApiFunctionsInFlight = null;
+let needsReloadAfterInFlight = false;
+async function loadApiFunctions(viteServer) {
+  if (loadApiFunctionsInFlight) {
+    needsReloadAfterInFlight = true;
+    return;
+  }
+  do {
+    needsReloadAfterInFlight = false;
+    loadApiFunctionsInFlight = internalLoadApiFunctions(viteServer);
+    try {
+      await loadApiFunctionsInFlight;
+    } finally {
+      loadApiFunctionsInFlight = null;
+    }
+  } while (needsReloadAfterInFlight);
+}
+async function internalLoadApiFunctions(viteServer) {
+  const cedarPaths = getPaths();
+  for (const key of Object.keys(LAMBDA_FUNCTIONS)) {
+    delete LAMBDA_FUNCTIONS[key];
+  }
+  let srcFunctions = [];
+  try {
+    srcFunctions = await Array.fromAsync(
+      glob("**/*.{ts,tsx,js,jsx}", {
+        cwd: cedarPaths.api.functions,
+        exclude: [
+          "**/*.test.{ts,tsx,js,jsx}",
+          "**/*.scenarios.{ts,tsx,js,jsx}",
+          "**/*.fixtures.{ts,tsx,js,jsx}",
+          "**/*.d.ts"
+        ]
+      }),
+      (entry) => path.join(cedarPaths.api.functions, entry)
+    );
+  } catch {
+    srcFunctions = [];
+  }
+  console.log(ansis.dim.italic("Importing Server Functions... "));
+  const tsImport = Date.now();
+  let extractedGraphqlOptions = null;
+  const imports = srcFunctions.map(async (fnPath) => {
+    const ts = Date.now();
+    const routeName = path.basename(fnPath).replace(/\.(ts|tsx|js|jsx)$/, "");
+    try {
+      const mod = await viteServer.ssrLoadModule(pathToFileURL(fnPath).href);
+      const cedarHandler = (() => {
+        if ("handleRequest" in mod) {
+          return mod.handleRequest;
+        }
+        if ("default" in mod && mod.default && "handleRequest" in mod.default) {
+          return mod.default.handleRequest;
+        }
+        let legacyHandler;
+        if ("handler" in mod) {
+          legacyHandler = mod.handler;
+        } else if ("default" in mod && mod.default && "handler" in mod.default) {
+          legacyHandler = mod.default.handler;
+        }
+        if (legacyHandler) {
+          return wrapLegacyHandler(legacyHandler);
+        }
+        return void 0;
+      })();
+      if (cedarHandler) {
+        LAMBDA_FUNCTIONS[routeName] = cedarHandler;
+        console.log(
+          ansis.magenta("/" + routeName),
+          ansis.dim.italic(Date.now() - ts + " ms")
+        );
+      } else {
+        console.warn(
+          `[apiDevMiddleware] No handler or handleRequest export found in function: ${fnPath}`
+        );
+      }
+      if (routeName === "graphql" && "__cedar_graphqlOptions" in mod) {
+        extractedGraphqlOptions = mod.__cedar_graphqlOptions;
+      }
+    } catch (err) {
+      viteServer.ssrFixStacktrace(err);
+      console.error(
+        `[apiDevMiddleware] Failed to load function "${routeName}" from ${fnPath}:`,
+        err
+      );
+    }
+  });
+  await Promise.all(imports);
+  if (extractedGraphqlOptions) {
+    loadedGraphqlServer = await createGraphQLYoga(extractedGraphqlOptions);
+  } else {
+    loadedGraphqlServer = null;
+  }
+  console.log(
+    ansis.dim.italic("...Done importing in " + (Date.now() - tsImport) + " ms")
+  );
+}
+async function createApiViteServer() {
+  const cedarPaths = getPaths();
+  const cedarConfig = getConfig();
+  const normalizedBase = normalizePath(cedarPaths.base);
+  const babelPlugins = getApiSideBabelConfigPath() ? getApiSideBabelPluginsForVite() : null;
+  const workspacePkgSourceMap = Object.fromEntries(
+    Object.entries(getWorkspacePackageAliases(cedarPaths, cedarConfig)).map(
+      ([name, sourceFile]) => [name, normalizePath(sourceFile)]
+    )
+  );
+  const { createServer: createViteServer } = await import("vite");
+  return createViteServer({
+    configFile: false,
+    root: cedarPaths.api.base,
+    appType: "custom",
+    clearScreen: false,
+    logLevel: "warn",
+    server: {
+      middlewareMode: true
+    },
+    resolve: {
+      alias: workspacePkgSourceMap
+    },
+    plugins: [
+      // tsconfigPaths resolves user-defined tsconfig.json `paths` aliases; it
+      // replaces the Babel module-resolver's tsconfig-paths handling for dev.
+      tsconfigPaths(),
+      cedarApiLogFormatterDevPlugin(),
+      {
+        name: "cedar-api-src-redirect",
+        enforce: "pre",
+        resolveId(id, importer) {
+          const normalizedImporter = importer && normalizePath(importer);
+          const normalizedApiSrc = normalizePath(cedarPaths.api.src);
+          if (!normalizedImporter?.startsWith(`${normalizedApiSrc}/`)) {
+            return null;
+          }
+          if (id.startsWith("src/")) {
+            return resolveWithExtensions(
+              path.join(cedarPaths.api.src, id.slice(4))
+            );
+          }
+          return null;
+        }
+      },
+      cedarImportDirPlugin(),
+      cedarDirectoryNamedImportPlugin(),
+      cedarAutoImportsPlugin(),
+      cedarjsJobPathInjectorPlugin(),
+      (() => {
+        const p = gqlTagPlugin();
+        p.enforce = "post";
+        return p;
+      })(),
+      {
+        name: "cedar-api-babel-transform",
+        enforce: "pre",
+        async transform(code, id) {
+          if (!/\.(ts|tsx|js|jsx)$/.test(id)) {
+            return null;
+          }
+          if (id.includes("node_modules")) {
+            return null;
+          }
+          if (!id.startsWith(normalizedBase)) {
+            return null;
+          }
+          let sourceCode = code;
+          let sourceMap = null;
+          if (normalizePath(id).endsWith("/graphql.ts") || normalizePath(id).endsWith("/graphql.js")) {
+            const extracted = applyGraphqlOptionsExtract(sourceCode);
+            if (extracted) {
+              sourceCode = extracted.code;
+              sourceMap = extracted.map;
+            }
+            const injected = applyGqlormInject(sourceCode, id);
+            if (injected) {
+              sourceCode = injected;
+              sourceMap = null;
+            }
+          }
+          try {
+            if (cedarConfig.experimental?.opentelemetry?.enabled && cedarConfig.experimental?.opentelemetry?.wrapApi) {
+              const relativePath = normalizePath(id).slice(
+                normalizedBase.length + "/api/src/".length
+              );
+              const apiFolder = relativePath.split("/")[0] ?? "?";
+              const wrapped = applyOtelWrapping(sourceCode, id, apiFolder);
+              if (wrapped) {
+                sourceCode = wrapped;
+                sourceMap = null;
+              }
+            }
+            if (!babelPlugins) {
+              if (sourceCode === code) {
+                return null;
+              }
+              return {
+                code: sourceCode,
+                map: sourceMap ?? generateDiffSourceMap(code, sourceCode)
+              };
+            }
+            const inputSourceMap = sourceCode === code ? null : sourceMap ?? generateDiffSourceMap(code, sourceCode);
+            if (inputSourceMap) {
+              inputSourceMap.sources = [id];
+            }
+            const result = await transformWithBabel(
+              sourceCode,
+              id,
+              babelPlugins,
+              true,
+              true,
+              inputSourceMap ?? void 0
+            );
+            if (!result?.code) {
+              return null;
+            }
+            return {
+              code: result.code,
+              map: result.map ?? null
+            };
+          } catch (err) {
+            this.warn(
+              `[cedar-api-babel-transform] Failed to transform ${id}: ${String(err)}`
+            );
+            return null;
+          }
+        }
+      }
+    ]
+  });
+}
+function invalidateApiModules(viteServer, normalizedApiSrc) {
+  const invalidated = /* @__PURE__ */ new Set();
+  const invalidateWithImporters = (mod) => {
+    if (!mod || invalidated.has(mod.id ?? mod.url)) {
+      return;
+    }
+    invalidated.add(mod.id ?? mod.url);
+    viteServer.moduleGraph.invalidateModule(mod);
+    for (const importer of mod.importers) {
+      invalidateWithImporters(importer);
+    }
+  };
+  for (const mod of viteServer.moduleGraph.idToModuleMap.values()) {
+    if (mod.id?.startsWith(normalizedApiSrc)) {
+      invalidateWithImporters(mod);
+    }
+  }
+}
+function setupHmrHandlers(viteServer) {
+  const cedarPaths = getPaths();
+  const normalizedApiSrc = normalizePath(cedarPaths.api.src);
+  const normalizedApiBase = normalizePath(cedarPaths.api.base);
+  viteServer.watcher.on("change", async (filePath) => {
+    const normalizedFilePath = normalizePath(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    const displayPath = path.relative(normalizedApiBase, normalizedFilePath);
+    console.log(ansis.dim(`[change] ${displayPath}`));
+    const fileUrl = pathToFileURL(normalizedFilePath).href;
+    const mod = viteServer.moduleGraph.getModuleById(normalizedFilePath) ?? viteServer.moduleGraph.getModuleById(fileUrl);
+    if (mod) {
+      const invalidated = /* @__PURE__ */ new Set();
+      const invalidateWithImporters = (m) => {
+        if (!m || invalidated.has(m.id ?? m.url)) {
+          return;
+        }
+        invalidated.add(m.id ?? m.url);
+        viteServer.moduleGraph.invalidateModule(m);
+        for (const importer of m.importers) {
+          invalidateWithImporters(importer);
+        }
+      };
+      invalidateWithImporters(mod);
+    }
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("add", async (filePath) => {
+    const normalizedFilePath = normalizePath(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      ansis.dim(
+        `[add] ${path.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("unlink", async (filePath) => {
+    const normalizedFilePath = normalizePath(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      ansis.dim(
+        `[unlink] ${path.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+}
+function createApiFetchHandler() {
+  const cedarConfig = getConfig();
+  const apiUrlPrefix = cedarConfig.web.apiUrl.replace(/\/$/, "");
+  return async (request) => {
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+    if (pathname.startsWith(apiUrlPrefix + "/")) {
+      pathname = pathname.slice(apiUrlPrefix.length);
+    } else if (pathname === apiUrlPrefix) {
+      pathname = "/";
+    }
+    if (pathname === "/graphql" || pathname.startsWith("/graphql/")) {
+      const graphqlServer = loadedGraphqlServer;
+      if (!graphqlServer) {
+        return new Response(
+          JSON.stringify({ error: "GraphQL Yoga instance not initialized" }),
+          { status: 503, headers: { "Content-Type": "application/json" } }
+        );
+      }
+      return getAsyncStoreInstance().run(/* @__PURE__ */ new Map(), async () => {
+        try {
+          const cedarContext = await graphqlServer.buildRequestContext(request);
+          return await graphqlServer.yoga.handle(request, {
+            request,
+            cedarContext
+          });
+        } catch (e) {
+          if (!!e && typeof e === "object" && "code" in e && e.code === "ERR_STREAM_PREMATURE_CLOSE") {
+            return new Response(null, { status: 499 });
+          }
+          throw e;
+        }
+      });
+    }
+    const match = pathname.match(/^\/([^/]+)(?:\/.*)?$/);
+    if (!match) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const routeName = match[1];
+    const handler = LAMBDA_FUNCTIONS[routeName];
+    if (!handler) {
+      return new Response(
+        JSON.stringify({
+          error: `Function "${routeName}" was not found.`,
+          availableFunctions: Object.keys(LAMBDA_FUNCTIONS)
+        }),
+        { status: 404, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    try {
+      const ctx = await buildCedarContext(request, {
+        params: { routeName }
+      });
+      return await handler(request, ctx);
+    } catch (err) {
+      console.error(
+        `[apiDevMiddleware] Error handling function "${routeName}":`,
+        err
+      );
+      return new Response(
+        JSON.stringify({
+          error: err instanceof Error ? err.message : "Internal Server Error"
+        }),
+        { status: 500, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  };
+}
+async function startApiDevMiddleware() {
+  const viteServer = await createApiViteServer();
+  console.log(ansis.dim.italic("Starting API dev server..."));
+  await loadApiFunctions(viteServer);
+  setupHmrHandlers(viteServer);
+  const close = async () => {
+    await viteServer.close();
+  };
+  const handler = createApiFetchHandler();
+  return { viteServer, close, handler };
+}
+export {
+  createApiFetchHandler,
+  createApiViteServer,
+  loadApiFunctions,
+  setupHmrHandlers,
+  startApiDevMiddleware
+};

package/dist/build/build.d.ts

@@ -1,3 +1,4 @@
+export { buildCedarApp } from '../buildApp.js';
 interface BuildOptions {
     verbose?: boolean;
 }
@@ -6,5 +7,4 @@ interface BuildOptions {
  * because we want to set the process.cwd to web.base
  */
 export declare const buildWeb: ({ verbose }: BuildOptions) => Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher>;
-export {};
 //# sourceMappingURL=build.d.ts.map

package/dist/build/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/build/build.ts"],"names":[],"mappings":"AAEA,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAU,aAAa,YAAY,8GAoBvD,CAAA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/build/build.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAE9C,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAU,aAAa,YAAY,8GAoBvD,CAAA"}

package/dist/build/build.js

@@ -1,4 +1,5 @@
 import { getPaths } from "@cedarjs/project-config";
+import { buildCedarApp } from "../buildApp.js";
 const buildWeb = async ({ verbose }) => {
   const { build } = await import("vite");
   const viteConfig = getPaths().web.viteConfig;
@@ -17,5 +18,6 @@ const buildWeb = async ({ verbose }) => {
   });
 };
 export {
+  buildCedarApp,
   buildWeb
 };

package/dist/buildApp.d.ts

@@ -0,0 +1,16 @@
+export interface BuildCedarAppOptions {
+    verbose?: boolean;
+    workspace?: string[];
+    ud?: boolean;
+}
+/**
+ * Unified build for Cedar apps using Vite's builder API.
+ *
+ * Declares `client` and `api` environments and builds them in a single
+ * orchestrated pass. The web client is built from the project's web Vite
+ * config. The API is built as an SSR environment with Babel transforms and
+ * `src/` import redirection so it resolves correctly even though the builder
+ * root is the web source directory.
+ */
+export declare function buildCedarApp({ verbose, workspace, ud, }?: BuildCedarAppOptions): Promise<void>;
+//# sourceMappingURL=buildApp.d.ts.map

package/dist/buildApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildApp.d.ts","sourceRoot":"","sources":["../src/buildApp.ts"],"names":[],"mappings":"AA6DA,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,iBAsa3B"}