@mnaoumov/create-obsidian-plugin 1.0.2 → 1.2.0

package/dist/main.js

@@ -5,7 +5,7 @@ import {
   cancel as cancel3,
   confirm,
   intro,
-  log as log4,
+  log as log5,
   note,
   outro,
   select as select2,
@@ -15,23 +15,17 @@ import {
 import { spawn } from "node:child_process";
 import {
   chmodSync,
-  existsSync as existsSync6,
-  readFileSync as readFileSync6,
+  existsSync as existsSync8,
+  readFileSync as readFileSync8,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import {
-  join as join5,
+  join as join9,
   resolve as resolvePath
 } from "node:path";
 import { compare } from "semver";
 
-// src/cli-args.ts
-import {
-  existsSync,
-  readFileSync
-} from "node:fs";
-
-// src/clack-select.ts
+// src/prompts/clack-select.ts
 import {
   SelectPrompt,
   settings
@@ -41,11 +35,11 @@ import {
   S_BAR_END,
   S_RADIO_ACTIVE,
   S_RADIO_INACTIVE,
-  symbol
+  symbol as $symbol
 } from "@clack/prompts";
 import { styleText } from "node:util";
 
-// src/clack-utils.ts
+// src/prompts/clack-utils.ts
 import {
   cancel,
   isCancel
@@ -80,14 +74,14 @@ function throwGoBackOnCancel(value) {
   return value;
 }
 
-// src/clack-select.ts
+// src/prompts/clack-select.ts
 async function select(opts) {
   const selectOpts = {
     options: opts.options,
     render() {
       const withGuide = settings.withGuide;
       const header = `${withGuide ? `${styleText("gray", S_BAR)}
-` : ""}${symbol(this.state)}  ${opts.message}
+` : ""}${$symbol(this.state)}  ${opts.message}
 `;
       const selected = this.options[this.cursor];
       switch (this.state) {
@@ -168,309 +162,173 @@ function resolveFeature(options, value) {
   return option;
 }
 
-// src/features/api-subset/official.ts
-var Official = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Stable, documented API only", promptLabel: "Official API", settingValue: "official" });
-  }
-};
-
-// src/features/api-subset/with-unofficial.ts
-var WithUnofficial = class extends FeatureOption {
+// src/features/preset/official-sample.ts
+var OFFICIAL_SAMPLE_PRESET = "official-sample";
+var OFFICIAL_SAMPLE_ANSWER_KEYS = [
+  "authorGitHubName",
+  "authorName",
+  "defaultBranch",
+  "fundingPlatform",
+  "fundingUrl",
+  "fundingUsername",
+  "pluginDescription",
+  "pluginId",
+  "pluginName",
+  "preset"
+];
+var OfficialSample = class extends FeatureOption {
   constructor() {
-    super({ promptHint: "Includes internal undocumented APIs (for experienced devs)", promptLabel: "Official + Unofficial", settingValue: "with-unofficial" });
-  }
-  configure(builder) {
-    builder.addPackage("@obsidian-typings/obsidian-public-latest");
+    super({
+      promptHint: "Exactly obsidianmd/obsidian-sample-plugin, with your plugin's id, name, author and description filled in",
+      promptLabel: "Official sample plugin",
+      settingValue: OFFICIAL_SAMPLE_PRESET
+    });
   }
 };
-
-// src/features/api-subset/index.ts
-var API_SUBSET_OPTIONS = [new Official(), new WithUnofficial()];
-async function promptApiSubset(savedValue) {
-  return promptFeature({ defaultOption: new Official(), message: "Obsidian API subset", options: API_SUBSET_OPTIONS, savedValue });
+function isOfficialSamplePreset(preset) {
+  return preset === OFFICIAL_SAMPLE_PRESET;
 }
 
-// src/features/preset/is-dev-utils-preset.ts
-var DEV_UTILS_PRESETS = /* @__PURE__ */ new Set(["demo", "enhanced"]);
-function isDevUtilsPreset(preset) {
-  return DEV_UTILS_PRESETS.has(preset);
-}
+// src/answers/cli-args.ts
+import {
+  existsSync,
+  readFileSync
+} from "node:fs";
 
-// src/features/bundler/esbuild.ts
-var Esbuild = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Fast and simple (recommended)", promptLabel: "esbuild", settingValue: "esbuild" });
-  }
-  configure(builder, answers) {
-    builder.addPackage("esbuild");
-    if (isDevUtilsPreset(answers.preset)) {
-      builder.addFiles(["scripts/esbuild-plugins.ts"]);
+// src/directory/directory-constraints.ts
+var CORE_FEATURE_NAMES = [
+  "Audio recorder",
+  "Backlinks",
+  "Bases",
+  "Bookmarks",
+  "Canvas",
+  "Command palette",
+  "Daily notes",
+  "File recovery",
+  "Files",
+  "Footnotes",
+  "Format converter",
+  "Graph view",
+  "Live Preview",
+  "Note composer",
+  "Outgoing links",
+  "Outline",
+  "Page preview",
+  "Properties view",
+  "Publish",
+  "Quick Switcher",
+  "Random note",
+  "Reading view",
+  "Search",
+  "Slash commands",
+  "Slides",
+  "Source mode",
+  "Sync",
+  "Tags view",
+  "Templates",
+  "Unique note creator",
+  "Web viewer",
+  "Word count",
+  "Workspaces"
+];
+var MAX_DESCRIPTION_LENGTH = 250;
+var MIN_DESCRIPTION_LENGTH = 10;
+var ALLOWED_ID_CHARACTERS = /^[a-z0-9-]+$/;
+var ALLOWED_NAME_CHARACTERS = /^[A-Za-z0-9 \-+()]+$/;
+var EMOJI = /\p{Extended_Pictographic}/u;
+var OBSIDIAN_WORD = /\bobsidian\b/i;
+var OBSIDIAN_NAME_VARIANTS = /obsi|sidian/i;
+var SELF_REFERENCE_PATTERNS = [
+  /\bthis plugin\b/i,
+  /\bthis is a plugin\b/i,
+  /\ba plugin (?:that|which)\b/i,
+  /^the plugin\b/i,
+  /^plugin\b/i
+];
+function findUnlistableManifestAnswers(answers) {
+  const checked = [
+    { key: "pluginId", message: validatePluginId(answers.pluginId), value: answers.pluginId },
+    { key: "pluginName", message: validatePluginName(answers.pluginName), value: answers.pluginName },
+    { key: "pluginDescription", message: validatePluginDescription(answers.pluginDescription), value: answers.pluginDescription }
+  ];
+  const problems = [];
+  for (const { key, message, value } of checked) {
+    if (message !== void 0) {
+      problems.push({ key, message, value });
     }
   }
-};
-
-// src/features/bundler/parcel.ts
-var Parcel = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Zero-config bundler", promptLabel: "Parcel", settingValue: "parcel" });
+  return problems;
+}
+function validatePluginDescription(input) {
+  if (!input) {
+    return "Should not be empty";
   }
-  configure(builder) {
-    builder.addPackage("parcel").addDepcheckIgnore("parcel", "run as a CLI by the build script.").addPackage("@parcel/config-default").addDepcheckIgnore("@parcel/config-default", "extended by name in `.parcelrc`.").addPackage("@parcel/plugin").addFiles([
-      ".parcelrc",
-      "parcel-namer-obsidian.cjs",
-      "parcel-resolver-obsidian.cjs",
-      "parcel-transformer-inline-imports.cjs"
-    ]);
-    builder.addPartial("cli-bundler");
+  if (EMOJI.test(input)) {
+    return "Should not contain emoji -- the Community directory rejects them, though it does accept ordinary punctuation such as backticks, em dashes and parentheses";
   }
-};
-
-// src/features/bundler/rollup.ts
-var Rollup = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Flexible with plugin ecosystem", promptLabel: "Rollup", settingValue: "rollup" });
+  if (OBSIDIAN_WORD.test(input)) {
+    return 'Should not contain the word "Obsidian" -- the Community directory rejects it as implied by the plugin directory, even though no Obsidian document says so';
   }
-  configure(builder) {
-    builder.addPackage("@rollup/plugin-commonjs").addPackage("@rollup/plugin-node-resolve").addPackage("@rollup/plugin-typescript").addPackage("@rollup/plugin-terser").addPackage("rollup").addFiles([
-      "rollup.config.mjs",
-      "scripts/rollup.config.ts"
-    ]);
-    builder.addPartial("cli-bundler");
+  if (SELF_REFERENCE_PATTERNS.some((pattern) => pattern.test(input))) {
+    return 'Should say what the plugin does rather than refer to itself -- the Community directory rejects "This plugin..." and "a plugin that...". Naming another plugin is fine';
   }
-};
-
-// src/features/bundler/vite.ts
-var Vite = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Modern dev server with HMR", promptLabel: "Vite", settingValue: "vite" });
+  if (input.length < MIN_DESCRIPTION_LENGTH) {
+    return `Should be at least ${String(MIN_DESCRIPTION_LENGTH)} characters, so it says what the plugin does`;
   }
-  configure(builder) {
-    builder.addPackage("vite").addFiles([
-      "vite.config.ts",
-      "scripts/vite.config.ts"
-    ]);
-    builder.addPartial("cli-bundler");
+  if (input.length > MAX_DESCRIPTION_LENGTH) {
+    return `Should be at most ${String(MAX_DESCRIPTION_LENGTH)} characters -- the Community directory rejects a longer one`;
   }
-};
-
-// src/features/bundler/webpack.ts
-var Webpack = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Mature bundler with broad plugin support", promptLabel: "Webpack", settingValue: "webpack" });
+  if (!/^[A-Z]/.test(input)) {
+    return 'Should start with a capital letter, ideally on an action verb: "Translates selected text...", "Imports notes from..."';
   }
-  configure(builder) {
-    builder.addPackage("webpack").addPackage("webpack-cli").addDepcheckIgnore("webpack-cli", "what `npx webpack` in the build script runs.").addPackage("terser-webpack-plugin").addPackage("ts-loader").addDepcheckIgnore("ts-loader", "named as a loader string in `scripts/webpack.config.ts`.").addFiles([
-      "webpack.config.ts",
-      "scripts/webpack.config.ts"
-    ]);
-    builder.addPartial("cli-bundler");
+  if (!input.endsWith(".")) {
+    return "Should end with a dot";
   }
-};
-
-// src/features/bundler/index.ts
-var BUNDLER_OPTIONS = [new Esbuild(), new Parcel(), new Rollup(), new Vite(), new Webpack()];
-async function promptBundler(savedValue) {
-  return promptFeature({ defaultOption: new Esbuild(), message: "Bundler", options: BUNDLER_OPTIONS, savedValue });
-}
-
-// src/features/git-hooks.ts
-function addHusky(builder) {
-  builder.addPackage("husky").addDepcheckIgnore("husky", "run as a CLI by `scripts/prepare.ts`; the hooks in `.husky/` are its output.").addScript("prepare").addFiles(["scripts/prepare.ts"]);
-}
-function addStagedFilesHook(builder) {
-  addHusky(builder);
-  builder.addPackage("nano-staged").addDepcheckIgnore("nano-staged", "`.husky/pre-commit` runs it; configured by `scripts/nano-staged-config.ts`.").addFiles([
-    ".husky/pre-commit",
-    ".nano-staged.mjs",
-    "scripts/nano-staged-config.ts"
-  ]);
+  return void 0;
 }
-
-// src/features/commit-linting/conventional-commits.ts
-var ConventionalCommits = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "commitlint + a husky commit-msg hook", promptLabel: "Conventional Commits", settingValue: "conventional-commits" });
+function validatePluginId(input) {
+  if (!input) {
+    return "Should not be empty";
   }
-  configure(builder) {
-    addHusky(builder);
-    builder.addPackage("@commitlint/cli").addDepcheckIgnore("@commitlint/cli", "`.husky/commit-msg` runs it as the `commitlint` binary.").addPackage("@commitlint/config-conventional").addDepcheckIgnore("@commitlint/config-conventional", "extended by name (a string in the `extends` of `scripts/commitlint-config.ts`), never imported.").addPackage("@commitlint/types").addPackage("czg").addDepcheckIgnore("czg", "run as a CLI by `scripts/commit.ts`.").addScript("commit").addFiles([
-      "commitlint.config.ts",
-      "scripts/commit.ts",
-      "scripts/commitlint-config.ts",
-      ".husky/commit-msg"
-    ]);
+  if (!ALLOWED_ID_CHARACTERS.test(input)) {
+    return "Should contain only lowercase English letters, digits and hyphens";
   }
-};
-
-// src/features/commit-linting/none.ts
-var None = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "No commit linting", promptLabel: "(none)", settingValue: "none" });
+  if (!/^[a-z]/.test(input)) {
+    return "Should start with a letter";
   }
-};
-
-// src/features/commit-linting/index.ts
-var COMMIT_LINTING_OPTIONS = [new None(), new ConventionalCommits()];
-async function promptCommitLinting(savedValue) {
-  return promptFeature({ defaultOption: new ConventionalCommits(), message: "Commit linting", options: COMMIT_LINTING_OPTIONS, savedValue });
-}
-
-// src/features/coverage-badge/coverage-badge.ts
-var CoverageBadge = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: 'A "coverage: 100%" README badge', promptLabel: "Coverage badge", settingValue: "coverage-badge" });
+  if (!/[a-z0-9]$/.test(input)) {
+    return "Should end with a letter or digit";
   }
-  configure(builder, answers) {
-    builder.addBadge(
-      `[![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/${answers.authorGitHubName}/obsidian-${answers.pluginId})`
-    );
+  if (input.includes("obsidian")) {
+    return 'Should not contain "obsidian" anywhere -- the Community directory rejects it as implied by the plugin directory, and an id can never be changed once the plugin is published';
   }
-};
-
-// src/features/coverage-badge/none.ts
-var None2 = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "No coverage badge", promptLabel: "(none)", settingValue: "none" });
+  if (input.endsWith("plugin")) {
+    return 'Should not end with "plugin" -- the Community directory rejects it as implied, and an id can never be changed once the plugin is published';
   }
-};
-
-// src/features/coverage-badge/index.ts
-var COVERAGE_BADGE_OPTIONS = [new None2(), new CoverageBadge()];
-async function promptCoverageBadge(savedValue) {
-  return promptFeature({ defaultOption: new None2(), message: "Coverage badge", options: COVERAGE_BADGE_OPTIONS, savedValue });
+  return void 0;
 }
-
-// src/features/e2e-test-runner/none.ts
-var None3 = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "No E2E testing", promptLabel: "(none)", settingValue: "none" });
-  }
-};
-
-// src/features/e2e-test-runner/obsidian-test.ts
-var ObsidianTest = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Tests run inside Obsidian with real app APIs", promptLabel: "obsidian-test", settingValue: "obsidian-test" });
+function validatePluginName(input) {
+  if (!input) {
+    return "Should not be empty";
   }
-  configure(builder) {
-    builder.addPackage("obsidian-test").addScript("test:e2e").addFiles([
-      "e2e/sample.spec.ts",
-      "scripts/test-e2e.ts"
-    ]).addPartial("has-e2e");
+  if (OBSIDIAN_NAME_VARIANTS.test(input)) {
+    return 'Should not contain "Obsidian" or an abbreviation of it ("Obsi", "sidian") -- the Community directory rejects it as implied by the plugin directory';
   }
-};
-
-// src/features/e2e-test-runner/wdio-obsidian.ts
-var WdioObsidian = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "WebdriverIO service for Obsidian, multi-version & CI/CD", promptLabel: "wdio-obsidian", settingValue: "wdio-obsidian" });
-  }
-  configure(builder) {
-    builder.addPackage("@wdio/cli").addDepcheckIgnore("@wdio/cli", "run as the `wdio` CLI by `scripts/test-e2e.ts`.").addPackage("@wdio/globals").addPackage("@wdio/mocha-framework").addPackage("expect-webdriverio").addPackage("wdio-obsidian-service").addScript("test:e2e").addFiles([
-      "wdio.conf.ts",
-      "e2e/sample.spec.ts",
-      "scripts/test-e2e.ts"
-    ]).addPartial("has-e2e");
-  }
-};
-
-// src/features/e2e-test-runner/index.ts
-var E2E_TEST_RUNNER_OPTIONS = [new None3(), new ObsidianTest(), new WdioObsidian()];
-async function promptE2eTestRunner(savedValue) {
-  return promptFeature({ defaultOption: new None3(), message: "E2E testing", options: E2E_TEST_RUNNER_OPTIONS, savedValue });
-}
-
-// src/features/editor-extensions/code-mirror.ts
-var CodeMirror = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "CodeMirror 6 state fields, view plugins, decorations", promptLabel: "CodeMirror", settingValue: "codemirror" });
-  }
-  configure(builder) {
-    builder.addPackage("@codemirror/state").addPackage("@codemirror/view").addFiles([
-      "src/editor-extensions/sample-state-field.ts",
-      "src/editor-extensions/sample-view-plugin.ts",
-      "src/editor-extensions/sample-widget.ts",
-      "src/editor-suggests/sample-editor-suggest.ts"
-    ]);
-  }
-};
-
-// src/features/editor-extensions/none.ts
-var None4 = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "No editor extensions", promptLabel: "(none)", settingValue: "none" });
-  }
-};
-
-// src/features/editor-extensions/index.ts
-var EDITOR_EXTENSIONS_OPTIONS = [new None4(), new CodeMirror()];
-async function promptEditorExtensions(savedValue) {
-  return promptFeature({ defaultOption: new None4(), message: "Editor extensions", options: EDITOR_EXTENSIONS_OPTIONS, savedValue });
-}
-
-// src/features/formatter/biome.ts
-var Biome = class extends FeatureOption {
-  constructor() {
-    super({ partialName: "biome-formatter", promptHint: "Fast formatter (pairs with Biome linter)", promptLabel: "Biome", settingValue: "biome" });
-  }
-  configure(builder, answers) {
-    if (answers.linter !== "biome") {
-      builder.addLintStagedCommand("*.{ts,tsx,mts}", "biome format --write --no-errors-on-unmatched");
-    }
-    builder.addPackage("@biomejs/biome").addDepcheckIgnore("@biomejs/biome", "run as the `biome` CLI by the format and lint scripts, configured by `biome.jsonc`.").addScript("format").addScript("format:check").addFiles([
-      "biome.jsonc",
-      "scripts/format.ts",
-      "scripts/format-check.ts"
-    ]);
-  }
-};
-
-// src/features/formatter/dprint.ts
-var Dprint = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Fast, pluggable, written in Rust", promptLabel: "dprint", settingValue: "dprint" });
-  }
-  configure(builder) {
-    builder.addLintStagedCommand("*.{ts,tsx,mts}", "dprint fmt").addPackage("dprint").addDepcheckIgnore("dprint", "run as a CLI by the format scripts, configured by `dprint.json`.").addScript("format").addScript("format:check").addFiles([
-      "dprint.json",
-      "scripts/format.ts",
-      "scripts/format-check.ts"
-    ]);
-  }
-};
-
-// src/features/formatter/none.ts
-var None5 = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "No formatting", promptLabel: "(none)", settingValue: "none" });
+  if (input.toLowerCase().includes("plugin")) {
+    return 'Should not contain "Plugin" -- the Community directory rejects it as implied by the plugin directory';
   }
-};
-
-// src/features/formatter/prettier.ts
-var Prettier = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Opinionated, widely adopted", promptLabel: "Prettier", settingValue: "prettier" });
+  const coreName = findCoreFeatureName(input);
+  if (coreName !== void 0) {
+    return `Should not be the name of an Obsidian core plugin or core feature -- "${coreName}" is one, and the Community directory rejects a name that takes it`;
   }
-  configure(builder) {
-    builder.addLintStagedCommand("*.{ts,tsx,mts}", "prettier --write").addPackage("prettier").addScript("format").addScript("format:check").addFiles([
-      ".prettierignore",
-      "prettier.config.mjs",
-      "scripts/prettier.config.ts",
-      "scripts/format.ts",
-      "scripts/format-check.ts"
-    ]);
+  if (!ALLOWED_NAME_CHARACTERS.test(input)) {
+    return "Should use Basic Latin letters and digits only, with hyphens, plus signs and parentheses the only punctuation the Community directory accepts";
   }
-};
-
-// src/features/formatter/index.ts
-var FORMATTER_OPTIONS = [new None5(), new Biome(), new Dprint(), new Prettier()];
-var FORMATTERS_NEEDING_INITIAL_FORMAT = /* @__PURE__ */ new Set(["biome", "prettier"]);
-function needsInitialFormat(formatter) {
-  return FORMATTERS_NEEDING_INITIAL_FORMAT.has(formatter);
+  return void 0;
 }
-async function promptFormatter(savedValue) {
-  return promptFeature({ defaultOption: new Dprint(), message: "Formatter", options: FORMATTER_OPTIONS, savedValue });
+function findCoreFeatureName(name) {
+  const normalized = name.trim().toLowerCase();
+  return CORE_FEATURE_NAMES.find((candidate) => candidate.toLowerCase() === normalized);
 }
 
 // src/features/funding-platform/funding-platform-option.ts
@@ -546,186 +404,534 @@ var Custom = class extends FundingPlatformOption {
   }
 };
 
-// src/features/funding-platform/github-sponsors.ts
-var GitHubSponsors = class extends FundingPlatformOption {
+// src/features/funding-platform/github-sponsors.ts
+var GitHubSponsors = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "ea4aaa",
+      badgeLabel: "GitHub Sponsors",
+      badgeLogo: "githubsponsors",
+      badgeLogoColor: "white",
+      fundingYmlKey: "github",
+      promptHint: "github.com/sponsors/<username>",
+      promptLabel: "GitHub Sponsors",
+      settingValue: "github-sponsors"
+    });
+  }
+  getUrl(answers) {
+    return `https://github.com/sponsors/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/ko-fi.ts
+var KoFi = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "ff5e5b",
+      badgeLabel: "Ko-fi",
+      badgeLogo: "kofi",
+      badgeLogoColor: "white",
+      fundingYmlKey: "ko_fi",
+      promptHint: "ko-fi.com/<username>",
+      promptLabel: "Ko-fi",
+      settingValue: "ko-fi"
+    });
+  }
+  getUrl(answers) {
+    return `https://ko-fi.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/liberapay.ts
+var Liberapay = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "f6c915",
+      badgeLabel: "Liberapay",
+      badgeLogo: "liberapay",
+      badgeLogoColor: "black",
+      fundingYmlKey: "liberapay",
+      promptHint: "liberapay.com/<username>",
+      promptLabel: "Liberapay",
+      settingValue: "liberapay"
+    });
+  }
+  getUrl(answers) {
+    return `https://liberapay.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/none.ts
+var None = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "",
+      badgeLabel: "",
+      fundingYmlKey: "",
+      promptHint: "No funding link, FUNDING.yml or badge",
+      promptLabel: "(none)",
+      settingValue: "none"
+    });
+  }
+  getUrl() {
+    return "";
+  }
+};
+
+// src/features/funding-platform/open-collective.ts
+var OpenCollective = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "7fadf2",
+      badgeLabel: "Open Collective",
+      badgeLogo: "opencollective",
+      badgeLogoColor: "white",
+      fundingYmlKey: "open_collective",
+      promptHint: "opencollective.com/<username>",
+      promptLabel: "Open Collective",
+      settingValue: "open-collective"
+    });
+  }
+  getUrl(answers) {
+    return `https://opencollective.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/patreon.ts
+var Patreon = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "f96854",
+      badgeLabel: "Patreon",
+      badgeLogo: "patreon",
+      badgeLogoColor: "white",
+      fundingYmlKey: "patreon",
+      promptHint: "patreon.com/<username>",
+      promptLabel: "Patreon",
+      settingValue: "patreon"
+    });
+  }
+  getUrl(answers) {
+    return `https://www.patreon.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/polar.ts
+var Polar = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "0062ff",
+      badgeLabel: "Polar",
+      fundingYmlKey: "polar",
+      promptHint: "polar.sh/<username>",
+      promptLabel: "Polar",
+      settingValue: "polar"
+    });
+  }
+  getUrl(answers) {
+    return `https://polar.sh/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/thanks-dev.ts
+var ThanksDev = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "000000",
+      badgeLabel: "thanks.dev",
+      fundingYmlKey: "thanks_dev",
+      promptHint: "thanks.dev/<username>, e.g. u/gh/<GitHub username>",
+      promptLabel: "thanks.dev",
+      settingValue: "thanks-dev"
+    });
+  }
+  getUrl(answers) {
+    return `https://thanks.dev/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/index.ts
+var FUNDING_PLATFORM_OPTIONS = [
+  new None(),
+  new BuyMeACoffee(),
+  new GitHubSponsors(),
+  new KoFi(),
+  new Liberapay(),
+  new OpenCollective(),
+  new Patreon(),
+  new Polar(),
+  new ThanksDev(),
+  new Custom()
+];
+function asksFundingUsername(platform) {
+  return platform !== void 0 && platform !== "none" && platform !== "custom";
+}
+async function promptFundingPlatform(savedValue) {
+  return promptFeature({ defaultOption: new BuyMeACoffee(), message: "Funding platform", options: FUNDING_PLATFORM_OPTIONS, savedValue });
+}
+function resolveFunding(answers) {
+  const option = FUNDING_PLATFORM_OPTIONS.find((candidate) => candidate.settingValue === answers.fundingPlatform);
+  if (!option?.getUrl(answers)) {
+    return null;
+  }
+  return option;
+}
+function validateFundingUsername(value) {
+  if (!value) {
+    return "Should not be empty";
+  }
+  if (!/^[\w./-]+$/.test(value)) {
+    return "Use only letters, digits, `.`, `_`, `-` and `/`";
+  }
+  return void 0;
+}
+
+// src/prompts/prompts.ts
+import {
+  cancel as cancel2,
+  log
+} from "@clack/prompts";
+import { styleText as styleText3 } from "node:util";
+
+// src/features/api-subset/official.ts
+var Official = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Stable, documented API only", promptLabel: "Official API", settingValue: "official" });
+  }
+};
+
+// src/features/api-subset/with-unofficial.ts
+var WithUnofficial = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Includes internal undocumented APIs (for experienced devs)", promptLabel: "Official + Unofficial", settingValue: "with-unofficial" });
+  }
+  configure(builder) {
+    builder.addPackage("@obsidian-typings/obsidian-public-latest");
+  }
+};
+
+// src/features/api-subset/index.ts
+var API_SUBSET_OPTIONS = [new Official(), new WithUnofficial()];
+async function promptApiSubset(savedValue) {
+  return promptFeature({ defaultOption: new Official(), message: "Obsidian API subset", options: API_SUBSET_OPTIONS, savedValue });
+}
+
+// src/features/preset/is-framework-preset.ts
+var FRAMEWORK_PRESETS = /* @__PURE__ */ new Set(["all-in-one", "demo", "docs-showcase"]);
+function isFrameworkPreset(preset) {
+  return FRAMEWORK_PRESETS.has(preset);
+}
+
+// src/features/bundler/esbuild.ts
+var Esbuild = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Fast and simple (recommended)", promptLabel: "esbuild", settingValue: "esbuild" });
+  }
+  configure(builder, answers) {
+    if (isFrameworkPreset(answers.preset)) {
+      return;
+    }
+    builder.addPackage("esbuild");
+  }
+};
+
+// src/features/bundler/parcel.ts
+var Parcel = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Zero-config bundler", promptLabel: "Parcel", settingValue: "parcel" });
+  }
+  configure(builder, answers) {
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPackage("@parcel/core").addPackage("@parcel/config-default").addDepcheckIgnore("@parcel/config-default", "extended by name by the `.parcelrc` obsidian-dev-toolkit writes.").addPackage("@parcel/plugin").addDepcheckIgnore("@parcel/plugin", "the base of the parcel plugins obsidian-dev-toolkit registers; nothing here imports it.").addPartial("parcel-adapter");
+      return;
+    }
+    builder.addPackage("parcel").addDepcheckIgnore("parcel", "run as a CLI by the build script.").addPackage("@parcel/config-default").addDepcheckIgnore("@parcel/config-default", "extended by name in `.parcelrc`.").addPackage("@parcel/plugin").addFiles([
+      ".parcelrc",
+      "parcel-namer-obsidian.cjs",
+      "parcel-resolver-obsidian.cjs",
+      "parcel-transformer-inline-imports.cjs"
+    ]).addPartial("parcel-targets").addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/rollup.ts
+var Rollup = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Flexible with plugin ecosystem", promptLabel: "Rollup", settingValue: "rollup" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("@rollup/plugin-commonjs").addPackage("@rollup/plugin-node-resolve").addPackage("rollup").addFiles([
+      "rollup.config.mjs",
+      "scripts/rollup.config.ts"
+    ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPackage("esbuild").addDepcheckIgnore("esbuild", "the peer dependency `rollup-plugin-esbuild` runs; nothing imports it.").addPackage("rollup-plugin-esbuild").addPartial("adapter-cli");
+      return;
+    }
+    builder.addPackage("@rollup/plugin-typescript").addPackage("@rollup/plugin-terser").addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/vite.ts
+var Vite = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Modern dev server with HMR", promptLabel: "Vite", settingValue: "vite" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("vite").addFiles([
+      "vite.config.ts",
+      "scripts/vite.config.ts"
+    ]);
+    builder.addPartial(isFrameworkPreset(answers.preset) ? "adapter-cli" : "cli-bundler");
+  }
+};
+
+// src/features/bundler/webpack.ts
+var Webpack = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Mature bundler with broad plugin support", promptLabel: "Webpack", settingValue: "webpack" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("webpack").addPackage("webpack-cli").addDepcheckIgnore("webpack-cli", "what the build script runs as the `webpack` command.").addFiles([
+      "webpack.config.ts",
+      "scripts/webpack.config.ts"
+    ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPackage("esbuild-loader").addDepcheckIgnore("esbuild-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPartial("adapter-cli");
+      return;
+    }
+    builder.addPackage("terser-webpack-plugin").addPackage("ts-loader").addDepcheckIgnore("ts-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/index.ts
+var BUNDLER_OPTIONS = [new Esbuild(), new Parcel(), new Rollup(), new Vite(), new Webpack()];
+async function promptBundler(savedValue) {
+  return promptFeature({ defaultOption: new Esbuild(), message: "Bundler", options: BUNDLER_OPTIONS, savedValue });
+}
+
+// src/features/git-hooks.ts
+var INITIAL_COMMIT_MESSAGE = "chore: initial commit from create-obsidian-plugin";
+function addHusky(builder) {
+  builder.addPackage("husky").addDepcheckIgnore("husky", "run as a CLI by `scripts/prepare.ts`; the hooks in `.husky/` are its output.").addScript("prepare").addFiles(["scripts/prepare.ts"]);
+}
+function addStagedFilesHook(builder, preset) {
+  addHusky(builder);
+  builder.addPartial(usesToolkitNanoStagedConfig(preset) ? "toolkit-nano-staged" : "inline-nano-staged");
+  builder.addPackage("nano-staged").addDepcheckIgnore("nano-staged", "`.husky/pre-commit` runs it; configured by `scripts/nano-staged-config.ts`.").addFiles([
+    ".husky/pre-commit",
+    ".nano-staged.mjs",
+    "scripts/nano-staged-config.ts"
+  ]);
+}
+function usesToolkitNanoStagedConfig(preset) {
+  return isFrameworkPreset(preset);
+}
+
+// src/features/commit-linting/conventional-commits.ts
+var ConventionalCommits = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "commitlint + a husky commit-msg hook", promptLabel: "Conventional Commits", settingValue: "conventional-commits" });
+  }
+  configure(builder, answers) {
+    addHusky(builder);
+    builder.addPackage("@commitlint/cli").addDepcheckIgnore("@commitlint/cli", "`.husky/commit-msg` runs it as the `commitlint` binary.").addPackage("czg").addDepcheckIgnore("czg", "run as a CLI by `scripts/commit.ts`.").addScript("commit").addFiles([
+      "commitlint.config.ts",
+      "scripts/commit.ts",
+      "scripts/commitlint-config.ts",
+      ".husky/commit-msg"
+    ]);
+    if (isFrameworkPreset(answers.preset)) {
+      return;
+    }
+    builder.addPackage("@commitlint/config-conventional").addDepcheckIgnore("@commitlint/config-conventional", "extended by name (a string in the `extends` of `scripts/commitlint-config.ts`), never imported.").addPackage("@commitlint/types");
+  }
+};
+
+// src/features/commit-linting/none.ts
+var None2 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No commit linting", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/commit-linting/index.ts
+var COMMIT_LINTING_OPTIONS = [new None2(), new ConventionalCommits()];
+async function promptCommitLinting(savedValue) {
+  return promptFeature({ defaultOption: new ConventionalCommits(), message: "Commit linting", options: COMMIT_LINTING_OPTIONS, savedValue });
+}
+
+// src/features/coverage-badge/coverage-badge.ts
+var CoverageBadge = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "A coverage README badge, measured by CI where the project has one", promptLabel: "Coverage badge", settingValue: "coverage-badge" });
+  }
+  configure(builder, answers) {
+    const repoUrl = `https://github.com/${answers.authorGitHubName}/obsidian-${answers.pluginId}`;
+    if (!isMeasured(answers)) {
+      builder.addBadge(`[![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen)](${repoUrl})`);
+      return;
+    }
+    builder.addPartial("measured-coverage-badge").addBadge(
+      `[![Coverage](https://raw.githubusercontent.com/${answers.authorGitHubName}/obsidian-${answers.pluginId}/badges/coverage.svg)](${repoUrl}/actions/workflows/ci.yml)`
+    );
+  }
+};
+var CI_ANSWERS = /* @__PURE__ */ new Set(["ci", "ci-and-release"]);
+var MEASURING_TEST_RUNNERS = /* @__PURE__ */ new Set(["jest", "vitest"]);
+function isMeasured(answers) {
+  return isFrameworkPreset(answers.preset) && CI_ANSWERS.has(answers.gitHubActions) && MEASURING_TEST_RUNNERS.has(answers.testRunner);
+}
+
+// src/features/coverage-badge/none.ts
+var None3 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No coverage badge", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/coverage-badge/index.ts
+var COVERAGE_BADGE_OPTIONS = [new None3(), new CoverageBadge()];
+async function promptCoverageBadge(savedValue) {
+  return promptFeature({ defaultOption: new None3(), message: "Coverage badge", options: COVERAGE_BADGE_OPTIONS, savedValue });
+}
+
+// src/features/e2e-test-runner/none.ts
+var None4 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No E2E testing", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/e2e-test-runner/obsidian-test.ts
+var ObsidianTest = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "ea4aaa",
-      badgeLabel: "GitHub Sponsors",
-      badgeLogo: "githubsponsors",
-      badgeLogoColor: "white",
-      fundingYmlKey: "github",
-      promptHint: "github.com/sponsors/<username>",
-      promptLabel: "GitHub Sponsors",
-      settingValue: "github-sponsors"
-    });
+    super({ promptHint: "Tests run inside Obsidian with real app APIs", promptLabel: "obsidian-test", settingValue: "obsidian-test" });
   }
