@madojs/mado 0.11.1 → 0.13.0

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@madojs/mado",
-  "version": "0.11.1",
-  "description": "Mado — a calm browser-native SPA framework for internal tools, admin panels and business apps. Routing, forms, state and data fetching without frontend infrastructure overhead.",
+  "version": "0.13.0",
+  "description": "A calm native-first web framework for sites and apps. Web Components, signals, routing, data, forms and browser-rendered static snapshots. Zero runtime dependencies.",
   "type": "module",
   "license": "MIT",
   "keywords": [
     "framework",
-    "spa",
+    "native-first",
     "web-components",
+    "declarative-shadow-dom",
     "signals",
     "tagged-templates",
     "router",
     "vite",
-    "tsc",
-    "minimal",
-    "lit-alternative",
-    "solid-alternative"
+    "static-snapshot",
+    "spa",
+    "minimal"
   ],
   "homepage": "https://github.com/madojs/mado#readme",
   "repository": {
@@ -29,7 +29,6 @@
     "mado": "./scripts/cli.mjs"
   },
   "main": "./dist/src/index.js",
-  "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
@@ -47,49 +46,78 @@
   },
   "files": [
     "dist/src",
-    "scripts",
-    "templates",
+    "scripts/cli.mjs",
+    "scripts/_config.mjs",
+    "scripts/clean.mjs",
+    "scripts/logger.mjs",
+    "scripts/output-guard.mjs",
+    "scripts/preview.mjs",
+    "scripts/static.mjs",
+    "scripts/vite.default.mjs",
+    "scripts/cli",
+    "scripts/static",
     "starters",
     "README.md",
     "LICENSE",
     "CHANGELOG.md",
-    "TODO.md",
     "AGENTS.md",
     "llms.txt",
-    "docs/**/*.md"
+    "docs/README.md",
+    "docs/en/**/*.md",
+    "docs/architecture/**/*.md",
+    "docs/recipes/**/*"
   ],
+  "sideEffects": [
+    "./dist/src/devtools.js"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "packageManager": "npm@11.16.0",
   "scripts": {
     "build": "node scripts/cli.mjs build",
     "watch": "node scripts/cli.mjs watch",
     "dev": "node scripts/cli.mjs dev",
-    "bake": "node scripts/cli.mjs bake",
+    "static": "node scripts/cli.mjs static",
     "preview": "node scripts/cli.mjs preview",
     "new": "node scripts/cli.mjs new",
     "size": "node scripts/size-budget.mjs",
     "package:smoke": "node scripts/package-smoke.mjs",
+    "docs:lint": "node scripts/docs-lint.mjs && node node_modules/typescript/bin/tsc --noEmit -p tsconfig.docs.json",
+    "api:check": "node scripts/api-check.mjs",
+    "benchmark:static": "node scripts/benchmark-static.mjs",
     "test": "node scripts/cli.mjs test",
     "typecheck": "node scripts/cli.mjs typecheck",
-    "clean": "rm -rf dist out",
-    "prepublishOnly": "npm run clean && npm run build && npm test"
+    "clean": "node scripts/clean.mjs",
+    "verify:release": "npm run clean && npm test && npm run docs:lint && npm run api:check && npm run size && npm run package:smoke && npm audit --audit-level=high",
+    "prepack": "node scripts/clean.mjs --dist-only && npm run build",
+    "prepublishOnly": "npm run verify:release"
   },
   "devDependencies": {
-    "@types/node": "^20.19.0",
-    "esbuild": "^0.28.0",
-    "lightningcss": "^1.32.0",
-    "linkedom": "^0.18.12",
-    "playwright-core": "^1.47.0",
-    "typescript": "^6.0.3",
-    "vite": "^8.0.16"
+    "@types/node": "^22.12.0",
+    "esbuild": "^0.28.1",
+    "linkedom": "^0.18.13",
+    "playwright-core": "^1.61.1",
+    "typescript": "^7.0.2",
+    "vite": "^8.1.4"
   },
   "peerDependencies": {
+    "playwright-core": "^1.61.1",
     "vite": "^8.0.0"
   },
   "peerDependenciesMeta": {
+    "playwright-core": {
+      "optional": true
+    },
     "vite": {
       "optional": true
     }
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.12"
+  },
+  "allowScripts": {
+    "esbuild@0.28.1": true
   }
 }

