create-mainz 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 soguten
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# create-mainz
+
+Simple unscoped npm package to create Mainz projects from the templates owned by
+[`soguten/mainz`](https://github.com/soguten/mainz).
+
+## Usage
+
+```bash
+npm create mainz my-app
+```
+
+Starter template:
+
+```bash
+npx create-mainz my-app --template starter
+```
+
+Deno runtime:
+
+```bash
+npx create-mainz my-app --runtime deno
+```
+
+## Development
+
+Sync templates from the `main` branch of [`soguten/mainz`](https://github.com/soguten/mainz):
+
+```bash
+node ./scripts/sync-templates.mjs
+```
+
+Run tests:
+
+```bash
+node --test
+```

package/bin/create-mainz.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+import { main } from "../src/cli/main.js";
+
+try {
+  const exitCode = await main(process.argv.slice(2));
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.stack ?? error.message : error);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "create-mainz",
+  "version": "0.1.0-alpha.0",
+  "description": "Simple npm project creator for Mainz",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/soguten/create-mainz.git"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "create-mainz": "bin/create-mainz.js"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "smoke": "node ./bin/create-mainz.js --help",
+    "sync:templates": "node ./scripts/sync-templates.mjs",
+    "test": "node --test",
+    "test:init": "node --test ./src/cli/main.test.js",
+    "test:templates": "node --test ./src/templates/materialize-template.test.js"
+  }
+}

package/src/cli/main.js

