@loom-js/create 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1202 @@
+// <define:__STAMPED_RANGES__>
+var define_STAMPED_RANGES_default = { "@loom-js/build": "^0.4.0", "@loom-js/core": "^0.22.0", "@loom-js/devtools": "^0.2.0", "@loom-js/pink": "^0.10.2", "@biomejs/biome": "^2.6.5", "@tailwindcss/cli": "^4.3.3", prettier: "^3.9.6", tailwindcss: "^4.3.3", turbo: "^2.10.13", typescript: "^7.0.2" };
+
+// src/choices.ts
+var NONE = "none";
+var DEFAULT_TARGET = "loom-app";
+var DEFAULTS = {
+  formatter: "biome",
+  git: { kind: "new" },
+  install: true,
+  js: false,
+  layout: "single",
+  spa: false,
+  tailwind: false,
+  ui: NONE
+};
+
+// src/json.ts
+var INDENT = "    ";
+var LINE_WIDTH = 80;
+var isPrimitive = (value) => value === null || typeof value !== "object";
+var print = (value, depth, prefixLength) => {
+  if (isPrimitive(value)) {
+    return JSON.stringify(value);
+  }
+  const inner = INDENT.repeat(depth + 1);
+  const outer = INDENT.repeat(depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const inline = `[${value.map((item) => print(item, 0, 0)).join(", ")}]`;
+    if (value.every(isPrimitive) && prefixLength + inline.length + 1 <= LINE_WIDTH) {
+      return inline;
+    }
+    const items = value.map(
+      (item) => `${inner}${print(item, depth + 1, inner.length)}`
+    );
+    return `[
+${items.join(",\n")}
+${outer}]`;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const lines = entries.map(([key, item]) => {
+    const keyText = `${inner}${JSON.stringify(key)}: `;
+    return `${keyText}${print(item, depth + 1, keyText.length)}`;
+  });
+  return `{
+${lines.join(",\n")}
+${outer}}`;
+};
+var toJson = (value) => `${print(value, 0, 0)}
+`;
+var toPackageJson = (value) => `${JSON.stringify(value, null, 4)}
+`;
+
+// src/registry/formatters.ts
+var IGNORED = [
+  "build",
+  ".generated",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lock"
+];
+var biome = {
+  checkCommand: ["biome", "check"],
+  devDependencies: ["@biomejs/biome"],
+  files: ({ ignored }) => ({
+    "biome.json": toJson({
+      // The installed version's schema, so it never drifts from the tool.
+      $schema: "./node_modules/@biomejs/biome/configuration_schema.json",
+      assist: {
+        actions: {
+          source: {
+            organizeImports: {
+              level: "on",
+              options: {
+                groups: [
+                  [
+                    ":NODE:",
+                    ":PACKAGE:",
+                    ":PACKAGE_WITH_PROTOCOL:"
+                  ],
+                  ":BLANK_LINE:",
+                  [":ALIAS:", ":PATH:"]
+                ]
+              }
+            }
+          }
+        }
+      },
+      css: {
+        formatter: { quoteStyle: "single" },
+        parser: { tailwindDirectives: true }
+      },
+      files: {
+        includes: [
+          "**",
+          ...[...IGNORED, ...ignored].map((path6) => `!**/${path6}`)
+        ]
+      },
+      formatter: { indentStyle: "space", indentWidth: 4, lineWidth: 80 },
+      javascript: {
+        formatter: {
+          quoteStyle: "single",
+          semicolons: "always",
+          trailingCommas: "none"
+        }
+      },
+      linter: { enabled: false },
+      yaml: { formatter: { quoteStyle: "single" } }
+    })
+  }),
+  fixCommand: ["biome", "check", "--write"],
+  id: "biome",
+  label: "Biome"
+};
+var prettier = {
+  checkCommand: ["prettier", "--check", "."],
+  devDependencies: ["prettier"],
+  files: ({ ignored }) => ({
+    ".prettierignore": `${[...IGNORED, ...ignored].join("\n")}
+`,
+    ".prettierrc": toJson({
+      semi: true,
+      singleQuote: true,
+      tabWidth: 4,
+      trailingComma: "none"
+    })
+  }),
+  fixCommand: ["prettier", "--write", "."],
+  id: "prettier",
+  label: "Prettier"
+};
+var FORMATTERS = [biome, prettier];
+
+// src/registry/task-runners.ts
+var TURBO_TASKS = {
+  build: { dependsOn: ["^build"], outputs: ["build/**"] },
+  dev: { cache: false, persistent: true }
+};
+var turbo = {
+  devDependencies: ["turbo"],
+  gitignore: [".turbo"],
+  id: "turbo",
+  label: "Turborepo",
+  rootFiles: ({ scripts }) => ({
+    "turbo.json": toJson({
+      $schema: "https://turborepo.com/schema.json",
+      tasks: Object.fromEntries(
+        scripts.map((script) => [script, TURBO_TASKS[script] ?? {}])
+      )
+    })
+  }),
+  runScript: (script) => `turbo run ${script}`
+};
+var TASK_RUNNERS = [turbo];
+
+// src/registry/ui-kits.ts
+var pink = {
+  bodyClass: "theme-light",
+  id: "pink",
+  label: "Pink (@loom-js/pink)",
+  packages: ["@loom-js/pink"],
+  stylesheets: ["@loom-js/pink/pink.css", "@loom-js/pink/icons.css"],
+  tailwind: {
+    // Pink block classes Tailwind would also generate as utilities.
+    sourceExclusions: ["container", "list-item", "table", "table-row"],
+    stylesheet: "@loom-js/pink/pink.css"
+  }
+};
+var UI_KITS = [pink];
+
+// src/registry/index.ts
+var REGISTRIES = {
+  formatters: FORMATTERS,
+  taskRunners: TASK_RUNNERS,
+  uiKits: UI_KITS
+};
+var findEntry = (entries, id) => entries.find((entry) => entry.id === id);
+var entryOf = (entries, id) => {
+  const entry = findEntry(entries, id);
+  if (!entry) {
+    throw new Error(`[create] unknown registry entry "${id}".`);
+  }
+  return entry;
+};
+
+// src/args.ts
+import { parseArgs } from "node:util";
+var UsageError = class extends Error {
+};
+var LAYOUTS = ["single", "monorepo"];
+var OPTIONS = {
+  formatter: { type: "string" },
+  git: { type: "string" },
+  help: { short: "h", type: "boolean" },
+  install: { type: "boolean" },
+  js: { type: "boolean" },
+  layout: { type: "string" },
+  "no-install": { type: "boolean" },
+  spa: { type: "boolean" },
+  tailwind: { type: "boolean" },
+  "task-runner": { type: "string" },
+  ui: { type: "string" },
+  yes: { short: "y", type: "boolean" }
+};
+var registryValue = (flag, value, entries, allowNone) => {
+  if (allowNone && value === NONE || findEntry(entries, value)) {
+    return value;
+  }
+  const ids = [...allowNone ? [NONE] : [], ...entries.map(({ id }) => id)];
+  throw new UsageError(
+    `--${flag} "${value}" is not one of: ${ids.join(", ")}.`
+  );
+};
+var looksLikeRepository = (value) => /[:/\\]/.test(value);
+var gitValue = (value) => {
+  if (value === "new" || value === NONE) {
+    return { kind: value };
+  }
+  if (looksLikeRepository(value)) {
+    return { kind: "clone", url: value };
+  }
+  throw new UsageError(
+    `--git takes new, none or a repository URL, not "${value}".`
+  );
+};
+var parse = (argv) => {
+  try {
+    return parseArgs({
+      allowPositionals: true,
+      args: [...argv],
+      options: OPTIONS,
+      strict: true
+    });
+  } catch (error) {
+    throw new UsageError(
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+};
+var parseCliArgs = (argv, registries) => {
+  const { positionals, values } = parse(argv);
+  const answers = {};
+  if (positionals.length > 1) {
+    throw new UsageError(
+      `expected one directory, got ${positionals.length}: ${positionals.join(" ")}.`
+    );
+  }
+  if (positionals[0] !== void 0) {
+    answers.target = positionals[0];
+  }
+  if (values.layout !== void 0) {
+    if (!LAYOUTS.includes(values.layout)) {
+      throw new UsageError(
+        `--layout "${values.layout}" is not one of: ${LAYOUTS.join(", ")}.`
+      );
+    }
+    answers.layout = values.layout;
+  }
+  if (values["task-runner"] !== void 0) {
+    if (answers.layout === "single") {
+      throw new UsageError(
+        "--task-runner applies only to --layout monorepo."
+      );
+    }
+    answers.layout = "monorepo";
+    answers.taskRunner = registryValue(
+      "task-runner",
+      values["task-runner"],
+      registries.taskRunners,
+      false
+    );
+  }
+  if (values.ui !== void 0) {
+    answers.ui = registryValue("ui", values.ui, registries.uiKits, true);
+  }
+  if (values.formatter !== void 0) {
+    answers.formatter = registryValue(
+      "formatter",
+      values.formatter,
+      registries.formatters,
+      true
+    );
+  }
+  if (values.git !== void 0) {
+    answers.git = gitValue(values.git);
+  }
+  if (values.install && values["no-install"]) {
+    throw new UsageError("--install and --no-install contradict.");
+  }
+  if (values.install || values["no-install"]) {
+    answers.install = Boolean(values.install);
+  }
+  if (values.spa) {
+    answers.spa = true;
+  }
+  if (values.tailwind) {
+    answers.tailwind = true;
+  }
+  if (values.js) {
+    answers.js = true;
+  }
+  return {
+    answers,
+    help: Boolean(values.help),
+    yes: Boolean(values.yes)
+  };
+};
+
+// src/package-manager.ts
+var NAMES = ["npm", "pnpm", "yarn", "bun"];
+var detectPackageManager = (env) => {
+  const [name, version] = env.npm_config_user_agent?.split(" ")[0]?.split("/") ?? [];
+  const known = NAMES.find((candidate) => candidate === name);
+  return known ? { name: known, version } : { name: "npm" };
+};
+var resolveVersion = async (packageManager, spawn2, cwd) => {
+  if (packageManager.version) {
+    return packageManager.version;
+  }
+  const { code, stdout } = await spawn2(packageManager.name, ["--version"], {
+    cwd
+  });
+  return code === 0 ? stdout.trim() : void 0;
+};
+var installCommand = ({ name }) => [name, "install"];
+var runCommand = ({ name }, script) => name === "npm" || name === "bun" ? `${name} run ${script}` : `${name} ${script}`;
+
+// src/prompts.ts
+var askText = async (io, question, fallback) => (await io.ask(`${question} (${fallback}) `)).trim() || fallback;
+var askConfirm = async (io, question, fallback) => {
+  for (; ; ) {
+    const answer = (await io.ask(`${question} (${fallback ? "Y/n" : "y/N"}) `)).trim().toLowerCase();
+    if (!answer) {
+      return fallback;
+    }
+    if (answer === "y" || answer === "yes") {
+      return true;
+    }
+    if (answer === "n" || answer === "no") {
+      return false;
+    }
+  }
+};
+var askChoice = async (io, question, options, fallback) => {
+  const fallbackIndex = Math.max(
+    0,
+    options.findIndex(({ value }) => value === fallback)
+  );
+  const list = options.map(({ label }, index) => `  ${index + 1}) ${label}`).join("\n");
+  for (; ; ) {
+    const answer = (await io.ask(`${question}
+${list}
+(${fallbackIndex + 1}) `)).trim();
+    const index = answer ? Number(answer) - 1 : fallbackIndex;
+    const option = options[index];
+    if (option) {
+      return option.value;
+    }
+  }
+};
+var entryOptions = (entries, withNone) => [
+  ...withNone ? [{ label: "None", value: NONE }] : [],
+  ...entries.map(({ id, label }) => ({ label, value: id }))
+];
+var askGit = async (io) => {
+  const kind = await askChoice(
+    io,
+    "Git repository?",
+    [
+      { label: "New repository with an initial commit", value: "new" },
+      { label: "Clone an existing repository", value: "clone" },
+      { label: "None", value: NONE }
+    ],
+    "new"
+  );
+  if (kind !== "clone") {
+    return { kind };
+  }
+  for (; ; ) {
+    const url = (await io.ask("Repository URL to clone: ")).trim();
+    if (url) {
+      return { kind: "clone", url };
+    }
+  }
+};
+var resolveChoices = async ({ answers, yes }, io, registries) => {
+  const ask = io.interactive && !yes;
+  const defaultTaskRunner = registries.taskRunners[0]?.id;
+  const target = answers.target ?? (ask ? await askText(io, "Project directory?", DEFAULT_TARGET) : DEFAULT_TARGET);
+  const layout = answers.layout ?? (ask ? await askChoice(
+    io,
+    "Layout?",
+    [
+      { label: "Single app", value: "single" },
+      { label: "Monorepo (app at apps/web)", value: "monorepo" }
+    ],
+    DEFAULTS.layout
+  ) : DEFAULTS.layout);
+  const taskRunner = layout !== "monorepo" ? void 0 : answers.taskRunner ?? // A one-entry registry has nothing to ask.
+  (ask && defaultTaskRunner && registries.taskRunners.length > 1 ? await askChoice(
+    io,
+    "Task runner?",
+    entryOptions(registries.taskRunners, false),
+    defaultTaskRunner
+  ) : defaultTaskRunner);
+  const spa = answers.spa ?? (ask ? await askChoice(
+    io,
+    "Rendering?",
+    [
+      {
+        label: "Server-first (prerender + hydrate)",
+        value: false
+      },
+      { label: "Client-only (SPA)", value: true }
+    ],
+    DEFAULTS.spa
+  ) : DEFAULTS.spa);
+  const ui = answers.ui ?? (ask ? await askChoice(
+    io,
+    "UI kit?",
+    entryOptions(registries.uiKits, true),
+    DEFAULTS.ui
+  ) : DEFAULTS.ui);
+  const tailwind = answers.tailwind ?? (ask ? await askConfirm(io, "Add Tailwind CSS?", DEFAULTS.tailwind) : DEFAULTS.tailwind);
+  const formatter = answers.formatter ?? (ask ? await askChoice(
+    io,
+    "Formatter?",
+    entryOptions(registries.formatters, true),
+    DEFAULTS.formatter
+  ) : DEFAULTS.formatter);
+  const js = answers.js ?? (ask ? await askChoice(
+    io,
+    "Language?",
+    [
+      { label: "TypeScript", value: false },
+      { label: "JavaScript", value: true }
+    ],
+    DEFAULTS.js
+  ) : DEFAULTS.js);
+  const git = answers.git ?? (ask ? await askGit(io) : DEFAULTS.git);
+  const install = answers.install ?? (ask ? await askConfirm(io, "Install dependencies?", DEFAULTS.install) : DEFAULTS.install);
+  return {
+    formatter,
+    git,
+    install,
+    js,
+    layout,
+    spa,
+    tailwind,
+    target,
+    taskRunner,
+    ui
+  };
+};
+
+// src/target.ts
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+var NPM_NAME = /^[a-z0-9~-][a-z0-9._~-]*$/;
+var NPM_NAME_MAX = 214;
+var packageNameOf = (target, cwd) => {
+  const name = path.basename(path.resolve(cwd, target)).toLowerCase().replace(/\s+/g, "-");
+  if (!NPM_NAME.test(name) || name.length > NPM_NAME_MAX) {
+    throw new UsageError(
+      `"${name}" is not a valid npm package name; pick another directory name.`
+    );
+  }
+  return name;
+};
+var checkTarget = async (directory) => {
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch {
+    return { exists: false };
+  }
+  const occupied = entries.filter((entry) => entry !== ".git");
+  if (occupied.length > 0) {
+    throw new UsageError(
+      `${directory} is not empty (${occupied.slice(0, 3).join(", ")}${occupied.length > 3 ? ", \u2026" : ""}); pick an empty or new directory.`
+    );
+  }
+  return { exists: true };
+};
+
+// src/usage.ts
+var COLUMN = 38;
+var idList = (entries, withNone) => [...withNone ? [NONE] : [], ...entries.map(({ id }) => id)].join("|");
+var row = ([flag, description]) => `  ${flag.padEnd(COLUMN - 3)} ${description}`;
+var usage = ({ formatters, taskRunners, uiKits }) => {
+  const rows = [
+    ["--layout <single|monorepo>", "App layout (default: single)"],
+    [
+      `--task-runner <${idList(taskRunners, false)}>`,
+      `Monorepo task runner (default: ${taskRunners[0]?.id})`
+    ],
+    ["--spa", "Client-only rendering (default: server-first)"],
+    [`--ui <${idList(uiKits, true)}>`, `UI kit (default: ${NONE})`],
+    ["--tailwind", "Tailwind CSS v4"],
+    [
+      `--formatter <${idList(formatters, true)}>`,
+      `Formatter (default: ${formatters[0]?.id})`
+    ],
+    ["--js", "JavaScript instead of TypeScript"],
+    [
+      "--git <new|none|url>",
+      "New repo, none, or clone a URL (default: new)"
+    ],
+    ["--install, --no-install", "Install dependencies (default: install)"],
+    ["-y, --yes", "Accept the defaults for every unanswered choice"],
+    ["-h, --help", "Show this help"]
+  ];
+  return `Usage: create @loom-js [directory] [options]
+
+Run it through your package manager: npm create @loom-js, pnpm create
+@loom-js, yarn create @loom-js or bun create @loom-js (or npx, pnpm dlx,
+yarn dlx or bunx @loom-js/create). In a terminal, unanswered choices are
+prompted for; otherwise they take their defaults.
+
+Options:
+${rows.map(row).join("\n")}`;
+};
+
+// src/versions.ts
+var STAMPED_RANGES = define_STAMPED_RANGES_default;
+var rangeOf = (name) => {
+  const range = STAMPED_RANGES[name];
+  if (!range) {
+    throw new Error(`[create] no stamped range for "${name}".`);
+  }
+  return range;
+};
+
+// src/git.ts
+import { access, readFile } from "node:fs/promises";
+import path2 from "node:path";
+var KEPT_FROM_CLONE = ["README.md", "LICENSE", ".gitignore"];
+var NEW_COMMIT_MESSAGE = "Initial commit from @loom-js/create";
+var CLONE_COMMIT_MESSAGE = "Add a loom app from @loom-js/create";
+var exists = (filePath) => access(filePath).then(
+  () => true,
+  () => false
+);
+var hasGit = async (spawn2, cwd) => (await spawn2("git", ["--version"], { cwd })).code === 0;
+var cloneConflicts = async (directory, planned) => {
+  const conflicts = [];
+  for (const filePath of planned) {
+    if (!KEPT_FROM_CLONE.includes(filePath) && await exists(path2.join(directory, filePath))) {
+      conflicts.push(filePath);
+    }
+  }
+  return conflicts;
+};
+var mergeGitignore = (existing, ours) => {
+  const present = new Set(existing.split("\n").map((line) => line.trim()));
+  const missing = ours.split("\n").filter((line) => line.trim() && !present.has(line.trim()));
+  if (missing.length === 0) {
+    return existing;
+  }
+  const base = existing.endsWith("\n") ? existing : `${existing}
+`;
+  return `${base}${missing.join("\n")}
+`;
+};
+var readCloned = (directory, filePath) => readFile(path2.join(directory, filePath), "utf8").catch(() => void 0);
+var commitAll = async (directory, message, spawn2, io) => {
+  const identity = await spawn2("git", ["config", "user.email"], {
+    cwd: directory
+  });
+  if (identity.code !== 0 || !identity.stdout.trim()) {
+    io.print(
+      [
+        "git has no identity, so nothing was committed. To finish:",
+        '  git config --global user.name "Your Name"',
+        "  git config --global user.email you@example.com",
+        `  git add -A && git commit -m "${message}"`
+      ].join("\n")
+    );
+    return false;
+  }
+  const add = await spawn2("git", ["add", "-A"], { cwd: directory });
+  const commit = add.code === 0 ? await spawn2("git", ["commit", "-q", "-m", message], {
+    cwd: directory
+  }) : add;
+  if (commit.code !== 0) {
+    io.error(`git commit failed:
+${commit.stderr.trim()}`);
+    return false;
+  }
+  return true;
+};
+
+// src/layers.ts
+import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import path3 from "node:path";
+var layerNamesFor = ({ spa, tailwind, ui }) => [
+  "base",
+  ...spa ? [] : ["server"],
+  ...ui === NONE ? [] : [`ui/${ui}`],
+  ...tailwind ? ["tailwind"] : []
+];
+var mergeLayers = (layers) => {
+  const files = {};
+  const owners = /* @__PURE__ */ new Map();
+  for (const { files: layerFiles, name } of layers) {
+    for (const [filePath, content] of Object.entries(layerFiles)) {
+      const owner = owners.get(filePath);
+      if (owner && owner !== "base") {
+        throw new Error(
+          `[create] layers "${owner}" and "${name}" both write ${filePath}.`
+        );
+      }
+      owners.set(filePath, name);
+      files[filePath] = content;
+    }
+  }
+  return files;
+};
+var diskLayerReader = (root) => async (name) => {
+  const directory = path3.join(root, name);
+  const entries = await readdir2(directory, {
+    recursive: true,
+    withFileTypes: true
+  });
+  const files = {};
+  for (const entry of entries.filter((item) => item.isFile())) {
+    const absolute = path3.join(entry.parentPath, entry.name);
+    const relative = path3.relative(directory, absolute).split(path3.sep).join("/");
+    files[relative] = await readFile2(absolute, "utf8");
+  }
+  return { files, name };
+};
+
+// src/render/bootstrap.ts
+var renderBootstrap = ({ choices, uiKit }) => {
+  const stylesheets = (uiKit?.stylesheets ?? []).filter(
+    // With Tailwind, the kit's main sheet is imported by `styles.css`.
+    (sheet) => !(choices.tailwind && sheet === uiKit?.tailwind.stylesheet)
+  );
+  const coreImport = choices.spa ? "import { APP_ROOT_ID, init } from '@loom-js/core';" : [
+    "import {",
+    "    APP_ROOT_ID,",
+    "    hydrate,",
+    "    primeResources,",
+    "    STATE_SCRIPT_ID",
+    "} from '@loom-js/core';"
+  ].join("\n");
+  const boot = choices.spa ? ["init({ app: App(), root: document.getElementById(APP_ROOT_ID) });"] : [
+    "// A prerendered page embeds its state; prime it so nothing refetches.",
+    "const payload = document.getElementById(STATE_SCRIPT_ID)?.textContent;",
+    "",
+    "if (payload) {",
+    "    primeResources(JSON.parse(payload));",
+    "}",
+    "",
+    "hydrate({ app: App(), root: document.getElementById(APP_ROOT_ID) });"
+  ];
+  return [
+    coreImport,
+    ...stylesheets.map((sheet) => `import '${sheet}';`),
+    "",
+    "import { App } from './app';",
+    "",
+    "// Reloads the page when `loom dev` rebuilds; production builds drop it.",
+    "if (__DEV__) {",
+    "    new EventSource('/esbuild').addEventListener('change', () =>",
+    "        location.reload()",
+    "    );",
+    "}",
+    "",
+    ...boot,
+    ""
+  ].join("\n");
+};
+
+// src/render/compiler-config.ts
+var PATHS = { "@app/*": ["./src/*"] };
+var COMPILER_OPTIONS = {
+  esModuleInterop: true,
+  isolatedModules: true,
+  lib: ["ES2022", "DOM", "DOM.Iterable"],
+  module: "ESNext",
+  moduleDetection: "force",
+  moduleResolution: "Bundler",
+  noEmit: true,
+  noUncheckedIndexedAccess: true,
+  resolveJsonModule: true,
+  skipLibCheck: true,
+  strict: true,
+  target: "ES2022"
+};
+var renderCompilerConfig = ({
+  choices
+}) => {
+  if (choices.js) {
+    return {
+      "jsconfig.json": toJson({
+        compilerOptions: {
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          paths: PATHS,
+          target: "ES2022"
+        },
+        include: ["src", "loom.config.mjs"]
+      })
+    };
+  }
+  const include = ["src", "loom.config.ts"];
+  return {
+    "tsconfig.json": toJson(
+      choices.layout === "monorepo" ? {
+        extends: "../../tsconfig.base.json",
+        compilerOptions: { paths: PATHS },
+        include
+      } : {
+        compilerOptions: { ...COMPILER_OPTIONS, paths: PATHS },
+        include
+      }
+    )
+  };
+};
+
+// src/render/context.ts
+var TAILWIND_INPUT = "./src/styles.css";
+var TAILWIND_OUTPUT = "./.generated/styles.css";
+var BASE_STYLESHEET = "./public/styles/base.css";
+var appScripts = ({ choices }) => [
+  "dev",
+  "build",
+  ...choices.js ? [] : ["type-check"]
+];
+var formatterInApp = ({ choices, formatter }) => Boolean(formatter) && choices.layout === "single";
+
+// src/render/loom-config.ts
+var LINE_WIDTH2 = 80;
+var stringArray = (key, values, indent) => {
+  const quoted = values.map((value) => `'${value}'`);
+  const inline = `${indent}${key}: [${quoted.join(", ")}],`;
+  return inline.length <= LINE_WIDTH2 ? inline : `${indent}${key}: [
+${quoted.map((value) => `${indent}    ${value}`).join(",\n")}
+${indent}],`;
+};
+var renderLoomConfig = ({ choices, name, uiKit }) => {
+  const styles = choices.tailwind ? [BASE_STYLESHEET, TAILWIND_OUTPUT] : [BASE_STYLESHEET];
+  const html = [
+    ...uiKit?.bodyClass ? [`        bodyClass: '${uiKit.bodyClass}',`] : [],
+    `        title: () => '${name}'`
+  ];
+  const prerender = choices.spa ? [] : [
+    "    prerender: {",
+    "        entry: './src/prerender.entry',",
+    "        routes: () => routes",
+    "    },"
+  ];
+  return [
+    "import { defineConfig } from '@loom-js/build';",
+    "",
+    "import { routes } from './src/routes';",
+    "",
+    "export default defineConfig({",
+    "    entry: './src/bootstrap',",
+    "    html: {",
+    ...html,
+    "    },",
+    ...prerender,
+    "    routes,",
+    stringArray("styles", styles, "    ").replace(/,$/, ""),
+    "});",
+    ""
+  ].join("\n");
+};
+
+// src/render/package-json.ts
+var sorted = (record) => Object.fromEntries(
+  Object.entries(record).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )
+);
+var rangesOf = (names) => sorted(Object.fromEntries(names.map((name) => [name, rangeOf(name)])));
+var formatterScripts = ({
+  formatter
+}) => formatter ? {
+  format: formatter.fixCommand.join(" "),
+  "format:check": formatter.checkCommand.join(" ")
+} : {};
+var renderAppPackageJson = (context) => {
+  const { choices, formatter, name, uiKit } = context;
+  const tailwindBuild = `tailwindcss -i ${TAILWIND_INPUT} -o ${TAILWIND_OUTPUT}`;
+  const ownsFormatter = formatterInApp(context);
+  return toPackageJson({
+    name: choices.layout === "monorepo" ? "web" : name,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts: sorted({
+      build: choices.tailwind ? `${tailwindBuild} && loom build` : "loom build",
+      dev: choices.tailwind ? "node scripts/dev.mjs" : "loom dev",
+      ...choices.js ? {} : { "type-check": "tsc --noEmit" },
+      ...ownsFormatter ? formatterScripts(context) : {}
+    }),
+    dependencies: rangesOf(["@loom-js/core", ...uiKit?.packages ?? []]),
+    devDependencies: rangesOf([
+      "@loom-js/build",
+      "@loom-js/devtools",
+      ...choices.js ? [] : ["typescript"],
+      ...choices.tailwind ? ["@tailwindcss/cli", "tailwindcss"] : [],
+      ...ownsFormatter && formatter ? formatter.devDependencies : []
+    ])
+  });
+};
+var renderRootPackageJson = (context, scripts, packageManagerField) => {
+  const { formatter, name, packageManager, taskRunner } = context;
+  if (!taskRunner) {
+    throw new Error("[create] a monorepo needs a task runner.");
+  }
+  return toPackageJson({
+    name,
+    private: true,
+    ...packageManagerField ? { packageManager: packageManagerField } : {},
+    ...packageManager.name === "pnpm" ? {} : { workspaces: ["apps/*", "packages/*"] },
+    scripts: sorted({
+      ...Object.fromEntries(
+        scripts.map((script) => [script, taskRunner.runScript(script)])
+      ),
+      ...formatterScripts(context)
+    }),
+    devDependencies: rangesOf([
+      ...taskRunner.devDependencies,
+      ...formatter?.devDependencies ?? []
+    ])
+  });
+};
+
+// src/render/repo-files.ts
+var SCRIPT_PURPOSE = {
+  build: ({ choices }) => choices.spa ? "build the app into `build/`." : "build the app into `build/`, prerendering every route.",
+  dev: () => "start the dev server, reloading on every change.",
+  format: ({ formatter }) => `format every file with ${formatter?.label}.`,
+  "format:check": () => "fail on any unformatted file.",
+  "type-check": () => "type-check with `tsc`."
+};
+var renderGitignore = ({ choices, taskRunner }) => `${[
+  "node_modules",
+  "build",
+  ".DS_Store",
+  "*.log",
+  ...choices.tailwind ? [".generated"] : [],
+  ...choices.layout === "monorepo" ? taskRunner?.gitignore ?? [] : []
+].join("\n")}
+`;
+var renderReadme = (context) => {
+  const { choices, formatter, name, packageManager } = context;
+  const scripts = [
+    ...appScripts(context),
+    ...formatter ? ["format", "format:check"] : []
+  ];
+  const where = choices.layout === "monorepo" ? "A monorepo with a [loom](https://loom-js-docs.vercel.app/docs) app in `apps/web`" : "A [loom](https://loom-js-docs.vercel.app/docs) app";
+  return [
+    `# ${name}`,
+    "",
+    `${where}, created with \`@loom-js/create\`.`,
+    "",
+    "## Scripts",
+    "",
+    ...scripts.map(
+      (script) => `- \`${runCommand(packageManager, script)}\`: ${SCRIPT_PURPOSE[script]?.(context)}`
+    ),
+    ""
+  ].join("\n");
+};
+var buildScriptPackages = ({ choices }) => [
+  ...choices.tailwind ? ["@parcel/watcher"] : [],
+  "esbuild"
+];
+var yamlKey = (name) => /^[\w-]+$/.test(name) ? name : `'${name}'`;
+var renderPnpmWorkspace = (context) => {
+  const packages = buildScriptPackages(context);
+  return [
+    ...context.choices.layout === "monorepo" ? ["packages:", "    - apps/*", "    - packages/*"] : [],
+    "allowBuilds:",
+    ...packages.map((name) => `    ${yamlKey(name)}: true`),
+    "onlyBuiltDependencies:",
+    ...packages.map((name) => `    - ${yamlKey(name)}`),
+    ""
+  ].join("\n");
+};
+var renderYarnrc = (version) => version && Number(version.split(".")[0]) >= 2 ? { ".yarnrc.yml": "nodeLinker: node-modules\n" } : {};
+
+// src/render/styles.ts
+var renderTailwindStyles = ({ uiKit }) => {
+  if (!uiKit) {
+    return "@import 'tailwindcss';\n";
+  }
+  return [
+    `/* ${uiKit.label} first: its layer order puts Tailwind's preflight`,
+    "   before the kit and Tailwind's utilities after it. */",
+    `@import '${uiKit.tailwind.stylesheet}';`,
+    "@import 'tailwindcss';",
+    ...uiKit.tailwind.sourceExclusions.length > 0 ? [
+      "",
+      "/* Kit classes Tailwind would also generate as utilities. */",
+      `@source not inline('${uiKit.tailwind.sourceExclusions.join(" ")}');`
+    ] : [],
+    ""
+  ].join("\n");
+};
+
+// src/scaffold.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import path4 from "node:path";
+var MONOREPO_APP_DIR = "apps/web";
+var when = (condition, files) => condition ? files() : {};
+var prefixed = (prefix, files) => Object.fromEntries(
+  Object.entries(files).map(([filePath, content]) => [
+    prefix ? `${prefix}/${filePath}` : filePath,
+    content
+  ])
+);
+var appFiles = async (context, readLayer) => {
+  const { choices } = context;
+  const layers = await Promise.all(
+    layerNamesFor(choices).map((name) => readLayer(name))
+  );
+  const extension = choices.js ? "js" : "ts";
+  return {
+    ...mergeLayers(layers),
+    [choices.js ? "loom.config.mjs" : "loom.config.ts"]: renderLoomConfig(context),
+    "package.json": renderAppPackageJson(context),
+    [`src/bootstrap.${extension}`]: renderBootstrap(context),
+    ...when(choices.tailwind, () => ({
+      "src/styles.css": renderTailwindStyles(context)
+    })),
+    ...renderCompilerConfig(context)
+  };
+};
+var repoFiles = (context, options) => ({
+  ".gitignore": renderGitignore(context),
+  "README.md": renderReadme(context),
+  ...context.formatter?.files({
+    ignored: context.choices.layout === "monorepo" ? context.taskRunner?.gitignore ?? [] : []
+  }) ?? {},
+  ...when(context.packageManager.name === "pnpm", () => ({
+    "pnpm-workspace.yaml": renderPnpmWorkspace(context)
+  })),
+  ...when(
+    context.packageManager.name === "yarn",
+    () => renderYarnrc(options.packageManagerVersion)
+  )
+});
+var workspaceFiles = (context, options) => {
+  const { choices, taskRunner } = context;
+  const delegated = appScripts(context);
+  return {
+    "package.json": renderRootPackageJson(
+      context,
+      delegated,
+      options.packageManagerField
+    ),
+    ...when(!choices.js, () => ({
+      "tsconfig.base.json": toJson({ compilerOptions: COMPILER_OPTIONS })
+    })),
+    ...taskRunner?.rootFiles({ scripts: delegated }) ?? {},
+    "packages/.gitkeep": ""
+  };
+};
+var planScaffold = async (context, readLayer, options = {}) => {
+  const app = await appFiles(context, readLayer);
+  if (context.choices.layout === "single") {
+    return { ...app, ...repoFiles(context, options) };
+  }
+  return {
+    ...prefixed(MONOREPO_APP_DIR, app),
+    ...repoFiles(context, options),
+    ...workspaceFiles(context, options)
+  };
+};
+var writeScaffold = async (directory, files) => {
+  for (const [filePath, content] of Object.entries(files)) {
+    const absolute = path4.join(directory, ...filePath.split("/"));
+    await mkdir(path4.dirname(absolute), { recursive: true });
+    await writeFile(absolute, content);
+  }
+};
+
+// src/cli.ts
+import { mkdir as mkdir2, readdir as readdir3, rm } from "node:fs/promises";
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
+var defaultTemplates = () => fileURLToPath(new URL("./templates/", import.meta.url));
+var contextOf = (choices, name, packageManager, registries) => ({
+  choices,
+  formatter: choices.formatter === NONE ? void 0 : entryOf(registries.formatters, choices.formatter),
+  name,
+  packageManager,
+  taskRunner: choices.taskRunner ? entryOf(registries.taskRunners, choices.taskRunner) : void 0,
+  uiKit: choices.ui === NONE ? void 0 : entryOf(registries.uiKits, choices.ui)
+});
+var treeOf = (choices, registries, root) => path5.join(
+  root,
+  choices.formatter === NONE ? registries.formatters[0]?.id ?? "" : choices.formatter,
+  choices.js ? "js" : "ts"
+);
+var removeClone = async (directory, created) => {
+  if (created) {
+    await rm(directory, { force: true, recursive: true });
+    return;
+  }
+  for (const entry of await readdir3(directory)) {
+    await rm(path5.join(directory, entry), { force: true, recursive: true });
+  }
+};
+var nextSteps = (choices, packageManager, installed) => [
+  "Next:",
+  ...choices.target === "." ? [] : [`  cd ${choices.target}`],
+  ...installed ? [] : [`  ${installCommand(packageManager).join(" ")}`],
+  `  ${runCommand(packageManager, "dev")}`,
+  ...choices.git.kind === "clone" ? ["  git push"] : []
+];
+var run = async ({
+  argv,
+  cwd,
+  env,
+  io,
+  registries = REGISTRIES,
+  spawn: spawn2,
+  templatesDirectory = defaultTemplates()
+}) => {
+  try {
+    const parsed = parseCliArgs(argv, registries);
+    if (parsed.help) {
+      io.print(usage(registries));
+      return 0;
+    }
+    const choices = await resolveChoices(parsed, io, registries);
+    const name = packageNameOf(choices.target, cwd);
+    const directory = path5.resolve(cwd, choices.target);
+    const { exists: exists2 } = await checkTarget(directory);
+    const detected = detectPackageManager(env);
+    const needsVersion = choices.layout === "monorepo" || detected.name === "yarn";
+    const version = needsVersion ? await resolveVersion(detected, spawn2, cwd) : detected.version;
+    const packageManager = { ...detected, version };
+    const context = contextOf(choices, name, packageManager, registries);
+    const files = await planScaffold(
+      context,
+      diskLayerReader(treeOf(choices, registries, templatesDirectory)),
+      {
+        packageManagerField: version ? `${packageManager.name}@${version}` : void 0,
+        packageManagerVersion: version
+      }
+    );
+    if (choices.git.kind === "clone") {
+      const clone = await spawn2(
+        "git",
+        ["clone", choices.git.url, directory],
+        { cwd }
+      );
+      if (clone.code !== 0) {
+        io.error(clone.stderr.trim() || "git clone failed.");
+        return 1;
+      }
+      const conflicts = await cloneConflicts(
+        directory,
+        Object.keys(files)
+      );
+      if (conflicts.length > 0) {
+        await removeClone(directory, !exists2);
+        io.error(
+          `The repository already has ${conflicts.join(", ")}; nothing was written.`
+        );
+        return 1;
+      }
+      for (const kept of KEPT_FROM_CLONE) {
+        const cloned = await readCloned(directory, kept);
+        if (cloned === void 0) {
+          continue;
+        }
+        if (kept === ".gitignore" && files[kept] !== void 0) {
+          files[kept] = mergeGitignore(cloned, files[kept]);
+        } else {
+          delete files[kept];
+        }
+      }
+    }
+    await mkdir2(directory, { recursive: true });
+    await writeScaffold(directory, files);
+    io.print(`Created ${name} in ${directory}.`);
+    if (choices.install) {
+      const [command = "npm", ...args] = installCommand(packageManager);
+      const install = await spawn2(command, args, {
+        cwd: directory,
+        inherit: true
+      });
+      if (install.code !== 0) {
+        io.error(
+          `Install failed. The files are in place; run it yourself:
+  cd ${choices.target}
+  ${installCommand(packageManager).join(" ")}`
+        );
+        return 1;
+      }
+    }
+    if (choices.git.kind !== "none") {
+      if (!await hasGit(spawn2, directory)) {
+        io.print("git is not installed, so no repository was set up.");
+      } else {
+        if (choices.git.kind === "new") {
+          await spawn2("git", ["init", "-q"], { cwd: directory });
+        }
+        await commitAll(
+          directory,
+          choices.git.kind === "new" ? NEW_COMMIT_MESSAGE : CLONE_COMMIT_MESSAGE,
+          spawn2,
+          io
+        );
+      }
+    }
+    io.print(
+      nextSteps(choices, packageManager, choices.install).join("\n")
+    );
+    return 0;
+  } catch (error) {
+    if (error instanceof UsageError) {
+      io.error(`${usage(registries)}
+
+${error.message}`);
+      return 1;
+    }
+    throw error;
+  } finally {
+    io.close();
+  }
+};
+
+// src/io.ts
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+var nodeIo = () => {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  let readline;
+  return {
+    ask: (question) => {
+      readline ??= createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      return readline.question(question);
+    },
+    close: () => readline?.close(),
+    error: (text) => console.error(text),
+    interactive,
+    print: (text) => console.info(text)
+  };
+};
+var nodeSpawn = (command, args, { cwd, inherit }) => new Promise((resolve) => {
+  let stdout = "";
+  let stderr = "";
+  const child = spawn(command, args, {
+    cwd,
+    // Package managers are `.cmd` shims on Windows.
+    shell: process.platform === "win32",
+    stdio: inherit ? "inherit" : "pipe"
+  });
+  child.stdout?.on("data", (chunk) => stdout += chunk);
+  child.stderr?.on("data", (chunk) => stderr += chunk);
+  child.on("error", () => resolve({ code: null, stderr, stdout }));
+  child.on("close", (code) => resolve({ code, stderr, stdout }));
+});
+export {
+  DEFAULTS,
+  NONE,
+  REGISTRIES,
+  STAMPED_RANGES,
+  UsageError,
+  checkTarget,
+  detectPackageManager,
+  entryOf,
+  findEntry,
+  installCommand,
+  layerNamesFor,
+  mergeGitignore,
+  mergeLayers,
+  nodeIo,
+  nodeSpawn,
+  packageNameOf,
+  parseCliArgs,
+  planScaffold,
+  rangeOf,
+  resolveChoices,
+  resolveVersion,
+  run,
+  runCommand,
+  toJson,
+  toPackageJson,
+  usage
+};