@zappdev/cli 0.1.0

package/native/vendor/webview2/include/WebView2EnvironmentOptions.h

@@ -0,0 +1,406 @@
+// Copyright (C) Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef __core_webview2_environment_options_h__
+#define __core_webview2_environment_options_h__
+
+#include <objbase.h>
+#include <wrl/implements.h>
+
+#include "WebView2.h"
+#define CORE_WEBVIEW_TARGET_PRODUCT_VERSION L"131.0.2903.40"
+
+#define COREWEBVIEW2ENVIRONMENTOPTIONS_STRING_PROPERTY(p)     \
+ public:                                                      \
+  HRESULT STDMETHODCALLTYPE get_##p(LPWSTR* value) override { \
+    if (!value)                                               \
+      return E_POINTER;                                       \
+    *value = m_##p.Copy();                                    \
+    if ((*value == nullptr) && (m_##p.Get() != nullptr))      \
+      return HRESULT_FROM_WIN32(GetLastError());              \
+    return S_OK;                                              \
+  }                                                           \
+  HRESULT STDMETHODCALLTYPE put_##p(LPCWSTR value) override { \
+    LPCWSTR result = m_##p.Set(value);                        \
+    if ((result == nullptr) && (value != nullptr))            \
+      return HRESULT_FROM_WIN32(GetLastError());              \
+    return S_OK;                                              \
+  }                                                           \
+                                                              \
+ protected:                                                   \
+  AutoCoMemString m_##p;
+
+#define COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(p, defPVal) \
+ public:                                                         \
+  HRESULT STDMETHODCALLTYPE get_##p(BOOL* value) override {      \
+    if (!value)                                                  \
+      return E_POINTER;                                          \
+    *value = m_##p;                                              \
+    return S_OK;                                                 \
+  }                                                              \
+  HRESULT STDMETHODCALLTYPE put_##p(BOOL value) override {       \
+    m_##p = value;                                               \
+    return S_OK;                                                 \
+  }                                                              \
+                                                                 \
+ protected:                                                      \
+  BOOL m_##p = defPVal ? TRUE : FALSE;
+
+#define DEFINE_AUTO_COMEM_STRING()                                      \
+ protected:                                                             \
+  class AutoCoMemString {                                               \
+   public:                                                              \
+    AutoCoMemString() {}                                                \
+    ~AutoCoMemString() { Release(); }                                   \
+    void Release() {                                                    \
+      if (m_string) {                                                   \
+        deallocate_fn(m_string);                                        \
+        m_string = nullptr;                                             \
+      }                                                                 \
+    }                                                                   \
+                                                                        \
+    LPCWSTR Set(LPCWSTR str) {                                          \
+      Release();                                                        \
+      if (str) {                                                        \
+        m_string = MakeCoMemString(str);                                \
+      }                                                                 \
+      return m_string;                                                  \
+    }                                                                   \
+    LPCWSTR Get() { return m_string; }                                  \
+    LPWSTR Copy() {                                                     \
+      if (m_string)                                                     \
+        return MakeCoMemString(m_string);                               \
+      return nullptr;                                                   \
+    }                                                                   \
+                                                                        \
+   protected:                                                           \
+    LPWSTR MakeCoMemString(LPCWSTR source) {                            \
+      const size_t length = wcslen(source);                             \
+      const size_t bytes = (length + 1) * sizeof(*source);              \
+                                                                        \
+      if (bytes <= length) {                                            \
+        return nullptr;                                                 \
+      }                                                                 \
+                                                                        \
+      wchar_t* result = reinterpret_cast<wchar_t*>(allocate_fn(bytes)); \
+                                                                        \
+      if (result)                                                       \
+        memcpy(result, source, bytes);                                  \
+      return result;                                                    \
+    }                                                                   \
+    LPWSTR m_string = nullptr;                                          \
+  };
+
+template <typename allocate_fn_t,
+          allocate_fn_t allocate_fn,
+          typename deallocate_fn_t,
+          deallocate_fn_t deallocate_fn>
+class CoreWebView2CustomSchemeRegistrationBase
+    : public Microsoft::WRL::RuntimeClass<
+          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
+          ICoreWebView2CustomSchemeRegistration> {
+ public:
+  CoreWebView2CustomSchemeRegistrationBase(LPCWSTR schemeName) {
+    m_schemeName.Set(schemeName);
+  }
+
+  CoreWebView2CustomSchemeRegistrationBase(
+      CoreWebView2CustomSchemeRegistrationBase&&) = default;
+  ~CoreWebView2CustomSchemeRegistrationBase() { ReleaseAllowedOrigins(); }
+
+  HRESULT STDMETHODCALLTYPE get_SchemeName(LPWSTR* schemeName) override {
+    if (!schemeName)
+      return E_POINTER;
+    *schemeName = m_schemeName.Copy();
+    if ((*schemeName == nullptr) && (m_schemeName.Get() != nullptr))
+      return HRESULT_FROM_WIN32(GetLastError());
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE
+  GetAllowedOrigins(UINT32* allowedOriginsCount,
+                    LPWSTR** allowedOrigins) override {
+    if (!allowedOrigins || !allowedOriginsCount) {
+      return E_POINTER;
+    }
+    *allowedOriginsCount = 0;
+    if (m_allowedOriginsCount == 0) {
+      *allowedOrigins = nullptr;
+      return S_OK;
+    } else {
+      *allowedOrigins = reinterpret_cast<LPWSTR*>(
+          allocate_fn(m_allowedOriginsCount * sizeof(LPWSTR)));
+      if (!(*allowedOrigins)) {
+        return HRESULT_FROM_WIN32(GetLastError());
+      }
+      ZeroMemory(*allowedOrigins, m_allowedOriginsCount * sizeof(LPWSTR));
+      for (UINT32 i = 0; i < m_allowedOriginsCount; i++) {
+        (*allowedOrigins)[i] = m_allowedOrigins[i].Copy();
+        if (!(*allowedOrigins)[i]) {
+          HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
+          for (UINT32 j = 0; j < i; j++) {
+            deallocate_fn((*allowedOrigins)[j]);
+          }
+          deallocate_fn(*allowedOrigins);
+          return hr;
+        }
+      }
+      *allowedOriginsCount = m_allowedOriginsCount;
+      return S_OK;
+    }
+  }
+
+  HRESULT STDMETHODCALLTYPE
+  SetAllowedOrigins(UINT32 allowedOriginsCount,
+                    LPCWSTR* allowedOrigins) override {
+    ReleaseAllowedOrigins();
+    if (allowedOriginsCount == 0) {
+      return S_OK;
+    } else {
+      m_allowedOrigins = new AutoCoMemString[allowedOriginsCount];
+      if (!m_allowedOrigins) {
+        return HRESULT_FROM_WIN32(GetLastError());
+      }
+      for (UINT32 i = 0; i < allowedOriginsCount; i++) {
+        m_allowedOrigins[i].Set(allowedOrigins[i]);
+        if (!m_allowedOrigins[i].Get()) {
+          HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
+          for (UINT32 j = 0; j < i; j++) {
+            m_allowedOrigins[j].Release();
+          }
+          m_allowedOriginsCount = 0;
+          delete[] (m_allowedOrigins);
+          return hr;
+        }
+      }
+      m_allowedOriginsCount = allowedOriginsCount;
+      return S_OK;
+    }
+  }
+
+ protected:
+  DEFINE_AUTO_COMEM_STRING();
+
+  void ReleaseAllowedOrigins() {
+    if (m_allowedOrigins) {
+      delete[] (m_allowedOrigins);
+      m_allowedOrigins = nullptr;
+    }
+  }
+
+  AutoCoMemString m_schemeName;
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(TreatAsSecure, false);
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(HasAuthorityComponent, false);
+  AutoCoMemString* m_allowedOrigins = nullptr;
+  unsigned int m_allowedOriginsCount = 0;
+};
+
+// This is a base COM class that implements ICoreWebView2EnvironmentOptions.
+template <typename allocate_fn_t,
+          allocate_fn_t allocate_fn,
+          typename deallocate_fn_t,
+          deallocate_fn_t deallocate_fn>
+class CoreWebView2EnvironmentOptionsBase
+    : public Microsoft::WRL::Implements<
+          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
+          ICoreWebView2EnvironmentOptions,
+          ICoreWebView2EnvironmentOptions2,
+          ICoreWebView2EnvironmentOptions3,
+          ICoreWebView2EnvironmentOptions4,
+          ICoreWebView2EnvironmentOptions5,
+          ICoreWebView2EnvironmentOptions6,
+          ICoreWebView2EnvironmentOptions7,
+          ICoreWebView2EnvironmentOptions8> {
+ public:
+  static const COREWEBVIEW2_RELEASE_CHANNELS kInternalChannel =
+      static_cast<COREWEBVIEW2_RELEASE_CHANNELS>(1 << 4);
+  static const COREWEBVIEW2_RELEASE_CHANNELS kAllChannels =
+      COREWEBVIEW2_RELEASE_CHANNELS_STABLE |
+      COREWEBVIEW2_RELEASE_CHANNELS_BETA | COREWEBVIEW2_RELEASE_CHANNELS_DEV |
+      COREWEBVIEW2_RELEASE_CHANNELS_CANARY | kInternalChannel;
+
+  CoreWebView2EnvironmentOptionsBase() {
+    // Initialize the target compatible browser version value to the version
+    // of the browser binaries corresponding to this version of the SDK.
+    m_TargetCompatibleBrowserVersion.Set(CORE_WEBVIEW_TARGET_PRODUCT_VERSION);
+  }
+
+  // ICoreWebView2EnvironmentOptions7
+  HRESULT STDMETHODCALLTYPE
+  get_ReleaseChannels(COREWEBVIEW2_RELEASE_CHANNELS* channels) override {
+    if (!channels) {
+      return E_POINTER;
+    }
+    *channels = m_releaseChannels;
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE
+  put_ReleaseChannels(COREWEBVIEW2_RELEASE_CHANNELS channels) override {
+    m_releaseChannels = channels;
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE
+  get_ChannelSearchKind(COREWEBVIEW2_CHANNEL_SEARCH_KIND* value) override {
+    if (!value) {
+      return E_POINTER;
+    }
+    *value = m_channelSearchKind;
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE
+  put_ChannelSearchKind(COREWEBVIEW2_CHANNEL_SEARCH_KIND value) override {
+    m_channelSearchKind = value;
+    return S_OK;
+  }
+
+  // ICoreWebView2EnvironmentOptions8
+  HRESULT STDMETHODCALLTYPE
+  get_ScrollBarStyle(COREWEBVIEW2_SCROLLBAR_STYLE* style) override {
+    if (!style) {
+      return E_POINTER;
+    }
+    *style = m_scrollbarStyle;
+    return S_OK;
+  }
+
+  HRESULT STDMETHODCALLTYPE
+  put_ScrollBarStyle(COREWEBVIEW2_SCROLLBAR_STYLE style) override {
+    m_scrollbarStyle = style;
+    return S_OK;
+  }
+
+ protected:
+  ~CoreWebView2EnvironmentOptionsBase() { ReleaseCustomSchemeRegistrations(); };
+
+  void ReleaseCustomSchemeRegistrations() {
+    if (m_customSchemeRegistrations) {
+      for (UINT32 i = 0; i < m_customSchemeRegistrationsCount; i++) {
+        m_customSchemeRegistrations[i]->Release();
+      }
+      deallocate_fn(m_customSchemeRegistrations);
+      m_customSchemeRegistrations = nullptr;
+      m_customSchemeRegistrationsCount = 0;
+    }
+  }
+
+ private:
+  ICoreWebView2CustomSchemeRegistration** m_customSchemeRegistrations = nullptr;
+  unsigned int m_customSchemeRegistrationsCount = 0;
+
+  COREWEBVIEW2_RELEASE_CHANNELS m_releaseChannels = kAllChannels;
+  COREWEBVIEW2_CHANNEL_SEARCH_KIND m_channelSearchKind =
+      COREWEBVIEW2_CHANNEL_SEARCH_KIND_MOST_STABLE;
+
+  // ICoreWebView2EnvironmentOptions8
+  COREWEBVIEW2_SCROLLBAR_STYLE m_scrollbarStyle =
+      COREWEBVIEW2_SCROLLBAR_STYLE_DEFAULT;
+
+  DEFINE_AUTO_COMEM_STRING();
+
+ public:
+  // ICoreWebView2EnvironmentOptions
+  COREWEBVIEW2ENVIRONMENTOPTIONS_STRING_PROPERTY(AdditionalBrowserArguments)
+  COREWEBVIEW2ENVIRONMENTOPTIONS_STRING_PROPERTY(Language)
+  COREWEBVIEW2ENVIRONMENTOPTIONS_STRING_PROPERTY(TargetCompatibleBrowserVersion)
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(
+      AllowSingleSignOnUsingOSPrimaryAccount,
+      false)
+
+  // ICoreWebView2EnvironmentOptions2
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(ExclusiveUserDataFolderAccess,
+                                               false)
+
+  // ICoreWebView2EnvironmentOptions3
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(IsCustomCrashReportingEnabled,
+                                               false)
+
+  // ICoreWebView2EnvironmentOptions4
+ public:
+  HRESULT STDMETHODCALLTYPE GetCustomSchemeRegistrations(
+      UINT32* count,
+      ICoreWebView2CustomSchemeRegistration*** schemeRegistrations) override {
+    if (!count || !schemeRegistrations) {
+      return E_POINTER;
+    }
+    *count = 0;
+    if (m_customSchemeRegistrationsCount == 0) {
+      *schemeRegistrations = nullptr;
+      return S_OK;
+    } else {
+      *schemeRegistrations =
+          reinterpret_cast<ICoreWebView2CustomSchemeRegistration**>(
+              allocate_fn(sizeof(ICoreWebView2CustomSchemeRegistration*) *
+                          m_customSchemeRegistrationsCount));
+      if (!*schemeRegistrations) {
+        return HRESULT_FROM_WIN32(GetLastError());
+      }
+      for (UINT32 i = 0; i < m_customSchemeRegistrationsCount; i++) {
+        (*schemeRegistrations)[i] = m_customSchemeRegistrations[i];
+        (*schemeRegistrations)[i]->AddRef();
+      }
+      *count = m_customSchemeRegistrationsCount;
+      return S_OK;
+    }
+  }
+
+  HRESULT STDMETHODCALLTYPE SetCustomSchemeRegistrations(
+      UINT32 count,
+      ICoreWebView2CustomSchemeRegistration** schemeRegistrations) override {
+    ReleaseCustomSchemeRegistrations();
+    m_customSchemeRegistrations =
+        reinterpret_cast<ICoreWebView2CustomSchemeRegistration**>(allocate_fn(
+            sizeof(ICoreWebView2CustomSchemeRegistration*) * count));
+    if (!m_customSchemeRegistrations) {
+      return GetLastError();
+    }
+    for (UINT32 i = 0; i < count; i++) {
+      m_customSchemeRegistrations[i] = schemeRegistrations[i];
+      m_customSchemeRegistrations[i]->AddRef();
+    }
+    m_customSchemeRegistrationsCount = count;
+    return S_OK;
+  }
+
+  // ICoreWebView2EnvironmentOptions5
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(EnableTrackingPrevention, true)
+
+  // ICoreWebView2EnvironmentOptions6
+  COREWEBVIEW2ENVIRONMENTOPTIONS_BOOL_PROPERTY(AreBrowserExtensionsEnabled,
+                                               false)
+};
+
+template <typename allocate_fn_t,
+          allocate_fn_t allocate_fn,
+          typename deallocate_fn_t,
+          deallocate_fn_t deallocate_fn>
+class CoreWebView2EnvironmentOptionsBaseClass
+    : public Microsoft::WRL::RuntimeClass<
+          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
+          CoreWebView2EnvironmentOptionsBase<allocate_fn_t,
+                                             allocate_fn,
+                                             deallocate_fn_t,
+                                             deallocate_fn>> {
+ public:
+  CoreWebView2EnvironmentOptionsBaseClass() {}
+
+ protected:
+  ~CoreWebView2EnvironmentOptionsBaseClass() override {}
+};
+
+typedef CoreWebView2CustomSchemeRegistrationBase<decltype(&::CoTaskMemAlloc),
+                                                 ::CoTaskMemAlloc,
+                                                 decltype(&::CoTaskMemFree),
+                                                 ::CoTaskMemFree>
+    CoreWebView2CustomSchemeRegistration;
+
+typedef CoreWebView2EnvironmentOptionsBaseClass<decltype(&::CoTaskMemAlloc),
+                                                ::CoTaskMemAlloc,
+                                                decltype(&::CoTaskMemFree),
+                                                ::CoTaskMemFree>
+    CoreWebView2EnvironmentOptions;
+
+#endif  // __core_webview2_environment_options_h__

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@zappdev/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI for building cross-platform desktop apps with Zapp",
+  "main": "dist/zapp-cli.js",
+  "bin": {
+    "zapp": "dist/zapp-cli.js"
+  },
+  "exports": {
+    ".": "./dist/zapp-cli.js",
+    "./config": "./src/config.ts"
+  },
+  "files": [
+    "dist/",
+    "native/",
+    "src/"
+  ],
+  "scripts": {
+    "build": "bun build ./src/zapp-cli.ts --outfile ./dist/zapp-cli.js --target bun --format esm"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.10",
+    "@types/node": "^22.0.0",
+    "@types/yargs": "^17.0.35",
+    "esbuild": "^0.27.4",
+    "typescript": "^5.0.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "yargs": "^18.0.0"
+  }
+}

package/src/backend.ts

@@ -0,0 +1,139 @@
+import path from "node:path";
+import process from "node:process";
+import { mkdir } from "node:fs/promises";
+import { runCmd } from "./common";
+
+const BACKEND_CONVENTIONS = ["zapp/backend.ts", "zapp/backend.js", "backend.ts", "backend.js"];
+
+async function findBackendScript(root: string): Promise<string | null> {
+  for (const name of BACKEND_CONVENTIONS) {
+    const candidate = path.join(root, name);
+    if (await Bun.file(candidate).exists()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function resolveZappPackage(pkg: string, root: string): string | null {
+  try {
+    return require.resolve(pkg, { paths: [root] });
+  } catch {
+    // not found in node_modules
+  }
+
+  const monorepoFallbacks: Record<string, string> = {
+    "@zapp/runtime": "packages/runtime/index.ts",
+    "@zapp/backend": "packages/backend/index.ts",
+  };
+  const relative = monorepoFallbacks[pkg];
+  if (!relative) return null;
+
+  const candidate = path.resolve(root, relative);
+  try {
+    if (require("node:fs").existsSync(candidate)) return candidate;
+  } catch {}
+
+  return null;
+}
+
+export async function resolveAndBundleBackend({
+  root,
+  frontendDir,
+  backendScript,
+}: {
+  root: string;
+  frontendDir: string;
+  backendScript?: string;
+}): Promise<string | null> {
+  let entryPath: string | null = null;
+
+  if (backendScript) {
+    entryPath = path.resolve(root, backendScript);
+    if (!(await Bun.file(entryPath).exists())) {
+      process.stderr.write(`[zapp] backend script not found: ${entryPath}\n`);
+      return null;
+    }
+  } else {
+    entryPath = await findBackendScript(root);
+  }
+
+  if (!entryPath) return null;
+
+  process.stdout.write(`[zapp] bundling backend script: ${path.relative(root, entryPath)}\n`);
+
+  const buildDir = path.join(root, ".zapp");
+  await mkdir(buildDir, { recursive: true });
+
+  const outFile = path.join(buildDir, "backend.bundle.js");
+
+  const runtimePath = resolveZappPackage("@zapp/runtime", root);
+  const backendPath = resolveZappPackage("@zapp/backend", root);
+
+  if (!runtimePath || !backendPath) {
+    process.stderr.write(
+      `[zapp] could not resolve @zapp/runtime or @zapp/backend from ${root}\n` +
+      `  Install them: bun add @zapp/runtime @zapp/backend\n`
+    );
+    return null;
+  }
+
+  const hasBunBuild =
+    typeof (globalThis as any).Bun !== "undefined" &&
+    (globalThis as any).Bun != null &&
+    typeof (globalThis as any).Bun.build === "function";
+
+  if (hasBunBuild) {
+    const result = await (globalThis as any).Bun.build({
+      entrypoints: [entryPath],
+      outdir: buildDir,
+      naming: "backend.bundle.js",
+      target: "browser",
+      format: "esm",
+      sourcemap: "none",
+      minify: false,
+      plugins: [
+        {
+          name: "zapp-backend-alias",
+          setup(build: any) {
+            build.onResolve({ filter: /^@zapp\/backend$/ }, () => ({ path: backendPath }));
+            build.onResolve({ filter: /^@zapp\/backend\/(.*)/ }, (args: any) => ({
+              path: path.join(path.dirname(backendPath), args.path.slice("@zapp/backend/".length)),
+            }));
+            build.onResolve({ filter: /^@zapp\/runtime$/ }, () => ({ path: runtimePath }));
+            build.onResolve({ filter: /^@zapp\/runtime\/(.*)/ }, (args: any) => ({
+              path: path.join(path.dirname(runtimePath), args.path.slice("@zapp/runtime/".length)),
+            }));
+          },
+        },
+      ],
+    });
+
+    if (!result.success) {
+      const lines = (result.logs ?? [])
+        .map((log: any) => log?.message)
+        .filter(Boolean)
+        .join("\n");
+      process.stderr.write(`[zapp] backend bundle failed:\n${lines}\n`);
+      return null;
+    }
+  } else {
+    const { build: esbuild } = await import("esbuild");
+    await esbuild({
+      entryPoints: [entryPath],
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      sourcemap: false,
+      minify: false,
+      outfile: outFile,
+      alias: {
+        "@zapp/backend": backendPath,
+        "@zapp/runtime": runtimePath,
+      },
+    });
+  }
+
+  return outFile;
+}

package/src/build-config.ts

@@ -0,0 +1,87 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { runCmd } from "./common";
+
+export type BuildMode = "dev" | "dev-embedded" | "prod" | "prod-embedded";
+
+export type LogLevel = "error" | "warn" | "info" | "debug" | "trace";
+
+const cString = (value: string): string => JSON.stringify(value.replace(/\\/g, "/"));
+
+export const generateBuildConfigZc = async ({
+  root,
+  mode,
+  assetDir,
+  devUrl,
+  backendScriptPath,
+  logLevel,
+  csp,
+  enableDevTools,
+}: {
+  root: string;
+  mode: BuildMode;
+  assetDir: string;
+  devUrl?: string;
+  backendScriptPath?: string | null;
+  logLevel?: LogLevel;
+  csp?: string;
+  enableDevTools?: boolean;
+}) => {
+  const buildDir = path.join(root, ".zapp");
+  await mkdir(buildDir, { recursive: true });
+
+  const isDev = mode === "dev" || mode === "dev-embedded";
+  const useEmbeddedAssets = mode === "dev-embedded" || mode === "prod-embedded";
+  const isDarwin = process.platform === "darwin";
+  const prodUrl = isDarwin ? "zapp://index.html" : "https://app.localhost/index.html";
+  const initialUrl = mode === "dev" ? devUrl ?? "http://localhost:5173" : prodUrl;
+  
+  // Default log levels: info for dev, warn for prod
+  const defaultLogLevel = isDev ? "info" : "warn";
+  const effectiveLogLevel = logLevel ?? defaultLogLevel;
+
+  const content = `// AUTO-GENERATED FILE. DO NOT EDIT.
+
+raw {
+    const char* zapp_build_mode_name(void) {
+        return ${cString(mode)};
+    }
+
+    const char* zapp_build_asset_root(void) {
+        return ${cString(assetDir)};
+    }
+
+    const char* zapp_build_initial_url(void) {
+        return ${cString(initialUrl)};
+    }
+
+    int zapp_build_is_dev_mode(void) {
+        return ${isDev ? 1 : 0};
+    }
+
+    int zapp_build_use_embedded_assets(void) {
+        return ${useEmbeddedAssets ? 1 : 0};
+    }
+
+    const char* zapp_build_backend_script_path(void) {
+        return ${backendScriptPath ? cString(backendScriptPath) : '""'};
+    }
+
+    const char* zapp_build_log_level(void) {
+        return ${cString(effectiveLogLevel)};
+    }
+
+    int zapp_build_dev_tools_default(void) {
+        return ${enableDevTools ?? isDev ? 1 : 0};
+    }
+
+    const char* zapp_build_csp(void) {
+        return ${csp ? cString(csp) : '""'};
+    }
+}
+`;
+
+  const outPath = path.join(buildDir, "zapp_build_config.zc");
+  await Bun.write(outPath, content);
+  return outPath;
+};