-  getUrl(answers) {
-    return `https://github.com/sponsors/${answers.fundingUsername}`;
+  configure(builder) {
+    builder.addPackage("obsidian-test").addScript("test:e2e").addFiles([
+      "e2e/sample.spec.ts",
+      "scripts/test-e2e.ts"
+    ]).addPartial("has-e2e");
   }
 };
 
-// src/features/funding-platform/ko-fi.ts
-var KoFi = class extends FundingPlatformOption {
+// src/features/e2e-test-runner/wdio-obsidian.ts
+var WdioObsidian = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "ff5e5b",
-      badgeLabel: "Ko-fi",
-      badgeLogo: "kofi",
-      badgeLogoColor: "white",
-      fundingYmlKey: "ko_fi",
-      promptHint: "ko-fi.com/<username>",
-      promptLabel: "Ko-fi",
-      settingValue: "ko-fi"
-    });
+    super({ promptHint: "WebdriverIO service for Obsidian, multi-version & CI/CD", promptLabel: "wdio-obsidian", settingValue: "wdio-obsidian" });
   }
-  getUrl(answers) {
-    return `https://ko-fi.com/${answers.fundingUsername}`;
+  configure(builder, answers) {
+    builder.addPackage("@wdio/cli").addDepcheckIgnore("@wdio/cli", "run as the `wdio` CLI by `scripts/test-e2e.ts`.").addPackage("@wdio/globals").addPackage("@wdio/local-runner").addDepcheckIgnore("@wdio/local-runner", "loaded by name by wdio for the config's `runner: 'local'`.").addPackage("@wdio/mocha-framework").addPackage("expect-webdriverio").addPackage("wdio-obsidian-service").addScript("test:e2e").addFiles([
+      "e2e/sample.spec.ts",
+      "scripts/test-e2e.ts"
+    ]).addPartial("has-e2e");
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPackage("wdio-obsidian-reporter").addDepcheckIgnore("wdio-obsidian-reporter", "loaded by name by wdio for the `obsidian` reporter `defineWdioObsidianConfig` names.").addFiles(["wdio.conf.mts"]);
+      return;
+    }
+    builder.addFiles(["wdio.conf.ts"]);
   }
 };
 
-// src/features/funding-platform/liberapay.ts
-var Liberapay = class extends FundingPlatformOption {
+// src/features/e2e-test-runner/index.ts
+var E2E_TEST_RUNNER_OPTIONS = [new None4(), new ObsidianTest(), new WdioObsidian()];
+async function promptE2eTestRunner(savedValue) {
+  return promptFeature({ defaultOption: new None4(), message: "E2E testing", options: E2E_TEST_RUNNER_OPTIONS, savedValue });
+}
+
+// src/features/editor-extensions/code-mirror.ts
+var CodeMirror = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "f6c915",
-      badgeLabel: "Liberapay",
-      badgeLogo: "liberapay",
-      badgeLogoColor: "black",
-      fundingYmlKey: "liberapay",
-      promptHint: "liberapay.com/<username>",
-      promptLabel: "Liberapay",
-      settingValue: "liberapay"
-    });
+    super({ promptHint: "CodeMirror 6 state fields, view plugins, decorations", promptLabel: "CodeMirror", settingValue: "codemirror" });
   }
-  getUrl(answers) {
-    return `https://liberapay.com/${answers.fundingUsername}`;
+  configure(builder) {
+    builder.addPackage("@codemirror/state").addPackage("@codemirror/view").addFiles([
+      "src/editor-extensions/sample-state-field.ts",
+      "src/editor-extensions/sample-view-plugin.ts",
+      "src/editor-extensions/sample-widget.ts",
+      "src/editor-suggests/sample-editor-suggest.ts"
+    ]);
   }
 };
 
-// src/features/funding-platform/none.ts
-var None6 = class extends FundingPlatformOption {
+// src/features/editor-extensions/none.ts
+var None5 = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "",
-      badgeLabel: "",
-      fundingYmlKey: "",
-      promptHint: "No funding link, FUNDING.yml or badge",
-      promptLabel: "(none)",
-      settingValue: "none"
-    });
-  }
-  getUrl() {
-    return "";
+    super({ promptHint: "No editor extensions", promptLabel: "(none)", settingValue: "none" });
   }
 };
 
-// src/features/funding-platform/open-collective.ts
-var OpenCollective = class extends FundingPlatformOption {
+// src/features/editor-extensions/index.ts
+var EDITOR_EXTENSIONS_OPTIONS = [new None5(), new CodeMirror()];
+async function promptEditorExtensions(savedValue) {
+  return promptFeature({ defaultOption: new None5(), message: "Editor extensions", options: EDITOR_EXTENSIONS_OPTIONS, savedValue });
+}
+
+// src/features/formatter/biome.ts
+var Biome = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "7fadf2",
-      badgeLabel: "Open Collective",
-      badgeLogo: "opencollective",
-      badgeLogoColor: "white",
-      fundingYmlKey: "open_collective",
-      promptHint: "opencollective.com/<username>",
-      promptLabel: "Open Collective",
-      settingValue: "open-collective"
-    });
+    super({ partialName: "biome-formatter", promptHint: "Fast formatter (pairs with Biome linter)", promptLabel: "Biome", settingValue: "biome" });
   }
-  getUrl(answers) {
-    return `https://opencollective.com/${answers.fundingUsername}`;
+  configure(builder, answers) {
+    if (answers.linter !== "biome") {
+      builder.addLintStagedCommand("*.{ts,tsx,mts}", "biome format --write --no-errors-on-unmatched");
+    }
+    builder.addPackage("@biomejs/biome").addDepcheckIgnore("@biomejs/biome", "run as the `biome` CLI by the format and lint scripts, configured by `biome.jsonc`.").addScript("format").addScript("format:check").addFiles([
+      "biome.jsonc",
+      "scripts/format.ts",
+      "scripts/format-check.ts"
+    ]);
   }
 };
 
-// src/features/funding-platform/patreon.ts
-var Patreon = class extends FundingPlatformOption {
+// src/features/formatter/dprint.ts
+var Dprint = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "f96854",
-      badgeLabel: "Patreon",
-      badgeLogo: "patreon",
-      badgeLogoColor: "white",
-      fundingYmlKey: "patreon",
-      promptHint: "patreon.com/<username>",
-      promptLabel: "Patreon",
-      settingValue: "patreon"
-    });
+    super({ promptHint: "Fast, pluggable, written in Rust", promptLabel: "dprint", settingValue: "dprint" });
   }
-  getUrl(answers) {
-    return `https://www.patreon.com/${answers.fundingUsername}`;
+  configure(builder) {
+    builder.addLintStagedCommand("*.{ts,tsx,mts}", "dprint fmt").addPackage("dprint").addDepcheckIgnore("dprint", "run as a CLI by the format scripts, configured by `dprint.json`.").addScript("format").addScript("format:check").addFiles([
+      "dprint.json",
+      "scripts/format.ts",
+      "scripts/format-check.ts"
+    ]);
   }
 };
 
-// src/features/funding-platform/polar.ts
-var Polar = class extends FundingPlatformOption {
+// src/features/formatter/none.ts
+var None6 = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "0062ff",
-      badgeLabel: "Polar",
-      fundingYmlKey: "polar",
-      promptHint: "polar.sh/<username>",
-      promptLabel: "Polar",
-      settingValue: "polar"
-    });
-  }
-  getUrl(answers) {
-    return `https://polar.sh/${answers.fundingUsername}`;
+    super({ promptHint: "No formatting", promptLabel: "(none)", settingValue: "none" });
   }
 };
 