@@ -0,0 +1,233 @@
+import { access } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import process from "node:process";
+import {
+  instantiateTemplate,
+  materializeTemplatePlan,
+  resolveBuiltInTemplateRoot,
+} from "../templates/index.js";
+
+class CliUsageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+}
+
+export async function main(args = process.argv.slice(2)) {
+  try {
+    return await runCli(args);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`[create-mainz] ${error.message}`);
+      console.error('[create-mainz] Run "create-mainz --help" for usage.');
+      return 1;
+    }
+
+    throw error;
+  }
+}
+
+async function runCli(args) {
+  if (
+    args.length === 0 ||
+    args.includes("--help") ||
+    args.includes("-h") ||
+    args[0] === "help"
+  ) {
+    printHelp();
+    return 0;
+  }
+
+  const options = parseInitOptions(args);
+  const outputDir = options.name
+    ? resolve(process.cwd(), options.name)
+    : process.cwd();
+  const runtime = options.runtime ?? "node";
+  const templateName = options.template ?? "empty";
+  const projectName = sanitizeProjectName(basename(outputDir) || "mainz-app");
+  const templateRoot = resolveBuiltInTemplateRoot(runtime, templateName);
+  const templateParams = buildTemplateParams({
+    runtime,
+    projectName,
+    mainzSpecifier: options.mainzSpecifier,
+  });
+  const plan = await instantiateTemplate({
+    templateRoot,
+    params: templateParams,
+  });
+
+  validateTemplateCompatibility(plan.manifest, runtime, templateName);
+
+  await materializeTemplatePlan({
+    plan,
+    outputDir,
+    beforeWrite: assertCanCreateFile,
+  });
+
+  console.log(
+    `[create-mainz] Created Mainz ${templateName} project in ${outputDir}.`,
+  );
+  console.log(
+    `[create-mainz] Created ${plan.files.map((file) => file.path).join(", ")}.`,
+  );
+  return 0;
+}
+
+function parseInitOptions(args) {
+  const options = {
+    name: undefined,
+    mainzSpecifier: undefined,
+    runtime: undefined,
+    template: undefined,
+  };
+  let positionalName;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const current = args[index];
+
+    if (current === "--mainz") {
+      options.mainzSpecifier = readOptionValue(current, args[index + 1]);
+      index += 1;
+      continue;
+    }
+
+    if (current === "--runtime") {
+      const runtime = readOptionValue(current, args[index + 1]);
+      if (runtime !== "node" && runtime !== "deno") {
+        throw new CliUsageError(
+          `Unsupported runtime "${runtime}". Use "node" or "deno".`,
+        );
+      }
+
+      options.runtime = runtime;
+      index += 1;
+      continue;
+    }
+
+    if (current === "--template") {
+      const template = readOptionValue(current, args[index + 1]);
+      if (template !== "empty" && template !== "starter") {
+        throw new CliUsageError(
+          `Unsupported template "${template}". Use "empty" or "starter".`,
+        );
+      }
+
+      options.template = template;
+      index += 1;
+      continue;
+    }
+
+    if (current.startsWith("--")) {
+      throw new CliUsageError(`Unknown option "${current}".`);
+    }
+
+    if (positionalName) {
+      throw new CliUsageError(
+        `Received multiple project names "${positionalName}" and "${current}".`,
+      );
+    }
+
+    positionalName = current;
+  }
+
+  options.name = positionalName;
+  return options;
+}
+
+function readOptionValue(option, value) {
+  if (!value || value.startsWith("--")) {
+    throw new CliUsageError(`Option "${option}" requires a value.`);
+  }
+
+  return value;
+}
+
+function buildTemplateParams(options) {
+  if (options.runtime === "deno") {
+    const mainzSpecifier = options.mainzSpecifier ?? "jsr:@mainz/mainz";
+    return {
+      projectName: options.projectName,
+      mainzSpecifier,
+      mainzSubpathPrefix: renderGeneratedMainzSubpathPrefix(mainzSpecifier),
+      mainzCliSpecifier: "jsr:@mainz/cli-deno",
+      denoConfigPath: "deno.json",
+      appName: "app",
+      appId: "app",
+      appNavigation: "enhanced-mpa",
+      appTitle: options.projectName,
+      rootDir: "./app",
+      outDir: "dist/app",
+    };
+  }
+
+  return {
+    projectName: options.projectName,
+    mainzSpecifier: options.mainzSpecifier ?? "latest",
+    appName: "app",
+    appId: "app",
+    appNavigation: "enhanced-mpa",
+    appTitle: options.projectName,
+    rootDir: "./app",
+    outDir: "dist/app",
+  };
+}
+
+function renderGeneratedMainzSubpathPrefix(mainzSpecifier) {
+  const trimmed = mainzSpecifier.trim().replace(/\/+$/, "");
+  if (trimmed.startsWith("jsr:@")) {
+    return `jsr:/${trimmed.slice("jsr:".length)}/`;
+  }
+
+  return `${trimmed}/`;
+}
+
+function sanitizeProjectName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9-_]/g, "-");
+}
+
+function validateTemplateCompatibility(manifest, runtime, templateName) {
+  if (manifest.kind !== "project") {
+    throw new CliUsageError(`Template "${templateName}" is not a project template.`);
+  }
+
+  if (manifest.runtime !== runtime) {
+    throw new CliUsageError(
+      `Template "${templateName}" only supports runtime "${manifest.runtime}".`,
+    );
+  }
+}
+
+async function assertCanCreateFile(path) {
+  try {
+    await access(path);
+    throw new CliUsageError(`Refusing to overwrite existing file "${path}".`);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+
+    throw error;
+  }
+}
+
+function printHelp() {
+  console.log(
+    [
+      "create-mainz",
+      "",
+      "Usage:",
+      "  create-mainz [<name>] [--template <empty|starter>] [--runtime <node|deno>] [--mainz <specifier>]",
+      "",
+      "Options:",
+      "  --template <empty|starter>  Choose the project template. Defaults to empty.",
+      "  --runtime <node|deno>       Choose which Mainz runtime template to generate.",
+      "  --mainz <specifier>         Override the Mainz package specifier written to the project.",
+      "",
+      "Examples:",
+      "  npm create mainz@latest my-app",
+      "  npm create mainz@latest my-app -- --template starter",
+      "  npm create mainz@latest my-deno-app -- --runtime deno",
+    ].join("\n"),
+  );
+}

package/src/cli/main.test.js

