@monospaced/create-set 0.0.0-stage → 0.20.2

package/README.md

@@ -1,3 +1,37 @@
-# Temporary Holding Version
+# @monospaced/create-set
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Project scaffolding for Set. Bootstraps a site or app with Set's components, tooling and defaults.
+
+```sh
+pnpm create @monospaced/set my-site
+```
+
+Prompts for a package name, site title and description, each showing its default, which Enter accepts. Each has a flag (`--name`, `--title`, `--description`), and `--defaults` takes every default without prompting, so it runs non-interactively too; without a terminal, anything unanswered is refused rather than guessed. Refuses a directory that isn't empty.
+
+## What you get
+
+A Vite and TypeScript project with a starter page built from Set components, a `src/styles.css` for your own styles, Set's ESLint and Stylelint presets, Prettier, Husky and lint-staged, VS Code settings, and Lightning CSS targets from Set's Baseline query.
+
+- Dependencies install live, so nothing in the template goes stale. Tools the config package declares as peers install at its declared ranges, so preset and tool agree.
+- `scripts/sync-set.mjs` copies the token catalog, agent skills and favicons into place on every install.
+- Git is initialised first, with an initial commit at the end.
+
+The Node and pnpm versions written to `engines`, `packageManager` and `.node-version` are generated into `src/toolchain.mjs` from the monorepo's toolchain by `pnpm create:sync`; `pnpm create:verify` fails CI when they drift.
+
+## Developing
+
+From the repository root:
+
+```sh
+pnpm create:test
+pnpm create:dev ../scratch/my-site
+```
+
+`create:dev` builds core first and runs the CLI from source. The generated project installs the published Set packages, which is what a user gets. To scaffold against the workspace instead, pack the Set packages and point the CLI at them:
+
+```sh
+pnpm --filter "@monospaced/set-{assets,config,core,skills,tokens}" pack --pack-destination ../scratch/pack
+CREATE_SET_PACK_DIR=../scratch/pack pnpm create:dev ../scratch/my-site
+```
+
+`plan()` in `src/plan.mjs` is pure and returns every file for a set of answers; the tests snapshot it. `execute()` does the I/O: git, files, `pnpm add`, the sync script, the commit.

package/bin/create-set.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from "../src/cli.mjs";
+
+await run(process.argv.slice(2));

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@monospaced/create-set",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.20.2",
+  "description": "Project scaffolding for Set. Bootstraps a site or app with Set's components, tooling and defaults.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/monospaced/set.git",
+    "directory": "packages/create"
+  },
+  "type": "module",
+  "bin": {
+    "create-set": "./bin/create-set.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "@monospaced/set-core": "0.20.2"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.6"
+  },
+  "scripts": {
+    "sync": "node scripts/sync.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "verify": "node scripts/verify.mjs"
+  }
 }

package/src/answers.mjs

