@flare-desktop/cli 0.1.1 → 0.1.2

package/README.md

@@ -33,6 +33,15 @@ Global options: `--project=<path>`, `--config=<path>`, `--environment=<name>`, `
 
 ## Frontend directory
 
+## Self-contained application configuration
+
+The scaffold generates a typed C++ `Flare::Config` header at build time from `flare.config.json` and its platform,
+environment and local layers. The executable does not read JSON from disk. Rebuild after changing any layer; the
+build system tracks them. `flare dev` embeds the development layer and `flare build` embeds production. The `--config`
+and `--environment` CLI flags select the input at build time. On Windows the generated CMake project enables
+`FLARE_NATIVE_WEBVIEW` before fetching the C++ core; the CLI verifies that the native backend was enabled.
+The generated project requires a CLI release containing `src/lib/embed-config-cli.js` (0.1.2 or newer). The new scaffold targets C++ core `v0.1.1`; publish that tag and its SDK release before using prebuilt mode.
+
 `flare build` passes `build.frontendDist` to CMake as `FLARE_FRONTEND_DIR`. The scaffolded `CMakeLists.txt` uses
 that variable for `FlareEmbedFrontend` and for the development directory. Change the config key, not the CMake
 file:
@@ -75,3 +84,19 @@ binaries are staged next to the application binary.
 
 The configuration is validated against
 [`schemas/flare.config.schema.json`](https://raw.githubusercontent.com/flare-desktop/flare/main/schemas/flare.config.schema.json).
+
+## Frontend templates, prebuilt SDK and codegen
+
+`npm create flare-desktop@latest` offers JavaScript (the existing plain frontend) and TypeScript + Vite.
+TypeScript projects copy version-matched `core.js` and `core.d.ts` into `frontend/`; `tsconfig.json` maps
+`/core.js` to the declaration, while Vite bundles the JavaScript frontend into `dist/` before CMake embeds it.
+
+Choose `--sdk=source` (FetchContent of core tag `v0.1.1`) or `--sdk=prebuilt` (download the matching
+GitHub Release SDK archives into `vendor/flare`). The first binary SDK matrix covers Windows x64 MSVC
+Debug/Release with MD/MT, Linux x64 GCC Debug/Release and macOS x64/arm64 Clang Debug/Release.
+Unsupported architectures/ABIs must use source mode. The current C++ core's native webview runtime is
+implemented on Windows; macOS and Linux builds remain headless. Release SDK archives do not exist until
+the core v0.1.1 tag workflow finishes.
+
+The former C++ `codegen` executable is replaced by `npx flare codegen --language=header|cpp|json` with
+`--config`, `--out`, `--namespace`, `--embed-assets` and `--frontend`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flare-desktop/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Command line interface for the flare desktop toolkit",
   "type": "module",
   "bin": {
@@ -36,9 +36,12 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test \"test/*.test.js\""
+    "test": "node --test"
   },
   "devDependencies": {
     "ajv": "^8.20.0"
+  },
+  "dependencies": {
+    "tar": "^7.5.22"
   }
 }

package/src/cli.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 
 import { buildCommand } from "./commands/build.js";
+import { codegenCommand } from "./commands/codegen.js";
 import { bundleCommand } from "./commands/bundle.js";
 import { completionsCommand } from "./commands/completions.js";
 import { devCommand } from "./commands/dev.js";
@@ -24,6 +25,8 @@ async function initCommand(context) {
     identifier: context.flags.identifier,
     appVersion: context.flags.appVersion ?? "0.1.0",
     force: Boolean(context.flags.force),
+    template: context.flags.template || "javascript",
+    sdkMode: context.flags.sdk || "source",
     logger: context.logger
   });
   return 0;
@@ -35,6 +38,7 @@ const handlers = {
   build: buildCommand,
   bundle: bundleCommand,
   icon: iconCommand,
+  codegen: codegenCommand,
   info: infoCommand,
   inspect: inspectCommand,
   doctor: doctorCommand,

package/src/commands/build.js

@@ -21,6 +21,8 @@ export async function buildCommand(context) {
   const { binary, directory } = await compileApplication({
     projectDirectory: context.projectDirectory,
     config,
+    configFile: context.flags.config || "flare.config.json",
+    environment: context.flags.environment,
     mode,
     logger: context.logger
   });

package/src/commands/bundle.js

@@ -21,6 +21,8 @@ export async function bundleCommand(context) {
   const { binary } = await compileApplication({
     projectDirectory: context.projectDirectory,
     config,
+    configFile: context.flags.config || "flare.config.json",
+    environment: context.flags.environment,
     mode: "Release",
     logger: context.logger
   });

package/src/commands/codegen.js

@@ -0,0 +1,53 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+import { generateEmbeddedConfig } from "../lib/embedded-config.js";
+import { FlareError } from "../lib/errors.js";
+import { loadProject, mergeConfig, parseConfig, toKebabCase } from "../lib/project.js";
+
+function filesIn(directory) {
+  const result = [];
+  const walk = (current) => {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolute = path.join(current, entry.name);
+      if (entry.isDirectory()) walk(absolute);
+      else if (entry.isFile()) result.push({ key: path.relative(directory, absolute).replaceAll(path.sep, "/"), size: statSync(absolute).size });
+    }
+  };
+  walk(directory);
+  return result.sort((a, b) => a.key.localeCompare(b.key));
+}
+
+const MIME = { ".html": "text/html", ".js": "text/javascript", ".css": "text/css", ".json": "application/json", ".svg": "image/svg+xml", ".png": "image/png" };
+
+export async function codegenCommand(context) {
+  const { config, files } = loadProject({
+    projectDirectory: context.projectDirectory,
+    configFile: context.flags.config,
+    environment: context.flags.environment
+  });
+  const output = path.resolve(context.projectDirectory, context.flags.out || "generated");
+  const language = context.flags.language || "header";
+  if (!["header", "hpp", "cpp", "source", "json"].includes(language)) throw new FlareError(`unsupported codegen language '${language}'`);
+  const namespace = context.flags.namespace || "FlareGenerated";
+  if (!/^[A-Za-z_][A-Za-z_0-9]*$/.test(namespace)) throw new FlareError("invalid C++ namespace");
+  mkdirSync(output, { recursive: true });
+  let raw = {};
+  for (const file of files) raw = mergeConfig(raw, parseConfig(readFileSync(file, "utf8"), file));
+  if (language === "json") {
+    const name = config.app.identifier.replace(/[^A-Za-z0-9]/g, "_");
+    writeFileSync(path.join(output, `${name}-config.json`), JSON.stringify(config, null, 2) + "\n");
+  } else {
+    const name = `${toKebabCase(config.app.productName)}-config.h`;
+    writeFileSync(path.join(output, name), generateEmbeddedConfig(config, raw, namespace));
+    const commands = (config.build?.removeUnusedCommands || []).map((item) => `    application.Commands().Unregister(${JSON.stringify(item)});`).join("\n");
+    writeFileSync(path.join(output, "commands.cpp"), `#include <flare/core/application.h>\n\nnamespace ${namespace} {\ninline void RegisterCommands(Flare::Application& application) {\n${commands}\n    (void)application;\n}\n}\n`);
+  }
+  if (context.flags.embedAssets) {
+    const directory = path.resolve(context.projectDirectory, context.flags.frontend || config.build?.frontendDist || "frontend");
+    const assets = filesIn(directory).map(({ key, size }) => ({ key, size, mimeType: MIME[path.extname(key).toLowerCase()] || "application/octet-stream" }));
+    writeFileSync(path.join(output, "asset-manifest.json"), JSON.stringify({ count: assets.length, totalBytes: assets.reduce((a, b) => a + b.size, 0), assets }, null, 2) + "\n");
+  }
+  context.logger.info(`generated configuration in '${output}'`);
+  return 0;
+}