@@ -0,0 +1,45 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { main } from "./main.js";
+
+test("creates a node empty project", async () => {
+  const root = await mkdtemp(join(tmpdir(), "create-mainz-node-"));
+
+  try {
+    const exitCode = await main([root]);
+    assert.equal(exitCode, 0);
+
+    const packageJson = JSON.parse(
+      await readFile(join(root, "package.json"), "utf8"),
+    );
+
+    assert.equal(
+      packageJson.name,
+      root.split(/[/\\]/).at(-1)?.toLowerCase(),
+    );
+    assert.equal(packageJson.dependencies.mainz, "latest");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("creates a deno starter project", async () => {
+  const parent = await mkdtemp(join(tmpdir(), "create-mainz-deno-"));
+  const root = join(parent, "demo-app");
+
+  try {
+    const exitCode = await main([root, "--runtime", "deno", "--template", "starter"]);
+    assert.equal(exitCode, 0);
+
+    const denoJson = JSON.parse(await readFile(join(root, "deno.json"), "utf8"));
+    assert.equal(denoJson.imports.mainz, "jsr:@mainz/mainz");
+
+    const configSource = await readFile(join(root, "mainz.config.ts"), "utf8");
+    assert.match(configSource, /name: "app"/);
+  } finally {
+    await rm(parent, { recursive: true, force: true });
+  }
+});

package/src/templates/index.js

@@ -0,0 +1,5 @@
+export { resolveBuiltInTemplateRoot } from "./load-template.js";
+export {
+  instantiateTemplate,
+  materializeTemplatePlan,
+} from "./materialize-template.js";

package/src/templates/load-template.js

@@ -0,0 +1,27 @@
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(moduleDir, "..", "..");
+
+export function resolveBuiltInTemplateRoot(runtime, name) {
+  return resolve(repoRoot, "templates", "project", runtime, name);
+}
+
+export async function loadTemplate(templateRoot) {
+  const manifestPath = resolve(templateRoot, "template.json");
+  const manifestSource = await readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestSource);
+
+  if (manifest.kind !== "project" || !manifest.name) {
+    throw new Error(`Invalid template manifest at "${manifestPath}".`);
+  }
+
+  return {
+    manifest,
+    manifestSource,
+    root: templateRoot,
+    filesRoot: resolve(templateRoot, "files"),
+  };
+}

package/src/templates/materialize-template.js

@@ -0,0 +1,89 @@
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { loadTemplate } from "./load-template.js";
+
+export async function instantiateTemplate(options) {
+  const template = await loadTemplate(resolveRequiredTemplateRoot(options.templateRoot));
+  const relativePaths = await collectTemplateFiles(template.filesRoot);
+  const params = options.params ?? {};
+
+  return {
+    manifest: JSON.parse(replaceTemplateTokens(template.manifestSource, params)),
+    files: await Promise.all(
+      relativePaths.map(async (relativePath) => {
+        const sourcePath = resolve(template.filesRoot, relativePath);
+        const renderedPath = stripTemplateSuffix(
+          replaceTemplateTokens(relativePath, params),
+        );
+        const renderedContent = replaceTemplateTokens(
+          await readFile(sourcePath, "utf8"),
+          params,
+        );
+
+        return {
+          path: renderedPath,
+          content: renderedContent,
+        };
+      }),
+    ),
+  };
+}
+
+export async function materializeTemplatePlan(options) {
+  const filesWithAbsolutePaths = options.plan.files.map((file) => ({
+    file,
+    absolutePath: resolve(options.outputDir, file.path),
+  }));
+
+  for (const { file, absolutePath } of filesWithAbsolutePaths) {
+    if (typeof options.beforeWrite === "function") {
+      await options.beforeWrite(absolutePath, file);
+    }
+  }
+
+  for (const { file, absolutePath } of filesWithAbsolutePaths) {
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, file.content, "utf8");
+  }
+
+  return options.plan;
+}
+
+function resolveRequiredTemplateRoot(templateRoot) {
+  if (!templateRoot) {
+    throw new Error("Template root is required.");
+  }
+
+  return templateRoot;
+}
+
+async function collectTemplateFiles(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const absolutePath = resolve(current, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await collectTemplateFiles(root, absolutePath)));
+      continue;
+    }
+
+    files.push(relative(root, absolutePath));
+  }
+
+  return files;
+}
+
+function replaceTemplateTokens(value, params) {
+  return value.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_match, key) => {
+    if (!(key in params) || params[key] === undefined || params[key] === null) {
+      throw new Error(`Missing template parameter "${key}".`);
+    }
+
+    return String(params[key]);
+  });
+}
+
+function stripTemplateSuffix(path) {
+  return path.endsWith(".tpl") ? path.slice(0, -".tpl".length) : path;
+}