@@ -0,0 +1,34 @@
+import { basename, resolve } from "node:path";
+
+const PACKAGE_NAME = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+
+/** A package name derived from a directory: lowercase, separators as hyphens. */
+export function toPackageName(dir) {
+  const name = basename(resolve(dir))
+    .toLowerCase()
+    .replace(/[^a-z0-9._~-]+/g, "-")
+    .replace(/^[-._]+|[-._]+$/g, "");
+
+  return name || "set-app";
+}
+
+/** A site title derived from a package name: words capitalised, scope dropped. */
+export function toTitle(name) {
+  return name
+    .replace(/^@[^/]+\//, "")
+    .split(/[-._]+/)
+    .filter(Boolean)
+    .map((word) => word[0].toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+export function toDescription(title) {
+  return `${title}, built with Set.`;
+}
+
+/** Returns a message when `value` is not a valid npm package name. */
+export function validatePackageName(value) {
+  if (!PACKAGE_NAME.test(value)) {
+    return "Use lowercase letters, digits, hyphens, dots or underscores, optionally scoped.";
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,167 @@
+import { createRequire } from "node:module";
+import { parseArgs } from "node:util";
+
+import * as p from "@clack/prompts";
+
+import {
+  toDescription,
+  toPackageName,
+  toTitle,
+  validatePackageName,
+} from "./answers.mjs";
+import { execute, isEmptyDirectory } from "./execute.mjs";
+
+const { version } = createRequire(import.meta.url)("../package.json");
+
+const USAGE = `Usage: pnpm create @monospaced/set [directory] [options]
+
+Scaffolds a Set site or app into an empty directory. Prompts for anything
+not given as a flag; Enter accepts a prompt's default.
+
+Options:
+  --name <name>         Package name (default: the directory name)
+  --title <title>       Site title (default: from the package name)
+  --description <text>  Site description (default: "<title>, built with Set.")
+  --defaults            Take every default without prompting
+  -h, --help            Show this help
+  -v, --version         Show the version
+`;
+
+const OPTIONS = {
+  defaults: { type: "boolean" },
+  description: { type: "string" },
+  help: { short: "h", type: "boolean" },
+  name: { type: "string" },
+  title: { type: "string" },
+  version: { short: "v", type: "boolean" },
+};
+
+/** Prompts, or returns `undefined` when the user cancels. */
+async function prompt(promise) {
+  const value = await promise;
+  return p.isCancel(value) ? undefined : value;
+}
+
+/**
+ * Answers a question from its flag, its default (with `--defaults`), or a
+ * prompt whose hint is the default.
+ */
+async function answer(values, key, fallback, { missing, ...options }) {
+  if (values[key] !== undefined) return values[key];
+  if (values.defaults) return fallback;
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      `No terminal to prompt for the ${key}. ${missing ?? `Pass --${key}`}, or pass --defaults.`,
+    );
+  }
+
+  return prompt(
+    p.text({ defaultValue: fallback, placeholder: fallback, ...options }),
+  );
+}
+
+/** Resolves the answers, or returns `undefined` when cancelled or refused. */
+async function ask(values, positional) {
+  const dir =
+    positional ??
+    (await answer(values, "directory", "set-app", {
+      message: "Where should the project be created?",
+      missing: "Pass it as the first argument",
+    }));
+  if (dir === undefined) return;
+
+  if (!isEmptyDirectory(dir)) {
+    p.cancel(`${dir} is not empty. Choose an empty or new directory.`);
+    return;
+  }
+
+  const name = await answer(values, "name", toPackageName(dir), {
+    message: "Package name",
+    validate: validatePackageName,
+  });
+  if (name === undefined) return;
+
+  const invalid = validatePackageName(name);
+  if (invalid) {
+    p.cancel(`${name} is not a valid package name. ${invalid}`);
+    return;
+  }
+
+  const title = await answer(values, "title", toTitle(name), {
+    message: "Site title",
+  });
+  if (title === undefined) return;
+
+  const description = await answer(
+    values,
+    "description",
+    toDescription(title),
+    { message: "Site description" },
+  );
+  if (description === undefined) return;
+
+  return { description, dir, name, title };
+}
+
+export async function run(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      allowPositionals: true,
+      args: argv,
+      options: OPTIONS,
+    });
+  } catch (error) {
+    console.error(`${error.message}\n\n${USAGE}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const { positionals, values } = parsed;
+
+  if (values.help) {
+    console.log(USAGE);
+    return;
+  }
+
+  if (values.version) {
+    console.log(version);
+    return;
+  }
+
+  p.intro(`create-set ${version}`);
+
+  let answers;
+  try {
+    answers = await ask(values, positionals[0]);
+  } catch (error) {
+    p.cancel(error.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!answers) {
+    p.cancel("Nothing created.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const spinner = p.spinner();
+  spinner.start("Creating project");
+
+  try {
+    const root = execute(answers, {
+      step: (message) => spinner.message(message),
+      warn: (message) => p.log.warn(message),
+    });
+    spinner.stop(`Created ${root}`);
+  } catch (error) {
+    spinner.stop("Failed", 1);
+    p.log.error(error.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  p.note(`cd ${answers.dir}\npnpm dev`, "Next steps");
+  p.outro("Happy building.");
+}

package/src/constants.mjs

@@ -0,0 +1,20 @@
+/** One social-share card for every page, shared with the Set docs. */
+export const OG_IMAGE =
+  "https://res.cloudinary.com/monospaced/image/upload/v1789307953/2018-04-20_15.28.26--cyan--og--mid.png";
+
+/** Installed live at generation time, so nothing in the template goes stale. */
+export const RUNTIME_DEPENDENCIES = [
+  "@monospaced/set-assets",
+  "@monospaced/set-core",
+];
+
+export const DEV_DEPENDENCIES = [
+  "@monospaced/set-config",
+  "@monospaced/set-skills",
+  "@monospaced/set-tokens",
+  "husky",
+  "lint-staged",
+  "prettier",
+  "vite",
+  "vitest",
+];

package/src/execute.mjs

@@ -0,0 +1,128 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+import { DEV_DEPENDENCIES, RUNTIME_DEPENDENCIES } from "./constants.mjs";
+import { plan } from "./plan.mjs";
+
+/** True when `dir` does not exist or holds nothing. */
+export function isEmptyDirectory(dir) {
+  try {
+    return readdirSync(dir).length === 0;
+  } catch (error) {
+    if (error.code === "ENOENT") return true;
+    throw error;
+  }
+}
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    stdio: "pipe",
+  });
+
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const output = `${result.stdout}\n${result.stderr}`.trim();
+    throw new Error(`\`${command} ${args.join(" ")}\` failed:\n${output}`);
+  }
+
+  return result.stdout;
+}
+
+const pnpm = (args, cwd) => run("pnpm", args, cwd);
+
+/**
+ * Dev harness: with CREATE_SET_PACK_DIR set, Set packages install from the
+ * `pnpm pack` tarballs in that directory instead of the registry, so the CLI
+ * can be exercised against unreleased packages. Users always get the registry.
+ */
+function setSpec(name) {
+  const packDir = process.env.CREATE_SET_PACK_DIR;
+  if (!packDir || !name.startsWith("@monospaced/")) return name;
+
+  const stem = `${name.slice(1).replace("/", "-")}-`;
+  const tarball = readdirSync(packDir).find(
+    (file) => file.startsWith(stem) && file.endsWith(".tgz"),
+  );
+
+  return tarball ? resolve(packDir, tarball) : name;
+}
+const git = (args, cwd) => run("git", args, cwd);
+
+/**
+ * The tools the config package drives, as `name@range` specs. Its presets
+ * declare them as peers, so they install at the range it supports rather
+ * than at latest, and the preset and the tool always agree.
+ */
+function configPeerSpecs(root) {
+  const manifest = JSON.parse(
+    readFileSync(
+      join(root, "node_modules/@monospaced/set-config/package.json"),
+      "utf8",
+    ),
+  );
+
+  return Object.entries(manifest.peerDependencies).map(
+    ([name, range]) => `${name}@${range}`,
+  );
+}
+
+/**
+ * Writes the project, installs its dependencies live, syncs the Set
+ * artifacts and makes the initial commit.
+ *
+ * @param {{ dir: string } & import("./plan.mjs").Answers} answers
+ * @param {{ step(message: string): void, warn(message: string): void }} report
+ */
+export function execute({ dir, ...answers }, report) {
+  const root = resolve(dir);
+  const files = plan(answers);
+
+  report.step("Initialising git");
+  mkdirSync(root, { recursive: true });
+  git(["init", "--initial-branch=main"], root);
+
+  report.step("Writing files");
+  for (const [path, content] of Object.entries(files)) {
+    const target = join(root, path);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, content);
+  }
+
+  // Lifecycle scripts wait until everything `prepare` needs is installed.
+  report.step("Installing Set");
+  pnpm(["add", "--ignore-scripts", ...RUNTIME_DEPENDENCIES.map(setSpec)], root);
+
+  report.step("Installing tooling");
+  pnpm(
+    ["add", "--ignore-scripts", "--save-dev", ...DEV_DEPENDENCIES.map(setSpec)],
+    root,
+  );
+  pnpm(
+    ["add", "--ignore-scripts", "--save-dev", ...configPeerSpecs(root)],
+    root,
+  );
+
+  // Explicit: `pnpm install` skips lifecycle scripts when nothing changed.
+  report.step("Syncing Set artifacts and git hooks");
+  pnpm(["run", "prepare"], root);
+
+  report.step("Formatting");
+  pnpm(["exec", "prettier", "--write", "."], root);
+
+  report.step("Committing");
+  git(["add", "--all"], root);
+  try {
+    git(
+      ["commit", "--message", "chore: bootstrap with @monospaced/create-set"],
+      root,
+    );
+  } catch (error) {
+    report.warn(`Initial commit skipped. ${error.message}`);
+  }
+
+  return root;
+}