package/src/commands/dev.js

@@ -61,6 +61,8 @@ export async function devCommand(context) {
     const { binary } = await compileApplication({
       projectDirectory: context.projectDirectory,
       config,
+    configFile: context.flags.config || "flare.config.json",
+    environment: context.flags.environment,
       mode: "Debug",
       logger: context.logger
     });

package/src/commands/init.js

@@ -1,11 +1,12 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 
 import { FlareError } from "../lib/errors.js";
 import { placeholderIcon } from "../lib/icons.js";
 import { isValidAppName, toKebabCase } from "../lib/project.js";
+import { installSdk } from "../lib/sdk.js";
 import { writePng } from "../lib/png.js";
-import { VERSION } from "../version.js";
+import { CORE_VERSION, MIN_CLI_VERSION } from "../release-versions.js";
 import {
   cmakeTemplate,
   configTemplate,
@@ -14,6 +15,9 @@ import {
   packageJsonTemplate,
   readmeTemplate,
   scriptTemplate,
+  typescriptTemplate,
+  tsconfigTemplate,
+  viteConfigTemplate,
   sourceTemplate,
   styleTemplate
 } from "../templates/project.js";
@@ -28,10 +32,15 @@ export async function initProject({
   baseDirectory = ".",
   identifier,
   appVersion = "0.1.0",
-  coreVersion = VERSION,
+  coreVersion = CORE_VERSION,
+  template = "javascript",
+  sdkMode = "source",
+  sdkFetch,
   force = false,
   logger
 }) {
+  if (!["javascript", "typescript"].includes(template)) throw new FlareError("template must be javascript or typescript");
+  if (!["source", "prebuilt"].includes(sdkMode)) throw new FlareError("SDK mode must be source or prebuilt");
   const projectName = toKebabCase(name);
   if (!isValidAppName(projectName)) {
     throw new FlareError(
@@ -58,7 +67,7 @@ export async function initProject({
     {
       file: "flare.config.json",
       content: `${JSON.stringify(
-        configTemplate({ name: projectName, identifier: appIdentifier, version: appVersion }),
+        configTemplate({ name: projectName, identifier: appIdentifier, version: appVersion, template }),
         null,
         2
       )}\n`
@@ -66,23 +75,30 @@ export async function initProject({
     {
       file: "package.json",
       content: `${JSON.stringify(
-        packageJsonTemplate({ name: projectName, version: appVersion, cliVersion: coreVersion }),
+        packageJsonTemplate({ name: projectName, version: appVersion, cliVersion: MIN_CLI_VERSION, template }),
         null,
         2
       )}\n`
     },
     {
       file: "CMakeLists.txt",
-      content: cmakeTemplate({ name: projectName, version: appVersion, coreVersion })
+      content: cmakeTemplate({ name: projectName, version: appVersion, coreVersion, sdkMode })
     },
     {
       file: "source/main.cpp",
-      content: sourceTemplate({ name: projectName, identifier: appIdentifier, version: appVersion })
+      content: sourceTemplate({ name: projectName })
     },
-    { file: "frontend/index.html", content: indexHtmlTemplate(projectName) },
+    { file: "frontend/index.html", content: indexHtmlTemplate(projectName, template) },
     { file: "frontend/style.css", content: styleTemplate() },
-    { file: "frontend/main.js", content: scriptTemplate() },
+    ...(template === "typescript" ? [
+      { file: "frontend/main.ts", content: typescriptTemplate() },
+      { file: "frontend/core.js", content: readFileSync(new URL("../templates/core.js", import.meta.url), "utf8") },
+      { file: "frontend/core.d.ts", content: readFileSync(new URL("../templates/core.d.ts", import.meta.url), "utf8") },
+      { file: "tsconfig.json", content: JSON.stringify(tsconfigTemplate(), null, 2) + "\n" },
+      { file: "vite.config.mjs", content: viteConfigTemplate() }
+    ] : [{ file: "frontend/main.js", content: scriptTemplate() }]),
     { file: ".gitignore", content: gitignoreTemplate() },
+    { file: ".clang-format", content: readFileSync(new URL("../templates/clang-format.txt", import.meta.url), "utf8") },
     { file: "README.md", content: readmeTemplate(projectName) }
   ];
 
@@ -90,6 +106,16 @@ export async function initProject({
     write(path.join(targetDirectory, entry.file), entry.content);
   }
 
+  if (sdkMode === "prebuilt") {
+    if (logger) logger.info(`downloading flare SDK v${coreVersion} for ${process.platform}/${process.arch}`);
+    try {
+      await installSdk({ destination: path.join(targetDirectory, "vendor", "flare"), version: coreVersion, ...(sdkFetch ? { fetchImpl: sdkFetch } : {}) });
+    } catch (error) {
+      if (!force) rmSync(targetDirectory, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
   writeFileSync(path.join(targetDirectory, "icons", "icon.png"), writePng(placeholderIcon()));
   writeFileSync(path.join(targetDirectory, "icons", "32x32.png"), writePng(placeholderIcon(32)));
 
@@ -104,5 +130,5 @@ export async function initProject({
     logger.step("npm run dev");
   }
 
-  return { directory: targetDirectory, name: projectName, identifier: appIdentifier, files: written };
+  return { directory: targetDirectory, name: projectName, identifier: appIdentifier, template, sdkMode, files: written };
 }

package/src/help.js

@@ -11,7 +11,7 @@ export function helpText() {
   ];
 
   for (const command of COMMANDS) {
-    lines.push(`  ${command.usage.padEnd(26)}${command.description}`);
+    lines.push(`  ${command.usage.padEnd(39)}${command.description}`);
   }
 
   lines.push(
@@ -20,6 +20,12 @@ export function helpText() {
     "  --project=<path>      project directory (default: .)",
     "  --config=<path>       configuration file (default: flare.config.json)",
     "  --environment=<name>  add the environment configuration layer",
+    "  --template=<javascript|typescript>  frontend template (init)",
+    "  --sdk=<source|prebuilt>  C++ dependency mode (init)",
+    "  --language=<header|cpp|json>  codegen format",
+    "  --namespace=<name>    codegen C++ namespace",
+    "  --frontend=<path>    codegen asset directory",
+    "  --embed-assets       codegen asset manifest",
     "  --bundles=<list>      bundle targets, for example nsis,msi,deb",
     "  --out=<path>          bundle output directory (default: target/bundle)",
     "  --json                machine readable output",

package/src/lib/args.js

@@ -8,6 +8,11 @@ const VALUE_FLAGS = new Set([
   "format",
   "identifier",
   "app-version",
+  "sdk",
+  "template",
+  "language",
+  "namespace",
+  "frontend",
   "dev-timeout"
 ]);
 

package/src/lib/build.js

@@ -10,14 +10,16 @@ export async function runHook(command, { cwd, env, logger, label }) {
   if (result.code !== 0) throw new FlareError(`${label} failed with code ${result.code}`);
 }
 
-export async function compileApplication({ projectDirectory, config, mode, env, logger }) {
+export async function compileApplication({ projectDirectory, config, mode, env, logger, configFile, environment }) {
   const directory = buildDirectory(projectDirectory, mode);
   await configureProject(projectDirectory, {
     directory,
     mode,
     env,
     logger,
-    frontendDirectory: frontendDirectory(projectDirectory, config)
+    frontendDirectory: frontendDirectory(projectDirectory, config),
+    configFile,
+    environment
   });
   await buildProject(projectDirectory, { directory, mode, env });
   const binary = findExecutable(directory, binaryName(config));

package/src/lib/cmake.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 
 import { FlareError } from "./errors.js";
@@ -35,7 +35,7 @@ export function buildDirectory(projectDirectory, mode) {
   return path.join(projectDirectory, "build", mode === "Debug" ? "debug" : "release");
 }
 
-export async function configureProject(projectDirectory, { directory, mode, env, logger, frontendDirectory }) {
+export async function configureProject(projectDirectory, { directory, mode, env, logger, frontendDirectory, configFile = "flare.config.json", environment = "production" }) {
   if (!cmakeVersion()) throw new FlareError("cmake was not found in PATH");
   const outputDirectory = path.join(directory, "bin");
   const configuration = mode.toUpperCase();
@@ -50,7 +50,6 @@ export async function configureProject(projectDirectory, { directory, mode, env,
     `-DCMAKE_RUNTIME_OUTPUT_DIRECTORY_${configuration}=${outputDirectory}`,
     "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
     `-DFLARE_FRONTEND_DIR=${frontendDirectory ?? path.join(projectDirectory, "frontend")}`,
-    "-DFLARE_BUILD_TOOLS=OFF",
     "-DFLARE_BUILD_EXAMPLES=OFF",
     "-DFLARE_BUILD_TESTS=OFF",
     "-DFLARE_INSTALL=OFF"
@@ -58,6 +57,12 @@ export async function configureProject(projectDirectory, { directory, mode, env,
   logger.debug(`cmake ${args.join(" ")}`);
   const result = await run("cmake", args, { cwd: projectDirectory, env });
   if (result.code !== 0) throw new FlareError("cmake configuration failed");
+  if (process.platform === "win32") {
+    const cache = readFileSync(path.join(directory, "CMakeCache.txt"), "utf8");
+    if (!/^FLARE_NATIVE_WEBVIEW:BOOL=ON$/m.test(cache)) {
+      throw new FlareError("Windows build has no native webview backend; configure with -DFLARE_NATIVE_WEBVIEW=ON");
+    }
+  }
 }
 
 export async function buildProject(projectDirectory, { directory, mode, target, env }) {

package/src/lib/commands.js

@@ -3,6 +3,7 @@ export const COMMANDS = [
   { name: "dev", usage: "dev", description: "build and run the application in development mode" },
   { name: "build", usage: "build [--debug]", description: "build the application" },
   { name: "bundle", usage: "bundle", description: "build and prepare the platform bundle targets" },
+  { name: "codegen", usage: "codegen [--language=header|json]", description: "generate a typed C++ config, JSON or an asset manifest" },
   { name: "icon", usage: "icon <source.png>", description: "generate the icon set from a square png" },
   { name: "info", usage: "info", description: "print project and platform information" },
   { name: "inspect", usage: "inspect", description: "print the resolved configuration layers" },

package/src/lib/embed-config-cli.js

@@ -0,0 +1,14 @@
+import { writeEmbeddedConfig } from "./embedded-config.js";
+
+const [projectDirectory, configFile, environment, output] = process.argv.slice(2);
+if (!projectDirectory || !configFile || !environment || !output) {
+  process.stderr.write("usage: embed-config-cli.js <project> <config> <environment> <output>\n");
+  process.exitCode = 1;
+} else {
+  try {
+    writeEmbeddedConfig({ projectDirectory, configFile, environment, output });
+  } catch (error) {
+    process.stderr.write(`failed to embed configuration: ${error.message}\n`);
+    process.exitCode = 1;
+  }
+}

package/src/lib/embedded-config.js

@@ -0,0 +1,181 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+import { loadProject, mergeConfig, parseConfig } from "./project.js";
+
+function cppString(value) {
+  const bytes = Buffer.from(value, "utf8");
+  let output = '"';
+  for (const byte of bytes) {
+    if (byte === 34) output += '\\"';
+    else if (byte === 92) output += "\\\\";
+    else if (byte >= 32 && byte <= 126) output += String.fromCharCode(byte);
+    else output += `\\${byte.toString(8).padStart(3, "0")}`;
+  }
+  return `${output}"`;
+}
+
+function cppJson(value) {
+  if (value === null) return "Flare::JSON(nullptr)";
+  if (Array.isArray(value)) return `Flare::JSON::array({${value.map(cppJson).join(", ")}})`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([key, item]) => `{${cppString(key)}, ${cppJson(item)}}`);
+    return `Flare::JSON::object({${entries.join(", ")}})`;
+  }
+  if (typeof value === "string") return `Flare::JSON(${cppString(value)})`;
+  if (typeof value === "boolean") return `Flare::JSON(${value})`;
+  if (typeof value === "number" && Number.isFinite(value)) return `Flare::JSON(${value})`;
+  throw new TypeError("unsupported JSON value in configuration");
+}
+
+function scalar(value, kind) {
+  if (kind === "string" && typeof value === "string") return cppString(value);
+  if (kind === "bool" && typeof value === "boolean") return `${value}`;
+  if (kind === "number" && typeof value === "number" && Number.isFinite(value)) return `${value}`;
+  if (kind === "int" && Number.isSafeInteger(value)) return `${value}`;
+  if (kind === "strings" && Array.isArray(value)) {
+    return `{${value.filter((item) => typeof item === "string").map(cppString).join(", ")}}`;
+  }
+  return null;
+}
+
+const FIELDS = {
+  package: { productName: "string", version: "string" },
+  app: { productName: "string", mainBinaryName: "string", version: "string", identifier: "string" },
+  build: {
+    beforeDevCommand: "string", afterDevCommand: "string", beforeBuildCommand: "string",
+    afterBuildCommand: "string", frontendDist: "string", devUrl: "string", removeUnusedCommands: "strings"
+  },
+  "build.features": { customProtocol: "bool", devtools: "bool", isolation: "bool", systemTray: "bool" },
+  bundle: {
+    active: "bool", identifier: "string", icon: "string", version: "string", publisher: "string",
+    homepage: "string", longDescription: "string", copyright: "string", category: "string",
+    shortDescription: "string", licenseFile: "string", targets: "strings", resources: "strings",
+    externalBin: "strings"
+  },
+  "bundle.linuxBundle": { depends: "string", desktopTemplate: "string", section: "string", priority: "string", files: "strings" },
+  "bundle.windows": { language: "string", installerIcon: "string", installMode: "int", webviewInstallModeOffline: "bool" },
+  "bundle.macos": { minimumSystemVersion: "string", frameworks: "bool", signingIdentity: "string" },
+  security: {
+    freezePrototype: "bool", dangerousDisableAssetCspModification: "bool", dangerousUseHttpScheme: "bool",
+    dangerousAcceptInvalidCertificates: "bool", capabilities: "strings", dangerousRemoteDomainIpcAccess: "strings"
+  },
+  window: {
+    label: "string", title: "string", resizable: "bool", maximized: "bool", fullscreen: "bool",
+    alwaysOnTop: "bool", decorations: "bool", transparent: "bool", visible: "bool", center: "bool",
+    devtools: "bool", url: "string"
+  }
+};
+
+function emitFields(lines, target, input, fields) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return;
+  for (const [key, kind] of Object.entries(fields)) {
+    const result = scalar(input[key], kind);
+    if (result !== null) lines.push(`${target}.${key} = ${result};`);
+  }
+}
+
+function emitSize(lines, target, input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return;
+  for (const key of ["width", "height"]) {
+    const result = scalar(input[key], "number");
+    if (result !== null) lines.push(`${target}.${key} = ${result};`);
+  }
+}
+
+function emitCsp(lines, input) {
+  if (typeof input === "string") {
+    const directives = input.split(";").map((statement) => statement.trim()).filter(Boolean);
+    lines.push(`config.security.csp.enabled = ${input.trim() ? "true" : "false"};`);
+    for (const statement of directives) {
+      const [name, ...sources] = statement.split(/\s+/);
+      lines.push(`config.security.csp.directives.push_back(Flare::CspDirective{${cppString(name)}, ${scalar(sources, "strings")}});`);
+    }
+  } else if (input && typeof input === "object" && !Array.isArray(input)) {
+    lines.push("config.security.csp.enabled = true;");
+    for (const [name, sources] of Object.entries(input).sort(([a], [b]) => a.localeCompare(b))) {
+      const values = typeof sources === "string" ? sources.trim().split(/\s+/).filter(Boolean) : sources;
+      lines.push(`config.security.csp.directives.push_back(Flare::CspDirective{${cppString(name)}, ${scalar(values, "strings") ?? "{}"}});`);
+    }
+  }
+}
+
+export function generateEmbeddedConfig(config, raw = config, namespace = "FlareGenerated") {
+  if (!/^[A-Za-z_][A-Za-z_0-9]*$/.test(namespace)) throw new Error("invalid C++ namespace");
+  config = structuredClone(config);
+  const lines = [
+    "#pragma once", "", "#include <flare/config/config.h>", "", `namespace ${namespace} {`,
+    "inline Flare::Config EmbeddedConfig() {", "Flare::Config config;"
+  ];
+  if (raw.package && typeof raw.package === "object" && !Array.isArray(raw.package)) {
+    config.package.version ??= "0.1.0";
+  }
+  if (raw.build && typeof raw.build === "object" && !Array.isArray(raw.build)) {
+    config.build.frontendDist ??= "../dist";
+  }
+  if (raw.bundle && typeof raw.bundle === "object" && !Array.isArray(raw.bundle)) {
+    config.bundle.active ??= true;
+    config.bundle.icon ??= "icons/icon.png";
+    config.bundle.category ??= "DeveloperTool";
+  }
+  if (raw.bundle?.linux && typeof raw.bundle.linux === "object") {
+    config.bundle.linux.section ??= "utils";
+    config.bundle.linux.priority ??= "optional";
+  }
+  if (raw.bundle?.windows && typeof raw.bundle.windows === "object") {
+    config.bundle.windows.language ??= "en-US";
+  }
+  emitFields(lines, "config.package", config.package, FIELDS.package);
+  emitFields(lines, "config.app", config.app, FIELDS.app);
+  emitFields(lines, "config.build", config.build, FIELDS.build);
+  emitFields(lines, "config.build.features", config.build?.features, FIELDS["build.features"]);
+  emitFields(lines, "config.bundle", config.bundle, FIELDS.bundle);
+  emitFields(lines, "config.bundle.linuxBundle", config.bundle?.linux, FIELDS["bundle.linuxBundle"]);
+  emitFields(lines, "config.bundle.windows", config.bundle?.windows, FIELDS["bundle.windows"]);
+  emitFields(lines, "config.bundle.macos", config.bundle?.macos, FIELDS["bundle.macos"]);
+  emitFields(lines, "config.security", config.security, FIELDS.security);
+  emitCsp(lines, config.security?.csp);
+  if (typeof config.$schema === "string") lines.push(`config.schema = ${cppString(config.$schema)};`);
+  const windows = Array.isArray(config.windows) && config.windows.length ? config.windows : [{}];
+  for (const value of windows) {
+    lines.push("{ Flare::WindowConfig window;");
+    emitFields(lines, "window", value, FIELDS.window);
+    emitSize(lines, "window.size", value);
+    emitSize(lines, "window.size", value.size);
+    lines.push("window.minimumSize = Flare::WindowSize{0.0, 0.0};");
+    lines.push("window.maximumSize = Flare::WindowSize{0.0, 0.0};");
+    emitSize(lines, "window.minimumSize", value.minimumSize);
+    emitSize(lines, "window.maximumSize", value.maximumSize);
+    if (value.position && typeof value.position === "object" && !Array.isArray(value.position)) {
+      const x = scalar(value.position.x, "number") ?? "0.0";
+      const y = scalar(value.position.y, "number") ?? "0.0";
+      lines.push(`window.position = Flare::WindowPosition{${x}, ${y}};`);
+    }
+    if (typeof value.theme === "string") {
+      const theme = { light: "Light", dark: "Dark", automatic: "Automatic", system: "Automatic", auto: "Automatic" }[value.theme.toLowerCase()];
+      if (theme) lines.push(`window.theme = Flare::WindowTheme::${theme};`);
+    }
+    lines.push("config.windows.push_back(window); }");
+  }
+  if (config.plugins && typeof config.plugins === "object" && !Array.isArray(config.plugins)) {
+    for (const [name, value] of Object.entries(config.plugins).sort(([a], [b]) => a.localeCompare(b))) {
+      lines.push(`config.plugins.push_back(Flare::PluginConfig{${cppString(name)}, ${cppJson(value)}});`);
+    }
+  }
+  lines.push(`config.raw = ${cppJson(raw)};`);
+  lines.push("return config;", "}", "}", "");
+  return lines.join("\n");
+}
+
+export function writeEmbeddedConfig({ projectDirectory, configFile = "flare.config.json", environment = "production", output }) {
+  const { config, files } = loadProject({ projectDirectory, configFile, environment });
+  let raw = {};
+  for (const file of files) raw = mergeConfig(raw, parseConfig(readFileSync(file, "utf8"), file));
+  writeFileSync(output, generateEmbeddedConfig(config, raw), "utf8");
+  const result = spawnSync("clang-format", ["-style=file", "-i", output], { cwd: projectDirectory });
+  if (result.error && result.error.code !== "ENOENT") throw result.error;
+  if (!result.error && result.status !== 0) {
+    throw new Error(`clang-format failed: ${result.stderr.toString("utf8")}`);
+  }
+  return files;
+}

package/src/lib/project.js

@@ -175,8 +175,8 @@ export function mergeConfig(base, overlay) {
 function normalizeWindow(window, fallbackTitle) {
   const value = isObject(window) ? { ...window } : {};
   const title = value.title ?? fallbackTitle;
-  const width = value.width ?? value.size?.width ?? 800;
-  const height = value.height ?? value.size?.height ?? 600;
+  const width = value.size?.width ?? value.width ?? 800;
+  const height = value.size?.height ?? value.height ?? 600;
   return {
     ...value,
     label: value.label ?? "main",
@@ -212,7 +212,8 @@ export function normalizeConfig(raw) {
   if (!config.app.mainBinaryName) config.app.mainBinaryName = config.app.productName;
 
   const fallbackTitle = config.app.productName || "flare-app";
-  const windows = Array.isArray(config.windows) && config.windows.length > 0 ? config.windows : [{}];
+  const sourceWindows = Array.isArray(config.windows) ? config.windows : config.app.windows;
+  const windows = Array.isArray(sourceWindows) && sourceWindows.length > 0 ? sourceWindows : [{}];
   config.windows = windows.map((window) => normalizeWindow(window, fallbackTitle));
 
   return config;

package/src/lib/sdk.js

@@ -0,0 +1,54 @@
+import { mkdtempSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { extract } from "tar";
+
+import { FlareError } from "./errors.js";
+
+export function sdkTarget(platform = process.platform, arch = process.arch) {
+  if (!(["x64", "arm64"].includes(arch))) throw new FlareError(`prebuilt SDK is not available for ${arch}; choose source mode`);
+  if (platform === "win32") {
+    if (arch !== "x64") throw new FlareError("prebuilt Windows SDK supports x64 MSVC only; choose source mode");
+    return { platform: "windows-x64", runtimes: ["md", "mt"] };
+  }
+  if (platform === "darwin") return { platform: `macos-${arch}`, runtimes: ["default"] };
+  if (platform === "linux" && arch === "x64") return { platform: "linux-x64", runtimes: ["default"] };
+  throw new FlareError(`prebuilt SDK is not available for ${platform}-${arch}; choose source mode`);
+}
+
+export async function installSdk({ destination, version, platform = process.platform, arch = process.arch, fetchImpl = fetch }) {
+  const target = sdkTarget(platform, arch);
+  mkdirSync(path.dirname(destination), { recursive: true });
+  const temporary = mkdtempSync(path.join(path.dirname(destination), ".flare-sdk-"));
+  const sdk = path.join(temporary, "flare");
+  mkdirSync(sdk);
+  try {
+    const checksumsUrl = `https://github.com/flare-desktop/flare/releases/download/v${version}/SHA256SUMS.txt`;
+    const checksumsResponse = await fetchImpl(checksumsUrl);
+    if (!checksumsResponse.ok) throw new FlareError(`SDK checksums are unavailable (HTTP ${checksumsResponse.status}); publish core v${version} first`);
+    const sums = new Map((await checksumsResponse.text()).split("\n").map((line) => /^(\w{64})\s+\*?(\S+)$/.exec(line)).filter(Boolean).map((match) => [match[2], match[1].toLowerCase()]));
+    for (const runtime of target.runtimes) {
+      const file = `flare-sdk-v${version}-${target.platform}-${runtime}.tar.gz`;
+      const url = `https://github.com/flare-desktop/flare/releases/download/v${version}/${file}`;
+      let response;
+      try { response = await fetchImpl(url); } catch (error) { throw new FlareError(`failed to download ${file}: ${error.message}`); }
+      if (!response.ok) throw new FlareError(`SDK archive ${file} is unavailable (HTTP ${response.status}); publish core v${version} SDK release first, or choose source mode`);
+      const archive = path.join(temporary, file);
+      const data = Buffer.from(await response.arrayBuffer());
+      const digest = createHash("sha256").update(data).digest("hex");
+      if (!sums.has(file) || sums.get(file) !== digest) throw new FlareError(`SDK checksum mismatch for ${file}`);
+      writeFileSync(archive, data);
+      await extract({ file: archive, cwd: temporary, strict: true, filter: (entry) => entry === "flare" || entry.startsWith("flare/") });
+      const manifest = JSON.parse(readFileSync(path.join(sdk, "sdk-manifest.json"), "utf8"));
+      if (manifest.version !== version || manifest.target !== target.platform || manifest.crt !== runtime) {
+        throw new FlareError(`SDK archive ${file} has incorrect platform or version metadata`);
+      }
+    }
+    rmSync(destination, { recursive: true, force: true });
+    mkdirSync(path.dirname(destination), { recursive: true });
+    renameSync(sdk, destination);
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+  return target;
+}

package/src/release-versions.js

@@ -0,0 +1,2 @@
+export const CORE_VERSION = "0.1.1";
+export const MIN_CLI_VERSION = "0.1.2";

package/src/templates/clang-format.txt

@@ -0,0 +1,32 @@
+BasedOnStyle: Google
+Standard: c++20
+ColumnLimit: 120
+IndentWidth: 4
+TabWidth: 4
+ContinuationIndentWidth: 4
+ConstructorInitializerIndentWidth: 4
+AccessModifierOffset: -4
+NamespaceIndentation: All
+UseTab: Never
+PointerAlignment: Left
+DerivePointerAlignment: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: false
+RemoveBracesLLVM: true
+SortIncludes: Never
+FixNamespaceComments: false
+AlignAfterOpenBracket: BlockIndent
+AlignOperands: DontAlign
+AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: NonAssignment
+BreakConstructorInitializers: BeforeColon
+PackConstructorInitializers: Never
+LambdaBodyIndentation: OuterScope
+PenaltyBreakBeforeFirstCallParameter: 10
+AlwaysBreakAfterReturnType: None
+PenaltyReturnTypeOnItsOwnLine: 1000

package/src/templates/core.d.ts

@@ -0,0 +1,135 @@
+export type Payload = Record<string, unknown> | unknown[] | string | number | boolean | null;
+
+export interface InvokeOptions {
+    id?: string;
+    window?: string;
+    webview?: string;
+}
+
+export interface ListenOptions {
+    window?: string;
+}
+
+export interface IpcErrorShape {
+    code: string;
+    message: string;
+    details?: Payload;
+}
+
+export interface IpcFailure extends Error {
+    code: string;
+    details?: Payload;
+}
+
+export interface ChannelMessage {
+    sequence: number;
+    payload: Payload;
+    state: 'open' | 'closed';
+}
+
+export interface Channel {
+    identifier: number;
+    name: string;
+    send(payload?: Payload): Promise<void>;
+    deliver(message: ChannelMessage): void;
+    close(): void;
+}
+
+export interface Metadata {
+    readonly protocol: string;
+    readonly host: string;
+    readonly version: string;
+}
+
+export function isFlare(): boolean;
+export function metadata(): Metadata;
+export function invoke<T = unknown>(command: string, payload?: Payload, options?: InvokeOptions): Promise<T>;
+export function listen(event: string, handler: (payload: Payload) => void, options?: ListenOptions): Promise<() => Promise<void>>;
+export function once(event: string, handler: (payload: Payload) => void, options?: ListenOptions): Promise<() => Promise<void>>;
+export function unlisten(event: string, id: number): Promise<void>;
+export function emit(event: string, payload?: Payload): Promise<void>;
+export function dispatch(event: string, payload?: Payload): number;
+export function createChannel(onMessage: (message: ChannelMessage) => void): Channel;
+export function currentWindow(): {
+    label: string;
+    close(): Promise<unknown>;
+    setTitle(title: string): Promise<unknown>;
+    show(): Promise<unknown>;
+    hide(): Promise<unknown>;
+};
+
+export const app: {
+    version(): Promise<string>;
+    describe(): Promise<Payload>;
+    config(): Promise<Payload>;
+    platform(): Promise<Payload>;
+    exit(): Promise<unknown>;
+};
+
+export const window: {
+    list(): Promise<string[]>;
+    emit(event: string, payload?: Payload): Promise<unknown>;
+};
+
+export const plugins: { list(): Promise<Payload> };
+export interface MenuItem {
+    id?: string;
+    kind?: 'text' | 'check' | 'radio' | 'separator' | 'submenu' | 'predefined';
+    text?: string;
+    accelerator?: string;
+    enabled?: boolean;
+    checked?: boolean;
+    icon?: string;
+    items?: MenuItem[];
+}
+
+export const menu: {
+    describe(): Promise<{ id: string; items: MenuItem[] }>;
+    set(items: MenuItem[]): Promise<boolean>;
+    dispatch(id: string): Promise<boolean>;
+    onCommand(handler: (id: string, payload: { id: string }) => void): () => Promise<boolean>;
+};
+export const commands: {
+    register(name: string, handler: (payload: Payload) => Payload): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    names(): string[];
+};
+export const log: {
+    trace(message: string): Promise<void>;
+    debug(message: string): Promise<void>;
+    info(message: string): Promise<void>;
+    warn(message: string): Promise<void>;
+    error(message: string): Promise<void>;
+};
+
+export type DirectoryName =
+    | 'appData'
+    | 'appLocalData'
+    | 'appConfig'
+    | 'appCache'
+    | 'appLog'
+    | 'home'
+    | 'documents'
+    | 'downloads'
+    | 'desktop'
+    | 'pictures'
+    | 'temp'
+    | 'executable'
+    | 'resource'
+    | 'current';
+
+export const path: {
+    resolve(name: DirectoryName | string): Promise<{ name: string; path: string }>;
+    all(): Promise<Record<DirectoryName, string>>;
+};
+
+export const tray: {
+    describe(): Promise<Payload & { menu: { id: string; items: MenuItem[] } }>;
+    setIcon(icon: string): Promise<Payload>;
+    setTooltip(tooltip: string): Promise<Payload>;
+    setTitle(title: string): Promise<Payload>;
+    setVisible(visible: boolean): Promise<Payload>;
+    setMenu(items: MenuItem[]): Promise<Payload>;
+    dispatch(id: string): Promise<boolean>;
+};

package/src/templates/core.js

@@ -0,0 +1,278 @@
+const protocol = 'flare';
+const defaultHost = 'localhost';
+
+const coreCommands = new Map();
+const eventListeners = new Map();
+const channels = new Map();
+
+let listenerSequence = 0;
+let channelSequence = 0;
+
+function resolveBridge() {
+    const bridge = globalThis.__FLARE_BRIDGE__;
+    if (!bridge) {
+        throw new Error('flare: the ipc bridge is not available in this context');
+    }
+    return bridge;
+}
+
+function normalizeCallback(callback) {
+    if (callback === undefined || callback === null) {
+        return undefined;
+    }
+    if (typeof callback === 'function') {
+        return callback;
+    }
+    throw new TypeError('flare: callback must be a function');
+}
+
+export function isFlare() {
+    return typeof globalThis.__FLARE_BRIDGE__ !== 'undefined';
+}
+
+export function metadata() {
+    const bridge = globalThis.__FLARE_BRIDGE__;
+    return Object.freeze({
+        protocol,
+        host: (bridge && bridge.host) || defaultHost,
+        version: (bridge && bridge.version) || '0.0.0'
+    });
+}
+
+export async function invoke(command, payload = {}, options = {}) {
+    if (typeof command !== 'string' || command.length === 0) {
+        throw new TypeError('flare: command must be a non empty string');
+    }
+    const bridge = resolveBridge();
+    const request = {
+        id: options.id || `${Date.now().toString(36)}-${(listenerSequence += 1).toString(36)}`,
+        command,
+        payload: payload === undefined ? {} : payload,
+        window: options.window || '',
+        webview: options.webview || ''
+    };
+    const response = await bridge.invoke(request);
+    if (response === undefined || response === null) {
+        throw new Error(`flare: command '${command}' returned no response`);
+    }
+    if (response.successful === false) {
+        const error = response.error || {};
+        const failure = new Error(error.message || `flare: command '${command}' failed`);
+        failure.code = error.code || 'command-failed';
+        failure.details = error.details;
+        throw failure;
+    }
+    return response.result;
+}
+
+export async function listen(event, handler, options = {}) {
+    if (typeof event !== 'string' || event.length === 0) {
+        throw new TypeError('flare: event name must be a non empty string');
+    }
+    const callback = normalizeCallback(handler);
+    listenerSequence += 1;
+    const id = listenerSequence;
+    const window = options.window || '';
+    if (!eventListeners.has(event)) {
+        eventListeners.set(event, new Map());
+    }
+    eventListeners.get(event).set(id, { callback, window, once: false });
+    const bridge = resolveBridge();
+    if (typeof bridge.attachListener === 'function') {
+        bridge.attachListener(event, id, callback);
+    }
+    try {
+        await bridge.listen({ event, id, window });
+    } catch (error) {
+        eventListeners.get(event)?.delete(id);
+        await bridge.unlisten?.({ event, id });
+        throw error;
+    }
+    return () => unlisten(event, id);
+}
+
+export async function once(event, handler, options = {}) {
+    const remove = await listen(
+        event,
+        (payload) => {
+            remove();
+            if (typeof handler === 'function') {
+                handler(payload);
+            }
+        },
+        options
+    );
+    return remove;
+}
+
+export async function unlisten(event, id) {
+    const entries = eventListeners.get(event);
+    if (entries) {
+        entries.delete(id);
+        if (entries.size === 0) {
+            eventListeners.delete(event);
+        }
+    }
+    const bridge = globalThis.__FLARE_BRIDGE__;
+    if (bridge && typeof bridge.unlisten === 'function') {
+        await bridge.unlisten({ event, id });
+    }
+}
+
+export async function emit(event, payload = {}) {
+    const bridge = resolveBridge();
+    await bridge.emit({ event, payload });
+}
+
+export function dispatch(event, payload = {}) {
+    const entries = eventListeners.get(event);
+    if (!entries) {
+        return 0;
+    }
+    const pending = [];
+    for (const entry of entries.values()) {
+        pending.push(entry);
+    }
+    for (const entry of pending) {
+        if (entry.once) {
+            entries.delete(entry);
+        }
+        try {
+            entry.callback(payload);
+        } catch (error) {
+            console.error(`flare: listener for '${event}' failed`, error);
+        }
+    }
+    return pending.length;
+}
+
+export function createChannel(onMessage) {
+    channelSequence += 1;
+    const id = channelSequence;
+    const name = `channel-${id}`;
+    channels.set(id, { onMessage, closed: false });
+    return {
+        identifier: id,
+        name,
+        async send(payload = {}) {
+            const bridge = resolveBridge();
+            await bridge.channel({ id, payload });
+        },
+        deliver(message) {
+            if (onMessage) {
+                onMessage(message);
+            }
+            if (message && message.state === 'closed') {
+                channels.delete(id);
+            }
+        },
+        close() {
+            channels.delete(id);
+        }
+    };
+}
+
+export function currentWindow() {
+    const label = (globalThis.__FLARE_BRIDGE__ && globalThis.__FLARE_BRIDGE__.window) || 'main';
+    return {
+        label,
+        async close() {
+            return invoke('flare:window:close', { label });
+        },
+        async setTitle(title) {
+            return invoke('flare:window:set-title', { label, title });
+        },
+        async show() {
+            return invoke('flare:window:show', { label });
+        },
+        async hide() {
+            return invoke('flare:window:hide', { label });
+        }
+    };
+}
+
+export const app = Object.freeze({
+    version: () => invoke('flare:app:version'),
+    describe: () => invoke('flare:app:describe'),
+    config: () => invoke('flare:app:config'),
+    platform: () => invoke('flare:app:platform'),
+    exit: () => invoke('flare:app:exit')
+});
+
+export const window = Object.freeze({
+    list: () => invoke('flare:window:list'),
+    emit: (event, payload = {}) => invoke('flare:window:emit', { event, payload })
+});
+
+export const plugins = Object.freeze({
+    list: () => invoke('flare:plugin:list')
+});
+
+export const menu = Object.freeze({
+    describe: () => invoke('flare:menu:describe'),
+    set: (items) => invoke('flare:menu:set', { items }),
+    dispatch: (id) => invoke('flare:menu:dispatch', { id }),
+    onCommand: (handler) => listen('flare:menu:command', (payload) => handler(payload.id, payload))
+});
+
+export const commands = Object.freeze({
+    register(name, handler) {
+        if (typeof name !== 'string' || typeof handler !== 'function') {
+            throw new TypeError('flare: register expects a name and a handler');
+        }
+        coreCommands.set(name, handler);
+    },
+    unregister(name) {
+        return coreCommands.delete(name);
+    },
+    has(name) {
+        return coreCommands.has(name);
+    },
+    names() {
+        return Array.from(coreCommands.keys());
+    }
+});
+
+export const log = Object.freeze({
+    trace: (message) => emit('flare:log:trace', { message }),
+    debug: (message) => emit('flare:log:debug', { message }),
+    info: (message) => emit('flare:log:info', { message }),
+    warn: (message) => emit('flare:log:warn', { message }),
+    error: (message) => emit('flare:log:error', { message })
+});
+
+export const path = Object.freeze({
+    resolve: (name) => invoke('flare:path:resolve', { name }),
+    all: () => invoke('flare:path:all')
+});
+
+export const tray = Object.freeze({
+    describe: () => invoke('flare:tray:describe'),
+    setIcon: (icon) => invoke('flare:tray:set-icon', { icon }),
+    setTooltip: (tooltip) => invoke('flare:tray:set-tooltip', { tooltip }),
+    setTitle: (title) => invoke('flare:tray:set-title', { title }),
+    setVisible: (visible) => invoke('flare:tray:set-visible', { visible }),
+    setMenu: (items) => invoke('flare:tray:set-menu', { items }),
+    dispatch: (id) => invoke('flare:tray:dispatch', { id })
+});
+
+export default {
+    app,
+    commands,
+    createChannel,
+    currentWindow,
+    dispatch,
+    emit,
+    invoke,
+    isFlare,
+    listen,
+    log,
+    menu,
+    metadata,
+    once,
+    path,
+    plugins,
+    tray,
+    unlisten,
+    window
+};

package/src/templates/project.js

@@ -7,7 +7,7 @@ export function embeddedIdentifier(name) {
     .join("");
 }
 
-export function configTemplate({ name, identifier, version }) {
+export function configTemplate({ name, identifier, version, template = "javascript" }) {
   return {
     $schema: SCHEMA_URL,
     package: { productName: name, version },
@@ -18,11 +18,11 @@ export function configTemplate({ name, identifier, version }) {
       version
     },
     build: {
-      frontendDist: "frontend",
-      devUrl: "",
-      beforeDevCommand: "",
+      frontendDist: template === "typescript" ? "dist" : "frontend",
+      devUrl: template === "typescript" ? "http://127.0.0.1:5173" : "",
+      beforeDevCommand: template === "typescript" ? "npm run frontend:dev" : "",
       afterDevCommand: "",
-      beforeBuildCommand: "",
+      beforeBuildCommand: template === "typescript" ? "npm run frontend:build" : "",
       afterBuildCommand: ""
     },
     bundle: {
@@ -51,7 +51,7 @@ export function configTemplate({ name, identifier, version }) {
   };
 }
 
-export function packageJsonTemplate({ name, version, cliVersion }) {
+export function packageJsonTemplate({ name, version, cliVersion, template = "javascript" }) {
   return {
     name,
     version,
@@ -61,15 +61,17 @@ export function packageJsonTemplate({ name, version, cliVersion }) {
       dev: "flare dev",
       build: "flare build",
       bundle: "flare bundle",
-      icon: "flare icon icons/icon.png"
+      icon: "flare icon icons/icon.png",
+      ...(template === "typescript" ? { "frontend:dev": "vite --host 127.0.0.1", "frontend:build": "tsc --noEmit && vite build" } : {})
     },
     devDependencies: {
-      "@flare-desktop/cli": `^${cliVersion}`
+      "@flare-desktop/cli": `^${cliVersion}`,
+      ...(template === "typescript" ? { typescript: "^5.9.3", vite: "^6.4.5" } : {})
     }
   };
 }
 
-export function cmakeTemplate({ name, version, coreVersion }) {
+export function cmakeTemplate({ name, version, coreVersion, sdkMode = "source" }) {
   return `cmake_minimum_required(VERSION 3.24)
 
 project(${name} VERSION ${version} LANGUAGES CXX)
@@ -77,18 +79,46 @@ project(${name} VERSION ${version} LANGUAGES CXX)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-include(FetchContent)
+if(WIN32 AND NOT DEFINED FLARE_NATIVE_WEBVIEW)
+    set(FLARE_NATIVE_WEBVIEW ON CACHE BOOL "Use the Windows system webview")
+endif()
+
+${sdkMode === "prebuilt" ? `add_subdirectory("\${CMAKE_CURRENT_SOURCE_DIR}/vendor/flare" "\${CMAKE_CURRENT_BINARY_DIR}/flare-sdk")` : `include(FetchContent)
 
 FetchContent_Declare(
     flare
     GIT_REPOSITORY https://github.com/flare-desktop/flare.git
     GIT_TAG v${coreVersion}
     GIT_SHALLOW TRUE)
-FetchContent_MakeAvailable(flare)
+FetchContent_MakeAvailable(flare)`}
 
 add_executable(${name} source/main.cpp)
 target_link_libraries(${name} PRIVATE flare::core flare::assets)
 
+find_program(FLARE_NODE_EXECUTABLE node REQUIRED)
+set(FLARE_CONFIG_FILE "flare.config.json" CACHE STRING "Source application configuration")
+set(FLARE_CONFIG_ENVIRONMENT "production" CACHE STRING "Build configuration layer")
+get_filename_component(FLARE_CONFIG_ABSOLUTE "\${FLARE_CONFIG_FILE}" ABSOLUTE BASE_DIR "\${CMAKE_CURRENT_SOURCE_DIR}")
+get_filename_component(FLARE_CONFIG_DIRECTORY "\${FLARE_CONFIG_ABSOLUTE}" DIRECTORY)
+get_filename_component(FLARE_CONFIG_NAME "\${FLARE_CONFIG_ABSOLUTE}" NAME_WE)
+file(GLOB FLARE_CONFIG_LAYERS CONFIGURE_DEPENDS "\${FLARE_CONFIG_DIRECTORY}/\${FLARE_CONFIG_NAME}*.json")
+set(FLARE_CONFIG_GENERATOR "\${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@flare-desktop/cli/src/lib/embed-config-cli.js")
+set(FLARE_CONFIG_IMPLEMENTATION "\${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@flare-desktop/cli/src/lib/embedded-config.js")
+set(FLARE_CONFIG_LOADER "\${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@flare-desktop/cli/src/lib/project.js")
+set(FLARE_GENERATED_CONFIG "\${CMAKE_CURRENT_BINARY_DIR}/flare-embedded-config.h")
+file(GENERATE OUTPUT "\${CMAKE_CURRENT_BINARY_DIR}/flare-config-selection.txt"
+    CONTENT "\${FLARE_CONFIG_FILE}\n\${FLARE_CONFIG_ENVIRONMENT}\n")
+add_custom_command(
+    OUTPUT "\${FLARE_GENERATED_CONFIG}"
+    COMMAND "\${FLARE_NODE_EXECUTABLE}" "\${FLARE_CONFIG_GENERATOR}"
+            "\${CMAKE_CURRENT_SOURCE_DIR}" "\${FLARE_CONFIG_FILE}" "\${FLARE_CONFIG_ENVIRONMENT}"
+            "\${FLARE_GENERATED_CONFIG}"
+    DEPENDS "\${FLARE_CONFIG_GENERATOR}" "\${FLARE_CONFIG_IMPLEMENTATION}" "\${FLARE_CONFIG_LOADER}"
+            "\${CMAKE_CURRENT_BINARY_DIR}/flare-config-selection.txt" \${FLARE_CONFIG_LAYERS}
+    VERBATIM)
+target_sources(${name} PRIVATE "\${FLARE_GENERATED_CONFIG}")
+target_include_directories(${name} PRIVATE "\${CMAKE_CURRENT_BINARY_DIR}")
+
 set(FLARE_FRONTEND_DIR "frontend" CACHE PATH "Frontend directory")
 file(TO_CMAKE_PATH "\${FLARE_FRONTEND_DIR}" FLARE_FRONTEND_DIR)
 target_compile_definitions(${name} PRIVATE FLARE_FRONTEND_DIR="\${FLARE_FRONTEND_DIR}")
@@ -96,13 +126,14 @@ FlareEmbedFrontend(${name} "\${FLARE_FRONTEND_DIR}")
 `;
 }
 
-export function sourceTemplate({ name, identifier, version }) {
+export function sourceTemplate({ name }) {
   const embedded = embeddedIdentifier(name);
   return `#include <flare/config/config.h>
 #include <flare/core/application.h>
 #include <flare/log/log.h>
 
 #include <${name}-frontend.h>
+#include <flare-embedded-config.h>
 
 #include <cstdlib>
 #include <string>
@@ -115,20 +146,9 @@ int main() {
     const bool development = std::getenv("FLARE_DEV") != nullptr;
 
     Flare::ApplicationOptions options;
-    options.config = Flare::Config::Defaults("${identifier}", "${version}");
-    options.config.app.productName = "${name}";
-    options.config.windows.front().title = "${name}";
+    options.config = FlareGenerated::EmbeddedConfig();
     options.development = development;
 
-    std::string error;
-    Flare::ConfigLoader loader(
-        Flare::ConfigMergeOptions{"flare.config.json", development ? "development" : "production", "", {}});
-    if (const auto loaded = loader.Load(error); loaded.has_value()) {
-        options.config = *loaded;
-    } else {
-        Flare::LogWarn("using the built-in configuration: {}", error);
-    }
-
     const char* devUrl = std::getenv("FLARE_DEV_URL");
     if (devUrl != nullptr) options.devUrl = devUrl;
     if (development && options.devUrl.empty()) options.frontendDirectory = FLARE_FRONTEND_DIR;
@@ -150,7 +170,7 @@ int main() {
 `;
 }
 
-export function indexHtmlTemplate(name) {
+export function indexHtmlTemplate(name, template = "javascript") {
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -166,7 +186,7 @@ export function indexHtmlTemplate(name) {
 <button id="greet">call the backend</button>
 <pre id="output"></pre>
 </main>
-<script type="module" src="main.js"></script>
+<script type="module" src="${template === "typescript" ? "main.ts" : "main.js"}"></script>
 </body>
 </html>
 `;
@@ -246,8 +266,44 @@ document.querySelector("#greet").addEventListener("click", async () => {
 `;
 }
 
+export function typescriptTemplate() {
+  return `import { app, invoke } from "/core.js";
+
+const output = document.querySelector<HTMLPreElement>("#output");
+const button = document.querySelector<HTMLButtonElement>("#greet");
+
+button?.addEventListener("click", async () => {
+  const message = await invoke<string>("greet", { name: "flare" });
+  const version = await app.version();
+  if (output) output.textContent = \`\${message} (\${version})\`;
+});
+`;
+}
+
+export function tsconfigTemplate() {
+  return {
+    compilerOptions: {
+      target: "ES2022", lib: ["ES2022", "DOM"], module: "ESNext", moduleResolution: "Bundler",
+      strict: true, noEmit: true, skipLibCheck: true, types: ["vite/client"],
+      paths: { "/core.js": ["./frontend/core.d.ts"] }
+    },
+    include: ["frontend/main.ts"]
+  };
+}
+
+export function viteConfigTemplate() {
+  return `import { defineConfig } from "vite";
+export default defineConfig({
+  root: "frontend",
+  base: "./",
+  build: { outDir: "../dist", emptyOutDir: true },
+  server: { host: "127.0.0.1", port: 5173, strictPort: true }
+});
+`;
+}
+
 export function gitignoreTemplate() {
-  return "build/\ntarget/\nnode_modules/\n.DS_Store\n";
+  return "build/\ntarget/\nnode_modules/\ndist/\n.DS_Store\n";
 }
 
 export function readmeTemplate(name) {
@@ -270,7 +326,7 @@ npm run bundle
 \`\`\`
 
 \`npm run dev\` builds the C++ core and serves \`frontend/\` in the system webview.
-\`npm run build\` compiles the frontend into the executable and produces a release build.
+\`npm run build\` compiles the frontend and the effective typed configuration into the executable. No JSON file is needed at runtime. On Windows, the native webview is enabled automatically. A configuration change requires rebuilding.
 \`npm run bundle\` assembles the configured bundle targets under \`target/bundle\`.
 
 ## Icons