package/src/templates/materialize-template.test.js

@@ -0,0 +1,26 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { instantiateTemplate, resolveBuiltInTemplateRoot } from "./index.js";
+
+test("instantiates node starter template", async () => {
+  const plan = await instantiateTemplate({
+    templateRoot: resolveBuiltInTemplateRoot("node", "starter"),
+    params: {
+      projectName: "demo-app",
+      mainzSpecifier: "latest",
+      appName: "app",
+      appId: "app",
+      appNavigation: "enhanced-mpa",
+      appTitle: "demo-app",
+      rootDir: "./app",
+      outDir: "dist/app",
+    },
+  });
+
+  assert.equal(plan.manifest.kind, "project");
+  assert.equal(plan.manifest.runtime, "node");
+  assert.ok(plan.files.some((file) => file.path === "package.json"));
+  assert.ok(
+    plan.files.some((file) => file.path.replaceAll("\\", "/") === "app/src/app.ts"),
+  );
+});

package/templates/project/bun/.gitkeep

@@ -0,0 +1 @@
+

package/templates/project/deno/empty/files/deno.json.tpl

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "esnext"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "mainz",
+    "strict": true
+  },
+  "imports": {
+    "@deno/vite-plugin": "npm:@deno/vite-plugin@2.0.2",
+    "mainz": "{{mainzSpecifier}}",
+    "mainz/": "{{mainzSubpathPrefix}}",
+    "vite": "npm:vite@8.0.10"
+  },
+  "tasks": {
+    "dev": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} dev",
+    "build": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} build",
+    "preview": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} preview",
+    "test": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} test",
+    "publish-info": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} publish-info",
+    "diagnose": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} diagnose"
+  }
+}

package/templates/project/deno/empty/files/mainz.config.ts.tpl

@@ -0,0 +1,6 @@
+import { defineMainzConfig } from "mainz/config";
+
+export default defineMainzConfig({
+  runtime: "deno",
+  targets: [],
+});

package/templates/project/deno/empty/template.json

@@ -0,0 +1,5 @@
+{
+  "kind": "project",
+  "name": "empty",
+  "runtime": "deno"
+}

package/templates/project/deno/starter/files/app/deno.json.tpl

@@ -0,0 +1,3 @@
+{
+  "imports": {}
+}

package/templates/project/deno/starter/files/app/index.html.tpl

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{appTitle}}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/project/deno/starter/files/app/src/app.ts.tpl

@@ -0,0 +1,10 @@
+import { defineApp } from "mainz";
+import { HomePage } from "./pages/Home.page.tsx";
+import { NotFoundPage } from "./pages/NotFound.page.tsx";
+
+export const app = defineApp({
+  id: "{{appId}}",
+  navigation: "{{appNavigation}}",
+  pages: [HomePage],
+  notFound: NotFoundPage,
+});

package/templates/project/deno/starter/files/app/src/components/Counter.tsx.tpl

@@ -0,0 +1,31 @@
+import { Component } from "mainz";
+
+type CounterState = {
+  count: number;
+};
+
+export class Counter extends Component<{}, CounterState> {
+  protected override initState(): CounterState {
+    return { count: 0 };
+  }
+
+  private decrement = () => {
+    this.setState({ count: this.state.count - 1 });
+  };
+
+  private increment = () => {
+    this.setState({ count: this.state.count + 1 });
+  };
+
+  override render() {
+    return (
+      <section className="counter" aria-label="Counter example">
+        <p>Count: {this.state.count}</p>
+        <div>
+          <button type="button" onClick={this.decrement}>-</button>
+          <button type="button" onClick={this.increment}>+</button>
+        </div>
+      </section>
+    );
+  }
+}