package/src/page.mjs

@@ -0,0 +1,107 @@
+import {
+  renderSetBox,
+  renderSetContainer,
+  renderSetDivider,
+  renderSetHeading,
+  renderSetInline,
+  renderSetLightswitch,
+  renderSetPage,
+  renderSetRoot,
+  renderSetStack,
+  renderSetText,
+  SET_LIGHTSWITCH_STORAGE_KEY,
+} from "@monospaced/set-core";
+
+/** Escapes a value for an HTML attribute or text node. */
+export const escapeHtml = (value) =>
+  value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+
+/*
+ * Stamps a stored lightswitch override onto the root before its content
+ * parses, so an overridden theme paints correctly on first load. Must be the
+ * root's first child: earlier and the root doesn't exist yet, later and
+ * content above it may already have painted in the wrong theme.
+ */
+const themeBootstrap = `<script>try{var t=localStorage.getItem(${JSON.stringify(
+  SET_LIGHTSWITCH_STORAGE_KEY,
+)});if(t==="light"||t==="dark")document.currentScript.closest(".set").setAttribute("data-set-theme",t)}catch(e){}</script>`;
+
+/**
+ * The hello-world page: Root → Page with a header, a heading, a paragraph and
+ * a Lightswitch, built from Set components only. Rendered with core at
+ * generation time, so the markup is always what the installed core expects.
+ */
+export function renderHelloPage({ title }) {
+  const safeTitle = escapeHtml(title);
+
+  const header = renderSetContainer({
+    children: renderSetBox({
+      background: "transparent",
+      paddingBlock: "2xs",
+      paddingInline: "none",
+      children: renderSetInline({
+        gap: "sm",
+        justify: "between",
+        children:
+          renderSetHeading({ children: safeTitle, size: "md" }) +
+          renderSetLightswitch({ size: "sm" }),
+      }),
+    }),
+  });
+
+  const main = renderSetContainer({
+    children: renderSetBox({
+      paddingBlock: "lg",
+      paddingInline: "none",
+      responsive: true,
+      children: renderSetStack({
+        gap: "md",
+        children:
+          renderSetHeading({
+            children: "Hello, world",
+            level: 1,
+            responsive: true,
+            size: "xl",
+          }) +
+          renderSetText({
+            as: "p",
+            children: `${safeTitle} is built with <a href="https://set.monospaced.com">Set</a>. Edit <code>index.html</code> to begin.`,
+            responsive: true,
+          }),
+      }),
+    }),
+  });
+
+  const footer =
+    renderSetDivider({ tone: "subtle" }) +
+    renderSetContainer({
+      children: renderSetBox({
+        paddingBlock: "xs",
+        paddingInline: "none",
+        children: renderSetText({
+          as: "p",
+          children: "Built with Set.",
+          size: "sm",
+          tone: "muted",
+        }),
+      }),
+    });
+
+  const page = renderSetPage({
+    children: main,
+    footer,
+    header,
+    headerBorder: "always",
+    headerSize: "sm",
+  });
+
+  return renderSetRoot({
+    appOverscrollBehavior: "none",
+    appRoot: true,
+    children: themeBootstrap + page,
+  });
+}

