create-thally-docs 0.8.1 → 0.10.0

package/dist/chunk-KXJT2MG5.js

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+import {
+  STABLE_SCAFFOLD_RELEASE
+} from "./chunk-WMHBVXWW.js";
+
+// src/starter-sync.ts
+import { createHash } from "crypto";
+import {
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync
+} from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
+var MAX_MANIFEST_BYTES = 256 * 1024;
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function normalizedRelativePath(value) {
+  if (!value || value.includes("\0") || value.includes("\\") || value.startsWith("/")) {
+    return null;
+  }
+  const parts = value.split("/");
+  if (parts.some((part) => !part || part === "." || part === "..")) return null;
+  return parts.join("/");
+}
+function normalizedRule(value) {
+  const isDirectoryRule = value.endsWith("/**");
+  const isFilenamePrefixRule = !isDirectoryRule && value.endsWith("*");
+  const path = isDirectoryRule ? value.slice(0, -3) : isFilenamePrefixRule ? value.slice(0, -1) : value;
+  const normalized = normalizedRelativePath(path);
+  if (!normalized || path.includes("*")) return null;
+  if (isFilenamePrefixRule) {
+    const filenamePrefix = normalized.split("/").at(-1);
+    if (!filenamePrefix) return null;
+    return `${normalized}*`;
+  }
+  return isDirectoryRule ? `${normalized}/**` : normalized;
+}
+function parsePathRules(value, field, allowEmpty = false) {
+  if (!Array.isArray(value) || !allowEmpty && value.length === 0) {
+    throw new Error(`The starter ownership contract requires ${field}.`);
+  }
+  const rules = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of value) {
+    const rule = typeof candidate === "string" ? normalizedRule(candidate) : null;
+    if (!rule || seen.has(rule)) {
+      throw new Error(`The starter ownership contract contains invalid ${field}.`);
+    }
+    seen.add(rule);
+    rules.push(rule);
+  }
+  return rules;
+}
+function parseStarterOwnershipContract(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The starter ownership contract is invalid.");
+  }
+  const candidate = value;
+  return {
+    frameworkSyncEligible: parsePathRules(
+      candidate.frameworkSyncEligible,
+      "frameworkSyncEligible"
+    ),
+    userOwnedNeverOverwrite: parsePathRules(
+      candidate.userOwnedNeverOverwrite,
+      "userOwnedNeverOverwrite"
+    ),
+    manualReview: parsePathRules(candidate.manualReview, "manualReview", true)
+  };
+}
+function mergeStarterOwnershipContracts(previous, next) {
+  const oldContract = parseStarterOwnershipContract(previous);
+  const newContract = parseStarterOwnershipContract(next);
+  const unique = (values) => [...new Set(values)];
+  return {
+    frameworkSyncEligible: unique([
+      ...oldContract.frameworkSyncEligible,
+      ...newContract.frameworkSyncEligible
+    ]),
+    userOwnedNeverOverwrite: unique([
+      ...oldContract.userOwnedNeverOverwrite,
+      ...newContract.userOwnedNeverOverwrite,
+      STABLE_SCAFFOLD_RELEASE.source.manifestPath
+    ]),
+    manualReview: unique([
+      ...oldContract.manualReview,
+      ...newContract.manualReview
+    ])
+  };
+}
+function starterManifestSha256(source) {
+  return createHash("sha256").update(source, "utf8").digest("hex");
+}
+function parseStringRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`The starter release manifest contains invalid ${field}.`);
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0 || entries.some(([key, item]) => !key || typeof item !== "string")) {
+    throw new Error(`The starter release manifest contains invalid ${field}.`);
+  }
+  return Object.fromEntries(entries);
+}
+function parseStarterReleaseManifest(source, release = STABLE_SCAFFOLD_RELEASE) {
+  if (!source || Buffer.byteLength(source, "utf8") > MAX_MANIFEST_BYTES) {
+    throw new Error("The starter release manifest is missing or too large.");
+  }
+  const expectedHash = release.source.manifestSha256;
+  if (!SHA256_PATTERN.test(expectedHash) || starterManifestSha256(source) !== expectedHash) {
+    throw new Error("The starter release manifest does not match its promoted SHA-256.");
+  }
+  let value;
+  try {
+    value = JSON.parse(source);
+  } catch {
+    throw new Error("The starter release manifest is invalid JSON.");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The starter release manifest is invalid.");
+  }
+  const candidate = value;
+  if (candidate.schemaVersion !== 1 || !Number.isSafeInteger(candidate.starterVersion) || Number(candidate.starterVersion) < 1 || candidate.starterVersion !== release.starterVersion || candidate.repository !== release.source.repository || candidate.defaultBranch !== "main" || !candidate.runtime || candidate.runtime.repository !== release.runtime.repository || candidate.runtime.commitSha !== release.runtime.commitSha || candidate.runtime.treeSha !== release.runtime.treeSha) {
+    throw new Error("The starter release manifest identity does not match its release.");
+  }
+  return {
+    schemaVersion: 1,
+    starterVersion: candidate.starterVersion,
+    repository: candidate.repository,
+    defaultBranch: candidate.defaultBranch,
+    runtime: {
+      repository: candidate.runtime.repository,
+      commitSha: candidate.runtime.commitSha,
+      treeSha: candidate.runtime.treeSha
+    },
+    packages: parseStringRecord(candidate.packages, "packages"),
+    ownership: parseStarterOwnershipContract(candidate.ownership)
+  };
+}
+function readStarterReleaseManifest(starterDir, release = STABLE_SCAFFOLD_RELEASE) {
+  const manifest = parseStarterReleaseManifest(
+    readFileSync(join(starterDir, release.source.manifestPath), "utf8"),
+    release
+  );
+  let packageValue;
+  try {
+    packageValue = JSON.parse(readFileSync(join(starterDir, "package.json"), "utf8"));
+  } catch {
+    throw new Error("The stable Thally starter contains invalid package.json.");
+  }
+  if (!packageValue || typeof packageValue !== "object" || Array.isArray(packageValue)) {
+    throw new Error("The stable Thally starter contains invalid package.json.");
+  }
+  const packageJson = packageValue;
+  const declaredPackages = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  for (const [name, version] of Object.entries(manifest.packages)) {
+    if (declaredPackages[name] !== version) {
+      throw new Error(
+        `The starter release manifest package ${name} does not match package.json.`
+      );
+    }
+  }
+  return manifest;
+}
+function matchesRule(path, rule) {
+  if (rule.endsWith("/**")) {
+    const root = rule.slice(0, -3);
+    return path === root || path.startsWith(`${root}/`);
+  }
+  if (rule.endsWith("*")) {
+    const prefix = rule.slice(0, -1);
+    if (!path.startsWith(prefix)) return false;
+    return !path.slice(prefix.length).includes("/");
+  }
+  return path === rule;
+}
+function ruleRoot(rule) {
+  if (rule.endsWith("/**")) return rule.slice(0, -3);
+  if (!rule.endsWith("*")) return rule;
+  const prefix = rule.slice(0, -1);
+  const slash = prefix.lastIndexOf("/");
+  return slash === -1 ? "" : prefix.slice(0, slash);
+}
+function classifyStarterPath(path, contract) {
+  const normalized = normalizedRelativePath(path);
+  if (!normalized) throw new Error("Cannot classify an unsafe starter path.");
+  const parsed = parseStarterOwnershipContract(contract);
+  if (parsed.userOwnedNeverOverwrite.some((rule) => matchesRule(normalized, rule))) {
+    return "protected";
+  }
+  if (parsed.manualReview.some((rule) => matchesRule(normalized, rule))) {
+    return "manual";
+  }
+  if (parsed.frameworkSyncEligible.some((rule) => matchesRule(normalized, rule))) {
+    return "syncable";
+  }
+  return "unmanaged";
+}
+function filesystemPathToRepositoryPath(root, path) {
+  return relative(root, path).split(sep).join("/");
+}
+function collectFiles(root, contract, desiredOwnership) {
+  const files = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const rules = desiredOwnership === "syncable" ? contract.frameworkSyncEligible : contract.manualReview;
+  const visit = (absolutePath) => {
+    const resolvedPath = resolve(absolutePath);
+    if (visited.has(resolvedPath)) return;
+    visited.add(resolvedPath);
+    const repositoryPath = filesystemPathToRepositoryPath(root, resolvedPath);
+    const ownership = classifyStarterPath(repositoryPath, contract);
+    if (ownership === "protected") return;
+    const entry = lstatSync(resolvedPath);
+    if (entry.isSymbolicLink()) {
+      throw new Error("Starter synchronization does not follow symbolic links.");
+    }
+    if (entry.isFile()) {
+      if (ownership === desiredOwnership) files.set(repositoryPath, resolvedPath);
+      return;
+    }
+    if (!entry.isDirectory()) {
+      throw new Error("Starter synchronization supports only files and directories.");
+    }
+    for (const child of readdirSync(resolvedPath)) visit(join(resolvedPath, child));
+  };
+  for (const rule of rules) {
+    const rootPath = join(root, ruleRoot(rule));
+    if (!existsSync(rootPath)) continue;
+    if (rule.endsWith("*") && !rule.endsWith("/**")) {
+      for (const child of readdirSync(rootPath)) {
+        const childPath = join(rootPath, child);
+        const repositoryPath = filesystemPathToRepositoryPath(root, childPath);
+        if (matchesRule(repositoryPath, rule)) visit(childPath);
+      }
+    } else {
+      visit(rootPath);
+    }
+  }
+  return files;
+}
+function sameFile(left, right) {
+  if (!left || !right) return left === right;
+  return readFileSync(left).equals(readFileSync(right));
+}
+function fileSha256(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function captureTargetPrecondition(path) {
+  if (!existsSync(path)) return { kind: "missing" };
+  const entry = lstatSync(path);
+  if (!entry.isFile() || entry.isSymbolicLink()) {
+    throw new Error("Starter synchronization target mutations must be regular files.");
+  }
+  return { kind: "file", sha256: fileSha256(path) };
+}
+function matchesTargetPrecondition(path, precondition) {
+  if (precondition.kind === "missing") return !existsSync(path);
+  if (!existsSync(path)) return false;
+  const entry = lstatSync(path);
+  return entry.isFile() && !entry.isSymbolicLink() && fileSha256(path) === precondition.sha256;
+}
+function planStarterRuntimeSync(oldStarterDir, newStarterDir, targetDir, ownership) {
+  const contract = parseStarterOwnershipContract(ownership);
+  const oldFiles = collectFiles(resolve(oldStarterDir), contract, "syncable");
+  const newFiles = collectFiles(resolve(newStarterDir), contract, "syncable");
+  const targetFiles = collectFiles(resolve(targetDir), contract, "syncable");
+  const manualReviewPaths = /* @__PURE__ */ new Set([
+    ...collectFiles(resolve(oldStarterDir), contract, "manual").keys(),
+    ...collectFiles(resolve(newStarterDir), contract, "manual").keys(),
+    ...collectFiles(resolve(targetDir), contract, "manual").keys()
+  ]);
+  const copyPaths = [];
+  const deletePaths = [];
+  const conflictPaths = [];
+  const preservedPaths = [];
+  const unchangedPaths = [];
+  const paths = /* @__PURE__ */ new Set([
+    ...oldFiles.keys(),
+    ...newFiles.keys(),
+    ...targetFiles.keys()
+  ]);
+  for (const path of paths) {
+    const oldPath = oldFiles.get(path);
+    const newPath = newFiles.get(path);
+    const targetPath = targetFiles.get(path);
+    const targetMatchesOld = sameFile(targetPath, oldPath);
+    const newMatchesOld = sameFile(newPath, oldPath);
+    const targetMatchesNew = sameFile(targetPath, newPath);
+    if (!oldPath) {
+      if (!newPath) preservedPaths.push(path);
+      else if (!targetPath) copyPaths.push(path);
+      else if (targetMatchesNew) unchangedPaths.push(path);
+      else conflictPaths.push(path);
+      continue;
+    }
+    if (targetMatchesOld) {
+      if (!newPath) deletePaths.push(path);
+      else if (newMatchesOld) unchangedPaths.push(path);
+      else copyPaths.push(path);
+      continue;
+    }
+    if (newMatchesOld || targetMatchesNew || !targetPath && !newPath) {
+      preservedPaths.push(path);
+    } else {
+      conflictPaths.push(path);
+    }
+  }
+  const sortedCopyPaths = copyPaths.sort();
+  const sortedDeletePaths = deletePaths.sort();
+  const targetPreconditions = Object.fromEntries(
+    [...sortedCopyPaths, ...sortedDeletePaths].map((path) => [
+      path,
+      captureTargetPrecondition(ensureContained(targetDir, path))
+    ])
+  );
+  return {
+    copyPaths: sortedCopyPaths,
+    deletePaths: sortedDeletePaths,
+    conflictPaths: conflictPaths.sort(),
+    manualReviewPaths: [...manualReviewPaths].sort(),
+    preservedPaths: preservedPaths.sort(),
+    unchangedPaths: unchangedPaths.sort(),
+    targetPreconditions
+  };
+}
+function ensureContained(root, repositoryPath) {
+  const target = resolve(root, repositoryPath);
+  const prefix = `${resolve(root)}${sep}`;
+  if (!target.startsWith(prefix)) {
+    throw new Error("Starter synchronization resolved outside its target.");
+  }
+  return target;
+}
+function assertSafeTargetParents(root, path) {
+  const resolvedRoot = resolve(root);
+  let parent = dirname(resolve(path));
+  while (parent !== resolvedRoot) {
+    if (!parent.startsWith(`${resolvedRoot}${sep}`)) {
+      throw new Error("Starter synchronization parent resolved outside its target.");
+    }
+    if (existsSync(parent)) {
+      const entry = lstatSync(parent);
+      if (!entry.isDirectory() || entry.isSymbolicLink()) {
+        throw new Error("Starter synchronization refuses unsafe target parents.");
+      }
+    }
+    parent = dirname(parent);
+  }
+}
+function applyStarterRuntimeSyncPlan(newStarterDir, targetDir, plan, ownership, options) {
+  const contract = parseStarterOwnershipContract(ownership);
+  if (!options.confirmed) {
+    throw new Error("Review and confirm the starter synchronization plan first.");
+  }
+  if (plan.conflictPaths.length > 0) {
+    throw new Error("Resolve starter synchronization conflicts before applying.");
+  }
+  const uniqueMutations = /* @__PURE__ */ new Set([...plan.copyPaths, ...plan.deletePaths]);
+  if (uniqueMutations.size !== plan.copyPaths.length + plan.deletePaths.length) {
+    throw new Error("Starter synchronization plan contains conflicting mutations.");
+  }
+  for (const path of uniqueMutations) {
+    if (classifyStarterPath(path, contract) !== "syncable") {
+      throw new Error(`Starter synchronization refused owner path ${path}.`);
+    }
+    if (!plan.targetPreconditions[path]) {
+      throw new Error(`Starter synchronization plan lacks a target precondition for ${path}.`);
+    }
+  }
+  const targetRoot = resolve(targetDir);
+  const targetRootEntry = lstatSync(targetRoot);
+  if (!targetRootEntry.isDirectory() || targetRootEntry.isSymbolicLink()) {
+    throw new Error("Starter synchronization requires a regular target directory.");
+  }
+  if (options.provenance) {
+    const expectedTarget = ensureContained(
+      targetDir,
+      STABLE_SCAFFOLD_RELEASE.source.manifestPath
+    );
+    const expectedSource = ensureContained(
+      newStarterDir,
+      STABLE_SCAFFOLD_RELEASE.source.manifestPath
+    );
+    if (resolve(options.provenance.targetPath) !== expectedTarget || resolve(options.provenance.sourcePath) !== expectedSource) {
+      throw new Error("Starter synchronization received unsafe provenance paths.");
+    }
+  }
+  const transactionDir = mkdtempSync(join(dirname(targetRoot), ".thally-starter-transaction-"));
+  const stagedDir = join(transactionDir, "staged");
+  const backupDir = join(transactionDir, "backup");
+  mkdirSync(stagedDir);
+  mkdirSync(backupDir);
+  const applied = [];
+  let mutationIndex = 0;
+  const stagePath = (path) => {
+    const stagedPath = ensureContained(stagedDir, path);
+    mkdirSync(dirname(stagedPath), { recursive: true });
+    return stagedPath;
+  };
+  const backupPath = (path) => {
+    const pathInBackup = ensureContained(backupDir, path);
+    mkdirSync(dirname(pathInBackup), { recursive: true });
+    return pathInBackup;
+  };
+  const mutate = (path, targetPath, precondition, replacementPath) => {
+    assertSafeTargetParents(targetDir, targetPath);
+    if (!matchesTargetPrecondition(targetPath, precondition)) {
+      throw new Error(`Starter synchronization target changed after planning: ${path}.`);
+    }
+    if (precondition.kind === "file") {
+      copyFileSync(targetPath, backupPath(path));
+    }
+    applied.push({ path, targetPath, precondition });
+    if (replacementPath) {
+      mkdirSync(dirname(targetPath), { recursive: true });
+      renameSync(replacementPath, targetPath);
+    } else {
+      rmSync(targetPath, { force: true });
+    }
+    options.onMutationApplied?.(path, mutationIndex);
+    mutationIndex += 1;
+  };
+  try {
+    for (const path of plan.copyPaths) {
+      const sourcePath = ensureContained(newStarterDir, path);
+      if (!existsSync(sourcePath) || !lstatSync(sourcePath).isFile()) {
+        throw new Error(`Starter synchronization source is missing ${path}.`);
+      }
+      copyFileSync(sourcePath, stagePath(path));
+    }
+    let provenanceStagePath;
+    if (options.provenance) {
+      if (!existsSync(options.provenance.sourcePath) || !lstatSync(options.provenance.sourcePath).isFile()) {
+        throw new Error("Starter synchronization provenance source is missing.");
+      }
+      provenanceStagePath = join(transactionDir, "next-provenance");
+      copyFileSync(options.provenance.sourcePath, provenanceStagePath);
+    }
+    for (const path of uniqueMutations) {
+      const targetPath = ensureContained(targetDir, path);
+      assertSafeTargetParents(targetDir, targetPath);
+      if (!matchesTargetPrecondition(targetPath, plan.targetPreconditions[path])) {
+        throw new Error(`Starter synchronization target changed after planning: ${path}.`);
+      }
+    }
+    if (options.provenance) {
+      assertSafeTargetParents(targetDir, options.provenance.targetPath);
+      if (fileSha256(options.provenance.targetPath) !== options.provenance.expectedSha256) {
+        throw new Error("The project starter manifest changed during update planning.");
+      }
+    }
+    for (const path of plan.deletePaths) {
+      mutate(
+        path,
+        ensureContained(targetDir, path),
+        plan.targetPreconditions[path]
+      );
+    }
+    for (const path of plan.copyPaths) {
+      mutate(
+        path,
+        ensureContained(targetDir, path),
+        plan.targetPreconditions[path],
+        ensureContained(stagedDir, path)
+      );
+    }
+    if (options.provenance && provenanceStagePath) {
+      const provenancePrecondition = {
+        kind: "file",
+        sha256: options.provenance.expectedSha256
+      };
+      mutate(
+        STABLE_SCAFFOLD_RELEASE.source.manifestPath,
+        options.provenance.targetPath,
+        provenancePrecondition,
+        provenanceStagePath
+      );
+    }
+  } catch (error) {
+    let rollbackError;
+    for (const mutation of applied.reverse()) {
+      try {
+        rmSync(mutation.targetPath, { force: true });
+        if (mutation.precondition.kind === "file") {
+          mkdirSync(dirname(mutation.targetPath), { recursive: true });
+          renameSync(backupPath(mutation.path), mutation.targetPath);
+        }
+      } catch (candidate) {
+        rollbackError ??= candidate;
+      }
+    }
+    if (rollbackError) {
+      throw new AggregateError(
+        [error, rollbackError],
+        "Starter synchronization failed and rollback was incomplete."
+      );
+    }
+    throw error;
+  } finally {
+    rmSync(transactionDir, { recursive: true, force: true });
+  }
+}
+
+export {
+  parseStarterOwnershipContract,
+  mergeStarterOwnershipContracts,
+  starterManifestSha256,
+  parseStarterReleaseManifest,
+  readStarterReleaseManifest,
+  classifyStarterPath,
+  planStarterRuntimeSync,
+  applyStarterRuntimeSyncPlan
+};

package/dist/chunk-ORUAMPNF.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+// src/customize.ts
+import { cpSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function readJsonObject(filePath, label) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    throw new Error(`The stable Thally starter contains invalid ${label}.`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`The stable Thally starter contains invalid ${label}.`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizedStarterLocales(locales) {
+  const normalized = [{ code: "en", label: "English" }];
+  const seen = /* @__PURE__ */ new Set(["en"]);
+  for (const locale of locales ?? []) {
+    const code = locale.code.trim().toLowerCase();
+    const label = locale.label.trim();
+    if (!/^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/.test(code) || !label || label.length > 80 || seen.has(code)) {
+      continue;
+    }
+    seen.add(code);
+    normalized.push({ code, label });
+  }
+  return normalized;
+}
+function updateStarterDocsConfig(targetDir, enableAiChat, repoUrl, i18nLocales) {
+  const configPath = join(targetDir, "docs.json");
+  const config = readJsonObject(configPath, "docs.json");
+  const ai = isRecord(config.ai) ? { ...config.ai } : {};
+  ai.chat = enableAiChat;
+  config.ai = ai;
+  const navbar = isRecord(config.navbar) ? { ...config.navbar } : {};
+  const existingLinks = Array.isArray(navbar.links) ? navbar.links : [];
+  const links = existingLinks.filter(
+    (link) => !isRecord(link) || link.type !== "github" && link.label !== "GitHub"
+  );
+  if (repoUrl) {
+    links.push({ label: "GitHub", href: repoUrl, type: "github" });
+  }
+  if (links.length > 0) navbar.links = links;
+  else delete navbar.links;
+  if (Object.keys(navbar).length > 0) config.navbar = navbar;
+  else delete config.navbar;
+  config.i18n = {
+    defaultLocale: "en",
+    locales: normalizedStarterLocales(i18nLocales)
+  };
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function escapeTypeScriptString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function replaceRequired(source, pattern, replacement, field) {
+  if (!pattern.test(source)) {
+    throw new Error(`The stable Thally starter is missing owner field ${field}.`);
+  }
+  return source.replace(pattern, replacement);
+}
+function updateSiteConfig(targetDir, projectName, description, brandPreset, repoUrl) {
+  if (!projectName.trim() || /[\0\r\n]/.test(projectName)) {
+    throw new Error("The documentation project name is invalid.");
+  }
+  if (!["primary", "secondary"].includes(brandPreset)) {
+    throw new Error("The documentation brand preset is invalid.");
+  }
+  const siteFile = join(targetDir, "src", "data", "site.ts");
+  if (!existsSync(siteFile)) {
+    throw new Error("The stable Thally starter is missing src/data/site.ts.");
+  }
+  const escapedName = escapeTypeScriptString(projectName);
+  const escapedDescription = escapeTypeScriptString(description);
+  const escapedRepoUrl = escapeTypeScriptString(repoUrl);
+  let source = readFileSync(siteFile, "utf8");
+  source = replaceRequired(
+    source,
+    /name:[ \t]*'(?:\\.|[^'\\\r\n])*'/,
+    `name: '${escapedName}'`,
+    "site.name"
+  );
+  source = replaceRequired(
+    source,
+    /description:[ \t]*(?:\r?\n[ \t]*)?'(?:\\.|[^'\\\r\n])*'/,
+    `description:
+    '${escapedDescription}'`,
+    "site.description"
+  );
+  source = replaceRequired(
+    source,
+    /const brandPreset:[ \t]*BrandPresetKey[ \t]*=[ \t]*'(?:\\.|[^'\\\r\n])*'/,
+    `const brandPreset: BrandPresetKey = '${brandPreset}'`,
+    "site.brandPreset"
+  );
+  source = replaceRequired(
+    source,
+    /repoUrl:[ \t]*'(?:\\.|[^'\\\r\n])*'/,
+    `repoUrl: '${escapedRepoUrl}'`,
+    "site.repoUrl"
+  );
+  source = source.replace(
+    /\{[ \t]*label:[ \t]*'GitHub',[ \t]*href:[ \t]*'(?:\\.|[^'\\\r\n])*'[ \t]*\}/,
+    `{ label: 'GitHub', href: '${escapedRepoUrl}' }`
+  );
+  source = source.replace(
+    /\{[ \t]*label:[ \t]*'Support',[ \t]*href:[ \t]*'(?:\\.|[^'\\\r\n])*'[ \t]*\}/,
+    `{ label: 'Support', href: '${escapedRepoUrl ? `${escapedRepoUrl}/issues/new` : ""}' }`
+  );
+  if (!repoUrl) {
+    source = source.replace(
+      /\r?\n[ \t]*\{[ \t]*label:[ \t]*'(?:GitHub|Support)',[ \t]*href:[ \t]*''[ \t]*\},?/g,
+      ""
+    );
+  }
+  writeFileSync(siteFile, source, "utf8");
+}
+function updatePackageIdentity(targetDir, packageName) {
+  const packagePath = join(targetDir, "package.json");
+  const packageJson = readJsonObject(packagePath, "package.json");
+  packageJson.name = packageName;
+  writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+  const lockPath = join(targetDir, "package-lock.json");
+  if (!existsSync(lockPath)) return;
+  const lock = readJsonObject(lockPath, "package-lock.json");
+  lock.name = packageName;
+  if (isRecord(lock.packages) && isRecord(lock.packages[""])) {
+    lock.packages[""].name = packageName;
+  }
+  writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}
+`, "utf8");
+}
+function updateCloudflareRuntimeName(targetDir, packageName) {
+  const configPath = join(targetDir, "wrangler.jsonc");
+  if (!existsSync(configPath)) {
+    throw new Error("The stable Thally starter is missing wrangler.jsonc.");
+  }
+  const source = readFileSync(configPath, "utf8");
+  const pattern = /("name"\s*:\s*)"(?:\\.|[^"\\])*"/;
+  const updated = replaceRequired(
+    source,
+    pattern,
+    `$1${JSON.stringify(packageName)}`,
+    "wrangler.name"
+  );
+  writeFileSync(configPath, updated, "utf8");
+}
+function updateEnvExample(targetDir) {
+  const envFile = join(targetDir, ".env.example");
+  if (!existsSync(envFile)) return;
+  const envLocal = join(targetDir, ".env.local");
+  if (!existsSync(envLocal)) cpSync(envFile, envLocal);
+}
+function personalizeStarter(targetDir, options) {
+  updateStarterDocsConfig(
+    targetDir,
+    options.enableAiChat,
+    options.repoUrl,
+    options.i18nLocales
+  );
+  updateSiteConfig(
+    targetDir,
+    options.projectName,
+    options.description,
+    options.brandPreset,
+    options.repoUrl
+  );
+  updatePackageIdentity(targetDir, options.packageName);
+  updateCloudflareRuntimeName(targetDir, options.packageName);
+}
+
+export {
+  updateStarterDocsConfig,
+  updateSiteConfig,
+  updatePackageIdentity,
+  updateCloudflareRuntimeName,
+  updateEnvExample,
+  personalizeStarter
+};