package/templates/project/deno/starter/files/app/src/main.tsx.tpl

@@ -0,0 +1,6 @@
+import { startApp } from "mainz";
+import { app } from "./app.ts";
+
+startApp(app, {
+  mount: "#app",
+});

package/templates/project/deno/starter/files/app/src/pages/Home.page.tsx.tpl

@@ -0,0 +1,21 @@
+import { Page, Route } from "mainz";
+import { Counter } from "../components/Counter.tsx";
+
+@Route("/")
+export class HomePage extends Page {
+  override head() {
+    return {
+      title: "{{appTitle}}",
+    };
+  }
+
+  override render() {
+    return (
+      <main>
+        <h1>{{ appTitle }}</h1>
+        <p>Welcome to your Mainz starter app.</p>
+        <Counter />
+      </main>
+    );
+  }
+}

package/templates/project/deno/starter/files/app/src/pages/NotFound.page.tsx.tpl

@@ -0,0 +1,18 @@
+import { Page } from "mainz";
+
+export class NotFoundPage extends Page {
+  override head() {
+    return {
+      title: "404 | {{appTitle}}",
+    };
+  }
+
+  override render() {
+    return (
+      <main>
+        <h1>Page not found</h1>
+        <a href="/">Go home</a>
+      </main>
+    );
+  }
+}

package/templates/project/deno/starter/files/deno.json.tpl

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "esnext"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "mainz",
+    "strict": true
+  },
+  "imports": {
+    "@deno/vite-plugin": "npm:@deno/vite-plugin@2.0.2",
+    "mainz": "{{mainzSpecifier}}",
+    "mainz/": "{{mainzSubpathPrefix}}",
+    "vite": "npm:vite@8.0.10"
+  },
+  "tasks": {
+    "dev": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} dev",
+    "build": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} build",
+    "preview": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} preview",
+    "test": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} test",
+    "publish-info": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} publish-info",
+    "diagnose": "deno run -A --config {{denoConfigPath}} {{mainzCliSpecifier}} diagnose"
+  },
+  "workspace": [
+    "./app"
+  ]
+}

package/templates/project/deno/starter/files/mainz.config.ts.tpl

@@ -0,0 +1,14 @@
+import { defineMainzConfig } from "mainz/config";
+
+export default defineMainzConfig({
+  runtime: "deno",
+  targets: [
+    {
+      name: "{{appName}}",
+      rootDir: "{{rootDir}}",
+      appFile: "{{rootDir}}/src/app.ts",
+      appId: "{{appId}}",
+      outDir: "{{outDir}}",
+    },
+  ],
+});

package/templates/project/deno/starter/template.json

@@ -0,0 +1,5 @@
+{
+  "kind": "project",
+  "name": "starter",
+  "runtime": "deno"
+}

package/templates/project/node/empty/files/.npmrc.tpl

@@ -0,0 +1 @@
+@jsr:registry=https://npm.jsr.io

package/templates/project/node/empty/files/mainz.config.ts.tpl

@@ -0,0 +1,6 @@
+import { defineMainzConfig } from "mainz/config";
+
+export default defineMainzConfig({
+  runtime: "node",
+  targets: [],
+});

package/templates/project/node/empty/files/package.json.tpl

@@ -0,0 +1,18 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "mainz dev",
+    "build": "mainz build",
+    "preview": "mainz preview",
+    "test": "mainz test",
+    "diagnose": "mainz diagnose"
+  },
+  "dependencies": {
+    "mainz": "{{mainzSpecifier}}"
+  },
+  "devDependencies": {
+    "vite": "^8.0.10"
+  }
+}

package/templates/project/node/empty/files/tsconfig.json.tpl

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["DOM", "ES2022"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "mainz",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": []
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}

package/templates/project/node/empty/template.json

@@ -0,0 +1,5 @@
+{
+  "kind": "project",
+  "name": "empty",
+  "runtime": "node"
+}

package/templates/project/node/starter/files/.npmrc.tpl

@@ -0,0 +1 @@
+@jsr:registry=https://npm.jsr.io

package/templates/project/node/starter/files/app/index.html.tpl

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{appTitle}}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/project/node/starter/files/app/package.json.tpl