package/src/plan.mjs

@@ -0,0 +1,47 @@
+import * as templates from "./templates.mjs";
+import { NODE_MAJOR, PNPM_VERSION } from "./toolchain.mjs";
+
+/**
+ * @typedef {object} Answers
+ * @property {string} name Package name.
+ * @property {string} title Site title.
+ * @property {string} description Site description.
+ */
+
+/**
+ * Every file the CLI writes, keyed by path relative to the project root.
+ * Pure: the same answers always give the same files. Dependencies are not
+ * here; they are installed live by `execute`.
+ *
+ * @param {Answers} answers
+ * @returns {Record<string, string>}
+ */
+export function plan(answers) {
+  const context = {
+    ...answers,
+    nodeMajor: NODE_MAJOR,
+    pnpmVersion: PNPM_VERSION,
+  };
+
+  return {
+    ".editorconfig": templates.editorconfig(),
+    ".gitignore": templates.gitignore(),
+    ".husky/pre-commit": "pnpm exec lint-staged\n",
+    ".node-version": `${NODE_MAJOR}\n`,
+    ".prettierignore": templates.prettierignore(),
+    ".stylelintrc.mjs": templates.stylelintrc(),
+    ".vscode/extensions.json": templates.vscodeExtensions(),
+    ".vscode/settings.json": templates.vscodeSettings(),
+    "README.md": templates.readme(context),
+    "eslint.config.mjs": templates.eslintConfig(),
+    "index.html": templates.indexHtml(context),
+    "package.json": templates.packageJson(context),
+    "pnpm-workspace.yaml": templates.pnpmWorkspace(),
+    "public/manifest.webmanifest": templates.manifest(context),
+    "scripts/sync-set.mjs": templates.syncSet(),
+    "src/main.ts": templates.mainTs(),
+    "src/styles.css": templates.stylesCss(),
+    "tsconfig.json": templates.tsconfig(),
+    "vite.config.ts": templates.viteConfig(),
+  };
+}