package/scripts/clean.mjs

@@ -0,0 +1,8 @@
+import { rm } from "node:fs/promises";
+import { resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "..");
+const targets = process.argv.includes("--dist-only") ? ["dist"] : ["dist", "out"];
+for (const target of targets) {
+  await rm(resolve(root, target), { recursive: true, force: true });
+}

package/scripts/cli/generate.mjs

@@ -1,6 +1,9 @@
+import { existsSync } from "node:fs";
 import { access, mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, relative } from "node:path";
 
+import { logger } from "../logger.mjs";
+
 const KINDS = [
   "module",
   "page",
@@ -13,6 +16,35 @@ const KINDS = [
   "layout",
 ];
 
+/**
+ * Generators support two starter shapes:
+ *
+ *   modular  — src/modules/<name>/<...>           (default behaviour)
+ *   universal— src/pages, src/components, src/content (the default starter)
+ *
+ * Detection is structural: a project with `src/modules/` is treated as
+ * modular; otherwise the universal layout is assumed. This lets users of
+ * either starter run `mado new` without configuring anything, and keeps
+ * the modular contract intact for projects that opt into it.
+ */
+function detectStarterShape(ctx) {
+  if (existsSync(join(ctx.projectRoot, "src/modules"))) return "modular";
+  if (existsSync(join(ctx.projectRoot, "src/pages"))) return "universal";
+  // No explicit hint — fall back to modular, which matches the
+  // historical behaviour and is documented in the generator help.
+  return "modular";
+}
+
+/** Generators that only make sense inside the modular starter. */
+const MODULAR_ONLY = new Set([
+  "module",
+  "connector",
+  "resource",
+  "service",
+  "form",
+  "guard",
+]);
+
 export async function runNew(ctx, args) {
   const [kind, target] = args;
   if (!kind || !target) {
@@ -20,6 +52,13 @@ export async function runNew(ctx, args) {
     process.exit(1);
   }
 
+  const shape = detectStarterShape(ctx);
+  if (shape === "universal" && MODULAR_ONLY.has(kind)) {
+    logger.error("mado", "generator-shape", `'${kind}' is not available in the universal starter`);
+    logger.info("mado", "generator-hint", "Create src/modules/<name>/ or run: mado init my-app --starter modular");
+    process.exit(1);
+  }
+
   const generators = {
     module: scaffoldModule,
     page: scaffoldPage,
@@ -34,12 +73,12 @@ export async function runNew(ctx, args) {
 
   const fn = generators[kind];
   if (!fn) {
-    console.error(`[mado] unknown generator: ${kind}`);
-    console.error(`[mado] available generators: ${KINDS.join(", ")}`);
+    logger.error("mado", "unknown-generator", `unknown generator: ${kind}`);
+    logger.info("mado", "available-generators", `available generators: ${KINDS.join(", ")}`);
     process.exit(1);
   }
 
-  await fn(ctx, normalizeTarget(target));
+  await fn(ctx, normalizeTarget(target), shape);
 }
 
 function printUsage() {
@@ -86,8 +125,11 @@ async function scaffoldModule(ctx, name) {
   );
 }
 
-async function scaffoldPage(ctx, target) {
-  const file = moduleFile(ctx, target, ".page.ts");
+async function scaffoldPage(ctx, target, shape) {
+  const file =
+    shape === "universal"
+      ? join(srcDir(ctx), "pages", `${leafName(target)}.page.ts`)
+      : moduleFile(ctx, target, ".page.ts");
   const name = leafName(target);
   await writeOnce(
     file,
@@ -219,14 +261,19 @@ async function scaffoldForm(ctx, target) {
 // Call inside a page view: const form = ${useName}();
 export const ${useName} = () =>
   useForm({
-    // name: { required: true },
+    initial: {
+      // name: "",
+    },
   });
 `,
   );
 }
 
-async function scaffoldComponent(ctx, target) {
-  const file = moduleFile(ctx, target, ".component.ts");
+async function scaffoldComponent(ctx, target, shape) {
+  const file =
+    shape === "universal"
+      ? join(srcDir(ctx), "components", `${leafName(target)}.component.ts`)
+      : moduleFile(ctx, target, ".component.ts");
   const name = leafName(target);
   const tag = name.includes("-") ? name : `x-${name}`;
   await writeOnce(
@@ -300,7 +347,7 @@ function moduleFile(ctx, target, suffix) {
 
 async function writeOnce(path, content) {
   if (await exists(path)) {
-    console.error(`[mado] file already exists: ${path}`);
+    logger.error("mado", "file-exists", `file already exists: ${path}`);
     process.exit(2);
   }
   await mkdir(dirname(path), { recursive: true });
@@ -333,7 +380,7 @@ function leafName(target) {
 
 function assertSingleSegment(label, name) {
   if (name.includes("/")) {
-    console.error(`[mado] ${label.toLowerCase()} name must be a single path segment`);
+    logger.error("mado", "invalid-name", `${label.toLowerCase()} name must be a single path segment`);
     process.exit(1);
   }
 }

package/scripts/cli/help.mjs

@@ -1,20 +1,26 @@
 export function printHelp(ctx) {
   const mode = ctx.isRepo ? "repo-mode (framework repository)" : "app-mode";
+  const buildLine = ctx.isRepo
+    ? "    mado build             tsc package compile (writes internal dist/)"
+    : "    mado build             Vite production SPA build -> out/";
   console.log(`mado commands (${mode}):
 
   Project lifecycle:
     mado init <name> [--starter default] [--force]
                            scaffold a new app
     mado dev               Vite dev server
-    mado build             tsc package compile (writes internal dist/)
+${buildLine}
     mado typecheck         tsc --noEmit
     mado test              run unit tests
 
   Production:
-    mado bake [--entry <file>] [--template <html>] [--out <dir>] [--base-url <url>]
-                           prerender baked routes  -> out/
-    mado release           typecheck + vite build + bake -> out/
-    mado preview           serve exactly out/ locally
+    mado static [--entry <file>] [--out <dir>] [--base-url <url>]
+                [--browser-channel chrome | --browser-path <path>]
+                           browser-snapshot static routes -> out/
+                           (low-level; prefer \`mado release\`)
+    mado release           typecheck + vite build + static snapshots
+                           + deployment files -> out/
+    mado preview           serve exactly out/ locally (production-like)
 
   Generators:
     mado new <module|page|connector|resource|service|form|component|guard|layout> <path>
@@ -22,6 +28,8 @@ export function printHelp(ctx) {
   Configuration:
     Put app/dev/build settings in vite.config.ts.
     Mado CLI flags are explicit per command.
+    --log-level debug|info|warn|error|silent
+    --log-format pretty|plain|json   --no-color
 
   Docs: README.md and docs/en/README.md.`);
 }

package/scripts/cli/index.mjs

@@ -1,8 +1,9 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { detectContext } from "../_config.mjs";
+import { configureLogger, logger } from "../logger.mjs";
 import { runInit } from "./init.mjs";
 import { runNew } from "./generate.mjs";
 import { printHelp } from "./help.mjs";
@@ -12,6 +13,7 @@ import { hasFlag, listTestFiles, run, runNodeBin, runNodeScript, runVite } from
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 
 export async function main(argv) {
+  argv = configureLogger(argv);
   const projectRoot = resolve(process.cwd());
   const context = detectContext(projectRoot);
   const packageJson = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8"));
@@ -31,18 +33,35 @@ export async function main(argv) {
       await runInit(ctx, args);
       break;
     case "build":
-      await runNodeBin(ctx, "typescript/bin/tsc", args);
+      // Framework repo bootstraps via `tsc` (so the published package
+      // ships compiled .js). Every other context — user apps, the
+      // starter — gets a production Vite build of the deployable SPA.
+      if (ctx.isRepo) {
+        await runNodeBin(ctx, "typescript/bin/tsc", args);
+      } else {
+        const outputArgs = hasFlag(args, "--outDir") ? args : ["--outDir", "out", ...args];
+        await runVite(ctx, ["build", ...outputArgs], { defaultConfig: true });
+      }
       break;
     case "watch":
-      await runNodeBin(ctx, "typescript/bin/tsc", ["-w", ...args]);
+      if (ctx.isRepo) {
+        await runNodeBin(ctx, "typescript/bin/tsc", ["-w", ...args]);
+      } else {
+        await runVite(ctx, ["build", "--watch", ...args], { defaultConfig: true });
+      }
       break;
-    case "typecheck":
+    case "typecheck": {
       await runNodeBin(ctx, "typescript/bin/tsc", ["--noEmit", ...args]);
+      const nodeConfig = join(ctx.projectRoot, "tsconfig.node.json");
+      if (existsSync(nodeConfig) && !hasFlag(args, "--project", "-p")) {
+        await runNodeBin(ctx, "typescript/bin/tsc", ["--noEmit", "-p", nodeConfig]);
+      }
       break;
+    }
     case "test": {
       await runNodeBin(ctx, "typescript/bin/tsc", []);
       const files = await listTestFiles(projectRoot);
-      await run(process.execPath, ["--test", "--test-timeout=30000", ...files, ...args], {
+      await run(process.execPath, ["--test", "--test-timeout=120000", ...files, ...args], {
         cwd: projectRoot,
       });
       break;
@@ -55,7 +74,12 @@ export async function main(argv) {
       );
       break;
     case "bake":
-      await runNodeScript(ctx, "scripts/bake.mjs", args);
+      logger.error("mado", "command-removed", "`mado bake` was removed.");
+      logger.info("mado", "replacement", "Use `mado static`, or run the complete pipeline with `mado release`.");
+      process.exit(1);
+      break;
+    case "static":
+      await runNodeScript(ctx, "scripts/static.mjs", args);
       break;
     case "preview":
       await runNodeScript(ctx, "scripts/preview.mjs", args);
@@ -72,7 +96,7 @@ export async function main(argv) {
       printHelp(ctx);
       break;
     default:
-      console.error(`[mado] unknown command: ${command}`);
+      logger.error("mado", "unknown-command", `unknown command: ${command}`);
       printHelp(ctx);
       process.exit(1);
   }

package/scripts/cli/init.mjs

@@ -3,37 +3,43 @@ import { copyFile, cp, mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 
 import { parseFlags } from "../_config.mjs";
+import { logger } from "../logger.mjs";
 
-const STARTERS = ["default"];
+// `default` is the universal starter: minimal, runnable, zero backend.
+// `modular` is the long-lived business-app reference architecture:
+//   auth, billing, guards, layouts, services, connectors, contracts.
+// Both target the same Mado runtime — they only differ in how much
+// structure they pre-create.
+const STARTERS = ["default", "modular"];
 
 export async function runInit(ctx, rawArgs) {
   const { flags, positional } = parseFlags(rawArgs);
   const targetArg = positional[0];
   if (!targetArg) {
-    console.error("[mado] usage: mado init <name> [--starter default] [--force]");
+    logger.error("mado", "usage", "usage: mado init <name> [--starter default] [--force]");
     process.exit(1);
   }
 
   const starter = String(flags.starter ?? "default");
   if (!STARTERS.includes(starter)) {
-    console.error(`[mado] unknown starter: ${starter}`);
-    console.error(`[mado] available starters: ${STARTERS.join(", ")}`);
+    logger.error("mado", "unknown-starter", `unknown starter: ${starter}`);
+    logger.info("mado", "available-starters", `available starters: ${STARTERS.join(", ")}`);
     process.exit(1);
   }
 
   const target = resolve(ctx.projectRoot, targetArg);
   const source = join(ctx.packageRoot, "starters", starter);
   if (!existsSync(source)) {
-    console.error(`[mado] missing starter template: ${starter}`);
+    logger.error("mado", "missing-starter", `missing starter template: ${starter}`);
     process.exit(1);
   }
   if (existsSync(target) && statSync(target).isFile()) {
-    console.error(`[mado] target exists and is a file: ${target}`);
+    logger.error("mado", "target-is-file", `target exists and is a file: ${target}`);
     process.exit(1);
   }
   if (existsSync(target) && readdirSync(target).length > 0 && !flags.force) {
-    console.error(`[mado] target directory is not empty: ${target}`);
-    console.error("[mado] use --force to write into it");
+    logger.error("mado", "target-not-empty", `target directory is not empty: ${target}`);
+    logger.info("mado", "force-hint", "use --force to write into it");
     process.exit(1);
   }
 
@@ -45,7 +51,7 @@ export async function runInit(ctx, rawArgs) {
 
   const packageName = packageNameFromDir(target);
   if (!isValidPackageName(packageName)) {
-    console.error(`[mado] invalid package name derived from target: ${packageName}`);
+    logger.error("mado", "invalid-package-name", `invalid package name derived from target: ${packageName}`);
     process.exit(1);
   }
 
@@ -90,7 +96,10 @@ async function copyCanonicalLLMFiles(ctx, target) {
 async function ensureStarterGitignore(target) {
   const file = join(target, ".gitignore");
   if (existsSync(file)) return;
-  await writeFile(file, "node_modules\nout\n.DS_Store\n*.log\n");
+  await writeFile(
+    file,
+    "node_modules\ndist\nout\n.cache\n.env\n.env.*\n!.env.example\n.DS_Store\n*.log\n",
+  );
 }
 
 async function ensureStarterPackageJson(ctx, target) {
@@ -105,15 +114,6 @@ async function ensureStarterPackageJson(ctx, target) {
       process.env.MADOJS_PACKAGE_SPEC ||
       `^${ctx.packageJson.version}`,
   };
-  const rootDev = ctx.packageJson.devDependencies ?? {};
-  pkg.devDependencies = {
-    ...(pkg.devDependencies ?? {}),
-    typescript: rootDev.typescript ?? "^6.0.3",
-    linkedom: rootDev.linkedom ?? "^0.18.12",
-    lightningcss: rootDev.lightningcss ?? "^1.32.0",
-    vite: rootDev.vite ?? "^8.0.16",
-  };
-
   await writeFile(file, `${JSON.stringify(pkg, null, 2)}\n`);
 }
 

package/scripts/cli/release.mjs

@@ -1,9 +1,11 @@
 import { existsSync } from "node:fs";
-import { copyFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { brotliCompressSync, constants as zlibConst, gzipSync } from "node:zlib";
 
 import { parseFlags } from "../_config.mjs";
+import { logger } from "../logger.mjs";
+import { prepareOutputDirectory } from "../output-guard.mjs";
 import { runNodeBin, runNodeScript, runVite, writeIfMissing } from "./run.mjs";
 
 export async function runRelease(ctx, rawArgs) {
@@ -12,59 +14,44 @@ export async function runRelease(ctx, rawArgs) {
     ctx.projectRoot,
     typeof releaseFlags.out === "string" ? releaseFlags.out : "out",
   );
-  const bundledHtml = join(outDir, "index.html");
-  const bakedDir = join(outDir, "baked");
 
-  console.log(`[release] context: ${ctx.context}`);
-  console.log(`[release] artifact: ${outDir}`);
-  console.log("");
-
-  if (!releaseFlags["no-clean"]) {
-    if (existsSync(outDir)) {
-      await rm(outDir, { recursive: true, force: true });
-      console.log(`[release] cleaned ${outDir}`);
-    }
+  logger.info("release", "context", `context: ${ctx.context}`);
+  logger.info("release", "artifact", `artifact: ${outDir}`);
+
+  await prepareOutputDirectory({
+    projectRoot: ctx.projectRoot,
+    outDir,
+    clean: !releaseFlags["no-clean"],
+    force: releaseFlags["force-output"] === true,
+  });
+  if (releaseFlags["no-clean"]) {
+    logger.info("release", "clean-skip", "--no-clean: keeping existing out/");
   } else {
-    console.log("[release] --no-clean: keeping existing out/");
+    logger.info("release", "clean", `prepared ${outDir}`);
   }
 
-  console.log("[release] step 1/5  typecheck");
+  logger.info("release", "step", "step 1/5  typecheck");
   await runNodeBin(ctx, "typescript/bin/tsc", ["--noEmit"]);
 
-  console.log("[release] step 2/5  vite build");
+  logger.info("release", "step", "step 2/5  vite build");
   await runVite(ctx, ["build", "--outDir", outDir], { defaultConfig: true });
 
-  console.log("[release] step 3/5  bake");
-  if (releaseFlags["keep-bake-dir"]) {
-    await runNodeScript(ctx, "scripts/bake.mjs", [
-      ...rawArgs.filter((a) => a !== "--keep-bake-dir"),
-      "--template",
-      bundledHtml,
-      "--out",
-      bakedDir,
-    ]);
-    const promoted = await promoteBakedHtml(bakedDir, outDir);
-    if (promoted.html > 0) {
-      console.log(`[release]   promoted ${promoted.html} baked HTML page(s) into out/`);
-    }
-    if (promoted.sitemap) {
-      console.log(`[release]   copied sitemap.xml -> ${join(outDir, "sitemap.xml")}`);
-    }
-  } else {
-    await runNodeScript(ctx, "scripts/bake.mjs", [
-      ...rawArgs,
-      "--template",
-      bundledHtml,
-      "--out",
-      outDir,
-    ]);
+  logger.info("release", "step", "step 3/5  static snapshots");
+  await runNodeScript(ctx, "scripts/static.mjs", [
+    ...rawArgs.filter((a) => a !== "--no-clean"),
+    "--out",
+    outDir,
+  ]);
+
+  logger.info("release", "step", "step 4/5  deployment files");
+  // GitHub Pages / Netlify / Cloudflare Pages fallback. SPA fallback shell
+  // is written by `mado static`; here we only register the deployment
+  // bindings, and respect user-supplied files (writeIfMissing).
+  const spaShell = join(outDir, "_mado/spa.html");
+  if (existsSync(spaShell)) {
+    await writeIfMissing(join(outDir, "404.html"), await readFile(spaShell, "utf8"), "[release]  ");
   }
-
-  console.log("[release] step 4/5  precompress assets");
-  await precompressOut(outDir);
-
-  console.log("[release] step 5/5  CDN config");
-  await writeIfMissing(join(outDir, "_redirects"), "/* /index.html 200\n", "[release]  ");
+  await writeIfMissing(join(outDir, "_redirects"), "/* /_mado/spa.html 200\n", "[release]  ");
   await writeIfMissing(
     join(outDir, "_headers"),
     [
@@ -78,43 +65,11 @@ export async function runRelease(ctx, rawArgs) {
     "[release]  ",
   );
 
-  console.log("");
-  console.log(`[release] done. Deploy artifact: ${outDir}`);
-  console.log("[release] try:  mado preview");
-}
-
-async function promoteBakedHtml(bakedDir, outDir) {
-  if (!existsSync(bakedDir)) return { html: 0, sitemap: false };
-
-  let html = 0;
-
-  async function walk(dir, rel = "") {
-    for (const entry of await readdir(dir, { withFileTypes: true })) {
-      const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
-      const source = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(source, nextRel);
-        continue;
-      }
-      if (!entry.isFile() || !entry.name.endsWith(".html")) continue;
-      const target = join(outDir, nextRel);
-      await mkdir(dirname(target), { recursive: true });
-      await copyFile(source, target);
-      html++;
-    }
-  }
-
-  await walk(bakedDir);
-
-  const bakedSitemap = join(bakedDir, "sitemap.xml");
-  const rootSitemap = join(outDir, "sitemap.xml");
-  let sitemap = false;
-  if (existsSync(bakedSitemap)) {
-    await copyFile(bakedSitemap, rootSitemap);
-    sitemap = true;
-  }
+  logger.info("release", "step", "step 5/5  precompress assets");
+  await precompressOut(outDir);
 
-  return { html, sitemap };
+  logger.info("release", "done", `done. Deploy artifact: ${outDir}`);
+  logger.info("release", "next", "try: mado preview");
 }
 
 async function precompressOut(outDir) {
@@ -132,7 +87,7 @@ async function precompressOut(outDir) {
     );
     count++;
   }
-  console.log(`[release]   compressed ${count} file(s)`);
+  logger.info("release", "compress", `compressed ${count} file(s)`);
 }
 
 async function listCompressibleFiles(dir) {