@@ -0,0 +1,5 @@
+{
+  "name": "{{appName}}",
+  "private": true,
+  "type": "module"
+}

package/templates/project/node/starter/files/app/src/app.ts.tpl

@@ -0,0 +1,10 @@
+import { defineApp } from "mainz";
+import { HomePage } from "./pages/Home.page.tsx";
+import { NotFoundPage } from "./pages/NotFound.page.tsx";
+
+export const app = defineApp({
+  id: "{{appId}}",
+  navigation: "{{appNavigation}}",
+  pages: [HomePage],
+  notFound: NotFoundPage,
+});

package/templates/project/node/starter/files/app/src/components/Counter.tsx.tpl

@@ -0,0 +1,31 @@
+import { Component } from "mainz";
+
+type CounterState = {
+  count: number;
+};
+
+export class Counter extends Component<{}, CounterState> {
+  protected override initState(): CounterState {
+    return { count: 0 };
+  }
+
+  private decrement = () => {
+    this.setState({ count: this.state.count - 1 });
+  };
+
+  private increment = () => {
+    this.setState({ count: this.state.count + 1 });
+  };
+
+  override render() {
+    return (
+      <section className="counter" aria-label="Counter example">
+        <p>Count: {this.state.count}</p>
+        <div>
+          <button type="button" onClick={this.decrement}>-</button>
+          <button type="button" onClick={this.increment}>+</button>
+        </div>
+      </section>
+    );
+  }
+}

package/templates/project/node/starter/files/app/src/main.tsx.tpl

@@ -0,0 +1,6 @@
+import { startApp } from "mainz";
+import { app } from "./app.ts";
+
+startApp(app, {
+  mount: "#app",
+});

package/templates/project/node/starter/files/app/src/pages/Home.page.tsx.tpl

@@ -0,0 +1,21 @@
+import { Page, Route } from "mainz";
+import { Counter } from "../components/Counter.tsx";
+
+@Route("/")
+export class HomePage extends Page {
+  override head() {
+    return {
+      title: "{{appTitle}}",
+    };
+  }
+
+  override render() {
+    return (
+      <main>
+        <h1>{{ appTitle }}</h1>
+        <p>Welcome to your Mainz starter app.</p>
+        <Counter />
+      </main>
+    );
+  }
+}

package/templates/project/node/starter/files/app/src/pages/NotFound.page.tsx.tpl

@@ -0,0 +1,18 @@
+import { Page } from "mainz";
+
+export class NotFoundPage extends Page {
+  override head() {
+    return {
+      title: "404 | {{appTitle}}",
+    };
+  }
+
+  override render() {
+    return (
+      <main>
+        <h1>Page not found</h1>
+        <a href="/">Go home</a>
+      </main>
+    );
+  }
+}

package/templates/project/node/starter/files/mainz.config.ts.tpl

@@ -0,0 +1,14 @@
+import { defineMainzConfig } from "mainz/config";
+
+export default defineMainzConfig({
+  runtime: "node",
+  targets: [
+    {
+      name: "{{appName}}",
+      rootDir: "{{rootDir}}",
+      appFile: "{{rootDir}}/src/app.ts",
+      appId: "{{appId}}",
+      outDir: "{{outDir}}",
+    },
+  ],
+});

package/templates/project/node/starter/files/package.json.tpl

@@ -0,0 +1,21 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "mainz dev",
+    "build": "mainz build",
+    "preview": "mainz preview",
+    "test": "mainz test",
+    "diagnose": "mainz diagnose"
+  },
+  "dependencies": {
+    "mainz": "{{mainzSpecifier}}"
+  },
+  "devDependencies": {
+    "vite": "^8.0.10"
+  },
+  "workspaces": [
+    "app"
+  ]
+}

package/templates/project/node/starter/files/tsconfig.json.tpl

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["DOM", "ES2022"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "mainz",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": []
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}

package/templates/project/node/starter/template.json

@@ -0,0 +1,5 @@
+{
+  "kind": "project",
+  "name": "starter",
+  "runtime": "node"
+}