package/src/templates.mjs

@@ -0,0 +1,257 @@
+import { OG_IMAGE } from "./constants.mjs";
+import { escapeHtml, renderHelloPage } from "./page.mjs";
+
+const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+
+export const packageJson = ({ description, name, nodeMajor, pnpmVersion }) => {
+  const pnpmMajor = Number(pnpmVersion.split(".")[0]);
+
+  return json({
+    name,
+    version: "0.0.0",
+    description,
+    private: true,
+    type: "module",
+    engines: {
+      node: `>=${nodeMajor} <${nodeMajor + 1}`,
+      pnpm: `>=${pnpmMajor} <${pnpmMajor + 1}`,
+    },
+    packageManager: `pnpm@${pnpmVersion}`,
+    scripts: {
+      build: "vite build",
+      dev: "vite",
+      format: "prettier --write .",
+      "format:check": "prettier --check .",
+      lint: "eslint .",
+      "lint:fix": "eslint . --fix",
+      prepare: "node scripts/sync-set.mjs",
+      preview: "vite preview",
+      stylelint: 'stylelint "**/*.css" --allow-empty-input',
+      "stylelint:fix": 'stylelint "**/*.css" --allow-empty-input --fix',
+      test: "vitest run --passWithNoTests",
+      typecheck: "tsc --noEmit",
+    },
+    "lint-staged": {
+      "*": "prettier --ignore-unknown --write",
+      "*.css": "stylelint --fix",
+      "*.{js,mjs,ts}": "eslint --fix",
+    },
+  });
+};
+
+export const indexHtml = ({ description, title }) => `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light dark" />
+    <meta name="theme-color" content="#f8fbfb" media="(prefers-color-scheme: light)" />
+    <meta name="theme-color" content="#0e0f0f" media="(prefers-color-scheme: dark)" />
+    <title>${escapeHtml(title)}</title>
+    <meta name="description" content="${escapeHtml(description)}" />
+    <!-- Set the canonical URL and og:url once the site has a domain. -->
+    <link rel="canonical" href="https://example.com/" />
+    <meta property="og:type" content="website" />
+    <meta property="og:site_name" content="${escapeHtml(title)}" />
+    <meta property="og:title" content="${escapeHtml(title)}" />
+    <meta property="og:description" content="${escapeHtml(description)}" />
+    <meta property="og:url" content="https://example.com/" />
+    <meta property="og:image" content="${OG_IMAGE}" />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:title" content="${escapeHtml(title)}" />
+    <meta name="twitter:description" content="${escapeHtml(description)}" />
+    <meta name="twitter:image" content="${OG_IMAGE}" />
+    <link rel="icon" href="/favicons/favicon.ico" sizes="32x32" />
+    <link rel="icon" href="/favicons/favicon.svg" type="image/svg+xml" />
+    <link rel="apple-touch-icon" href="/favicons/apple-touch-icon.png" />
+    <link rel="manifest" href="/manifest.webmanifest" />
+  </head>
+  <body>
+    ${renderHelloPage({ title })}
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`;
+
+export const manifest = ({ description, title }) =>
+  json({
+    name: title,
+    short_name: title,
+    description,
+    start_url: "/",
+    scope: "/",
+    display: "standalone",
+    background_color: "#f8fbfb",
+    theme_color: "#f8fbfb",
+    icons: [192, 512].flatMap((size) =>
+      ["any", "maskable"].map((purpose) => ({
+        purpose,
+        sizes: `${size}x${size}`,
+        src: `/favicons/maskable-icon-${size}.png`,
+        type: "image/png",
+      })),
+    ),
+  });
+
+export const mainTs = () => `import "@monospaced/set-assets/fonts.css";
+import "@monospaced/set-core/styles.css";
+import "./styles.css";
+
+import { defineSetComponents } from "@monospaced/set-core";
+
+defineSetComponents();
+`;
+
+export const stylesCss =
+  () => `/* Project styles. Compose with Set components first; when something needs
+   its own CSS, write it here with Set tokens. */
+`;
+
+export const viteConfig =
+  () => `import target from "@monospaced/set-config/browserslist/esbuild";
+import targets from "@monospaced/set-config/browserslist/lightningcss";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: { cssMinify: "lightningcss", target },
+  css: { lightningcss: { targets }, transformer: "lightningcss" },
+});
+`;
+
+export const tsconfig = () =>
+  json({
+    compilerOptions: {
+      lib: ["ES2022", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      noEmit: true,
+      skipLibCheck: true,
+      strict: true,
+      target: "ES2022",
+      types: ["vite/client"],
+    },
+    include: ["src", "*.config.ts"],
+  });
+
+export const eslintConfig =
+  () => `import setEslint from "@monospaced/set-config/eslint";
+
+export default [...setEslint];
+`;
+
+export const stylelintrc = () => `export default {
+  extends: ["@monospaced/set-config/stylelint"],
+  ignoreFiles: [".vscode/set.catalog.css", "dist/**"],
+};
+`;
+
+export const prettierignore = () => `.vscode/set.catalog.css
+dist
+pnpm-lock.yaml
+`;
+
+export const editorconfig = () => `root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+`;
+
+export const gitignore = () => `node_modules/
+dist/
+.vscode/set.catalog.css
+.claude/skills/
+.agents/skills/
+.claude/settings.local.json
+.claude/.cc-writes/
+.DS_Store
+.env
+.env.*
+!.env.example
+*.local
+`;
+
+export const vscodeSettings = () =>
+  json({
+    "css.validate": false,
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true,
+    "stylelint.validate": ["css"],
+  });
+
+export const vscodeExtensions = () =>
+  json({
+    recommendations: [
+      "dbaeumer.vscode-eslint",
+      "esbenp.prettier-vscode",
+      "stylelint.vscode-stylelint",
+    ],
+  });
+
+export const pnpmWorkspace =
+  () => `# Minimum age of a release before it installs, in minutes (3 days).
+minimumReleaseAge: 4320
+`;
+
+export const syncSet = () => `/*
+ * Copies the Set artifacts this project keeps outside node_modules, so a
+ * fresh clone or a Set upgrade refreshes them. Runs from \`prepare\`.
+ */
+import { cpSync, existsSync, rmSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("../", import.meta.url));
+const from = (path) => new URL(\`../node_modules/\${path}\`, import.meta.url);
+const to = (path) => new URL(\`../\${path}\`, import.meta.url);
+
+const copy = (source, target) => {
+  rmSync(target, { force: true, recursive: true });
+  cpSync(source, target, { recursive: true });
+};
+
+// Token catalog for editor autocomplete and Stylelint validation.
+copy(from("@monospaced/set-config/set.catalog.css"), to(".vscode/set.catalog.css"));
+
+// Guardrails for coding agents, wherever they look for skills.
+for (const dir of [".claude/skills", ".agents/skills"]) {
+  copy(from("@monospaced/set-skills/src"), to(dir));
+}
+
+// Favicons are static files, so they live in public/ rather than being imported.
+copy(from("@monospaced/set-assets/src/favicons"), to("public/favicons"));
+
+// Git hooks, where there is a repository to hook into.
+if (existsSync(new URL(".git", \`file://\${root}\`))) {
+  const { default: husky } = await import("husky");
+  const message = husky();
+  if (message) console.log(message);
+}
+`;
+
+export const readme = ({ description, title }) => `# ${title}
+
+${description}
+
+Built with [Set](https://set.monospaced.com), scaffolded by \`@monospaced/create-set\`.
+
+## Scripts
+
+- \`pnpm dev\` / \`pnpm build\` / \`pnpm preview\`
+- \`pnpm lint\` / \`pnpm lint:fix\`
+- \`pnpm stylelint\` / \`pnpm stylelint:fix\`
+- \`pnpm format\` / \`pnpm format:check\`
+- \`pnpm typecheck\`
+- \`pnpm test\`
+
+Prettier, Stylelint and ESLint fixes run on staged files before every commit via Husky and lint-staged.
+
+## After bootstrapping
+
+- Set the canonical URL and \`og:url\` in \`index.html\` once the site has a domain.
+- \`.vscode/set.catalog.css\`, \`.claude/skills/\`, \`.agents/skills/\` and \`public/favicons/\` are copied from Set on every install by \`scripts/sync-set.mjs\`. Upgrade Set to refresh them rather than editing them by hand.
+- Markdown content? \`pnpm add @monospaced/set-markdown\` renders GFM to safe HTML that pairs with core's \`prose\` component.
+`;

package/src/toolchain.mjs

@@ -0,0 +1,7 @@
+// Generated by scripts/sync.mjs from the monorepo toolchain. Do not edit.
+
+/** Node major written to `engines` and `.node-version`. */
+export const NODE_MAJOR = 26;
+
+/** pnpm version written to `packageManager`; `engines` takes its major. */
+export const PNPM_VERSION = "12.17.0";