-// src/features/funding-platform/thanks-dev.ts
-var ThanksDev = class extends FundingPlatformOption {
+// src/features/formatter/prettier.ts
+var Prettier = class extends FeatureOption {
   constructor() {
-    super({
-      badgeColor: "000000",
-      badgeLabel: "thanks.dev",
-      fundingYmlKey: "thanks_dev",
-      promptHint: "thanks.dev/<username>, e.g. u/gh/<GitHub username>",
-      promptLabel: "thanks.dev",
-      settingValue: "thanks-dev"
-    });
+    super({ promptHint: "Opinionated, widely adopted", promptLabel: "Prettier", settingValue: "prettier" });
   }
-  getUrl(answers) {
-    return `https://thanks.dev/${answers.fundingUsername}`;
+  configure(builder, answers) {
+    builder.addLintStagedCommand("*.{ts,tsx,mts}", "prettier --write").addPackage("prettier").addScript("format").addScript("format:check").addFiles([
+      ".prettierignore",
+      "prettier.config.mjs",
+      "scripts/format.ts",
+      "scripts/format-check.ts"
+    ]);
+    if (!isFrameworkPreset(answers.preset)) {
+      builder.addFiles(["scripts/prettier.config.ts"]);
+    }
   }
 };
 
-// src/features/funding-platform/index.ts
-var FUNDING_PLATFORM_OPTIONS = [
-  new None6(),
-  new BuyMeACoffee(),
-  new GitHubSponsors(),
-  new KoFi(),
-  new Liberapay(),
-  new OpenCollective(),
-  new Patreon(),
-  new Polar(),
-  new ThanksDev(),
-  new Custom()
-];
-function asksFundingUsername(platform) {
-  return platform !== void 0 && platform !== "none" && platform !== "custom";
-}
-async function promptFundingPlatform(savedValue) {
-  return promptFeature({ defaultOption: new BuyMeACoffee(), message: "Funding platform", options: FUNDING_PLATFORM_OPTIONS, savedValue });
-}
-function resolveFunding(answers) {
-  const option = FUNDING_PLATFORM_OPTIONS.find((candidate) => candidate.settingValue === answers.fundingPlatform);
-  if (!option?.getUrl(answers)) {
-    return null;
-  }
-  return option;
+// src/features/formatter/index.ts
+var FORMATTER_OPTIONS = [new None6(), new Biome(), new Dprint(), new Prettier()];
+var FORMATTERS_NEEDING_INITIAL_FORMAT = /* @__PURE__ */ new Set(["biome", "prettier"]);
+function needsInitialFormat(formatter) {
+  return FORMATTERS_NEEDING_INITIAL_FORMAT.has(formatter);
 }
-function validateFundingUsername(value) {
-  if (!value) {
-    return "Should not be empty";
-  }
-  if (!/^[\w./-]+$/.test(value)) {
-    return "Use only letters, digits, `.`, `_`, `-` and `/`";
-  }
-  return void 0;
+async function promptFormatter(savedValue) {
+  return promptFeature({ defaultOption: new Dprint(), message: "Formatter", options: FORMATTER_OPTIONS, savedValue });
 }
 
 // src/features/git-hub-actions/ci-and-release.ts
@@ -772,12 +978,15 @@ var BugAndFeature = class extends FeatureOption {
   // The real plugins' names, underscores and all. They used to be emitted as `bug-report.yml` and
   // `feature-request.yml`, because any `_` in a basename was read as the partial marker and the render
   // Loop silently skipped both forms; `isPartialTemplatePath` now reads only a kebab-case tail as one.
-  configure(builder) {
+  configure(builder, answers) {
     builder.addFiles([
       ".github/ISSUE_TEMPLATE/bug_report.yml",
       ".github/ISSUE_TEMPLATE/config.yml",
       ".github/ISSUE_TEMPLATE/feature_request.yml"
     ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPartial("has-bug-report-command");
+    }
   }
 };
 
@@ -806,6 +1015,11 @@ var None9 = class extends FeatureOption {
   constructor() {
     super({ promptHint: "No hot reload support", promptLabel: "(none)", settingValue: "none" });
   }
+  configure(builder, answers) {
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildOption("reload", "false");
+    }
+  }
 };
 
 // src/features/hot-reload/obsidian-cli.ts
@@ -813,6 +1027,11 @@ var ObsidianCli = class extends FeatureOption {
   constructor() {
     super({ promptHint: "Reloads via obsidian plugin:reload CLI command", promptLabel: "Obsidian CLI", settingValue: "obsidian-cli" });
   }
+  configure(builder, answers) {
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildOption("reload", "'obsidian-cli'");
+    }
+  }
 };
 
 // src/features/hot-reload/index.ts
@@ -889,7 +1108,7 @@ var Eslint = class extends FeatureOption {
       "scripts/lint.ts",
       "scripts/lint-fix.ts"
     ]);
-    if (isDevUtilsPreset(answers.preset)) {
+    if (isFrameworkPreset(answers.preset)) {
       builder.addDepcheckIgnore("typescript-eslint", "imported by nothing here -- the shared config brings its own -- but the `typescript` pin's check reads its `package.json` for the peer range.").addFiles(["scripts/eslint-config.ts"]);
       return;
     }
@@ -918,7 +1137,7 @@ var Markdownlint = class extends FeatureOption {
   configure(builder, answers) {
     builder.addLintStagedCommand("*.md", "markdownlint-cli2 --fix").addPackage("markdownlint-cli2").addDepcheckIgnore("markdownlint-cli2", "run as a CLI by the `lint:md` scripts, configured by `.markdownlint-cli2.mjs`.").addPackage("linkinator").addDepcheckIgnore("linkinator", "run as a CLI by the `lint:md` scripts.").addScript("lint:md").addScript("lint:md:fix").addFiles([
       // `markdownlint-cli2` only discovers a config named `.markdownlint-cli2.{jsonc,yaml,cjs,mjs}`, and
-      // So does obsidian-dev-utils' runner -- which copies its own `.mjs` in when it finds none, pointing
+      // So does the toolkit's runner -- which copies its own `.mjs` in when it finds none, pointing
       // At a `scripts/markdownlint-cli2-config.ts` that then has to exist. Hence this shape rather than a
       // Single `.mts` that nothing reads.
       ".markdownlint-cli2.mjs",
@@ -929,7 +1148,7 @@ var Markdownlint = class extends FeatureOption {
       // Repository, which 404 until the user pushes it.
       "linkinator.config.json"
     ]);
-    if (isDevUtilsPreset(answers.preset)) {
+    if (isFrameworkPreset(answers.preset)) {
       return;
     }
     builder.addPackage("markdownlint").addPackage("markdownlint-rule-relative-links");
@@ -1026,23 +1245,22 @@ var DEMO_VAULT_TEMPLATE_FILES = [
   "demo-vault/00 Start.md",
   "demo-vault/01 Sample commands.md",
   "demo-vault/02 Settings.md",
-  "demo-vault/Materials/01 Sample commands/Scratch note.md",
   "demo-vault/README.md",
   "demo-vault/_assets/CodeScriptToolkit/demoSetup.ts",
   "demo-vault/_assets/CodeScriptToolkit/startup.ts"
 ];
 
-// src/features/preset/demo.ts
-var Demo = class extends FeatureOption {
+// src/features/preset/all-in-one.ts
+var AllInOne = class extends FeatureOption {
   constructor() {
-    super({ promptHint: "All features enabled for demonstration", promptLabel: "Demo", settingValue: "demo" });
+    super({
+      promptHint: "Recommended. The author's framework: @mnaoumov/obsidian-lib, a library of ready-made helpers for settings, commands, modals, notices, file and link handling, and more, plus the @mnaoumov toolkits for building, linting, testing and releases",
+      promptLabel: "All-in-one Framework",
+      settingValue: "all-in-one"
+    });
   }
-  configure(builder) {
-    builder.addPackage("@tsconfig/strictest").addPackage("moment").addDepcheckIgnore("moment", "imported through `obsidian` rather than directly, and the typings of `obsidian` resolve it by name.").addPackage("obsidian-dev-utils").addPackage("obsidian-integration-testing").addScript("dev").addScript("build").addScript("build:clean").addScript("build:compile").addScript("find-overexposed").addScript("find-overexposed:fix").addScript("version").addScript("gate").addFiles([
-      // Not gated on the gitHubActions answer, and deliberately so: this attests the assets of a
-      // Published RELEASE, and the release flow is the preset's, not CI's. Every plugin compared here
-      // Ships this workflow -- they have no ci.yml at all.
-      ".github/workflows/attest-release-assets.yml",
+  configure(builder, answers) {
+    builder.addPackage("@tsconfig/strictest").addPackage("@mnaoumov/obsidian-lib").addPackage("@mnaoumov/obsidian-dev-toolkit").addPackage("@mnaoumov/typescript-dev-toolkit").addPackage("obsidian-integration-testing").addScript("dev").addScript("build").addScript("build:clean").addScript("build:compile").addScript("find-overexposed").addScript("find-overexposed:fix").addScript("version").addScript("gate").addFiles([
       // Not gated on the answers either: the shared ESLint config's `obsidianmd/validate-license` compares
       // The LICENSE year with the current one, so without this bump every project turns red on 1 January.
       ".github/workflows/update-license-year.yml",
@@ -1054,28 +1272,24 @@ var Demo = class extends FeatureOption {
       "scripts/dev.ts",
       "scripts/gate.ts",
       "scripts/version.ts",
-      "src/modals/sample-form-modal.ts",
-      "src/modals/sample-suggest-modal.ts",
       "src/plugin-settings.ts",
       "src/plugin-settings-component.ts",
       "src/plugin-settings-tab.ts",
-      "src/views/sample-view.ts",
       ...DEMO_VAULT_TEMPLATE_FILES
-    ]).addPartial("dev-utils");
+    ]).addPartial("framework");
+    if (answers.gitHubActions !== "ci-and-release") {
+      builder.addFiles([".github/workflows/attest-release-assets.yml"]);
+    }
   }
 };
 
-// src/features/preset/enhanced.ts
-var Enhanced = class extends FeatureOption {
+// src/features/preset/demo.ts
+var Demo = class extends FeatureOption {
   constructor() {
-    super({ promptHint: "Recommended. Uses obsidian-dev-utils for settings, linting, and more", promptLabel: "Enhanced", settingValue: "enhanced" });
+    super({ promptHint: "All features enabled for demonstration", promptLabel: "Demo", settingValue: "demo" });
   }
-  configure(builder) {
-    builder.addPackage("@tsconfig/strictest").addPackage("obsidian-dev-utils").addPackage("obsidian-integration-testing").addScript("dev").addScript("build").addScript("build:clean").addScript("build:compile").addScript("find-overexposed").addScript("find-overexposed:fix").addScript("version").addScript("gate").addFiles([
-      // Not gated on the gitHubActions answer, and deliberately so: this attests the assets of a
-      // Published RELEASE, and the release flow is the preset's, not CI's. Every plugin compared here
-      // Ships this workflow -- they have no ci.yml at all.
-      ".github/workflows/attest-release-assets.yml",
+  configure(builder, answers) {
+    builder.addPackage("@tsconfig/strictest").addPackage("moment").addDepcheckIgnore("moment", "imported through `obsidian` rather than directly, and the typings of `obsidian` resolve it by name.").addPackage("@mnaoumov/obsidian-lib").addPackage("@mnaoumov/typescript-lib").addPackage("@mnaoumov/obsidian-dev-toolkit").addPackage("@mnaoumov/typescript-dev-toolkit").addPackage("obsidian-integration-testing").addScript("dev").addScript("build").addScript("build:clean").addScript("build:compile").addScript("find-overexposed").addScript("find-overexposed:fix").addScript("version").addScript("gate").addFiles([
       // Not gated on the answers either: the shared ESLint config's `obsidianmd/validate-license` compares
       // The LICENSE year with the current one, so without this bump every project turns red on 1 January.
       ".github/workflows/update-license-year.yml",
@@ -1087,18 +1301,43 @@ var Enhanced = class extends FeatureOption {
       "scripts/dev.ts",
       "scripts/gate.ts",
       "scripts/version.ts",
+      "src/modals/sample-form-modal.ts",
+      "src/modals/sample-suggest-modal.ts",
       "src/plugin-settings.ts",
       "src/plugin-settings-component.ts",
       "src/plugin-settings-tab.ts",
+      "src/views/sample-view.ts",
       ...DEMO_VAULT_TEMPLATE_FILES
-    ]).addPartial("dev-utils");
+    ]).addPartial("framework");
+    if (answers.gitHubActions !== "ci-and-release") {
+      builder.addFiles([".github/workflows/attest-release-assets.yml"]);
+    }
+  }
+};
+
+// src/features/preset/docs-showcase.ts
+var DOCS_SHOWCASE_PRESET = "docs-showcase";
+var DocsShowcase = class extends FeatureOption {
+  constructor() {
+    super({
+      promptHint: "The All-in-one Framework project, plus every code block of the Obsidian developer docs as a command you can run",
+      promptLabel: "Developer docs showcase",
+      settingValue: DOCS_SHOWCASE_PRESET
+    });
+  }
+  configure(builder, answers) {
+    new AllInOne().configure(builder, answers);
+    builder.addPartial("all-in-one").addPackage("@codemirror/language").addPackage("@codemirror/state").addPackage("@codemirror/view").addScript("build:compile:typescript").addFiles(["scripts/build-compile-typescript.ts"]);
+    if (answers.testRunner === "vitest") {
+      builder.addFiles(["src/docs-showcase.desktop.integration.test.ts"]);
+    }
   }
 };
 
 // src/features/preset/standalone.ts
 var Standalone = class extends FeatureOption {
   constructor() {
-    super({ promptHint: "Standalone plugin without obsidian-dev-utils dependency", promptLabel: "Standalone", settingValue: "standalone" });
+    super({ promptHint: "Standalone plugin without the @mnaoumov library dependencies", promptLabel: "Standalone", settingValue: "standalone" });
   }
   configure(builder) {
     builder.addScript("dev").addScript("build").addScript("version").addFiles([
@@ -1111,9 +1350,10 @@ var Standalone = class extends FeatureOption {
 };
 
 // src/features/preset/index.ts
-var PRESET_OPTIONS = [new Demo(), new Enhanced(), new Standalone()];
+var PRESET_OPTIONS = [new AllInOne(), new Demo(), new DocsShowcase(), new Standalone()];
+var PRESET_PROMPT_OPTIONS = [...PRESET_OPTIONS, new OfficialSample()];
 async function promptPreset(savedValue) {
-  return promptFeature({ defaultOption: new Enhanced(), message: "Choose a preset", options: PRESET_OPTIONS, savedValue });
+  return promptFeature({ defaultOption: new AllInOne(), message: "Choose a preset", options: PRESET_PROMPT_OPTIONS, savedValue });
 }
 
 // src/features/spell-checker/cspell.ts
@@ -1142,16 +1382,25 @@ async function promptSpellChecker(savedValue) {
   return promptFeature({ defaultOption: new Cspell(), message: "Spell checker", options: SPELL_CHECKER_OPTIONS, savedValue });
 }
 
+// src/features/styling/toolkit-styles.ts
+function addToolkitStyles(builder, bundler, flag) {
+  builder.addBuildStyles(flag).addPartial("toolkit-styles");
+  if (bundler === "webpack") {
+    builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "resolved by name by obsidian-dev-toolkit's webpack plugin for the stylesheet rule.").addPackage("mini-css-extract-plugin").addDepcheckIgnore("mini-css-extract-plugin", "applied by obsidian-dev-toolkit's webpack plugin to extract `styles.css`.");
+  }
+}
+
 // src/features/styling/css-modules.ts
 var CssModules = class extends FeatureOption {
   constructor() {
     super({ promptHint: "Scoped CSS with .module.css files", promptLabel: "CSS Modules", settingValue: "css-modules" });
   }
   configure(builder, answers) {
-    builder.addFiles([
-      "src/styles/main.module.css",
-      "src/styles/css-modules.d.ts"
-    ]);
+    builder.addFiles(["src/styles/css-modules.d.ts", "src/styles/main.module.css", "src/styles/sample-css-module-command.ts"]);
+    if (isFrameworkPreset(answers.preset)) {
+      addToolkitStyles(builder, answers.bundler, "cssModules");
+      return;
+    }
     if (answers.bundler === "rollup") {
       builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
     }
@@ -1167,7 +1416,12 @@ var Css = class extends FeatureOption {
     super({ promptHint: "Plain CSS styles", promptLabel: "CSS", settingValue: "css" });
   }
   configure(builder, answers) {
-    builder.addFiles(["src/styles/main.css", "src/styles/styles.d.ts"]);
+    builder.addFiles(["src/styles/main.css"]);
+    if (isFrameworkPreset(answers.preset)) {
+      addToolkitStyles(builder, answers.bundler);
+      return;
+    }
+    builder.addFiles(["src/styles/styles.d.ts"]);
     if (answers.bundler === "rollup") {
       builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
     }
@@ -1193,9 +1447,13 @@ var PostCss = class extends FeatureOption {
     builder.addPackage("autoprefixer").addPackage("postcss").addFiles([
       "postcss.config.cjs",
       "scripts/postcss.config.ts",
-      "src/styles/main.css",
-      "src/styles/styles.d.ts"
+      "src/styles/main.css"
     ]);
+    if (isFrameworkPreset(answers.preset)) {
+      addToolkitStyles(builder, answers.bundler, "postcss");
+      return;
+    }
+    builder.addFiles(["src/styles/styles.d.ts"]);
     if (answers.bundler === "esbuild") {
       builder.addPackage("esbuild-postcss");
     }
@@ -1226,8 +1484,13 @@ var Scss = class extends FeatureOption {
     super({ promptHint: "Sass/SCSS preprocessor", promptLabel: "SCSS", settingValue: "scss" });
   }
   configure(builder, answers) {
-    builder.addFiles(["src/styles/main.scss", "src/styles/styles.d.ts"]);
-    const plugin = isDevUtilsPreset(answers.preset) && answers.bundler === "esbuild" ? void 0 : SCSS_PLUGINS[answers.bundler];
+    builder.addFiles(["src/styles/main.scss"]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPartial("toolkit-styles");
+    } else {
+      builder.addFiles(["src/styles/styles.d.ts"]);
+    }
+    const plugin = isFrameworkPreset(answers.preset) && answers.bundler === "esbuild" ? void 0 : SCSS_PLUGINS[answers.bundler];
     if (plugin) {
       builder.addPackage(plugin);
       const depcheckReason = SCSS_PLUGIN_DEPCHECK_REASONS[answers.bundler];
@@ -1239,7 +1502,10 @@ var Scss = class extends FeatureOption {
       builder.addPackage("sass-embedded").addDepcheckIgnore("sass-embedded", "the Sass compiler `esbuild-sass-plugin` peers on; nothing imports it directly.");
     }
     if (answers.bundler === "webpack") {
-      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPackage("sass").addDepcheckIgnore("sass", "the Sass compiler `sass-loader` resolves by name; nothing imports it directly.").addPartial("webpack-css-extract");
+      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPackage("sass").addDepcheckIgnore("sass", "the Sass compiler `sass-loader` resolves by name; nothing imports it directly.");
+      if (!isFrameworkPreset(answers.preset)) {
+        builder.addPartial("webpack-css-extract");
+      }
     }
   }
 };
@@ -1250,11 +1516,16 @@ var Tailwind = class extends FeatureOption {
     super({ promptHint: "Utility-first CSS framework", promptLabel: "Tailwind CSS", settingValue: "tailwind" });
   }
   configure(builder, answers) {
-    builder.addPackage("@tailwindcss/cli").addDepcheckIgnore("@tailwindcss/cli", "run as a CLI by `scripts/build-styles.ts`.").addPackage("tailwindcss").addDepcheckIgnore("tailwindcss", 'imported by `src/styles/main.css` (`@import "tailwindcss"`), which depcheck does not read.').addScript("build:styles").addFiles([
+    builder.addPackage("tailwindcss").addDepcheckIgnore("tailwindcss", 'imported by `src/styles/main.css` (`@import "tailwindcss"`), which depcheck does not read.').addFiles(["src/styles/main.css"]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addPackage("@tailwindcss/postcss").addDepcheckIgnore("@tailwindcss/postcss", "loaded by obsidian-dev-toolkit for its `styles.tailwind` build option.");
+      addToolkitStyles(builder, answers.bundler, "tailwind");
+      return;
+    }
+    builder.addPackage("@tailwindcss/cli").addDepcheckIgnore("@tailwindcss/cli", "run as a CLI by `scripts/build-styles.ts`.").addScript("build:styles").addFiles([
       "scripts/build-styles.ts",
-      "src/styles/main.css",
       "src/styles/styles.d.ts"
-    ]);
+    ]).addPartial("tailwind-cli");
     if (answers.bundler === "rollup") {
       builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
     }
@@ -1273,12 +1544,12 @@ async function promptStyling(savedValue) {
 // src/features/test-runner/sample-unit-tests.ts
 function addSampleUnitTests(builder, answers) {
   builder.addFiles(["src/main.test.ts"]);
-  if (!isDevUtilsPreset(answers.preset)) {
+  if (!isFrameworkPreset(answers.preset)) {
     return;
   }
-  builder.addFiles(["src/plugin-settings-component.test.ts"]);
+  builder.addFiles(["src/plugin-settings-component.test.ts"]).addPackage("@mnaoumov/typescript-lib");
   if (answers.preset === "demo") {
-    builder.addFiles(["src/plugin-settings.test.ts"]);
+    builder.addFiles(["src/plugin-settings.test.ts"]).addPackage("@mnaoumov/typescript-test-toolkit");
   }
 }
 
@@ -1288,7 +1559,9 @@ var Jest = class extends FeatureOption {
     super({ promptHint: "Feature-rich, widely adopted", promptLabel: "Jest", settingValue: "jest" });
   }
   configure(builder, answers) {
-    builder.addPackage("@types/jest").addPackage("jest").addPackage("jest-environment-jsdom").addDepcheckIgnore("jest-environment-jsdom", "named by `testEnvironment` in `jest.config.ts`, never imported.").addPackage("obsidian-test-mocks").addPackage("ts-jest").addScript("test").addScript("test:watch").addFiles([
+    const isFramework = isFrameworkPreset(answers.preset);
+    const configNames = isFramework ? "`defineObsidianPluginJestConfig` from @mnaoumov/obsidian-dev-toolkit" : "`jest.config.ts`";
+    builder.addPackage("@types/jest").addPackage("jest").addPackage("jest-environment-jsdom").addDepcheckIgnore("jest-environment-jsdom", `named by \`testEnvironment\` in ${configNames}, never imported.`).addPackage("obsidian-test-mocks").addPackage("ts-jest").addDepcheckIgnore("ts-jest", `named as the TypeScript transform by ${configNames}, never imported.`).addScript("test").addScript("test:watch").addFiles([
       "jest.config.ts",
       "scripts/framework-component-stub.ts",
       "scripts/stylesheet-stub.ts",
@@ -1297,6 +1570,9 @@ var Jest = class extends FeatureOption {
       "scripts/test.ts",
       "scripts/test-watch.ts"
     ]);
+    if (isFramework) {
+      builder.addDepcheckIgnore("obsidian-test-mocks", "mapped onto `obsidian` and loaded as a setup file by name by `defineObsidianPluginJestConfig` from @mnaoumov/obsidian-dev-toolkit.").addPackage("@jest/globals").addDepcheckIgnore("@jest/globals", "imported by `@mnaoumov/obsidian-dev-toolkit/jest-setup`, which `defineObsidianPluginJestConfig` loads.").addScript("test:coverage").addFiles(["scripts/test-coverage.ts"]);
+    }
     addSampleUnitTests(builder, answers);
   }
 };
@@ -1316,23 +1592,23 @@ var Vitest = class extends FeatureOption {
   configure(builder, answers) {
     builder.addPackage("jsdom").addPackage("obsidian-test-mocks").addDepcheckIgnore(
       "obsidian-test-mocks",
-      isDevUtilsPreset(answers.preset) ? "aliased and loaded as a setup file by name by `defineObsidianPluginVitestConfig` from obsidian-dev-utils." : "aliased and loaded as a setup file by name in `vitest.config.ts`."
+      isFrameworkPreset(answers.preset) ? "aliased and loaded as a setup file by name by `defineObsidianPluginVitestConfig` from @mnaoumov/obsidian-dev-toolkit." : "aliased and loaded as a setup file by name in `vitest.config.ts`."
     ).addPackage("vitest").addScript("test").addScript("test:watch").addFiles([
       "vitest.config.ts",
       "src/plugin.test.ts",
       "scripts/test.ts",
       "scripts/test-watch.ts",
-      // Both presets, not just the dev-utils ones: the emitted `src/plugin.ts` reaches `src/wasm/answer.ts`
-      // On every preset when the `wasm` answer is chosen, so every vitest config aliases `.wasm` to
-      // This stub. `framework-component-stub.ts` is dev-utils-only because only those presets' `plugin.ts`
-      // Reaches a single-file component.
+      // Both presets, not just the framework ones: the emitted `src/plugin.ts` reaches `src/wasm/answer.ts`
+      // On every preset when the `wasm` answer is chosen, and registers the answered view, which may be a
+      // Single-file component. So every vitest config aliases `.wasm` and `.svelte` / `.vue` to these stubs.
       "scripts/wasm-module-stub.ts",
+      "scripts/framework-component-stub.ts",
       // `src/main.test.ts` imports `src/main.ts`, which imports the stylesheet -- and on `tailwind` that
       // File does not exist until the first build. See the stub's own comment.
       "scripts/stylesheet-stub.ts"
     ]);
     addSampleUnitTests(builder, answers);
-    if (!isDevUtilsPreset(answers.preset)) {
+    if (!isFrameworkPreset(answers.preset)) {
       return;
     }
     builder.addPackage("@vitest/coverage-v8").addScript("test:coverage").addScript("test:integration").addScript("test:integration:android").addScript("test:integration:demo-vault").addScript("test:integration:desktop").addScript("test:integration:desktop:performance").addScript("test:integration:no-app").addFiles([
@@ -1340,7 +1616,6 @@ var Vitest = class extends FeatureOption {
       "scripts/test-integration-desktop.ts",
       "scripts/test-integration-desktop-performance.ts",
       "scripts/demo-vault-global-setup.ts",
-      "scripts/framework-component-stub.ts",
       "scripts/test-coverage.ts",
       "scripts/test-integration.ts",
       "scripts/test-integration-demo-vault.ts",
@@ -1392,6 +1667,10 @@ var Preact = class extends FeatureOption {
       "src/preact-components/sample-preact-component.tsx",
       "src/views/sample-preact-view.tsx"
     ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildFramework("preact").addTsconfigExtends("@mnaoumov/obsidian-dev-toolkit/tsconfig/preact.json");
+      return;
+    }
     const plugin = BUILD_PLUGINS[answers.bundler];
     if (plugin) {
       builder.addPackage(plugin);
@@ -1419,6 +1698,10 @@ var React = class extends FeatureOption {
       "src/react-components/sample-react-component.tsx",
       "src/views/sample-react-view.tsx"
     ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildFramework("react").addTsconfigExtends("@mnaoumov/obsidian-dev-toolkit/tsconfig/react.json");
+      return;
+    }
     const plugin = BUILD_PLUGINS2[answers.bundler];
     if (plugin) {
       builder.addPackage(plugin);
@@ -1446,6 +1729,10 @@ var Solid = class extends FeatureOption {
       "src/solid-components/sample-solid-component.tsx",
       "src/views/sample-solid-view.tsx"
     ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildFramework("solid").addTsconfigExtends("@mnaoumov/obsidian-dev-toolkit/tsconfig/solid.json").addPackage("@babel/core").addDepcheckIgnore("@babel/core", "loaded by obsidian-dev-toolkit to compile Solid's JSX.").addPackage("babel-preset-solid").addDepcheckIgnore("babel-preset-solid", "loaded by obsidian-dev-toolkit to compile Solid's JSX.");
+      return;
+    }
     const plugin = BUILD_PLUGINS3[answers.bundler];
     if (plugin) {
       builder.addPackage(plugin);
@@ -1487,16 +1774,17 @@ var Svelte = class extends FeatureOption {
       "src/svelte-components/sample-svelte-component.svelte",
       "src/views/sample-svelte-view.ts"
     ]);
-    const isDevUtilsEsbuild = isDevUtilsPreset(answers.preset) && answers.bundler === "esbuild";
+    builder.addPackage("svelte-check");
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildFramework("svelte").addTsconfigExtends("@mnaoumov/obsidian-dev-toolkit/tsconfig/svelte.json").addDepcheckIgnore("svelte-check", "run as a CLI by typescript-dev-toolkit's `build:compile`, which refuses to build without it declared.");
+      return;
+    }
     const plugin = getBuildPlugin(answers.bundler);
-    if (plugin !== null && !isDevUtilsEsbuild) {
+    if (plugin !== null) {
       builder.addPackage(plugin);
     }
-    builder.addPackage("svelte-check").addDepcheckIgnore(
-      "svelte-check",
-      isDevUtilsEsbuild ? "run as a CLI by obsidian-dev-utils' `build:compile`, which refuses to build without it declared." : "run as a CLI by `scripts/build.ts`."
-    );
-    if (!isDevUtilsEsbuild && SVELTE_PREPROCESS_BUNDLERS.has(answers.bundler)) {
+    builder.addDepcheckIgnore("svelte-check", "run as a CLI by `scripts/build.ts`.");
+    if (SVELTE_PREPROCESS_BUNDLERS.has(answers.bundler)) {
       builder.addPackage("svelte-preprocess");
     }
     if (answers.bundler === "webpack") {
@@ -1527,11 +1815,19 @@ var Vue = class extends FeatureOption {
     super({ promptHint: "Progressive framework with SFC", promptLabel: "Vue", settingValue: "vue" });
   }
   configure(builder, answers) {
-    builder.addPackage("vue").addPackage(getBuildPlugin2(answers.bundler)).addPartial("ui-view").addSentenceCaseBrand("Vue").addFiles([
+    builder.addPackage("vue").addPartial("ui-view").addSentenceCaseBrand("Vue").addFiles([
       "src/vue-components/sample-vue-component.d.ts",
       "src/vue-components/sample-vue-component.vue",
       "src/views/sample-vue-view.ts"
     ]);
+    if (isFrameworkPreset(answers.preset)) {
+      builder.addBuildFramework("vue").addPackage("unplugin-vue").addDepcheckIgnore("unplugin-vue", "loaded by obsidian-dev-toolkit to compile `.vue` components.");
+      if (answers.bundler === "parcel") {
+        builder.addPackage("@parcel/transformer-vue").addDepcheckIgnore("@parcel/transformer-vue", "resolved by name by `@parcel/config-default` for `.vue`; nothing imports it.");
+      }
+      return;
+    }
+    builder.addPackage(getBuildPlugin2(answers.bundler));
     if (answers.bundler === "rollup") {
       builder.addPackage("@babel/core").addPackage("@babel/preset-typescript").addPackage("@rollup/plugin-babel").addDepcheckIgnore("@babel/preset-typescript", "named as a string in `scripts/rollup.config.ts`, never imported.").addPartial("rollup-babel");
     }
@@ -1545,261 +1841,76 @@ function getBuildPlugin2(bundler) {
   if (!plugin) {
     throw new Error(`Unsupported bundler for Vue: ${bundler}`);
   }
-  return plugin;
-}
-
-// src/features/ui-framework/index.ts
-var UI_FRAMEWORK_OPTIONS = [new None16(), new Lit(), new Preact(), new React(), new Solid(), new Svelte(), new Vue()];
-async function promptUiFramework(savedValue) {
-  return promptFeature({ defaultOption: new None16(), message: "UI framework", options: UI_FRAMEWORK_OPTIONS, savedValue });
-}
-
-// src/features/wasm-support/none.ts
-var None17 = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "No WASM", promptLabel: "(none)", settingValue: "none" });
-  }
-};
-
-// src/features/wasm-support/wasm.ts
-var WASM_PLUGINS = {
-  esbuild: null,
-  parcel: null,
-  rollup: "@rollup/plugin-wasm",
-  vite: null,
-  webpack: null
-};
-var Wasm = class extends FeatureOption {
-  constructor() {
-    super({ promptHint: "Import and use .wasm modules", promptLabel: "WASM", settingValue: "wasm" });
-  }
-  configure(builder, answers) {
-    const plugin = getWasmPlugin(answers.bundler);
-    if (plugin !== null) {
-      builder.addPackage(plugin);
-    }
-    builder.addSentenceCaseBrand("WASM");
-    builder.addFiles([
-      // The one binary in the template tree, copied verbatim (see `ASSET_EXTENSIONS`). 39 bytes, one
-      // Export, `answer()`, returning 42 -- the sample module from CodeScript Toolkit's demo vault.
-      "src/wasm/module.wasm",
-      // Its source in WebAssembly text format. Documentation only: nothing in the build reads it, and it
-      // Is here so the binary beside it is not opaque.
-      "src/wasm/module.wat",
-      "src/wasm.d.ts",
-      "src/wasm/answer.ts",
-      "src/wasm/sample-command.ts",
-      "src/wasm/README.md"
-    ]);
-    if (isDevUtilsPreset(answers.preset)) {
-      builder.addFiles(["demo-vault/03 WebAssembly.md"]);
-    }
-  }
-};
-function getWasmPlugin(bundler) {
-  if (!Object.hasOwn(WASM_PLUGINS, bundler)) {
-    throw new Error(`Unsupported bundler for WASM: ${bundler}`);
-  }
-  return WASM_PLUGINS[bundler] ?? null;
-}
-
-// src/features/wasm-support/index.ts
-var WASM_SUPPORT_OPTIONS = [new None17(), new Wasm()];
-async function promptWasmSupport(savedValue) {
-  return promptFeature({ defaultOption: new None17(), message: "WebAssembly support", options: WASM_SUPPORT_OPTIONS, savedValue });
-}
-
-// src/answer-space.ts
-var SAMPLE_FUNDING_URL = "https://example.com/support-testuser";
-var SAMPLE_OBSIDIAN_CONFIG_FOLDER = "demo-vault/.obsidian";
-var ANSWER_SPACE = [
-  toDimension("apiSubset", API_SUBSET_OPTIONS),
-  toDimension("bundler", BUNDLER_OPTIONS),
-  toDimension("commitLinting", COMMIT_LINTING_OPTIONS),
-  toDimension("coverageBadge", COVERAGE_BADGE_OPTIONS),
-  toDimension("e2eTestRunner", E2E_TEST_RUNNER_OPTIONS),
-  toDimension("editorExtensions", EDITOR_EXTENSIONS_OPTIONS),
-  toDimension("formatter", FORMATTER_OPTIONS),
-  toDimension("fundingPlatform", FUNDING_PLATFORM_OPTIONS),
-  toValueDimension("fundingUrl", ["", SAMPLE_FUNDING_URL]),
-  toDimension("gitHubActions", GITHUB_ACTIONS_OPTIONS),
-  toDimension("gitHubIssueTemplates", GITHUB_ISSUE_TEMPLATES_OPTIONS),
-  toDimension("hotReload", HOT_RELOAD_OPTIONS),
-  toDimension("internationalization", INTERNATIONALIZATION_OPTIONS),
-  toDimension("linter", LINTER_OPTIONS),
-  toDimension("markdownLinter", MARKDOWN_LINTER_OPTIONS),
-  toValueDimension("obsidianConfigFolder", ["", SAMPLE_OBSIDIAN_CONFIG_FOLDER]),
-  toDimension("packageManager", PACKAGE_MANAGER_OPTIONS),
-  toDimension("platformSupport", PLATFORM_SUPPORT_OPTIONS),
-  toDimension("preset", PRESET_OPTIONS),
-  toDimension("spellChecker", SPELL_CHECKER_OPTIONS),
-  toDimension("styling", STYLING_OPTIONS),
-  toDimension("testRunner", TEST_RUNNER_OPTIONS),
-  toDimension("uiFramework", UI_FRAMEWORK_OPTIONS),
-  toDimension("wasmSupport", WASM_SUPPORT_OPTIONS)
-];
-var ANSWER_SPACE_SIZE = ANSWER_SPACE.reduce((size, dimension) => size * dimension.values.length, 1);
-var ANSWER_SPACE_DIMENSION_SIZES = ANSWER_SPACE.map((dimension) => dimension.values.length);
-function toDimension(answerKey, options) {
-  return {
-    answerKey,
-    values: options.map((option) => option.settingValue)
-  };
-}
-function toValueDimension(answerKey, values) {
-  return { answerKey, values };
-}
-
-// src/answers.ts
-var CONFIG_FILE_NAME = ".create-obsidian-plugin.json";
-function getPluginShortName(pluginId) {
-  return pluginId.split("-").map((word) => (word[0] ?? "").toUpperCase() + word.slice(1)).join("");
-}
-
-// src/directory-constraints.ts
-var CORE_FEATURE_NAMES = [
-  "Audio recorder",
-  "Backlinks",
-  "Bases",
-  "Bookmarks",
-  "Canvas",
-  "Command palette",
-  "Daily notes",
-  "File recovery",
-  "Files",
-  "Footnotes",
-  "Format converter",
-  "Graph view",
-  "Live Preview",
-  "Note composer",
-  "Outgoing links",
-  "Outline",
-  "Page preview",
-  "Properties view",
-  "Publish",
-  "Quick Switcher",
-  "Random note",
-  "Reading view",
-  "Search",
-  "Slash commands",
-  "Slides",
-  "Source mode",
-  "Sync",
-  "Tags view",
-  "Templates",
-  "Unique note creator",
-  "Web viewer",
-  "Word count",
-  "Workspaces"
-];
-var MAX_DESCRIPTION_LENGTH = 250;
-var MIN_DESCRIPTION_LENGTH = 10;
-var ALLOWED_ID_CHARACTERS = /^[a-z0-9-]+$/;
-var ALLOWED_NAME_CHARACTERS = /^[A-Za-z0-9 \-+()]+$/;
-var EMOJI = /\p{Extended_Pictographic}/u;
-var OBSIDIAN_WORD = /\bobsidian\b/i;
-var OBSIDIAN_NAME_VARIANTS = /obsi|sidian/i;
-var SELF_REFERENCE_PATTERNS = [
-  /\bthis plugin\b/i,
-  /\bthis is a plugin\b/i,
-  /\ba plugin (?:that|which)\b/i,
-  /^the plugin\b/i,
-  /^plugin\b/i
-];
-function findUnlistableManifestAnswers(answers) {
-  const checked = [
-    { key: "pluginId", message: validatePluginId(answers.pluginId), value: answers.pluginId },
-    { key: "pluginName", message: validatePluginName(answers.pluginName), value: answers.pluginName },
-    { key: "pluginDescription", message: validatePluginDescription(answers.pluginDescription), value: answers.pluginDescription }
-  ];
-  const problems = [];
-  for (const { key, message, value } of checked) {
-    if (message !== void 0) {
-      problems.push({ key, message, value });
-    }
-  }
-  return problems;
-}
-function validatePluginDescription(input) {
-  if (!input) {
-    return "Should not be empty";
-  }
-  if (EMOJI.test(input)) {
-    return "Should not contain emoji -- the Community directory rejects them, though it does accept ordinary punctuation such as backticks, em dashes and parentheses";
-  }
-  if (OBSIDIAN_WORD.test(input)) {
-    return 'Should not contain the word "Obsidian" -- the Community directory rejects it as implied by the plugin directory, even though no Obsidian document says so';
-  }
-  if (SELF_REFERENCE_PATTERNS.some((pattern) => pattern.test(input))) {
-    return 'Should say what the plugin does rather than refer to itself -- the Community directory rejects "This plugin..." and "a plugin that...". Naming another plugin is fine';
-  }
-  if (input.length < MIN_DESCRIPTION_LENGTH) {
-    return `Should be at least ${String(MIN_DESCRIPTION_LENGTH)} characters, so it says what the plugin does`;
-  }
-  if (input.length > MAX_DESCRIPTION_LENGTH) {
-    return `Should be at most ${String(MAX_DESCRIPTION_LENGTH)} characters -- the Community directory rejects a longer one`;
-  }
-  if (!/^[A-Z]/.test(input)) {
-    return 'Should start with a capital letter, ideally on an action verb: "Translates selected text...", "Imports notes from..."';
-  }
-  if (!input.endsWith(".")) {
-    return "Should end with a dot";
-  }
-  return void 0;
-}
-function validatePluginId(input) {
-  if (!input) {
-    return "Should not be empty";
-  }
-  if (!ALLOWED_ID_CHARACTERS.test(input)) {
-    return "Should contain only lowercase English letters, digits and hyphens";
-  }
-  if (!/^[a-z]/.test(input)) {
-    return "Should start with a letter";
-  }
-  if (!/[a-z0-9]$/.test(input)) {
-    return "Should end with a letter or digit";
-  }
-  if (input.includes("obsidian")) {
-    return 'Should not contain "obsidian" anywhere -- the Community directory rejects it as implied by the plugin directory, and an id can never be changed once the plugin is published';
-  }
-  if (input.endsWith("plugin")) {
-    return 'Should not end with "plugin" -- the Community directory rejects it as implied, and an id can never be changed once the plugin is published';
-  }
-  return void 0;
+  return plugin;
 }
-function validatePluginName(input) {
-  if (!input) {
-    return "Should not be empty";
-  }
-  if (OBSIDIAN_NAME_VARIANTS.test(input)) {
-    return 'Should not contain "Obsidian" or an abbreviation of it ("Obsi", "sidian") -- the Community directory rejects it as implied by the plugin directory';
+
+// src/features/ui-framework/index.ts
+var UI_FRAMEWORK_OPTIONS = [new None16(), new Lit(), new Preact(), new React(), new Solid(), new Svelte(), new Vue()];
+async function promptUiFramework(savedValue) {
+  return promptFeature({ defaultOption: new None16(), message: "UI framework", options: UI_FRAMEWORK_OPTIONS, savedValue });
+}
+
+// src/features/wasm-support/none.ts
+var None17 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No WASM", promptLabel: "(none)", settingValue: "none" });
   }
-  if (input.toLowerCase().includes("plugin")) {
-    return 'Should not contain "Plugin" -- the Community directory rejects it as implied by the plugin directory';
+};
+
+// src/features/wasm-support/wasm.ts
+var WASM_PLUGINS = {
+  esbuild: null,
+  parcel: null,
+  rollup: "@rollup/plugin-wasm",
+  vite: null,
+  webpack: null
+};
+var Wasm = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Import and use .wasm modules", promptLabel: "WASM", settingValue: "wasm" });
   }
-  const coreName = findCoreFeatureName(input);
-  if (coreName !== void 0) {
-    return `Should not be the name of an Obsidian core plugin or core feature -- "${coreName}" is one, and the Community directory rejects a name that takes it`;
+  configure(builder, answers) {
+    const isFramework = isFrameworkPreset(answers.preset);
+    if (isFramework) {
+      builder.addBuildOption("wasm", "true").addPartial("wasm-adapter");
+    } else {
+      const plugin = getWasmPlugin(answers.bundler);
+      if (plugin !== null) {
+        builder.addPackage(plugin);
+      }
+      builder.addFiles(["src/wasm.d.ts"]).addPartial(`wasm-${answers.bundler}`);
+    }
+    builder.addSentenceCaseBrand("WASM");
+    builder.addFiles([
+      // The one binary in the template tree, copied verbatim (see `ASSET_EXTENSIONS`). 39 bytes, one
+      // Export, `answer()`, returning 42 -- the sample module from `CodeScript Toolkit`'s demo vault.
+      "src/wasm/module.wasm",
+      // Its source in WebAssembly text format. Documentation only: nothing in the build reads it, and it
+      // Is here so the binary beside it is not opaque.
+      "src/wasm/module.wat",
+      "src/wasm/answer.ts",
+      "src/wasm/sample-command.ts",
+      "src/wasm/README.md"
+    ]);
+    if (isFramework) {
+      builder.addFiles(["demo-vault/03 WebAssembly.md"]);
+    }
   }
-  if (!ALLOWED_NAME_CHARACTERS.test(input)) {
-    return "Should use Basic Latin letters and digits only, with hyphens, plus signs and parentheses the only punctuation the Community directory accepts";
+};
+function getWasmPlugin(bundler) {
+  if (!Object.hasOwn(WASM_PLUGINS, bundler)) {
+    throw new Error(`Unsupported bundler for WASM: ${bundler}`);
   }
-  return void 0;
-}
-function findCoreFeatureName(name) {
-  const normalized = name.trim().toLowerCase();
-  return CORE_FEATURE_NAMES.find((candidate) => candidate.toLowerCase() === normalized);
+  return WASM_PLUGINS[bundler] ?? null;
 }
 
-// src/prompts.ts
-import {
-  cancel as cancel2,
-  log
-} from "@clack/prompts";
-import { styleText as styleText3 } from "node:util";
+// src/features/wasm-support/index.ts
+var WASM_SUPPORT_OPTIONS = [new None17(), new Wasm()];
+async function promptWasmSupport(savedValue) {
+  return promptFeature({ defaultOption: new None17(), message: "WebAssembly support", options: WASM_SUPPORT_OPTIONS, savedValue });
+}
 
-// src/clack-text.ts
+// src/prompts/clack-text.ts
 import {
   settings as settings2,
   TextPrompt
@@ -1807,7 +1918,7 @@ import {
 import {
   S_BAR as S_BAR2,
   S_BAR_END as S_BAR_END2,
-  symbol as symbol2
+  symbol as $symbol2
 } from "@clack/prompts";
 import { styleText as styleText2 } from "node:util";
 var TextPromptWithCompletion = class extends TextPrompt {
@@ -1836,7 +1947,7 @@ async function text(opts) {
     render() {
       const withGuide = settings2.withGuide;
       const header = `${withGuide ? `${styleText2("gray", S_BAR2)}
-` : ""}${symbol2(this.state)}  ${opts.message}
+` : ""}${$symbol2(this.state)}  ${opts.message}
 `;
       const placeholderDisplay = opts.placeholder ? styleText2("inverse", opts.placeholder[0] ?? "") + styleText2("dim", opts.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_");
       const input = this.userInput ? this.userInputWithCursor : placeholderDisplay;
@@ -1890,7 +2001,31 @@ ${barEnd}
   return throwGoBackOnCancel(result) ?? "";
 }
 
-// src/prompts.ts
+// src/prompts/prompts.ts
+var MAX_HINTED_CHANGES = 3;
+var TOOLING_QUESTIONS = {
+  bundler: { message: "Bundler", options: BUNDLER_OPTIONS },
+  uiFramework: { message: "UI framework", options: UI_FRAMEWORK_OPTIONS },
+  linter: { message: "Linter", options: LINTER_OPTIONS },
+  formatter: { message: "Formatter", options: FORMATTER_OPTIONS },
+  spellChecker: { message: "Spell checker", options: SPELL_CHECKER_OPTIONS },
+  markdownLinter: { message: "Markdown linter", options: MARKDOWN_LINTER_OPTIONS },
+  testRunner: { message: "Unit testing", options: TEST_RUNNER_OPTIONS },
+  e2eTestRunner: { message: "E2E testing", options: E2E_TEST_RUNNER_OPTIONS },
+  editorExtensions: { message: "Editor extensions", options: EDITOR_EXTENSIONS_OPTIONS },
+  styling: { message: "Styling", options: STYLING_OPTIONS },
+  wasmSupport: { message: "WebAssembly support", options: WASM_SUPPORT_OPTIONS },
+  commitLinting: { message: "Commit linting", options: COMMIT_LINTING_OPTIONS },
+  hotReload: { message: "Hot reload", options: HOT_RELOAD_OPTIONS },
+  internationalization: { message: "Internationalization", options: INTERNATIONALIZATION_OPTIONS },
+  gitHubActions: { message: "GitHub Actions", options: GITHUB_ACTIONS_OPTIONS },
+  gitHubIssueTemplates: { message: "GitHub issue templates", options: GITHUB_ISSUE_TEMPLATES_OPTIONS },
+  coverageBadge: { message: "Coverage badge", options: COVERAGE_BADGE_OPTIONS },
+  apiSubset: { message: "Obsidian API subset", options: API_SUBSET_OPTIONS },
+  packageManager: { message: "Package manager", options: PACKAGE_MANAGER_OPTIONS },
+  platformSupport: { message: "Platform support", options: PLATFORM_SUPPORT_OPTIONS }
+};
+var API_SUBSET_PRESETS = ["all-in-one", "docs-showcase"];
 var DEFAULT_PLUGIN_ID = "my-awesome-helper";
 function getDefaultAnswers(defaults) {
   const pluginId = defaults?.pluginId ?? DEFAULT_PLUGIN_ID;
@@ -1909,10 +2044,10 @@ function getDefaultAnswers(defaults) {
 function makePluginName(pluginId) {
   return extractWords(pluginId).join(" ");
 }
-async function promptAnswers(defaults) {
+async function promptAnswers(defaults, supplied = defaults ?? {}) {
   showHotkeyHints();
   const defaultTooling = getDefaultTooling();
-  const steps = skipSuppliedAnswers(buildPromptSteps(defaults ?? {}, defaultTooling), defaults ?? {});
+  const steps = skipSuppliedAnswers(buildPromptSteps(defaults ?? {}, supplied, defaultTooling), supplied);
   const answers = await runPromptSteps(steps);
   return buildAnswers(answers, defaultTooling);
 }
@@ -1922,6 +2057,9 @@ function validateNotEmpty(value) {
   }
   return void 0;
 }
+function asksApiSubset(preset) {
+  return API_SUBSET_PRESETS.includes(preset ?? "");
+}
 function buildAnswers(answers, defaultTooling) {
   function get(key, fallback) {
     return answers.get(key) ?? fallback;
@@ -1931,7 +2069,7 @@ function buildAnswers(answers, defaultTooling) {
     apiSubset: get("apiSubset", defaultTooling.apiSubset),
     authorGitHubName: get("authorGitHubName", "johndoe"),
     authorName: get("authorName", "John Doe"),
-    bundler: get("bundler", "esbuild"),
+    bundler: get("bundler", defaultTooling.bundler),
     commitLinting: get("commitLinting", defaultTooling.commitLinting),
     coverageBadge: get("coverageBadge", defaultTooling.coverageBadge),
     currentYear: (/* @__PURE__ */ new Date()).getFullYear(),
@@ -1949,154 +2087,165 @@ function buildAnswers(answers, defaultTooling) {
     linter: get("linter", defaultTooling.linter),
     markdownLinter: get("markdownLinter", defaultTooling.markdownLinter),
     obsidianConfigFolder: get("obsidianConfigFolder", ""),
-    packageManager: get("packageManager", "npm"),
-    platformSupport: get("platformSupport", "desktop-only"),
+    packageManager: get("packageManager", defaultTooling.packageManager),
+    platformSupport: get("platformSupport", defaultTooling.platformSupport),
     pluginDescription: get("pluginDescription", "Does something awesome."),
     pluginId,
     pluginName: get("pluginName", makePluginName(pluginId)),
-    preset: get("preset", "enhanced"),
+    preset: get("preset", "all-in-one"),
     spellChecker: get("spellChecker", defaultTooling.spellChecker),
     styling: get("styling", defaultTooling.styling),
     testRunner: get("testRunner", defaultTooling.testRunner),
-    uiFramework: get("uiFramework", "none"),
+    uiFramework: get("uiFramework", defaultTooling.uiFramework),
     wasmSupport: get("wasmSupport", defaultTooling.wasmSupport)
   };
 }
-function buildPromptSteps(d, defaultTooling) {
+function buildPromptSteps(d, supplied, defaultTooling) {
   function isCustomize(answers) {
     return answers.get("toolingMode") === "customize";
   }
   function skipUnlessCustomize(answers) {
     return !isCustomize(answers);
   }
+  function tooling(key, answers) {
+    if (answers.get("toolingMode") === "defaults" && supplied[key] === void 0) {
+      return defaultTooling[key];
+    }
+    return d[key] ?? defaultTooling[key];
+  }
+  function changes(answers) {
+    return findToolingChanges(d, supplied, defaultTooling, answers.get("preset"));
+  }
   return [
     {
-      defaultValue: () => d.preset ?? "enhanced",
+      defaultValue: () => d.preset ?? "all-in-one",
       key: "preset",
       prompt: (saved) => promptPreset(saved)
     },
     {
-      defaultValue: () => "defaults",
+      // A skipped `Tooling` keeps what was saved, which is what the question offers first when there is any.
+      defaultValue: (answers) => changes(answers).length > 0 ? "keep" : "defaults",
       key: "toolingMode",
-      prompt: () => promptToolingMode(),
-      skip: (answers) => answers.get("preset") === "demo"
+      prompt: (saved, answers) => promptToolingMode(saved, changes(answers)),
+      // The official sample is upstream's tooling as it is, so there is nothing to customize.
+      skip: (answers) => answers.get("preset") === "demo" || isOfficialSamplePreset(answers.get("preset"))
     },
     {
-      defaultValue: (answers) => answers.get("preset") === "demo" ? "esbuild" : d.bundler ?? "esbuild",
+      defaultValue: (answers) => answers.get("preset") === "demo" ? "esbuild" : tooling("bundler", answers),
       key: "bundler",
       prompt: (saved) => promptBundler(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: (answers) => answers.get("preset") === "demo" ? "none" : d.uiFramework ?? "none",
+      defaultValue: (answers) => answers.get("preset") === "demo" ? "none" : tooling("uiFramework", answers),
       key: "uiFramework",
       prompt: (saved) => promptUiFramework(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.linter ?? defaultTooling.linter,
+      defaultValue: (answers) => tooling("linter", answers),
       key: "linter",
       prompt: (saved) => promptLinter(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.formatter ?? defaultTooling.formatter,
+      defaultValue: (answers) => tooling("formatter", answers),
       key: "formatter",
       prompt: (saved) => promptFormatter(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.spellChecker ?? defaultTooling.spellChecker,
+      defaultValue: (answers) => tooling("spellChecker", answers),
       key: "spellChecker",
       prompt: (saved) => promptSpellChecker(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.markdownLinter ?? defaultTooling.markdownLinter,
+      defaultValue: (answers) => tooling("markdownLinter", answers),
       key: "markdownLinter",
       prompt: (saved) => promptMarkdownLinter(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.testRunner ?? defaultTooling.testRunner,
+      defaultValue: (answers) => tooling("testRunner", answers),
       key: "testRunner",
       prompt: (saved) => promptTestRunner(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.e2eTestRunner ?? defaultTooling.e2eTestRunner,
+      defaultValue: (answers) => tooling("e2eTestRunner", answers),
       key: "e2eTestRunner",
       prompt: (saved) => promptE2eTestRunner(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.editorExtensions ?? defaultTooling.editorExtensions,
+      defaultValue: (answers) => tooling("editorExtensions", answers),
       key: "editorExtensions",
       prompt: (saved) => promptEditorExtensions(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.styling ?? defaultTooling.styling,
+      defaultValue: (answers) => tooling("styling", answers),
       key: "styling",
       prompt: (saved) => promptStyling(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.wasmSupport ?? defaultTooling.wasmSupport,
+      defaultValue: (answers) => tooling("wasmSupport", answers),
       key: "wasmSupport",
       prompt: (saved) => promptWasmSupport(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.commitLinting ?? defaultTooling.commitLinting,
+      defaultValue: (answers) => tooling("commitLinting", answers),
       key: "commitLinting",
       prompt: (saved) => promptCommitLinting(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.hotReload ?? defaultTooling.hotReload,
+      defaultValue: (answers) => tooling("hotReload", answers),
       key: "hotReload",
       prompt: (saved) => promptHotReload(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.internationalization ?? defaultTooling.internationalization,
+      defaultValue: (answers) => tooling("internationalization", answers),
       key: "internationalization",
       prompt: (saved) => promptInternationalization(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.gitHubActions ?? defaultTooling.gitHubActions,
+      defaultValue: (answers) => tooling("gitHubActions", answers),
       key: "gitHubActions",
       prompt: (saved) => promptGitHubActions(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.gitHubIssueTemplates ?? defaultTooling.gitHubIssueTemplates,
+      defaultValue: (answers) => tooling("gitHubIssueTemplates", answers),
       key: "gitHubIssueTemplates",
       prompt: (saved) => promptGitHubIssueTemplates(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.coverageBadge ?? defaultTooling.coverageBadge,
+      defaultValue: (answers) => tooling("coverageBadge", answers),
       key: "coverageBadge",
       prompt: (saved) => promptCoverageBadge(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.apiSubset ?? defaultTooling.apiSubset,
+      defaultValue: (answers) => tooling("apiSubset", answers),
       key: "apiSubset",
       prompt: (saved) => promptApiSubset(saved),
-      skip: (answers) => !(isCustomize(answers) && answers.get("preset") === "enhanced")
+      skip: (answers) => !(isCustomize(answers) && asksApiSubset(answers.get("preset")))
     },
     {
-      defaultValue: () => d.packageManager ?? "npm",
+      defaultValue: (answers) => tooling("packageManager", answers),
       key: "packageManager",
       prompt: (saved) => promptPackageManager(saved),
       skip: skipUnlessCustomize
     },
     {
-      defaultValue: () => d.platformSupport ?? "desktop-only",
+      defaultValue: (answers) => tooling("platformSupport", answers),
       key: "platformSupport",
       prompt: (saved) => promptPlatformSupport(saved),
       skip: skipUnlessCustomize
@@ -2187,37 +2336,59 @@ function buildPromptSteps(d, defaultTooling) {
         defaultValue: saved || void 0,
         message: "Path to test vault config folder (.obsidian, by default, but it is configurable in Obsidian settings). This enables auto-update of your plugin in your test vault during dev. Leave empty if you prefer to update the plugin manually.",
         placeholder: saved || "path/to/test-vault/.obsidian"
-      })
+      }),
+      // Upstream builds into the project folder and copies nothing into a vault.
+      skip: (answers) => isOfficialSamplePreset(answers.get("preset"))
     }
   ];
 }
+function describeChanges(changes, describe) {
+  const named = changes.slice(0, MAX_HINTED_CHANGES).map(describe).join(", ");
+  const rest = changes.length - MAX_HINTED_CHANGES;
+  return rest > 0 ? `${named}, and ${String(rest)} more` : named;
+}
 function extractWords(pluginId) {
   return pluginId.split("-").map((w) => (w[0] ?? "").toUpperCase() + w.slice(1));
 }
+function findToolingChanges(d, supplied, defaultTooling, preset) {
+  const changes = [];
+  for (const [key, question] of Object.entries(TOOLING_QUESTIONS)) {
+    const saved = d[key];
+    if (saved === void 0 || supplied[key] !== void 0 || saved === defaultTooling[key]) {
+      continue;
+    }
+    if (key === "apiSubset" && !asksApiSubset(preset)) {
+      continue;
+    }
+    changes.push({
+      question: question.message,
+      recommended: getOptionLabel(question, defaultTooling[key]),
+      saved: getOptionLabel(question, saved)
+    });
+  }
+  return changes;
+}
 function getDefaultAnswersBase(pluginId) {
   return {
     ...getDefaultTooling(),
     authorGitHubName: "johndoe",
     authorName: "John Doe",
-    bundler: "esbuild",
     currentYear: (/* @__PURE__ */ new Date()).getFullYear(),
     defaultBranch: "main",
     fundingPlatform: "buy-me-a-coffee",
     fundingUrl: "",
     fundingUsername: "johndoe",
     obsidianConfigFolder: "",
-    packageManager: "npm",
-    platformSupport: "desktop-only",
     pluginDescription: "Does something awesome.",
     pluginId,
     pluginName: makePluginName(pluginId),
-    preset: "enhanced",
-    uiFramework: "none"
+    preset: "all-in-one"
   };
 }
 function getDefaultTooling() {
   return {
     apiSubset: "official",
+    bundler: "esbuild",
     commitLinting: "conventional-commits",
     coverageBadge: "none",
     e2eTestRunner: "none",
@@ -2229,12 +2400,18 @@ function getDefaultTooling() {
     internationalization: "none",
     linter: "eslint",
     markdownLinter: "markdownlint",
+    packageManager: "npm",
+    platformSupport: "desktop-only",
     spellChecker: "cspell",
     styling: "scss",
     testRunner: "vitest",
+    uiFramework: "none",
     wasmSupport: "none"
   };
 }
+function getOptionLabel(question, value) {
+  return question.options.find((option) => option.settingValue === value)?.promptLabel ?? value;
+}
 function promptPluginDescription(saved) {
   const value = saved || void 0;
   return text({
@@ -2253,13 +2430,29 @@ function promptPluginName(saved) {
     validate: validatePluginName
   });
 }
-async function promptToolingMode() {
+async function promptToolingMode(savedValue, changes) {
+  const customize = { hint: "Choose each tool individually", label: "Customize", value: "customize" };
+  if (changes.length === 0) {
+    return select({
+      initialValue: savedValue,
+      message: "Tooling",
+      options: [
+        customize,
+        { hint: "ESLint, dprint, SCSS, Vitest, and more", label: "Use recommended defaults", value: "defaults" }
+      ]
+    });
+  }
   return select({
-    initialValue: "defaults",
+    initialValue: savedValue,
     message: "Tooling",
     options: [
-      { hint: "Choose each tool individually", label: "Customize", value: "customize" },
-      { hint: "ESLint, dprint, SCSS, Vitest, and more", label: "Use recommended defaults", value: "defaults" }
+      { hint: describeChanges(changes, (change) => `${change.question}: ${change.saved}`), label: "Keep current tooling", value: "keep" },
+      customize,
+      {
+        hint: describeChanges(changes, (change) => `${change.question}: ${change.saved} -> ${change.recommended}`),
+        label: "Use recommended defaults",
+        value: "defaults"
+      }
     ]
   });
 }
@@ -2275,7 +2468,7 @@ async function runPromptSteps(steps) {
     }
     try {
       const savedValue = answers.get(step.key) ?? step.defaultValue(answers);
-      answers.set(step.key, await step.prompt(savedValue));
+      answers.set(step.key, await step.prompt(savedValue, answers));
       i++;
     } catch (error) {
       if (!(error instanceof GoBackError)) {
@@ -2315,7 +2508,70 @@ function skipSuppliedAnswers(steps, supplied) {
   }));
 }
 
-// src/cli-args.ts
+// src/answers/answer-space.ts
+var SAMPLE_FUNDING_URL = "https://example.com/support-testuser";
+var SAMPLE_OBSIDIAN_CONFIG_FOLDER = "demo-vault/.obsidian";
+var ANSWER_SPACE = [
+  toDimension("apiSubset", API_SUBSET_OPTIONS),
+  toDimension("bundler", BUNDLER_OPTIONS),
+  toDimension("commitLinting", COMMIT_LINTING_OPTIONS),
+  toDimension("coverageBadge", COVERAGE_BADGE_OPTIONS),
+  toDimension("e2eTestRunner", E2E_TEST_RUNNER_OPTIONS),
+  toDimension("editorExtensions", EDITOR_EXTENSIONS_OPTIONS),
+  toDimension("formatter", FORMATTER_OPTIONS),
+  toDimension("fundingPlatform", FUNDING_PLATFORM_OPTIONS),
+  toValueDimension("fundingUrl", ["", SAMPLE_FUNDING_URL]),
+  toDimension("gitHubActions", GITHUB_ACTIONS_OPTIONS),
+  toDimension("gitHubIssueTemplates", GITHUB_ISSUE_TEMPLATES_OPTIONS),
+  toDimension("hotReload", HOT_RELOAD_OPTIONS),
+  toDimension("internationalization", INTERNATIONALIZATION_OPTIONS),
+  toDimension("linter", LINTER_OPTIONS),
+  toDimension("markdownLinter", MARKDOWN_LINTER_OPTIONS),
+  toValueDimension("obsidianConfigFolder", ["", SAMPLE_OBSIDIAN_CONFIG_FOLDER]),
+  toDimension("packageManager", PACKAGE_MANAGER_OPTIONS),
+  toDimension("platformSupport", PLATFORM_SUPPORT_OPTIONS),
+  toDimension("preset", PRESET_OPTIONS),
+  toDimension("spellChecker", SPELL_CHECKER_OPTIONS),
+  toDimension("styling", STYLING_OPTIONS),
+  toDimension("testRunner", TEST_RUNNER_OPTIONS),
+  toDimension("uiFramework", UI_FRAMEWORK_OPTIONS),
+  toDimension("wasmSupport", WASM_SUPPORT_OPTIONS)
+];
+var ANSWER_SPACE_SIZE = ANSWER_SPACE.reduce((size, dimension) => size * dimension.values.length, 1);
+var ANSWER_SPACE_DIMENSION_SIZES = ANSWER_SPACE.map((dimension) => dimension.values.length);
+function toDimension(answerKey, options) {
+  return {
+    answerKey,
+    values: options.map((option) => option.settingValue)
+  };
+}
+function toValueDimension(answerKey, values) {
+  return { answerKey, values };
+}
+
+// src/answers/answers.ts
+var CONFIG_FILE_NAME = ".create-obsidian-plugin.json";
+function getPluginShortName(pluginId) {
+  return pluginId.split("-").map((word) => (word[0] ?? "").toUpperCase() + word.slice(1)).join("");
+}
+
+// src/answers/deprecated-answers.ts
+import { log as log2 } from "@clack/prompts";
+var DEPRECATED_ANSWER_VALUES = {
+  preset: {
+    enhanced: "all-in-one"
+  }
+};
+function resolveDeprecatedAnswer(key, value, source) {
+  const replacement = DEPRECATED_ANSWER_VALUES[key]?.[value];
+  if (replacement === void 0) {
+    return value;
+  }
+  log2.warn(`${key} "${value}" in ${source} is deprecated and was read as "${replacement}". Use "${replacement}" instead.`);
+  return replacement;
+}
+
+// src/answers/cli-args.ts
 var COMPUTED_ANSWER_KEYS = ["currentYear"];
 var DERIVED_TEMPLATE_KEYS = ["pluginShortName"];
 var REFUSED_KEYS = [...COMPUTED_ANSWER_KEYS, ...DERIVED_TEMPLATE_KEYS];
@@ -2323,6 +2579,7 @@ var ANSWERS_FILE_PREFIX = "--answersFile=";
 var CUSTOM_TEMPLATE_PREFIX = "--customTemplate=";
 var MODE_PREFIX = "--mode=";
 var MODES = ["create" /* Create */, "update" /* Update */];
+var MODE_BY_VALUE = new Map(MODES.map((mode) => [mode, mode]));
 var FLAG_PREFIX_LENGTH = 2;
 var FREE_TEXT_VALIDATORS = {
   authorGitHubName: validateNotEmpty,
@@ -2334,6 +2591,9 @@ var FREE_TEXT_VALIDATORS = {
   pluginName: validatePluginName
 };
 var DEMO_PINNED_ANSWER_KEYS = ["bundler", "uiFramework"];
+var VALUES_OUTSIDE_ANSWER_SPACE = {
+  preset: [OFFICIAL_SAMPLE_PRESET]
+};
 function assertValidAnswer(key, value) {
   const dimension = findChoiceDimension(key);
   if (dimension) {
@@ -2366,6 +2626,8 @@ function getHelpText() {
     "      --customTemplate=<dir> Layer your own templates over the built-in ones: a directory",
     "                            mirroring templates/default, plus an overlay.json. Recorded in the",
     "                            project and re-applied on update; pass it empty to drop it.",
+    "      --latest              With --preset=official-sample: copy obsidianmd/obsidian-sample-plugin",
+    "                            as it is upstream today, not the snapshot this release vendored.",
     "",
     "Answers (any of these may be given as --<key>=<value>):"
   ];
@@ -2380,6 +2642,7 @@ function parseCliArgs(argv) {
   let answersFilePath = null;
   let customTemplate;
   let force = false;
+  let latest = false;
   let mode;
   let showHelp = false;
   let useDefaults = false;
@@ -2404,27 +2667,40 @@ function parseCliArgs(argv) {
       force = true;
       continue;
     }
+    if (argument === "--latest") {
+      latest = true;
+      continue;
+    }
     if (argument.startsWith(MODE_PREFIX)) {
       mode = toMode(argument.slice(MODE_PREFIX.length));
       continue;
     }
-    const [rawKey, value] = splitFlag(argument);
+    const [rawKey, rawValue] = splitFlag(argument);
     const key = toAnswerKey(rawKey);
-    assertValidAnswer(key, value);
-    flagAnswers[key] = value;
+    flagAnswers[key] = resolveAnswer(key, rawValue, `--${key}`);
   }
   const fileAnswers = answersFilePath === null ? {} : readAnswersFile(answersFilePath);
-  const answers = { ...fileAnswers, ...flagAnswers };
+  const isOfficialSample = isOfficialSamplePreset(flagAnswers.preset ?? fileAnswers.preset);
+  if (isOfficialSample) {
+    assertNoOfficialSampleConflict(flagAnswers);
+  }
+  const answers = { ...isOfficialSample ? pickOfficialSampleAnswers(fileAnswers) : fileAnswers, ...flagAnswers };
   assertNoDemoConflict(answers);
   return {
     answers,
     customTemplate,
     force,
+    latest,
     mode,
     showHelp,
     useDefaults
   };
 }
+function resolveAnswer(key, value, source) {
+  const resolved = resolveDeprecatedAnswer(key, value, source);
+  assertValidAnswer(key, resolved);
+  return resolved;
+}
 function toAnswerKey(key) {
   if (REFUSED_KEYS.includes(key)) {
     throw new Error(`${key} is computed by the generator, not answered, so it cannot be set.`);
@@ -2445,12 +2721,23 @@ function assertNoDemoConflict(answers) {
     }
   }
 }
+function assertNoOfficialSampleConflict(answers) {
+  const conflicting = Object.keys(answers).filter((key) => answers[key] !== void 0 && !OFFICIAL_SAMPLE_ANSWER_KEYS.includes(key));
+  if (conflicting.length > 0) {
+    const flags = conflicting.map((key) => `--${key}`).join(", ");
+    throw new Error(`preset=official-sample copies obsidianmd/obsidian-sample-plugin as it is, so it takes no ${conflicting.join(", ")}. Drop ${flags}, or choose another preset.`);
+  }
+}
 function findChoiceDimension(key) {
   const dimension = ANSWER_SPACE.find((candidate) => candidate.answerKey === key);
   if (!dimension || dimension.values.includes("")) {
     return null;
   }
-  return dimension;
+  const extraValues = VALUES_OUTSIDE_ANSWER_SPACE[key];
+  return extraValues ? { ...dimension, values: [...dimension.values, ...extraValues] } : dimension;
+}
+function pickOfficialSampleAnswers(answers) {
+  return Object.fromEntries(Object.entries(answers).filter(([key]) => OFFICIAL_SAMPLE_ANSWER_KEYS.includes(key)));
 }
 function readAnswersFile(path) {
   if (!existsSync(path)) {
@@ -2477,8 +2764,7 @@ function readAnswersFile(path) {
       throw new Error(`${rawKey} in ${path} should be a string, got ${typeof value}.`);
     }
     const key = toAnswerKey(rawKey);
-    assertValidAnswer(key, value);
-    answers[key] = value;
+    answers[key] = resolveAnswer(key, value, path);
   }
   return answers;
 }
@@ -2493,13 +2779,14 @@ function splitFlag(argument) {
   return [argument.slice(FLAG_PREFIX_LENGTH, separatorIndex), argument.slice(separatorIndex + 1)];
 }
 function toMode(value) {
-  if (!MODES.includes(value)) {
+  const mode = MODE_BY_VALUE.get(value);
+  if (mode === void 0) {
     throw new Error(`"${value}" is not a mode. It accepts: ${MODES.join(", ")}.`);
   }
-  return value;
+  return mode;
 }
 
-// src/answers-export.ts
+// src/answers/answers-export.ts
 var CREATE_COMMANDS = {
   bun: { prefix: "bun create @mnaoumov/obsidian-plugin", separator: "" },
   npm: { prefix: "npm create @mnaoumov/obsidian-plugin", separator: " --" },
@@ -2536,6 +2823,9 @@ function formatCreateScript(answers, shell, customTemplate) {
 }
 function getExportableKeys(answers) {
   const keys = getAnswerableKeys();
+  if (isOfficialSamplePreset(answers.preset)) {
+    return keys.filter((key) => OFFICIAL_SAMPLE_ANSWER_KEYS.includes(key));
+  }
   if (answers.preset !== "demo") {
     return keys;
   }
@@ -2554,7 +2844,7 @@ function quote(value, shell) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 
-// src/directory-registry.ts
+// src/directory/directory-registry.ts
 var COMMUNITY_PLUGINS_JSON_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/community-plugins.json";
 async function fetchCommunityPluginIds() {
   try {
@@ -2589,49 +2879,51 @@ function validatePluginIdIsUnlisted(pluginId, listedIds) {
   return `"${pluginId}" is already the id of a plugin in the Community directory -- the directory requires every id to be unique, and an id can never be changed once the plugin is published`;
 }
 
-// src/overlay.ts
-import {
-  existsSync as existsSync4,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
-  statSync as statSync2
-} from "node:fs";
-import {
-  isAbsolute,
-  join as join3,
-  relative,
-  resolve
-} from "node:path";
-
-// src/plan-checks.ts
-import {
-  existsSync as existsSync3,
-  readdirSync,
-  readFileSync as readFileSync3,
-  statSync
-} from "node:fs";
-import {
-  extname as extname2,
-  join as join2
-} from "node:path";
+// src/official-sample.ts
+import { join as join5 } from "node:path";
 
 // src/templates.ts
-import { log as log3 } from "@clack/prompts";
+import { log as log4 } from "@clack/prompts";
 import ejs from "ejs";
 import { createHash } from "node:crypto";
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync4,
   mkdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   writeFileSync
 } from "node:fs";
 import {
   dirname,
   extname,
-  join
+  join as join3
 } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/docs-showcase/docs-showcase-files.ts
+import {
+  existsSync as existsSync2,
+  readdirSync,
+  readFileSync as readFileSync2
+} from "node:fs";
+import {
+  join,
+  relative
+} from "node:path";
+var DOCS_SHOWCASE_TREE_DIR = join("src", "docs");
+var DOCS_SHOWCASE_FILES_DIR = join("templates", "docs-showcase", "files");
+var DOCS_SHOWCASE_HOST_DIR = join("templates", "docs-showcase", "host");
+var DOCS_SHOWCASE_REPORT_PATH = join("templates", "docs-showcase", "snippets.json");
+function readDocsShowcaseFiles(packageRoot) {
+  const filesDir = join(packageRoot, DOCS_SHOWCASE_FILES_DIR);
+  if (!existsSync2(filesDir)) {
+    return [];
+  }
+  return readdirSync(filesDir, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => join(entry.parentPath, entry.name)).sort((a, b) => a.localeCompare(b)).map((fullPath) => ({
+    content: readFileSync2(fullPath, "utf-8"),
+    destinationPath: relative(filesDir, fullPath).replaceAll("\\", "/")
+  }));
+}
+
 // src/template-builder.ts
 var PARTIAL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var Dependency = class {
@@ -2647,10 +2939,31 @@ var Dependency = class {
     this.version = version;
   }
 };
+var FRAMEWORKS_ESBUILD_COMPILES_UNASKED = /* @__PURE__ */ new Set(["preact", "react", "svelte"]);
 var TemplateBuilder = class {
   get badges() {
     return [...this._badges];
   }
+  /**
+   * The options every obsidian-dev-toolkit bundler adapter takes, as `key: <TypeScript literal>` source, sorted by key.
+   *
+   * `framework` is a single value, and only `preset: demo` registers more than one, a set it builds only with esbuild.
+   * There the toolkit compiles Svelte, React and Preact unasked, so the framework that needs the option is the one
+   * passed.
+   */
+  get buildOptions() {
+    const options = new Map(this._buildOptions);
+    const frameworks = [...this._buildFrameworks];
+    const framework = frameworks.length > 1 ? frameworks.find((name) => !FRAMEWORKS_ESBUILD_COMPILES_UNASKED.has(name)) : frameworks[0];
+    if (framework !== void 0) {
+      options.set("framework", `'${framework}'`);
+    }
+    if (this._buildStyles !== null) {
+      const flags = [...this._buildStyles].sort((a, b) => a.localeCompare(b));
+      options.set("styles", flags.length === 0 ? "{}" : `{ ${flags.map((flag) => `${flag}: true`).join(", ")} }`);
+    }
+    return [...options.entries()].map(([key, value]) => ({ key, value })).sort((a, b) => a.key.localeCompare(b.key));
+  }
   get depcheckIgnores() {
     return [...this._depcheckIgnores.entries()].map(([packageName, reason]) => ({ packageName, reason })).sort((a, b) => a.packageName.localeCompare(b.packageName));
   }
@@ -2658,7 +2971,7 @@ var TemplateBuilder = class {
     return [...this._dependencies.values()].sort((a, b) => a.packageName.localeCompare(b.packageName));
   }
   get lintStagedPatterns() {
-    return [...this._lintStagedPatterns.entries()].map(([pattern, commands]) => ({ commands: [...commands], pattern }));
+    return [...this._lintStagedPatterns.entries()].map(([pattern, commands]) => ({ commands: [...commands], pattern })).sort((a, b) => a.pattern.localeCompare(b.pattern));
   }
   get partials() {
     return new Set(this._partials);
@@ -2672,7 +2985,16 @@ var TemplateBuilder = class {
   get templateFiles() {
     return new Set(this._templateFiles);
   }
+  /**
+   * The configs the emitted `tsconfig.json` extends after its base, in registration order.
+   */
+  get tsconfigExtends() {
+    return [...this._tsconfigExtends];
+  }
   _badges = [];
+  _buildFrameworks = /* @__PURE__ */ new Set();
+  _buildOptions = /* @__PURE__ */ new Map();
+  _buildStyles = null;
   _depcheckIgnores = /* @__PURE__ */ new Map();
   _dependencies = /* @__PURE__ */ new Map();
   _lintStagedPatterns = /* @__PURE__ */ new Map();
@@ -2680,6 +3002,7 @@ var TemplateBuilder = class {
   _scripts = {};
   _sentenceCaseBrands = /* @__PURE__ */ new Set();
   _templateFiles = /* @__PURE__ */ new Set();
+  _tsconfigExtends = /* @__PURE__ */ new Set();
   /**
    * Registers a README badge, rendered in registration order on the line under the title.
    *
@@ -2691,6 +3014,35 @@ var TemplateBuilder = class {
     this._badges.push(markdown);
     return this;
   }
+  /**
+   * Registers a UI framework the obsidian-dev-toolkit bundler adapters compile, through their `framework` option.
+   */
+  addBuildFramework(framework) {
+    this._buildFrameworks.add(framework);
+    return this;
+  }
+  /**
+   * Registers an obsidian-dev-toolkit bundler adapter option other than `framework` and `styles`.
+   *
+   * @param key - The option name.
+   * @param value - The option's value, as TypeScript source.
+   */
+  addBuildOption(key, value) {
+    this._buildOptions.set(key, value);
+    return this;
+  }
+  /**
+   * Turns on the adapters' `styles` option, which compiles the project's plain stylesheets, with a flag of it if given.
+   *
+   * @param flag - `postcss`, `tailwind` or `cssModules`; omitted, the stylesheets are compiled as plain CSS.
+   */
+  addBuildStyles(flag) {
+    this._buildStyles ??= /* @__PURE__ */ new Set();
+    if (flag !== void 0) {
+      this._buildStyles.add(flag);
+    }
+    return this;
+  }
   /**
    * Registers a declared package that depcheck reports as unused although it is not -- one only ever
    * invoked as a CLI, named as a string in a config, or reached by a compiler option.
@@ -2718,6 +3070,11 @@ var TemplateBuilder = class {
    * The commands are collected here rather than concatenated from template partials because a partial can
    * only ever emit `'<command>',` -- and the trailing comma the last one leaves behind is exactly what the
    * generated formatter config strips, so the file failed its own `format:check`.
+   *
+   * The patterns are rendered sorted, not in registration order: they become the keys of the emitted
+   * `nano-staged-config.ts` object, which the shared ESLint config's `perfectionist/sort-objects` checks,
+   * and answers register them in question order (markdownlint's `*.md` before the `*.{ts,tsx,mts}` that
+   * `preset: demo` forces in). Commands under one pattern keep their order, since nano-staged runs them so.
    */
   addLintStagedCommand(pattern, command) {
     const commands = this._lintStagedPatterns.get(pattern) ?? [];
@@ -2755,13 +3112,69 @@ var TemplateBuilder = class {
     this._sentenceCaseBrands.add(brand);
     return this;
   }
+  /**
+   * Registers a config the emitted `tsconfig.json` extends after its base, such as a framework's JSX preset.
+   *
+   * Collected here rather than composed from partials for the same reason as {@link addLintStagedCommand}: the
+   * `extends` value is a list whose last entry must not carry a comma, and a single entry is written as a plain string.
+   */
+  addTsconfigExtends(config) {
+    this._tsconfigExtends.add(config);
+    return this;
+  }
 };
 
+// src/template-index.ts
+import {
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
+  statSync
+} from "node:fs";
+import { join as join2 } from "node:path";
+var GROUP_FOLDER_PATTERN = /^\(.+\)$/;
+function getLogicalTemplatePath(physicalPath) {
+  return physicalPath.split("/").filter((segment) => !GROUP_FOLDER_PATTERN.test(segment)).join("/");
+}
+function indexTemplateDir(root) {
+  const index = /* @__PURE__ */ new Map();
+  for (const physicalPath of walkFiles(root, "")) {
+    const logicalPath = getLogicalTemplatePath(physicalPath);
+    const existing = index.get(logicalPath);
+    if (existing !== void 0) {
+      throw new Error(`Two templates in ${root} resolve to ${logicalPath}: ${existing} and ${physicalPath}.`);
+    }
+    index.set(logicalPath, physicalPath);
+  }
+  return index;
+}
+function walkFiles(root, relativeDir) {
+  const absoluteDir = join2(root, relativeDir);
+  if (!existsSync3(absoluteDir)) {
+    return [];
+  }
+  const found = [];
+  for (const entry of readdirSync2(absoluteDir)) {
+    const relativePath = relativeDir === "" ? entry : `${relativeDir}/${entry}`;
+    if (statSync(join2(root, relativePath)).isDirectory()) {
+      found.push(...walkFiles(root, relativePath));
+    } else {
+      found.push(relativePath);
+    }
+  }
+  return found;
+}
+
 // src/versions.ts
-import { log as log2 } from "@clack/prompts";
+import { log as log3 } from "@clack/prompts";
+import {
+  maxSatisfying,
+  minVersion,
+  subset,
+  validRange
+} from "semver";
 var PINNED_VERSIONS = {
   "@babel/core": {
-    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@rollup/plugin-babel/package.json','utf8')).peerDependencies['@babel/core'])"`,
     checkRequires: "@rollup/plugin-babel",
     expect: "^7.0.0",
     manualCheck: null,
@@ -2771,7 +3184,7 @@ var PINNED_VERSIONS = {
     why: "@babel/core is only ever added alongside @rollup/plugin-babel, whose newest release still peers on `^7.0.0` while the registry tags 8.x as latest. Resolving latest therefore produced an `npm install` that fails outright with ERESOLVE for rollup with preact, react or solid. The check reads the peer range @rollup/plugin-babel itself declares, so the pin retires itself when that widens to ^8."
   },
   "@babel/plugin-transform-react-jsx": {
-    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@rollup/plugin-babel/package.json','utf8')).peerDependencies['@babel/core'])"`,
     checkRequires: "@rollup/plugin-babel",
     expect: "^7.0.0",
     manualCheck: null,
@@ -2781,7 +3194,7 @@ var PINNED_VERSIONS = {
     why: "Held on 7.x for the same reason as @babel/core, and it has to move as one set: 8.0.1 peers on `@babel/core@^8.0.0`, so pinning core to 7 without pinning this one just moves the ERESOLVE. Only ever added for rollup + preact, which is exactly where @rollup/plugin-babel forces 7."
   },
   "@babel/preset-react": {
-    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@rollup/plugin-babel/package.json','utf8')).peerDependencies['@babel/core'])"`,
     checkRequires: "@rollup/plugin-babel",
     expect: "^7.0.0",
     manualCheck: null,
@@ -2791,7 +3204,7 @@ var PINNED_VERSIONS = {
     why: "Held on 7.x for the same reason as @babel/core, and it has to move as one set: 8.0.1 peers on `@babel/core@^8.0.0`. Only ever added for rollup + react, which is exactly where @rollup/plugin-babel forces 7."
   },
   "@babel/preset-typescript": {
-    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@rollup/plugin-babel/package.json','utf8')).peerDependencies['@babel/core'])"`,
     checkRequires: "@rollup/plugin-babel",
     expect: "^7.0.0",
     manualCheck: null,
@@ -2813,23 +3226,73 @@ var PINNED_VERSIONS = {
   "@codemirror/state": {
     check: `node -e "process.stdout.write(require('obsidian/package.json').peerDependencies['@codemirror/state'])"`,
     checkRequires: "obsidian",
-    expect: "6.5.0",
+    expect: "6.7.6",
     manualCheck: null,
     needsOverride: true,
     section: "devDependencies",
-    version: "6.5.0",
+    version: "6.7.6",
     why: "obsidian peers on this exact version. Anything else fails npm install with ERESOLVE, and a second copy in the tree breaks editor extensions at runtime."
   },
   "@codemirror/view": {
     check: `node -e "process.stdout.write(require('obsidian/package.json').peerDependencies['@codemirror/view'])"`,
     checkRequires: "obsidian",
-    expect: "6.38.6",
+    expect: "6.43.13",
     manualCheck: null,
     needsOverride: true,
     section: "devDependencies",
-    version: "6.38.6",
+    version: "6.43.13",
     why: "obsidian peers on this exact version. Anything else fails npm install with ERESOLVE, and a second copy in the tree breaks editor extensions at runtime."
   },
+  "@wdio/cli": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/wdio-obsidian-service/package.json','utf8')).peerDependencies.webdriverio)"`,
+    checkRequires: "wdio-obsidian-service",
+    expect: "^9.18.1",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^9.32.0",
+    why: "wdio-obsidian-service peers on `webdriverio ^9.18.1`, while the registry tags wdio 10 as latest. Resolving latest installed a webdriverio 10 tree beside the service and failed `npm install` with ERESOLVE. The wdio packages move as one set, and the check reads the service's own peer range, so the pin retires itself when that moves to ^10."
+  },
+  "@wdio/globals": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/wdio-obsidian-service/package.json','utf8')).peerDependencies.webdriverio)"`,
+    checkRequires: "wdio-obsidian-service",
+    expect: "^9.18.1",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^9.31.3",
+    why: "wdio-obsidian-service peers on `webdriverio ^9.18.1`, while the registry tags wdio 10 as latest. Resolving latest installed a webdriverio 10 tree beside the service and failed `npm install` with ERESOLVE. The wdio packages move as one set, and the check reads the service's own peer range, so the pin retires itself when that moves to ^10."
+  },
+  "@wdio/local-runner": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/wdio-obsidian-service/package.json','utf8')).peerDependencies.webdriverio)"`,
+    checkRequires: "wdio-obsidian-service",
+    expect: "^9.18.1",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^9.32.0",
+    why: "wdio-obsidian-service peers on `webdriverio ^9.18.1`, while the registry tags wdio 10 as latest. Resolving latest installed a webdriverio 10 tree beside the service and failed `npm install` with ERESOLVE. The wdio packages move as one set, and the check reads the service's own peer range, so the pin retires itself when that moves to ^10."
+  },
+  "@wdio/mocha-framework": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/wdio-obsidian-service/package.json','utf8')).peerDependencies.webdriverio)"`,
+    checkRequires: "wdio-obsidian-service",
+    expect: "^9.18.1",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^9.32.0",
+    why: "wdio-obsidian-service peers on `webdriverio ^9.18.1`, while the registry tags wdio 10 as latest. Resolving latest installed a webdriverio 10 tree beside the service and failed `npm install` with ERESOLVE. The wdio packages move as one set, and the check reads the service's own peer range, so the pin retires itself when that moves to ^10."
+  },
+  "expect-webdriverio": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/wdio-obsidian-service/package.json','utf8')).peerDependencies.webdriverio)"`,
+    checkRequires: "wdio-obsidian-service",
+    expect: "^9.18.1",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^6.1.0",
+    why: "Held on 6.x with the wdio packages: expect-webdriverio 7 and later peer on `webdriverio ^10`, and @wdio/globals 9 peers on `expect-webdriverio ^6`. wdio-obsidian-service peers on `webdriverio ^9.18.1`, while the registry tags wdio 10 as latest. Resolving latest installed a webdriverio 10 tree beside the service and failed `npm install` with ERESOLVE. The wdio packages move as one set, and the check reads the service's own peer range, so the pin retires itself when that moves to ^10."
+  },
   "moment": {
     check: null,
     checkRequires: null,
@@ -2856,17 +3319,25 @@ var ADVISORY_OVERRIDES = {
     check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@wdio/utils/package.json','utf8')).dependencies['@puppeteer/browsers'])"`,
     expect: "^2.2.0",
     manualCheck: "The check reads @wdio/utils's own declared range, not a version, because that range is what makes the override necessary. When it moves to ^3 or later, @wdio/utils no longer pulls extract-zip in and both this override and this entry can go.",
-    requires: ["obsidian-dev-utils", "wdio-obsidian-service"],
+    requires: ["obsidian-integration-testing", "wdio-obsidian-service"],
     spec: "^3.2.1",
     why: "Clears GHSA-jmr9-qjv8-65gv (extract-zip unvalidated symlink path traversal). extract-zip is vulnerable at every published version, so there is nothing to override it to, and the direct dependency cannot be bumped either: even the newest webdriverio reaches extract-zip through @wdio/utils -> @puppeteer/browsers ^2.x. @puppeteer/browsers@3 replaced extract-zip with modern-tar, so forcing 3.x on @wdio/utils, the only consumer left on 2.x, removes the subtree. @wdio/utils imports only install, canDownload, resolveBuildId, detectBrowserPlatform, Browser, ChromeReleaseChannel, computeExecutablePath and the InstallOptions type, all still exported by 3.x, and both packages are ESM-only. Never take the `npm audit fix --force` remedy: it downgrades obsidian-integration-testing to 1.1.2."
   },
   "deepmerge-ts": {
-    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@wdio/utils/package.json','utf8')).dependencies['deepmerge-ts'])"`,
+    check: `node -e "const fs=require('node:fs');const path=['node_modules/obsidian-integration-testing/node_modules/@wdio/utils/package.json','node_modules/@wdio/utils/package.json'].find((candidate)=>fs.existsSync(candidate));process.stdout.write(JSON.parse(fs.readFileSync(path,'utf8')).dependencies['deepmerge-ts'])"`,
     expect: "^7.0.3",
-    manualCheck: "The check reads the range @wdio/utils declares, which is what forces the override. When it moves to ^8 or later the override and this entry can go. Before lifting it, re-run the deepmergeCustom probe: @wdio/config passes a `mergeArrays` handler that reads `meta.key`, and that is the API 8.0.0 renamed.",
-    requires: ["obsidian-dev-utils", "wdio-obsidian-service"],
+    manualCheck: "The check reads the range declared by the @wdio/utils that obsidian-integration-testing reaches, nested under it when the project also has a newer wdio, which is what forces the override. When it moves to ^8 or later the override and this entry can go. Before lifting it, re-run the deepmergeCustom probe: @wdio/config passes a `mergeArrays` handler that reads `meta.key`, and that is the API 8.0.0 renamed.",
+    requires: ["obsidian-integration-testing"],
     spec: "^8.0.2",
-    why: "Clears GHSA-ggr8-5vv4-36mx (stack exhaustion merging recursive object graphs), patched in 8.0.0. Every wdio package still declares ^7.0.3, including the newest, so no direct bump reaches it and `npm audit fix --force` only offers a downgrade of obsidian-integration-testing to 1.1.2. The forced major is safe for these consumers: 8.0.0 breaks by renaming the mergeInfo system and aligning the customization shorthand, and both surfaces were measured to behave identically on 7.1.6 and 8.0.1 in the exact shapes the tree uses -- @wdio/config's `deepmergeCustom` with a `mergeArrays` handler reading `meta.key` and returning `utils.actions.defaultMerge`, and webdriver's `deepmergeCustom({ mergeArrays: false })`. A scan of the whole installed tree found no other binding than `deepmerge` and `deepmergeCustom`."
+    why: "Clears GHSA-ggr8-5vv4-36mx (stack exhaustion merging recursive object graphs), patched in 8.0.0. @wdio/utils declares ^7.0.3 up to 9.30, and obsidian-integration-testing pins webdriverio 9.27.0, so no direct bump reaches it and `npm audit fix --force` only offers a downgrade of obsidian-integration-testing to 1.1.2. The forced major is safe for these consumers: 8.0.0 breaks by renaming the mergeInfo system and aligning the customization shorthand, and both surfaces were measured to behave identically on 7.1.6 and 8.0.1 in the exact shapes the tree uses -- @wdio/config's `deepmergeCustom` with a `mergeArrays` handler reading `meta.key` and returning `utils.actions.defaultMerge`, and webdriver's `deepmergeCustom({ mergeArrays: false })`. A scan of the whole installed tree found no other binding than `deepmerge` and `deepmergeCustom`."
+  },
+  "re2js": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/markdownlint/package.json','utf8')).dependencies.re2js)"`,
+    expect: "2.8.6",
+    manualCheck: "The check reads the exact re2js pin of the installed markdownlint, which moves only when a markdownlint-cli2 release pins a newer markdownlint. When it reads 2.8.7 or later, drop the override and this entry and re-run `npm audit`.",
+    requires: ["markdownlint", "markdownlint-cli2", "@mnaoumov/typescript-dev-toolkit", "@mnaoumov/obsidian-dev-toolkit"],
+    spec: "^2.9.1",
+    why: "Clears GHSA-gg6h-894w-4m9c (RE2JS quadratic-time denial of service in lookbehind matching, >=2.2.0 <2.8.7). Reached only through markdownlint, whose newest release 0.42.0 pins re2js at the exact 2.8.6, and markdownlint-cli2 0.24.0 pins that markdownlint exactly in turn, so no bump reaches the fix. The toolkits reach it through their own markdownlint-cli2. 2.9.1 is the version markdownlint itself moved to upstream, so the forced minor is the one it is tested against. Never take the `npm audit fix --force` remedy: it downgrades the toolkit packages."
   },
   "serialize-javascript": {
     check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/mocha/package.json','utf8')).dependencies['serialize-javascript'])"`,
@@ -2882,6 +3353,8 @@ var FALLBACK_MIN_APP_VERSION = "1.13.0";
 var FALLBACK_VERSION = "latest";
 var JSON_INDENT_SPACES2 = 2;
 var REGISTRY_URL = "https://registry.npmjs.org";
+var ABBREVIATED_PACKUMENT_MEDIA_TYPE = "application/vnd.npm.install-v1+json";
+var CONSTRAINING_PACKAGES = ["@mnaoumov/obsidian-dev-toolkit", "@mnaoumov/typescript-dev-toolkit"];
 function buildOverrides(dependencies) {
   const overrides = {};
   for (const packageName of getPinnedPackageNames(dependencies)) {
@@ -2985,22 +3458,68 @@ async function resolveVersions(dependencies) {
     }
     unresolved.push(dependency.packageName);
   }
-  const fetched = await Promise.all(unresolved.map(fetchLatestVersion));
   const failed = [];
-  for (const [index, version] of fetched.entries()) {
-    const packageName = unresolved[index] ?? "";
-    if (version === null) {
+  const constraints = /* @__PURE__ */ new Map();
+  function record(packageName, resolution) {
+    if (resolution === null) {
       failed.push(packageName);
       resolved.set(packageName, FALLBACK_VERSION);
+      return;
+    }
+    resolved.set(packageName, resolution.spec);
+    if (resolution.heldBelow !== null) {
+      log3.info(`Holding ${packageName} on ${resolution.spec}, the range ${resolution.heldBy ?? ""} declares, rather than the latest ${resolution.heldBelow}.`);
+    }
+  }
+  for (const constrainer of CONSTRAINING_PACKAGES) {
+    if (!unresolved.includes(constrainer)) {
+      continue;
+    }
+    const resolution = await resolveWithin(constrainer, constraints.get(constrainer));
+    record(constrainer, resolution);
+    if (resolution === null) {
       continue;
     }
-    resolved.set(packageName, `^${version}`);
+    const manifest = await fetchManifest(constrainer, resolution.version);
+    for (const [packageName, range] of Object.entries({ ...manifest?.peerDependencies, ...manifest?.dependencies })) {
+      if (!constraints.has(packageName)) {
+        constraints.set(packageName, { by: constrainer, range });
+      }
+    }
+  }
+  const rest = unresolved.filter((packageName) => !CONSTRAINING_PACKAGES.includes(packageName));
+  const resolutions = await Promise.all(rest.map((packageName) => resolveWithin(packageName, constraints.get(packageName))));
+  for (const [index, resolution] of resolutions.entries()) {
+    record(rest[index] ?? "", resolution);
   }
   if (failed.length > 0) {
-    log2.warn(`Could not look up the latest version of ${failed.join(", ")}. Falling back to "${FALLBACK_VERSION}".`);
+    log3.warn(`Could not look up the latest version of ${failed.join(", ")}. Falling back to "${FALLBACK_VERSION}".`);
   }
   return resolved;
 }
+async function fetchManifest(packageName, version) {
+  try {
+    const response = await fetch(`${REGISTRY_URL}/${packageName}/${version}`);
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchPublishedVersions(packageName) {
+  try {
+    const response = await fetch(`${REGISTRY_URL}/${packageName}`, { headers: { accept: ABBREVIATED_PACKUMENT_MEDIA_TYPE } });
+    if (!response.ok) {
+      return null;
+    }
+    const packument = await response.json();
+    return Object.keys(packument.versions ?? {});
+  } catch {
+    return null;
+  }
+}
 function getAdvisoryOverrides(dependencies) {
   return Object.entries(ADVISORY_OVERRIDES).filter(([, advisoryOverride]) => advisoryOverride.requires.some((packageName) => hasPackage(dependencies, packageName))).sort(([a], [b]) => a.localeCompare(b));
 }
@@ -3010,11 +3529,31 @@ function getPinnedPackageNames(dependencies) {
 function hasPackage(dependencies, packageName) {
   return dependencies.some((dependency) => dependency.packageName === packageName);
 }
+function isCaretWithin(version, range) {
+  if (version === null || validRange(range) === null) {
+    return false;
+  }
+  return subset(`^${version}`, range);
+}
+async function resolveWithin(packageName, constraint) {
+  const latest = await fetchLatestVersion(packageName);
+  if (constraint === void 0 || isCaretWithin(latest, constraint.range)) {
+    return latest === null ? null : { heldBelow: null, heldBy: null, spec: `^${latest}`, version: latest };
+  }
+  const versions = await fetchPublishedVersions(packageName);
+  const newest = versions === null ? null : maxSatisfying(versions, constraint.range);
+  if (newest === null) {
+    return { heldBelow: latest, heldBy: constraint.by, spec: constraint.range, version: minVersion(constraint.range)?.version ?? constraint.range };
+  }
+  const spec = isCaretWithin(newest, constraint.range) ? `^${newest}` : constraint.range;
+  return { heldBelow: latest, heldBy: constraint.by, spec, version: newest };
+}
 
 // src/templates.ts
 var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([".wasm"]);
 var JSON_INDENT_SPACES3 = 2;
 var UNRESOLVED_VERSION = "latest";
+var TOOLKIT_WORKFLOW_REF = "3.0.0";
 var BASE_TEMPLATE_FILES = [
   // Never empty: `tslib` and `typescript` below are false positives on every answer set.
   ".depcheckrc.json",
@@ -3023,6 +3562,9 @@ var BASE_TEMPLATE_FILES = [
   ".gitattributes",
   ".gitignore",
   ".npmrc",
+  // The same Node major as this repo's own `.nvmrc`. Every CI workflow reads it, the toolkit's reusable ones by
+  // Default, and without it they fall back to the latest LTS, which is not the version the project is developed on.
+  ".nvmrc",
   "CONTRIBUTING.md",
   "LICENSE",
   "README.md",
@@ -3080,7 +3622,9 @@ var DEMO_OVERRIDES = [
   { answerKey: "spellChecker", demoValue: "cspell", options: SPELL_CHECKER_OPTIONS },
   { answerKey: "styling", demoValue: "scss", options: STYLING_OPTIONS }
 ];
-function buildTemplate(answers, overlay = null) {
+var DEMO_PINNED_ANSWERS = { bundler: "esbuild", uiFramework: "none" };
+function buildTemplate(givenAnswers, overlay = null) {
+  const answers = pinPresetAnswers(givenAnswers);
   const builder = new TemplateBuilder();
   builder.addFiles(BASE_TEMPLATE_FILES).addPackage("@types/node").addPackage("jiti").addPackage("obsidian").addPackage("tslib").addDepcheckIgnore("tslib", "never imported by name: `importHelpers: true` in `tsconfig.json` makes the compiled output import it.").addPackage("typescript").addDepcheckIgnore("typescript", "the compiler `tsconfig.json` configures, reached by `tsc`, by the TypeScript step of the bundler and by the editor rather than by an import.").addSentenceCaseBrand(answers.pluginName).addPartial("common");
   const funding = resolveFunding(answers);
@@ -3114,45 +3658,53 @@ function buildTemplate(answers, overlay = null) {
       builder.addPartial(option.partialName);
     }
   }
+  if (builder.lintStagedPatterns.length > 0) {
+    addStagedFilesHook(builder, answers.preset);
+  }
+  if (isFrameworkPreset(answers.preset) && builder.buildOptions.length > 0) {
+    builder.addFiles(["scripts/build-options.ts"]);
+  }
   if (overlay) {
     applyOverlay(builder, overlay);
   }
-  if (builder.lintStagedPatterns.length > 0) {
-    addStagedFilesHook(builder);
-  }
   return builder;
 }
-function copyTemplates(answers, targetDir, currentVersion, existingConfig, resolvedVersions = /* @__PURE__ */ new Map(), minAppVersion = FALLBACK_MIN_APP_VERSION, overlay = null, projectFormatter) {
-  const templatesDir = join(getScriptDir(), "..", "templates", "default");
+function copyTemplates(givenAnswers, targetDir, currentVersion, existingConfig, resolvedVersions = /* @__PURE__ */ new Map(), minAppVersion = FALLBACK_MIN_APP_VERSION, overlay = null, projectFormatter) {
+  const answers = pinPresetAnswers(givenAnswers);
+  const templatesDir = join3(getScriptDir(), "..", "templates", "default");
+  const overlayIndex = overlay ? indexTemplateDir(overlay.dir) : null;
+  const builtInIndex = getBuiltInTemplateIndex(templatesDir);
   function findTemplate(relativePath) {
-    if (overlay) {
-      const overlayPath = join(overlay.dir, relativePath);
-      if (existsSync2(overlayPath)) {
-        return overlayPath;
-      }
+    const overlayPath = overlayIndex?.get(relativePath);
+    if (overlay && overlayPath !== void 0) {
+      return join3(overlay.dir, overlayPath);
     }
-    const builtInPath = join(templatesDir, relativePath);
-    return existsSync2(builtInPath) ? builtInPath : null;
+    const builtInPath = builtInIndex.get(relativePath);
+    return builtInPath === void 0 ? null : join3(templatesDir, builtInPath);
   }
-  const newConfig = {
-    fileHashes: {},
-    generatorVersion: currentVersion
-  };
   const builder = buildTemplate(answers, overlay);
   const templateFiles = builder.templateFiles;
   const partials = builder.partials;
   const dependencies = builder.dependencies;
+  const hasBuildOptions = templateFiles.has("scripts/build-options.ts");
   let currentTemplatePath = "";
   let renderRoot = "";
   const templateContext = {
     ...answers,
     ...getFundingTemplateContext(answers),
     _badges: builder.badges,
+    _buildOptionsArgument: hasBuildOptions ? "buildOptions" : "",
+    _buildOptionsImport: hasBuildOptions ? "\nimport { buildOptions } from './build-options.ts';\n" : "",
+    _buildOptionsLiteral: toObjectLiteral(builder.buildOptions),
+    _cspellIdentityWords: getCspellIdentityWords(answers),
     _depcheckIgnores: builder.depcheckIgnores,
     _dependencies: dependencies.map((dependency) => ({
       packageName: dependency.packageName,
       version: dependency.version ?? resolvedVersions.get(dependency.packageName) ?? PINNED_VERSIONS[dependency.packageName]?.version ?? UNRESOLVED_VERSION
     })),
+    // The README's `support` seam opens `## Support` in the funding partial, so the issue-filing partial
+    // After it opens the section itself only when there is no funding.
+    _hasFunding: partials.has("has-funding"),
     _lintStagedPatterns: builder.lintStagedPatterns,
     _minAppVersion: minAppVersion,
     _overrides: Object.entries(buildOverrides(dependencies)).map(([packageName, spec]) => ({ packageName, spec })),
@@ -3161,6 +3713,8 @@ function copyTemplates(answers, targetDir, currentVersion, existingConfig, resol
     _resolutions: Object.entries(buildResolutions(dependencies)).map(([packageName, spec]) => ({ packageName, spec })),
     _scripts: builder.scripts,
     _sentenceCaseBrands: builder.sentenceCaseBrands,
+    _toolkitWorkflowRef: TOOLKIT_WORKFLOW_REF,
+    _tsconfigExtendsJson: toTsconfigExtendsJson(builder.tsconfigExtends),
     pluginShortName: getPluginShortName(answers.pluginId),
     render(options) {
       const { indentLevel, section } = typeof options === "string" ? { indentLevel: 0, section: options } : { indentLevel: 0, section: void 0, ...options };
@@ -3176,7 +3730,7 @@ function copyTemplates(answers, targetDir, currentVersion, existingConfig, resol
         }
         currentTemplatePath = partialPath;
         renderRoot = previousRenderRoot || partialPath;
-        let rendered = ejs.render(readFileSync2(fullPath, "utf-8"), templateContext);
+        let rendered = ejs.render(readFileSync3(fullPath, "utf-8"), templateContext);
         if (indentLevel > 0) {
           const indent = "  ".repeat(indentLevel);
           rendered = rendered.replaceAll(/^(?<Content>.+)$/gm, `${indent}$<Content>`);
@@ -3192,7 +3746,7 @@ function copyTemplates(answers, targetDir, currentVersion, existingConfig, resol
      *
      * A section that contributes imports emits them in PARTIAL order, which is the order the answers were
      * registered in {@link FEATURE_REGISTRIES} -- and that has nothing to do with the order an
-     * import-sorting lint rule wants. The obsidian-dev-utils presets now adopt that package's shared
+     * import-sorting lint rule wants. The toolkit presets now adopt obsidian-dev-toolkit's shared
      * ESLint config, which sorts imports as an ERROR, so `uiFramework=lit editorExtensions=codemirror`
      * emitted a `src/plugin.ts` that was red the moment it was generated. The sorting cannot be pushed
      * into the partials: each one knows only itself, and which others are beside it is the answer set.
@@ -3201,75 +3755,40 @@ function copyTemplates(answers, targetDir, currentVersion, existingConfig, resol
       return sortImportStatements(text3);
     }
   };
-  const skipped = [];
-  const updated = [];
-  const created = [];
-  const written = [];
+  const renderedFiles = [];
   for (const registeredPath of templateFiles) {
     const destinationPath = getDestinationPath(registeredPath, answers);
-    const fullDestinationPath = join(targetDir, destinationPath);
     const isAsset = ASSET_EXTENSIONS.has(extname(registeredPath));
     const ejsPath = findTemplate(`${registeredPath}.ejs`);
     let rendered;
     if (isAsset) {
       currentTemplatePath = registeredPath;
-      rendered = readFileSync2(findTemplate(registeredPath) ?? join(templatesDir, registeredPath));
+      rendered = readFileSync3(findTemplate(registeredPath) ?? join3(templatesDir, registeredPath));
     } else if (ejsPath === null) {
       currentTemplatePath = `${registeredPath}.ejs`;
       rendered = templateContext["render"]();
     } else {
       currentTemplatePath = `${registeredPath}.ejs`;
       try {
-        rendered = ejs.render(readFileSync2(ejsPath, "utf-8"), templateContext);
+        rendered = ejs.render(readFileSync3(ejsPath, "utf-8"), templateContext);
       } catch (error) {
         if (overlay && ejsPath.startsWith(overlay.dir)) {
           throw new Error(`${ejsPath} failed to render: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
-        rendered = readFileSync2(ejsPath, "utf-8");
-      }
-    }
-    const newHash = sha256(rendered);
-    if (existingConfig && existsSync2(fullDestinationPath)) {
-      const currentContent = isAsset ? readFileSync2(fullDestinationPath) : readFileSync2(fullDestinationPath, "utf-8");
-      const currentHash = sha256(currentContent);
-      const originalHash = existingConfig.fileHashes[destinationPath];
-      if (matchesRender(currentHash, newHash, projectFormatter, destinationPath, rendered)) {
-        newConfig.fileHashes[destinationPath] = currentHash;
-        continue;
-      }
-      if (originalHash === void 0) {
-        skipped.push(destinationPath);
-        continue;
-      }
-      if (currentHash !== originalHash) {
-        skipped.push(destinationPath);
-        newConfig.fileHashes[destinationPath] = originalHash;
-        continue;
+        rendered = readFileSync3(ejsPath, "utf-8");
       }
-      updated.push(destinationPath);
-    } else {
-      created.push(destinationPath);
-    }
-    newConfig.fileHashes[destinationPath] = newHash;
-    const destDir = dirname(fullDestinationPath);
-    if (!existsSync2(destDir)) {
-      mkdirSync(destDir, { recursive: true });
     }
-    writeFileSync(fullDestinationPath, rendered);
-    written.push(destinationPath);
+    renderedFiles.push({ content: rendered, destinationPath });
   }
-  formatWrittenFiles(projectFormatter, targetDir, written, newConfig);
-  const configPath = join(targetDir, CONFIG_FILE_NAME);
-  writeFileSync(configPath, `${JSON.stringify(newConfig, null, JSON_INDENT_SPACES3)}
-`);
-  if (existingConfig) {
-    logUpdateSummary(updated, created, skipped);
+  if (answers.preset === DOCS_SHOWCASE_PRESET) {
+    renderedFiles.push(...readDocsShowcaseFiles(join3(getScriptDir(), "..")));
   }
-  return newConfig;
+  return writeGeneratedFiles(renderedFiles, targetDir, currentVersion, existingConfig, projectFormatter);
 }
 function getDestinationPath(templatePath, answers) {
   return templatePath.replace(/%= (?<AnswerKey>.+?) %/g, (_match, ...args) => String(answers[String(args[0])]));
 }
+var builtInTemplateIndexes = /* @__PURE__ */ new Map();
 function getScriptDir() {
   return dirname(fileURLToPath(import.meta.url));
 }
@@ -3279,20 +3798,23 @@ function isPartialTemplatePath(templatePath) {
   return markerIndex > 0 && PARTIAL_NAME_PATTERN.test(fileName.slice(markerIndex + 1));
 }
 function loadConfig(dir) {
-  const configPath = join(dir, CONFIG_FILE_NAME);
-  if (!existsSync2(configPath)) {
+  const configPath = join3(dir, CONFIG_FILE_NAME);
+  if (!existsSync4(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync2(configPath, "utf-8"));
+  const parsed = JSON.parse(readFileSync3(configPath, "utf-8"));
   const raw = parsed;
   migrateAnswers(raw);
   return parsed;
 }
+function pinPresetAnswers(answers) {
+  return answers.preset === "demo" ? { ...answers, ...DEMO_PINNED_ANSWERS } : answers;
+}
 function recordHashesOnDisk(targetDir, config) {
   const fileHashes = {};
   for (const [destinationPath, hash] of Object.entries(config.fileHashes)) {
-    const fullPath = join(targetDir, destinationPath);
-    fileHashes[destinationPath] = existsSync2(fullPath) ? sha256(readFileSync2(fullPath)) : hash;
+    const fullPath = join3(targetDir, destinationPath);
+    fileHashes[destinationPath] = existsSync4(fullPath) ? sha256(readFileSync3(fullPath)) : hash;
   }
   return { ...config, fileHashes };
 }
@@ -3321,6 +3843,56 @@ function sortImportStatements(text3) {
   return `${statements.join("\n")}
 `;
 }
+function writeGeneratedFiles(files, targetDir, currentVersion, existingConfig, projectFormatter) {
+  const newConfig = {
+    fileHashes: {},
+    generatorVersion: currentVersion
+  };
+  const skipped = [];
+  const updated = [];
+  const created = [];
+  const written = [];
+  for (const { content: rendered, destinationPath } of files) {
+    const fullDestinationPath = join3(targetDir, destinationPath);
+    const newHash = sha256(rendered);
+    if (existingConfig && existsSync4(fullDestinationPath)) {
+      const currentContent = Buffer.isBuffer(rendered) ? readFileSync3(fullDestinationPath) : readFileSync3(fullDestinationPath, "utf-8");
+      const currentHash = sha256(currentContent);
+      const originalHash = existingConfig.fileHashes[destinationPath];
+      if (matchesRender(currentHash, newHash, projectFormatter, destinationPath, rendered)) {
+        newConfig.fileHashes[destinationPath] = currentHash;
+        continue;
+      }
+      if (originalHash === void 0) {
+        skipped.push(destinationPath);
+        continue;
+      }
+      if (currentHash !== originalHash) {
+        skipped.push(destinationPath);
+        newConfig.fileHashes[destinationPath] = originalHash;
+        continue;
+      }
+      updated.push(destinationPath);
+    } else {
+      created.push(destinationPath);
+    }
+    newConfig.fileHashes[destinationPath] = newHash;
+    const destDir = dirname(fullDestinationPath);
+    if (!existsSync4(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+    writeFileSync(fullDestinationPath, rendered);
+    written.push(destinationPath);
+  }
+  formatWrittenFiles(projectFormatter, targetDir, written, newConfig);
+  const configPath = join3(targetDir, CONFIG_FILE_NAME);
+  writeFileSync(configPath, `${JSON.stringify(newConfig, null, JSON_INDENT_SPACES3)}
+`);
+  if (existingConfig) {
+    logUpdateSummary(updated, created, skipped);
+  }
+  return newConfig;
+}
 function applyOverlay(builder, overlay) {
   builder.addFiles([...overlay.files]);
   for (const packageName of overlay.packages) {
@@ -3343,8 +3915,20 @@ function formatWrittenFiles(projectFormatter, targetDir, written, config) {
   }
   projectFormatter.formatFiles(textFiles);
   for (const destinationPath of textFiles) {
-    config.fileHashes[destinationPath] = sha256(readFileSync2(join(targetDir, destinationPath)));
+    config.fileHashes[destinationPath] = sha256(readFileSync3(join3(targetDir, destinationPath)));
+  }
+}
+function getBuiltInTemplateIndex(templatesDir) {
+  let index = builtInTemplateIndexes.get(templatesDir);
+  if (index === void 0) {
+    index = indexTemplateDir(templatesDir);
+    builtInTemplateIndexes.set(templatesDir, index);
   }
+  return index;
+}
+function getCspellIdentityWords(answers) {
+  const words = [answers.authorGitHubName, "mnaoumov"];
+  return words.filter((word, index) => words.findIndex((other) => other.toLowerCase() === word.toLowerCase()) === index);
 }
 function getFundingTemplateContext(answers) {
   const funding = resolveFunding(answers);
@@ -3363,25 +3947,25 @@ function importedModule(block) {
 }
 function logUpdateSummary(updated, created, skipped) {
   if (updated.length > 0) {
-    log3.success(`Updated ${String(updated.length)} file(s):`);
+    log4.success(`Updated ${String(updated.length)} file(s):`);
     for (const f of updated) {
-      log3.info(`  ${f}`);
+      log4.info(`  ${f}`);
     }
   }
   if (created.length > 0) {
-    log3.success(`Created ${String(created.length)} new file(s):`);
+    log4.success(`Created ${String(created.length)} new file(s):`);
     for (const f of created) {
-      log3.info(`  ${f}`);
+      log4.info(`  ${f}`);
     }
   }
   if (skipped.length > 0) {
-    log3.warn(`Skipped ${String(skipped.length)} file(s) with local modifications:`);
+    log4.warn(`Skipped ${String(skipped.length)} file(s) with local modifications:`);
     for (const f of skipped) {
-      log3.info(`  ${f}`);
+      log4.info(`  ${f}`);
     }
   }
   if (updated.length === 0 && created.length === 0) {
-    log3.info("Everything is already up to date.");
+    log4.info("Everything is already up to date.");
   }
 }
 function matchesRender(currentHash, newHash, projectFormatter, destinationPath, rendered) {
@@ -3416,6 +4000,11 @@ function migrateAnswers(raw) {
   answers["fundingUsername"] ??= answers["authorGitHubName"];
   answers["coverageBadge"] ??= "none";
   delete answers["pluginShortName"];
+  for (const [key, value] of Object.entries(answers)) {
+    if (typeof value === "string") {
+      answers[key] = resolveDeprecatedAnswer(key, value, CONFIG_FILE_NAME);
+    }
+  }
 }
 function migrateFundingAnswers(answers) {
   if (answers["fundingPlatform"] !== void 0) {
@@ -3450,8 +4039,209 @@ function migrateFundingAnswers(answers) {
 function sha256(content) {
   return createHash("sha256").update(content).digest("hex");
 }
+function toObjectLiteral(options) {
+  return options.length === 0 ? "{}" : `{
+${options.map((option) => `  ${option.key}: ${option.value}`).join(",\n")}
+}`;
+}
+function toTsconfigExtendsJson(extraConfigs) {
+  const base = JSON.stringify("@tsconfig/strictest/tsconfig.json");
+  return extraConfigs.length === 0 ? base : `[
+${[base, ...extraConfigs.map((config) => JSON.stringify(config))].map((config) => `    ${config}`).join(",\n")}
+  ]`;
+}
+
+// src/upstream-snapshot.ts
+import {
+  existsSync as existsSync5,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4
+} from "node:fs";
+import {
+  join as join4,
+  relative as relative2
+} from "node:path";
+var VENDORED_SUFFIX = ".vendored";
+var REGULAR_FILE_MODES = /* @__PURE__ */ new Set(["100644", "100755"]);
+async function fetchUpstreamSnapshot(repo, ref) {
+  const headers = { Accept: "application/vnd.github+json" };
+  const token = process.env["GITHUB_TOKEN"];
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const commit = await fetchJson(`https://api.github.com/repos/${repo}/commits/${encodeURIComponent(ref)}`, headers);
+  const tree = await fetchJson(`https://api.github.com/repos/${repo}/git/trees/${commit.sha}?recursive=1`, headers);
+  if (tree.truncated) {
+    throw new Error(`The tree of ${repo}@${commit.sha} is too large for one API response.`);
+  }
+  const paths = tree.tree.filter((entry) => entry.type === "blob" && REGULAR_FILE_MODES.has(entry.mode)).map((entry) => entry.path);
+  const contents = await Promise.all(paths.map(async (path) => {
+    const response = await fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/${path.split("/").map(encodeURIComponent).join("/")}`);
+    if (!response.ok) {
+      throw new Error(`Could not download ${path} from ${repo}@${commit.sha}: HTTP ${String(response.status)}.`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  }));
+  return {
+    commit: commit.sha,
+    files: new Map(paths.map((path, index) => [path, contents[index] ?? Buffer.alloc(0)]))
+  };
+}
+function readUpstream(upstreamsPath, name) {
+  const parsed = JSON.parse(readFileSync4(upstreamsPath, "utf-8"));
+  const upstream = parsed.upstreams.find((candidate) => candidate.name === name);
+  if (!upstream) {
+    throw new Error(`${upstreamsPath} has no upstream named "${name}".`);
+  }
+  return upstream;
+}
+function readVendoredFiles(dir) {
+  const files = /* @__PURE__ */ new Map();
+  if (!existsSync5(dir)) {
+    return files;
+  }
+  const paths = readdirSync3(dir, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(VENDORED_SUFFIX)).map((entry) => join4(entry.parentPath, entry.name)).sort();
+  for (const fullPath of paths) {
+    const upstreamPath = relative2(dir, fullPath).replaceAll("\\", "/").slice(0, -VENDORED_SUFFIX.length);
+    files.set(upstreamPath, readFileSync4(fullPath));
+  }
+  return files;
+}
+async function fetchJson(url, headers) {
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(`GET ${url} failed: HTTP ${String(response.status)}.`);
+  }
+  return await response.json();
+}
+
+// src/official-sample.ts
+var OFFICIAL_SAMPLE_UPSTREAM_NAME = "obsidian-sample-plugin";
+var OFFICIAL_SAMPLE_FILES_DIR = join5("templates", "official-sample", "files");
+var OFFICIAL_SAMPLE_PINNED_ANSWERS = {
+  formatter: "none",
+  packageManager: "npm"
+};
+function applyOfficialSampleIdentity(files, answers) {
+  const packageName = `obsidian-${answers.pluginId}`;
+  const result = new Map(files);
+  editJson(result, "manifest.json", (manifest) => {
+    const fundingUrl = resolveFunding(answers)?.getUrl(answers);
+    const edited = {};
+    for (const [key, value] of Object.entries(manifest)) {
+      switch (key) {
+        case "author":
+          edited[key] = answers.authorName;
+          break;
+        case "authorUrl":
+          edited[key] = `https://github.com/${answers.authorGitHubName}`;
+          break;
+        case "description":
+          edited[key] = answers.pluginDescription;
+          break;
+        case "fundingUrl":
+          if (fundingUrl) {
+            edited[key] = fundingUrl;
+          }
+          break;
+        case "id":
+          edited[key] = answers.pluginId;
+          break;
+        case "name":
+          edited[key] = answers.pluginName;
+          break;
+        default:
+          edited[key] = value;
+      }
+    }
+    return edited;
+  });
+  const upstreamPackageName = readUpstreamPackageName(files);
+  editJson(result, "package.json", (packageJson) => ({ ...packageJson, name: packageName }));
+  editJson(result, "package-lock.json", (lock) => renamePackageInLock(lock, upstreamPackageName, packageName));
+  const readme = result.get("README.md");
+  if (readme) {
+    result.set("README.md", Buffer.from(readme.toString("utf-8").replace(/^# .*$/m, `# ${answers.pluginName}`), "utf-8"));
+  }
+  return result;
+}
+function copyOfficialSample(answers, targetDir, currentVersion, existingConfig, snapshot) {
+  const files = applyOfficialSampleIdentity(snapshot.files, answers);
+  const config = writeGeneratedFiles(
+    [...files].map(([destinationPath, content]) => ({ content, destinationPath })),
+    targetDir,
+    currentVersion,
+    existingConfig
+  );
+  return { ...config, upstreamCommit: snapshot.commit };
+}
+function getPackageRoot() {
+  return join5(getScriptDir(), "..");
+}
+function getUpstreamsPath() {
+  return join5(getPackageRoot(), "upstreams.json");
+}
+function loadOfficialSampleSnapshot() {
+  const upstream = readUpstream(getUpstreamsPath(), OFFICIAL_SAMPLE_UPSTREAM_NAME);
+  const files = readVendoredFiles(join5(getPackageRoot(), OFFICIAL_SAMPLE_FILES_DIR));
+  if (files.size === 0) {
+    throw new Error(`The vendored snapshot of ${upstream.repo} is missing from ${OFFICIAL_SAMPLE_FILES_DIR}.`);
+  }
+  return { commit: upstream.commit, files };
+}
+function editJson(files, path, edit) {
+  const content = files.get(path);
+  if (!content) {
+    return;
+  }
+  const text3 = content.toString("utf-8");
+  const indent = /^\{\r?\n(?<Indent>[ \t]+)/.exec(text3)?.groups?.["Indent"] ?? "	";
+  const finalNewline = /\r?\n$/.exec(text3)?.[0] ?? "";
+  const edited = edit(JSON.parse(text3));
+  files.set(path, Buffer.from(`${JSON.stringify(edited, null, indent)}${finalNewline}`, "utf-8"));
+}
+function readUpstreamPackageName(files) {
+  const content = files.get("package.json");
+  if (!content) {
+    return void 0;
+  }
+  const name = JSON.parse(content.toString("utf-8"))["name"];
+  return typeof name === "string" ? name : void 0;
+}
+function renamePackageInLock(lock, upstreamName, packageName) {
+  const renamed = { ...lock };
+  if (renamed["name"] === upstreamName) {
+    renamed["name"] = packageName;
+  }
+  const packages = renamed["packages"];
+  if (typeof packages === "object" && packages !== null) {
+    const root = packages[""];
+    if (typeof root === "object" && root !== null && root["name"] === upstreamName) {
+      renamed["packages"] = { ...packages, "": { ...root, name: packageName } };
+    }
+  }
+  return renamed;
+}
+
+// src/overlay.ts
+import {
+  existsSync as existsSync6,
+  readFileSync as readFileSync6,
+  statSync as statSync2
+} from "node:fs";
+import {
+  isAbsolute,
+  join as join7,
+  relative as relative3,
+  resolve
+} from "node:path";
 
-// src/plan-checks.ts
+// src/verification/plan-checks.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+import {
+  extname as extname2,
+  join as join6
+} from "node:path";
 var EJS_SUFFIX = ".ejs";
 var RENDER_SITE_PATTERN = /(?:<%[-=]?|\$\{)\s*render\(\s*(?:'(?<Section>[^']*)'|\{(?<Options>[^}]*)\})/g;
 var SECTION_OPTION_PATTERN = /section\s*:\s*'(?<Section>[^']*)'/;
@@ -3476,7 +4266,7 @@ function loadTemplateInventory(templatesDir = defaultTemplatesDir()) {
   const emptyTemplates = /* @__PURE__ */ new Set();
   const partials = [];
   const renderSites = [];
-  for (const relativePath of walkTemplates(templatesDir, "")) {
+  for (const [relativePath, physicalPath] of indexTemplateDir(templatesDir)) {
     if (ASSET_EXTENSIONS.has(extname2(relativePath))) {
       assetTemplates.add(relativePath);
       continue;
@@ -3485,7 +4275,7 @@ function loadTemplateInventory(templatesDir = defaultTemplatesDir()) {
       continue;
     }
     const withoutSuffix = relativePath.slice(0, -EJS_SUFFIX.length);
-    const body = readFileSync3(join2(templatesDir, relativePath), "utf-8");
+    const body = readFileSync5(join6(templatesDir, physicalPath), "utf-8");
     if (isPartialTemplatePath(relativePath)) {
       partials.push(parsePartialPath(relativePath));
     } else {
@@ -3538,7 +4328,7 @@ function parsePartialPath(relativePath) {
   };
 }
 function defaultTemplatesDir() {
-  return join2(getScriptDir(), "..", "templates", "default");
+  return join6(getScriptDir(), "..", "templates", "default");
 }
 function getRenderBase(templatePath) {
   if (!isPartialTemplatePath(templatePath)) {
@@ -3547,22 +4337,6 @@ function getRenderBase(templatePath) {
   const { basePath } = parsePartialPath(`${templatePath}${EJS_SUFFIX}`);
   return isPartialTemplatePath(basePath) ? getRenderBase(basePath) : templatePath;
 }
-function walkTemplates(templatesDir, relativeDir) {
-  const absoluteDir = join2(templatesDir, relativeDir);
-  if (!existsSync3(absoluteDir)) {
-    return [];
-  }
-  const found = [];
-  for (const entry of readdirSync(absoluteDir)) {
-    const relativePath = relativeDir === "" ? entry : `${relativeDir}/${entry}`;
-    if (statSync(join2(templatesDir, relativePath)).isDirectory()) {
-      found.push(...walkTemplates(templatesDir, relativePath));
-    } else {
-      found.push(relativePath);
-    }
-  }
-  return found;
-}
 
 // src/overlay.ts
 var OVERLAY_MANIFEST_FILE_NAME = "overlay.json";
@@ -3572,11 +4346,11 @@ var MANIFEST_KEYS = ["badges", "files", "packages", "partials"];
 var PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
 function loadOverlay(dir, builtIn = loadTemplateInventory()) {
   const absoluteDir = resolve(dir);
-  if (!existsSync4(absoluteDir) || !statSync2(absoluteDir).isDirectory()) {
+  if (!existsSync6(absoluteDir) || !statSync2(absoluteDir).isDirectory()) {
     throw new Error(`Custom template directory not found: ${absoluteDir}`);
   }
-  const manifestPath = join3(absoluteDir, OVERLAY_MANIFEST_FILE_NAME);
-  if (!existsSync4(manifestPath)) {
+  const manifestPath = join7(absoluteDir, OVERLAY_MANIFEST_FILE_NAME);
+  if (!existsSync6(manifestPath)) {
     throw new Error(`Custom template directory has no ${OVERLAY_MANIFEST_FILE_NAME}: ${absoluteDir}`);
   }
   const manifest = readManifest(manifestPath);
@@ -3589,7 +4363,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   return overlay;
 }
 function toRecordedOverlayPath(overlayDir, projectDir) {
-  const relativePath = relative(projectDir, overlayDir);
+  const relativePath = relative3(projectDir, overlayDir);
   return isAbsolute(relativePath) ? relativePath : relativePath.replaceAll("\\", "/");
 }
 function findManifestProblems(overlay, own, builtIn) {
@@ -3683,12 +4457,12 @@ function listStrayFiles(dir, own) {
     OVERLAY_MANIFEST_FILE_NAME,
     OVERLAY_README_FILE_NAME
   ]);
-  return walkFiles(dir, "").filter((path) => !accounted.has(path));
+  return [...indexTemplateDir(dir)].filter(([logicalPath]) => !accounted.has(logicalPath)).map(([, physicalPath]) => physicalPath);
 }
 function readManifest(manifestPath) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+    parsed = JSON.parse(readFileSync6(manifestPath, "utf-8"));
   } catch {
     throw new Error(`${manifestPath} is not valid JSON.`);
   }
@@ -3715,26 +4489,14 @@ function readManifest(manifestPath) {
     partials: readList("partials")
   };
 }
-function walkFiles(root, relativeDir) {
-  const found = [];
-  for (const entry of readdirSync2(join3(root, relativeDir))) {
-    const relativePath = relativeDir === "" ? entry : `${relativeDir}/${entry}`;
-    if (statSync2(join3(root, relativePath)).isDirectory()) {
-      found.push(...walkFiles(root, relativePath));
-    } else {
-      found.push(relativePath);
-    }
-  }
-  return found;
-}
 
 // src/project-formatter.ts
 import { spawnSync } from "node:child_process";
 import {
-  existsSync as existsSync5,
-  readFileSync as readFileSync5
+  existsSync as existsSync7,
+  readFileSync as readFileSync7
 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join8 } from "node:path";
 import process2 from "node:process";
 var FORMATTER_COMMANDS = {
   biome: {
@@ -3769,14 +4531,14 @@ function createProjectFormatter(targetDir, formatter) {
   };
 }
 function resolveBin(targetDir, packageName) {
-  const packageDir = join4(targetDir, "node_modules", packageName);
-  const packageJsonPath = join4(packageDir, "package.json");
-  if (!existsSync5(packageJsonPath)) {
+  const packageDir = join8(targetDir, "node_modules", packageName);
+  const packageJsonPath = join8(packageDir, "package.json");
+  if (!existsSync7(packageJsonPath)) {
     return null;
   }
-  const { bin } = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+  const { bin } = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
   const relativeBin = typeof bin === "string" ? bin : Object.values(bin ?? {})[0];
-  return relativeBin === void 0 ? null : join4(packageDir, relativeBin);
+  return relativeBin === void 0 ? null : join8(packageDir, relativeBin);
 }
 function runCli(binPath, targetDir, args, input) {
   const result = spawnSync(process2.execPath, [binPath, ...args], { cwd: targetDir, encoding: "utf-8", input });
@@ -3786,7 +4548,22 @@ function runCli(binPath, targetDir, args, input) {
 // src/main.ts
 var ARGV_OFFSET = 2;
 var JSON_INDENT_SPACES4 = 2;
+var SHORT_SHA_LENGTH = 7;
 var SCRIPT_MODE = 493;
+function applyPresetFlags(answers, cliArgs, hasOverlay) {
+  if (!isOfficialSamplePreset(answers.preset)) {
+    if (cliArgs.latest) {
+      exitWithUsageError(`--latest picks which upstream tree preset=official-sample copies, and the preset is ${answers.preset}.
+Drop --latest, or pass --preset=official-sample.`);
+    }
+    return answers;
+  }
+  if (hasOverlay) {
+    exitWithUsageError(`--customTemplate layers over the built-in templates, and preset=official-sample renders none: it copies obsidianmd/obsidian-sample-plugin as it is.
+Drop --customTemplate, or choose another preset.`);
+  }
+  return { ...answers, ...OFFICIAL_SAMPLE_PINNED_ANSWERS };
+}
 function assertManifestAnswersAreListable(answers) {
   const problems = findUnlistableManifestAnswers(answers);
   if (problems.length === 0) {
@@ -3802,7 +4579,7 @@ function buildSavedConfig(newConfig, answers, overlay, targetDir) {
 async function checkForUpdates(currentVersion) {
   const latestVer = await fetchLatestVersion("@mnaoumov/create-obsidian-plugin");
   if (latestVer !== null && compare(currentVersion, latestVer) < 0) {
-    log4.warn(`Your version is outdated. Latest: ${latestVer}. Update with:
+    log5.warn(`Your version is outdated. Latest: ${latestVer}. Update with:
   npm install -g @mnaoumov/create-obsidian-plugin`);
   }
 }
@@ -3810,8 +4587,8 @@ async function detectMode(cliArgs) {
   if (cliArgs.mode) {
     return cliArgs.mode;
   }
-  const configPath = join5(process.cwd(), CONFIG_FILE_NAME);
-  if (existsSync6(configPath)) {
+  const configPath = join9(process.cwd(), CONFIG_FILE_NAME);
+  if (existsSync8(configPath)) {
     if (cliArgs.useDefaults) {
       exitWithUsageError(`Existing project detected (${CONFIG_FILE_NAME}), and --yes cannot ask whether to update it.
 Pass --mode=update to update it, or --mode=create to scaffold a new plugin beside it.`);
@@ -3830,7 +4607,7 @@ async function ensurePluginIdIsUnlisted(answers, useDefaults) {
   const listedIds = await fetchCommunityPluginIds();
   if (listedIds === null) {
     s.stop("Could not check the plugin id against the Community directory.");
-    log4.warn(`Could not fetch community-plugins.json, so "${answers.pluginId}" was not checked for a collision with a published plugin. The directory rejects a duplicate id, and an id can never be changed once published: check it by hand before submitting.`);
+    log5.warn(`Could not fetch community-plugins.json, so "${answers.pluginId}" was not checked for a collision with a published plugin. The directory rejects a duplicate id, and an id can never be changed once published: check it by hand before submitting.`);
     return answers;
   }
   const collision = validatePluginIdIsUnlisted(answers.pluginId, listedIds);
@@ -3843,7 +4620,7 @@ async function ensurePluginIdIsUnlisted(answers, useDefaults) {
     exitWithUsageError(`${collision}.
 Pass --pluginId=<value> to choose another.`);
   }
-  log4.warn(collision);
+  log5.warn(collision);
   const choice = await select2({
     initialValue: "reenter",
     message: `What should happen to "${answers.pluginId}"?`,
@@ -3901,6 +4678,10 @@ function exitWithUsageError(message) {
 `);
   process.exit(1);
 }
+function hasPrepareScript(targetDir) {
+  const packageJson = JSON.parse(readFileSync8(join9(targetDir, "package.json"), "utf-8"));
+  return Object.hasOwn(packageJson.scripts ?? {}, "prepare");
+}
 function loadOverlayOrExit(dir, hint = "") {
   try {
     return loadOverlay(dir);
@@ -3909,8 +4690,8 @@ function loadOverlayOrExit(dir, hint = "") {
   }
 }
 async function main() {
-  const packageJsonPath = join5(getScriptDir(), "..", "package.json");
-  const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+  const packageJsonPath = join9(getScriptDir(), "..", "package.json");
+  const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
   const currentVersion = packageJson.version ?? "0.0.0";
   const m = "\x1B[38;5;135m";
   const r = "\x1B[0m";
@@ -3965,16 +4746,16 @@ async function offerAnswersExport(answers, customTemplate) {
   let choice = await ask();
   while (choice !== "generate") {
     if (choice === "script") {
-      const scriptPath = join5(process.cwd(), scriptName);
+      const scriptPath = join9(process.cwd(), scriptName);
       writeFileSync2(scriptPath, formatCreateScript(answers, shell, customTemplate));
       if (shell === "sh") {
         chmodSync(scriptPath, SCRIPT_MODE);
       }
-      log4.success(`Wrote ${scriptName}`);
+      log5.success(`Wrote ${scriptName}`);
       note(formatCreateCommand(answers, shell, customTemplate), "Non-interactive command");
     } else {
-      writeFileSync2(join5(process.cwd(), answersFileName), formatAnswersJson(answers));
-      log4.success(`Wrote ${answersFileName}`);
+      writeFileSync2(join9(process.cwd(), answersFileName), formatAnswersJson(answers));
+      log5.success(`Wrote ${answersFileName}`);
       const overlayFlag = customTemplate ? ` --customTemplate=${customTemplate}` : "";
       note(`npm create @mnaoumov/obsidian-plugin -- --yes --mode=create --answersFile=${answersFileName}${overlayFlag}`, "Non-interactive command");
     }
@@ -3991,18 +4772,41 @@ async function resolveExternalVersions(answers, overlay) {
   s.stop("Versions resolved.");
   return { minAppVersion, resolvedVersions };
 }
+async function resolveOfficialSampleSnapshot(latest) {
+  const vendored = loadOfficialSampleSnapshot();
+  if (!latest) {
+    return vendored;
+  }
+  const upstream = readUpstream(getUpstreamsPath(), OFFICIAL_SAMPLE_UPSTREAM_NAME);
+  const s = spinner();
+  s.start(`Fetching ${upstream.repo}@${upstream.ref}...`);
+  try {
+    const snapshot = await fetchUpstreamSnapshot(upstream.repo, upstream.ref);
+    s.stop(`Fetched ${upstream.repo} at ${snapshot.commit.slice(0, SHORT_SHA_LENGTH)}.`);
+    return snapshot;
+  } catch (error) {
+    s.stop(`Could not fetch ${upstream.repo}.`);
+    log5.warn(`${error instanceof Error ? error.message : String(error)}
+Using the snapshot this release vendored, ${vendored.commit.slice(0, SHORT_SHA_LENGTH)}.`);
+    return vendored;
+  }
+}
 async function runCreate(currentVersion, cliArgs) {
   const { answers: suppliedAnswers, customTemplate, useDefaults } = cliArgs;
   const overlay = customTemplate ? loadOverlayOrExit(resolvePath(customTemplate)) : null;
-  const answers = await ensurePluginIdIsUnlisted(
-    assertManifestAnswersAreListable(useDefaults ? getDefaultAnswers(suppliedAnswers) : await promptAnswers(suppliedAnswers)),
-    useDefaults
+  const answers = applyPresetFlags(
+    await ensurePluginIdIsUnlisted(
+      assertManifestAnswersAreListable(useDefaults ? getDefaultAnswers(suppliedAnswers) : await promptAnswers(suppliedAnswers)),
+      useDefaults
+    ),
+    cliArgs,
+    overlay !== null
   );
   if (!useDefaults) {
     await offerAnswersExport(answers, customTemplate);
   }
-  const targetDir = join5(process.cwd(), `obsidian-${answers.pluginId}`);
-  if (existsSync6(targetDir) && !cliArgs.force) {
+  const targetDir = join9(process.cwd(), `obsidian-${answers.pluginId}`);
+  if (existsSync8(targetDir) && !cliArgs.force) {
     if (useDefaults) {
       exitWithUsageError(`Directory obsidian-${answers.pluginId} already exists, and --yes cannot ask whether to scaffold into it.
 Pass --force to scaffold into it anyway.`);
@@ -4017,19 +4821,28 @@ Pass --force to scaffold into it anyway.`);
       process.exit(0);
     }
   }
-  const { minAppVersion, resolvedVersions } = await resolveExternalVersions(answers, overlay);
-  const s = spinner();
-  s.start("Scaffolding plugin...");
-  const newConfig = copyTemplates(answers, targetDir, currentVersion, null, resolvedVersions, minAppVersion, overlay);
-  const configPath = join5(targetDir, CONFIG_FILE_NAME);
+  let newConfig;
+  if (isOfficialSamplePreset(answers.preset)) {
+    const snapshot = await resolveOfficialSampleSnapshot(cliArgs.latest);
+    const s = spinner();
+    s.start("Copying the official sample plugin...");
+    newConfig = copyOfficialSample(answers, targetDir, currentVersion, null, snapshot);
+    s.stop(`Copied obsidianmd/obsidian-sample-plugin at ${snapshot.commit.slice(0, SHORT_SHA_LENGTH)}.`);
+  } else {
+    const { minAppVersion, resolvedVersions } = await resolveExternalVersions(answers, overlay);
+    const s = spinner();
+    s.start("Scaffolding plugin...");
+    newConfig = copyTemplates(answers, targetDir, currentVersion, null, resolvedVersions, minAppVersion, overlay);
+    s.stop("Plugin scaffolded.");
+  }
+  const configPath = join9(targetDir, CONFIG_FILE_NAME);
   const configWithAnswers = buildSavedConfig(newConfig, answers, overlay, targetDir);
   writeFileSync2(configPath, `${JSON.stringify(configWithAnswers, null, JSON_INDENT_SPACES4)}
 `);
-  s.stop("Plugin scaffolded.");
   const isFormatted = useDefaults ? false : await runPostScaffold(targetDir, answers);
   const pm = answers.packageManager;
   const dirName = `obsidian-${answers.pluginId}`;
-  const needsInstall = !existsSync6(join5(targetDir, "node_modules"));
+  const needsInstall = !existsSync8(join9(targetDir, "node_modules"));
   const needsFormat = needsInitialFormat(answers.formatter) && !isFormatted;
   const steps = [
     ...needsInstall ? [getInstallCommand(pm)] : [],
@@ -4047,8 +4860,8 @@ async function runInitialFormat(targetDir, answers, isInstalled) {
   s.start("Formatting...");
   try {
     await execAsync(getRunCommand(answers.packageManager, "format"), targetDir);
-    const configPath = join5(targetDir, CONFIG_FILE_NAME);
-    const config = JSON.parse(readFileSync6(configPath, "utf-8"));
+    const configPath = join9(targetDir, CONFIG_FILE_NAME);
+    const config = JSON.parse(readFileSync8(configPath, "utf-8"));
     writeFileSync2(configPath, `${JSON.stringify(recordHashesOnDisk(targetDir, config), null, JSON_INDENT_SPACES4)}
 `);
     s.stop("Formatted.");
@@ -4077,7 +4890,7 @@ async function runPostScaffold(targetDir, answers) {
     } catch (error) {
       s.stop(`Failed to install dependencies. Run \`${installCmd}\` manually.`);
       if (error instanceof Error && "stderr" in error) {
-        log4.error(String(error.stderr));
+        log5.error(String(error.stderr));
       }
     }
   }
@@ -4092,11 +4905,17 @@ async function runPostScaffold(targetDir, answers) {
     s.start("Initializing git repository...");
     try {
       await execAsync(`git init -b ${answers.defaultBranch}`, targetDir);
+      if (isInstalled && hasPrepareScript(targetDir)) {
+        await execAsync(getRunCommand(pm, "prepare"), targetDir);
+      }
       await execAsync("git add -A", targetDir);
-      await execAsync('git commit -m "Initial commit from create-obsidian-plugin"', targetDir);
+      await execAsync(`git commit -m "${INITIAL_COMMIT_MESSAGE}"`, targetDir);
       s.stop("Git repository initialized with initial commit.");
-    } catch {
+    } catch (error) {
       s.stop("Failed to initialize git. Run `git init` manually.");
+      if (error instanceof Error && "stderr" in error) {
+        log5.error(String(error.stderr));
+      }
     }
   }
   const shouldCreateGitHubRepo = await confirm({
@@ -4121,10 +4940,10 @@ async function runUpdate(currentVersion, cliArgs) {
   const targetDir = process.cwd();
   const existingConfig = loadConfig(targetDir);
   if (!existingConfig) {
-    log4.error("No config file found. Cannot update.");
+    log5.error("No config file found. Cannot update.");
     process.exit(1);
   }
-  log4.info(`Current project was generated with v${existingConfig.generatorVersion}`);
+  log5.info(`Current project was generated with v${existingConfig.generatorVersion}`);
   let overlay = null;
   if (customTemplate !== void 0) {
     overlay = customTemplate ? loadOverlayOrExit(resolvePath(customTemplate)) : null;
@@ -4134,21 +4953,21 @@ async function runUpdate(currentVersion, cliArgs) {
       `
 This project records it in ${CONFIG_FILE_NAME}. Pass --customTemplate=<dir> to point at where it is now, or --customTemplate= to stop using it.`
     );
-    log4.info(`Applying the custom template recorded for this project: ${existingConfig.customTemplate}`);
+    log5.info(`Applying the custom template recorded for this project: ${existingConfig.customTemplate}`);
   }
-  const configPath = join5(targetDir, CONFIG_FILE_NAME);
-  const savedConfig = JSON.parse(readFileSync6(configPath, "utf-8"));
+  const configPath = join9(targetDir, CONFIG_FILE_NAME);
+  const savedConfig = JSON.parse(readFileSync8(configPath, "utf-8"));
   let answers;
   if (savedConfig.answers) {
     const saved = { ...savedConfig.answers, ...suppliedAnswers };
-    log4.info("Using saved answers from previous generation.");
+    log5.info("Using saved answers from previous generation.");
     const shouldRePrompt = useDefaults ? false : await confirm({
       initialValue: false,
       message: "Would you like to change any settings?"
     });
     assertNotCancelled(shouldRePrompt);
     if (shouldRePrompt) {
-      answers = await promptAnswers(saved);
+      answers = await promptAnswers(saved, suppliedAnswers);
     } else {
       answers = saved;
     }
@@ -4157,17 +4976,29 @@ This project records it in ${CONFIG_FILE_NAME}. Pass --customTemplate=<dir> to p
       exitWithUsageError(`${CONFIG_FILE_NAME} records no answers, so --yes has none to reuse.
 Run without --yes to answer them again.`);
     }
-    log4.warn("No saved answers found. Please provide the settings again.");
+    log5.warn("No saved answers found. Please provide the settings again.");
     answers = await promptAnswers(suppliedAnswers);
   }
   const savedPluginId = savedConfig.answers?.pluginId;
   if (savedPluginId !== void 0 && answers.pluginId !== savedPluginId) {
     answers = await ensurePluginIdIsUnlisted(answers, useDefaults);
   }
+  answers = applyPresetFlags(answers, cliArgs, overlay !== null);
+  if (isOfficialSamplePreset(answers.preset)) {
+    const snapshot = await resolveOfficialSampleSnapshot(cliArgs.latest);
+    const s2 = spinner();
+    s2.start("Updating project files...");
+    const newConfig2 = copyOfficialSample(answers, targetDir, currentVersion, existingConfig, snapshot);
+    writeFileSync2(configPath, `${JSON.stringify({ ...newConfig2, answers }, null, JSON_INDENT_SPACES4)}
+`);
+    s2.stop(`Update complete: obsidianmd/obsidian-sample-plugin at ${snapshot.commit.slice(0, SHORT_SHA_LENGTH)}.`);
+    outro("Project updated successfully!");
+    return;
+  }
   const { minAppVersion, resolvedVersions } = await resolveExternalVersions(answers, overlay);
   const projectFormatter = createProjectFormatter(targetDir, answers.formatter);
   if (projectFormatter === null && needsInitialFormat(answers.formatter)) {
-    log4.warn(`${answers.formatter} is not installed, so the update cannot tell the files it formatted from hand edits and skips them. Install the dependencies and update again to have them updated.`);
+    log5.warn(`${answers.formatter} is not installed, so the update cannot tell the files it formatted from hand edits and skips them. Install the dependencies and update again to have them updated.`);
   }
   const s = spinner();
   s.start("Updating project files...");