create-thally-docs 0.8.1 → 0.10.0

package/dist/chunk-WMHBVXWW.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+// src/stable-scaffold-release.json
+var stable_scaffold_release_default = {
+  schemaVersion: 1,
+  id: "2026-08-05.04438581.baf29307",
+  source: {
+    repository: "thallylabs/starter",
+    commitSha: "04438581a402d02e9f4308ff047c4c4a48d8169f",
+    treeSha: "c962a01b3b8b24ffdb65671c2f7805a47175ba42",
+    archiveUrl: "https://codeload.github.com/thallylabs/starter/tar.gz/04438581a402d02e9f4308ff047c4c4a48d8169f",
+    manifestPath: "starter-release.json",
+    manifestSha256: "e019c6416c6c6872114cdf9d9b5eec6579873f46f826748cf39254fd16628392"
+  },
+  runtime: {
+    repository: "thallylabs/thally",
+    commitSha: "baf2930771baf449238bd6c68101ceb3af33ee96",
+    treeSha: "56f8217b4da6740015e4775d2ce0aeb60bc167a0",
+    contentSource: "assets",
+    identityContractVersion: 1
+  },
+  starterVersion: 2
+};
+
+// src/previous-scaffold-releases.json
+var previous_scaffold_releases_default = [
+  {
+    schemaVersion: 1,
+    id: "2026-08-05.d5fef916.f3817263",
+    source: {
+      repository: "thallylabs/starter",
+      commitSha: "d5fef9167ea81f12a861deec5515a78a0f756781",
+      treeSha: "31c1e49342ce9f4122dc0cd60fe714868ca03150",
+      archiveUrl: "https://codeload.github.com/thallylabs/starter/tar.gz/d5fef9167ea81f12a861deec5515a78a0f756781",
+      manifestPath: "starter-release.json",
+      manifestSha256: "06cccd3496c368ef95a11b3afc15add610f261b8106e8371720b084adbf7fa5a"
+    },
+    runtime: {
+      repository: "thallylabs/thally",
+      commitSha: "f38172638cd2cc944ac9ecda19c096ce4d9b4599",
+      treeSha: "d33ad60ad0acabee1cf950880c8bd908e83a002a",
+      contentSource: "assets",
+      identityContractVersion: 1
+    },
+    starterVersion: 1
+  }
+];
+
+// src/release.ts
+var STABLE_SCAFFOLD_RELEASE = stable_scaffold_release_default;
+var SUPPORTED_SCAFFOLD_RELEASES = [
+  STABLE_SCAFFOLD_RELEASE,
+  ...previous_scaffold_releases_default
+];
+function isStableScaffoldRelease(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  return candidate.schemaVersion === STABLE_SCAFFOLD_RELEASE.schemaVersion && candidate.id === STABLE_SCAFFOLD_RELEASE.id && candidate.starterVersion === STABLE_SCAFFOLD_RELEASE.starterVersion && candidate.source?.repository === STABLE_SCAFFOLD_RELEASE.source.repository && candidate.source?.commitSha === STABLE_SCAFFOLD_RELEASE.source.commitSha && candidate.source?.treeSha === STABLE_SCAFFOLD_RELEASE.source.treeSha && candidate.source?.archiveUrl === STABLE_SCAFFOLD_RELEASE.source.archiveUrl && candidate.source?.manifestPath === STABLE_SCAFFOLD_RELEASE.source.manifestPath && candidate.source?.manifestSha256 === STABLE_SCAFFOLD_RELEASE.source.manifestSha256 && candidate.runtime?.repository === STABLE_SCAFFOLD_RELEASE.runtime.repository && candidate.runtime?.commitSha === STABLE_SCAFFOLD_RELEASE.runtime.commitSha && candidate.runtime?.treeSha === STABLE_SCAFFOLD_RELEASE.runtime.treeSha && candidate.runtime?.contentSource === STABLE_SCAFFOLD_RELEASE.runtime.contentSource && candidate.runtime?.identityContractVersion === STABLE_SCAFFOLD_RELEASE.runtime.identityContractVersion;
+}
+
+export {
+  STABLE_SCAFFOLD_RELEASE,
+  SUPPORTED_SCAFFOLD_RELEASES,
+  isStableScaffoldRelease
+};

package/dist/customize.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Documented owner-field personalization for the immutable starter tree.
+ *
+ * Runtime source, authored pages, navigation structure, dependencies, CI, and
+ * repository policy all belong to `thallylabs/starter`. This module may change
+ * only the small set of fields an owner answers during creation.
+ */
+interface StarterLocale {
+    code: string;
+    label: string;
+}
+interface StarterPersonalizationOptions {
+    projectName: string;
+    packageName: string;
+    description: string;
+    brandPreset: string;
+    repoUrl: string;
+    enableAiChat: boolean;
+    i18nLocales?: Array<StarterLocale>;
+}
+/**
+ * Personalize only the owner-controlled settings in `docs.json`.
+ *
+ * Authored tabs, groups, pages, theme choices, and every unrelated key remain
+ * byte-for-byte equivalent after JSON normalization.
+ */
+declare function updateStarterDocsConfig(targetDir: string, enableAiChat: boolean, repoUrl: string, i18nLocales?: Array<StarterLocale>): void;
+/** Personalize the documented identity and repository fields in `site.ts`. */
+declare function updateSiteConfig(targetDir: string, projectName: string, description: string, brandPreset: string, repoUrl: string): void;
+/** Rename only the root package identity; dependency pins belong to starter. */
+declare function updatePackageIdentity(targetDir: string, packageName: string): void;
+/** Update the provider-portable Worker name without recreating its config. */
+declare function updateCloudflareRuntimeName(targetDir: string, packageName: string): void;
+/** Copy the canonical environment guide to the ignored local filename. */
+declare function updateEnvExample(targetDir: string): void;
+/** Apply the complete, intentionally narrow owner-personalization contract. */
+declare function personalizeStarter(targetDir: string, options: StarterPersonalizationOptions): void;
+
+export { type StarterLocale, type StarterPersonalizationOptions, personalizeStarter, updateCloudflareRuntimeName, updateEnvExample, updatePackageIdentity, updateSiteConfig, updateStarterDocsConfig };

package/dist/customize.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  personalizeStarter,
+  updateCloudflareRuntimeName,
+  updateEnvExample,
+  updatePackageIdentity,
+  updateSiteConfig,
+  updateStarterDocsConfig
+} from "./chunk-ORUAMPNF.js";
+export {
+  personalizeStarter,
+  updateCloudflareRuntimeName,
+  updateEnvExample,
+  updatePackageIdentity,
+  updateSiteConfig,
+  updateStarterDocsConfig
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   migrateDocs
-} from "./chunk-SDZZYPSN.js";
+} from "./chunk-GAFCLXU4.js";
 import {
   logo,
   readDocsJson,
@@ -9,7 +9,11 @@ import {
   slugify,
   success,
   writeDocsJson
-} from "./chunk-RS6U2GSX.js";
+} from "./chunk-GTGHYJXS.js";
+import "./chunk-ORUAMPNF.js";
+import "./chunk-ENQIF6MA.js";
+import "./chunk-KXJT2MG5.js";
+import "./chunk-WMHBVXWW.js";
 
 // src/index.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
@@ -149,13 +153,13 @@ async function gatherAnswers(dirArg, useDefaults, installPreference) {
   let i18nLocales;
   if (!useDefaults) {
     const enableI18n = await input({
-      message: "  Enable multi-language support? (y/N):",
+      message: "  Add another documentation language? (y/N):",
       default: "N"
     });
     if (enableI18n.toLowerCase() === "y") {
       const localesInput = await input({
-        message: "  Which locales? (comma-separated codes, e.g. es,fr,de):",
-        default: "es"
+        message: "  Which additional locales? (comma-separated codes, e.g. fr,de,ja):",
+        default: "fr"
       });
       const LOCALE_LABELS = {
         en: "English",

package/dist/migrate/index.d.ts

@@ -0,0 +1,35 @@
+import { MigrationPlatform, MigrationFetcher, MigrationBundle, MigrationWarning } from '@thallylabs/migrate';
+
+/**
+ * CLI materializer for the shared Thally migration engine. Discovery completes
+ * before scaffolding or writing, and every generated path is proven to remain
+ * inside the selected project directory.
+ */
+
+interface MigrateOptions {
+    sourceUrl: string;
+    projectDir: string;
+    into: boolean;
+    /** Retained for CLI compatibility; Markdown/MDX imports do not require a key. */
+    apiKey?: string;
+    branch?: string;
+    docsDir?: string;
+    projectName?: string;
+    yes: boolean;
+    maxPages?: number;
+    /** Explicit source platform selected by an interactive or automated caller. */
+    platform?: MigrationPlatform;
+    /** Optional host fetch boundary; used by Thally Cloud adapters and tests. */
+    fetcher?: MigrationFetcher;
+}
+interface MigrateResult {
+    pagesWritten: number;
+    assetsWritten: number;
+    projectDir: string;
+    platform: MigrationBundle['platform'];
+    warnings: Array<MigrationWarning>;
+}
+/** Import a GitHub docs repository or public docs URL into a Thally project. */
+declare function migrateDocs(options: MigrateOptions): Promise<MigrateResult>;
+
+export { type MigrateOptions, type MigrateResult, migrateDocs };

package/dist/migrate/index.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 import {
   migrateDocs
-} from "../chunk-SDZZYPSN.js";
-import "../chunk-RS6U2GSX.js";
+} from "../chunk-GAFCLXU4.js";
+import "../chunk-GTGHYJXS.js";
+import "../chunk-ORUAMPNF.js";
+import "../chunk-ENQIF6MA.js";
+import "../chunk-KXJT2MG5.js";
+import "../chunk-WMHBVXWW.js";
 export {
   migrateDocs
 };

package/dist/release.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Immutable source and runtime identity for every newly scaffolded Thally site.
+ *
+ * A release is promoted only after the source snapshot and its compiled runtime
+ * have passed the scaffold, build, and identity-safety gates. Consumers must
+ * use the whole record: independently resolving "latest template" and "latest
+ * runtime" recreates the drift this contract exists to prevent.
+ */
+interface ScaffoldSourceRelease {
+    repository: string;
+    commitSha: string;
+    treeSha: string;
+    archiveUrl: string;
+    manifestPath: 'starter-release.json';
+    manifestSha256: string;
+}
+interface ScaffoldOwnershipContract {
+    frameworkSyncEligible: readonly string[];
+    userOwnedNeverOverwrite: readonly string[];
+    manualReview: readonly string[];
+}
+interface StarterReleaseManifest {
+    schemaVersion: 1;
+    starterVersion: number;
+    repository: string;
+    defaultBranch: string;
+    runtime: Pick<ScaffoldRuntimeRelease, 'repository' | 'commitSha' | 'treeSha'>;
+    packages: Record<string, string>;
+    ownership: ScaffoldOwnershipContract;
+}
+interface ScaffoldRuntimeRelease {
+    repository: string;
+    commitSha: string;
+    treeSha: string;
+    contentSource: 'assets';
+    identityContractVersion: number;
+}
+interface ScaffoldRelease {
+    schemaVersion: 1;
+    id: string;
+    source: ScaffoldSourceRelease;
+    runtime: ScaffoldRuntimeRelease;
+    starterVersion: number;
+}
+/**
+ * Current stable scaffold release.
+ *
+ * The source commit is the complete, standalone `thallylabs/starter` tree and
+ * the runtime commit is the matching engine change. `create-thally-docs`, the
+ * CLI, MCP, and Thally Cloud all import this exact record rather than following
+ * a moving branch independently. Promotion replaces the placeholders in the
+ * adjacent JSON record, which is also consumed by Cloud build parity checks.
+ */
+declare const STABLE_SCAFFOLD_RELEASE: ScaffoldRelease;
+/**
+ * Immutable releases this toolchain can use as a three-way update base.
+ *
+ * Promotion prepends the new stable record but retains earlier records. That
+ * lets a project created directly from GitHub carry only the exact manifest
+ * bytes and still resolve its original starter without mutable branch state.
+ */
+declare const SUPPORTED_SCAFFOLD_RELEASES: readonly ScaffoldRelease[];
+/** True only when an unknown record is the currently supported release. */
+declare function isStableScaffoldRelease(value: unknown): value is ScaffoldRelease;
+
+export { STABLE_SCAFFOLD_RELEASE, SUPPORTED_SCAFFOLD_RELEASES, type ScaffoldOwnershipContract, type ScaffoldRelease, type ScaffoldRuntimeRelease, type ScaffoldSourceRelease, type StarterReleaseManifest, isStableScaffoldRelease };

package/dist/release.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  STABLE_SCAFFOLD_RELEASE,
+  SUPPORTED_SCAFFOLD_RELEASES,
+  isStableScaffoldRelease
+} from "./chunk-WMHBVXWW.js";
+export {
+  STABLE_SCAFFOLD_RELEASE,
+  SUPPORTED_SCAFFOLD_RELEASES,
+  isStableScaffoldRelease
+};

package/dist/scaffold.d.ts

@@ -0,0 +1,53 @@
+export { STABLE_SCAFFOLD_RELEASE } from './release.js';
+
+/**
+ * Immutable starter archive download and extraction.
+ *
+ * The dedicated starter repository is already a customer-ready project. Every
+ * safe filesystem entry is extracted; there is no exclusion list or second
+ * manifest that can silently produce a different scaffold.
+ */
+
+/** Repository whose complete tree becomes every newly scaffolded site. */
+declare const STARTER_REPOSITORY: string;
+/** Exact starter commit consumed by every creation surface. */
+declare const STARTER_COMMIT_SHA: string;
+/** GitHub codeload's single top-level directory for the pinned archive. */
+declare const STARTER_ARCHIVE_ROOT: string;
+interface StarterArchiveEntryMetadata {
+    type: string;
+    size: number;
+}
+/**
+ * Validate one codeload entry before `strip: 1` can write it to disk.
+ *
+ * Git cannot store devices or FIFOs, and starter sites do not need links. A
+ * release containing one is rejected rather than partially extracted because
+ * the entire repository tree is the immutable contract.
+ */
+declare function validateStarterArchiveEntry(archivePath: string, entry: StarterArchiveEntryMetadata, archiveRoot?: string): void;
+
+interface ScaffoldOptions {
+    projectDir: string;
+    projectName: string;
+    description: string;
+    brandPreset: string;
+    repoUrl: string;
+    doInstall: boolean;
+    enableAiChat?: boolean;
+    i18nLocales?: Array<{
+        code: string;
+        label: string;
+    }>;
+    /** Repos to pre-register for Thally Track (opt-in). Empty/undefined = Track off. */
+    trackRepos?: Array<{
+        owner: string;
+        repo: string;
+    }>;
+}
+interface ScaffoldResult {
+    projectDir: string;
+}
+declare function scaffold(options: ScaffoldOptions): Promise<ScaffoldResult>;
+
+export { STARTER_ARCHIVE_ROOT, STARTER_COMMIT_SHA, STARTER_REPOSITORY, type ScaffoldOptions, type ScaffoldResult, scaffold, validateStarterArchiveEntry };

package/dist/scaffold.js

@@ -1,7 +1,23 @@
 #!/usr/bin/env node
 import {
   scaffold
-} from "./chunk-RS6U2GSX.js";
+} from "./chunk-GTGHYJXS.js";
+import "./chunk-ORUAMPNF.js";
+import {
+  STARTER_ARCHIVE_ROOT,
+  STARTER_COMMIT_SHA,
+  STARTER_REPOSITORY,
+  validateStarterArchiveEntry
+} from "./chunk-ENQIF6MA.js";
+import "./chunk-KXJT2MG5.js";
+import {
+  STABLE_SCAFFOLD_RELEASE
+} from "./chunk-WMHBVXWW.js";
 export {
-  scaffold
+  STABLE_SCAFFOLD_RELEASE,
+  STARTER_ARCHIVE_ROOT,
+  STARTER_COMMIT_SHA,
+  STARTER_REPOSITORY,
+  scaffold,
+  validateStarterArchiveEntry
 };

package/dist/starter-sync.d.ts

@@ -0,0 +1,68 @@
+import { ScaffoldOwnershipContract, ScaffoldRelease, StarterReleaseManifest } from './release.js';
+
+/**
+ * Ownership-aware, three-way planning for future starter runtime updates.
+ *
+ * The ownership contract comes from the pinned starter archive's
+ * `starter-release.json`. Automatic updates touch only framework-eligible files
+ * that still match the recorded old starter; owner and manual-review paths are
+ * never included in an apply plan.
+ */
+
+type StarterPathOwnership = 'protected' | 'manual' | 'syncable' | 'unmanaged';
+interface StarterRuntimeSyncPlan {
+    copyPaths: string[];
+    deletePaths: string[];
+    conflictPaths: string[];
+    manualReviewPaths: string[];
+    preservedPaths: string[];
+    unchangedPaths: string[];
+    targetPreconditions: Record<string, StarterTargetPrecondition>;
+}
+interface StarterTargetPrecondition {
+    kind: 'missing' | 'file';
+    sha256?: string;
+}
+interface StarterApplyProvenance {
+    sourcePath: string;
+    targetPath: string;
+    expectedSha256: string;
+}
+interface ApplyStarterRuntimeSyncOptions {
+    /** Explicit acknowledgement that the caller reviewed this exact plan. */
+    confirmed: boolean;
+    /** Optional immutable provenance file, atomically replaced after mutations. */
+    provenance?: StarterApplyProvenance;
+    /** Integration hook; an exception aborts and rolls back the transaction. */
+    onMutationApplied?: (path: string, index: number) => void;
+}
+/** Parse and validate the ownership section in `starter-release.json`. */
+declare function parseStarterOwnershipContract(value: unknown): ScaffoldOwnershipContract;
+/**
+ * Combine the previous and next release policies without weakening ownership.
+ *
+ * A later starter may broaden framework ownership, but it cannot retroactively
+ * make a path safe to overwrite when either release marked that path as owner
+ * controlled or manual-review. Classification precedence enforces that union.
+ */
+declare function mergeStarterOwnershipContracts(previous: ScaffoldOwnershipContract, next: ScaffoldOwnershipContract): ScaffoldOwnershipContract;
+/** Stable SHA-256 of the exact manifest bytes promoted with a release. */
+declare function starterManifestSha256(source: string): string;
+/**
+ * Parse the archive-owned release manifest and bind it to its promoted source,
+ * runtime identity, and SHA-256. Branch names never participate in updates.
+ */
+declare function parseStarterReleaseManifest(source: string, release?: ScaffoldRelease): StarterReleaseManifest;
+/** Read and validate the canonical ownership manifest from an extracted archive. */
+declare function readStarterReleaseManifest(starterDir: string, release?: ScaffoldRelease): StarterReleaseManifest;
+/** Protected > manual-review > syncable > unmanaged. */
+declare function classifyStarterPath(path: string, contract: ScaffoldOwnershipContract): StarterPathOwnership;
+/**
+ * Build a safe three-way update plan from the recorded old starter, the new
+ * starter, and the customer's current tree.
+ */
+declare function planStarterRuntimeSync(oldStarterDir: string, newStarterDir: string, targetDir: string, ownership: ScaffoldOwnershipContract): StarterRuntimeSyncPlan;
+/** Apply an explicitly confirmed, conflict-free three-way plan. */
+declare function applyStarterRuntimeSyncPlan(newStarterDir: string, targetDir: string, plan: StarterRuntimeSyncPlan, ownership: ScaffoldOwnershipContract, options: ApplyStarterRuntimeSyncOptions): void;
+
+export { type ApplyStarterRuntimeSyncOptions, type StarterApplyProvenance, type StarterPathOwnership, type StarterRuntimeSyncPlan, type StarterTargetPrecondition, applyStarterRuntimeSyncPlan, classifyStarterPath, mergeStarterOwnershipContracts, parseStarterOwnershipContract, parseStarterReleaseManifest, planStarterRuntimeSync, readStarterReleaseManifest, starterManifestSha256 };

package/dist/starter-sync.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  applyStarterRuntimeSyncPlan,
+  classifyStarterPath,
+  mergeStarterOwnershipContracts,
+  parseStarterOwnershipContract,
+  parseStarterReleaseManifest,
+  planStarterRuntimeSync,
+  readStarterReleaseManifest,
+  starterManifestSha256
+} from "./chunk-KXJT2MG5.js";
+import "./chunk-WMHBVXWW.js";
+export {
+  applyStarterRuntimeSyncPlan,
+  classifyStarterPath,
+  mergeStarterOwnershipContracts,
+  parseStarterOwnershipContract,
+  parseStarterReleaseManifest,
+  planStarterRuntimeSync,
+  readStarterReleaseManifest,
+  starterManifestSha256
+};

package/dist/starter-update.d.ts

@@ -0,0 +1,43 @@
+import { ScaffoldRelease } from './release.js';
+import { StarterRuntimeSyncPlan } from './starter-sync.js';
+
+/**
+ * User-reachable orchestration for immutable starter release updates.
+ *
+ * Projects carry the exact bytes of `starter-release.json`. The manifest hash
+ * resolves the old release from the toolchain's retained immutable catalog;
+ * neither the old nor new side follows a branch. Updates are dry-run by
+ * default and advance provenance only after a confirmed, conflict-free apply.
+ */
+
+interface StarterUpdateDownload {
+    (targetDir: string, release: ScaffoldRelease): Promise<void>;
+}
+interface UpdateStarterProjectOptions {
+    targetDir: string;
+    /** Applying is opt-in. Omitted/false always produces a dry-run plan. */
+    apply?: boolean;
+    /** Separate acknowledgement for programmatic callers. */
+    confirmed?: boolean;
+    targetRelease?: ScaffoldRelease;
+    releases?: readonly ScaffoldRelease[];
+    download?: StarterUpdateDownload;
+}
+interface StarterUpdateResult {
+    previousRelease: ScaffoldRelease;
+    targetRelease: ScaffoldRelease;
+    plan: StarterRuntimeSyncPlan;
+    isUpToDate: boolean;
+    applied: boolean;
+}
+/** Resolve exact downstream provenance without consulting a moving branch. */
+declare function resolveStarterReleaseFromManifest(source: string, releases?: readonly ScaffoldRelease[]): ScaffoldRelease;
+/**
+ * Plan or explicitly apply an immutable three-way starter update.
+ *
+ * Direct GitHub-template copies need no generated state beyond the canonical
+ * manifest: its pinned hash selects the old archive from the retained catalog.
+ */
+declare function updateStarterProject(options: UpdateStarterProjectOptions): Promise<StarterUpdateResult>;
+
+export { type StarterUpdateDownload, type StarterUpdateResult, type UpdateStarterProjectOptions, resolveStarterReleaseFromManifest, updateStarterProject };

package/dist/starter-update.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import {
+  downloadStarter
+} from "./chunk-ENQIF6MA.js";
+import {
+  applyStarterRuntimeSyncPlan,
+  mergeStarterOwnershipContracts,
+  parseStarterReleaseManifest,
+  planStarterRuntimeSync,
+  readStarterReleaseManifest,
+  starterManifestSha256
+} from "./chunk-KXJT2MG5.js";
+import {
+  STABLE_SCAFFOLD_RELEASE,
+  SUPPORTED_SCAFFOLD_RELEASES
+} from "./chunk-WMHBVXWW.js";
+
+// src/starter-update.ts
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync
+} from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var EMPTY_PLAN = {
+  copyPaths: [],
+  deletePaths: [],
+  conflictPaths: [],
+  manualReviewPaths: [],
+  preservedPaths: [],
+  unchangedPaths: [],
+  targetPreconditions: {}
+};
+function readDownstreamManifest(targetDir, manifestPath) {
+  const path = join(targetDir, manifestPath);
+  if (!existsSync(path)) {
+    throw new Error(
+      `This project has no ${manifestPath}; update it from a versioned Thally starter first.`
+    );
+  }
+  return readFileSync(path, "utf8");
+}
+function resolveStarterReleaseFromManifest(source, releases = SUPPORTED_SCAFFOLD_RELEASES) {
+  const hash = starterManifestSha256(source);
+  const matching = releases.filter(
+    (release) => release.source.manifestSha256 === hash
+  );
+  if (matching.length !== 1) {
+    throw new Error(
+      "The project starter manifest is edited, unknown, or ambiguously registered; refusing to update."
+    );
+  }
+  parseStarterReleaseManifest(source, matching[0]);
+  return matching[0];
+}
+function assertForwardRelease(previous, target) {
+  if (previous.source.repository !== target.source.repository || previous.source.manifestPath !== target.source.manifestPath) {
+    throw new Error("Starter updates cannot cross repository or manifest contracts.");
+  }
+  if (previous.source.commitSha !== target.source.commitSha && previous.starterVersion >= target.starterVersion) {
+    throw new Error("The installed CLI does not contain a newer starter release.");
+  }
+}
+async function updateStarterProject(options) {
+  const targetRelease = options.targetRelease ?? STABLE_SCAFFOLD_RELEASE;
+  const releases = options.releases ?? SUPPORTED_SCAFFOLD_RELEASES;
+  const manifestPath = targetRelease.source.manifestPath;
+  const downstreamManifest = readDownstreamManifest(options.targetDir, manifestPath);
+  const previousRelease = resolveStarterReleaseFromManifest(
+    downstreamManifest,
+    releases
+  );
+  assertForwardRelease(previousRelease, targetRelease);
+  if (previousRelease.source.commitSha === targetRelease.source.commitSha) {
+    return {
+      previousRelease,
+      targetRelease,
+      plan: EMPTY_PLAN,
+      isUpToDate: true,
+      applied: false
+    };
+  }
+  if (options.apply && !options.confirmed) {
+    throw new Error("Pass explicit confirmation before applying a starter update.");
+  }
+  const workspace = mkdtempSync(join(tmpdir(), "thally-starter-update-"));
+  const oldStarterDir = join(workspace, "old");
+  const newStarterDir = join(workspace, "new");
+  mkdirSync(oldStarterDir);
+  mkdirSync(newStarterDir);
+  const download = options.download ?? (async (targetDir, release) => {
+    await downloadStarter(targetDir, void 0, release, { announce: false });
+  });
+  try {
+    await download(oldStarterDir, previousRelease);
+    await download(newStarterDir, targetRelease);
+    const oldManifest = readStarterReleaseManifest(oldStarterDir, previousRelease);
+    const newManifest = readStarterReleaseManifest(newStarterDir, targetRelease);
+    const ownership = mergeStarterOwnershipContracts(
+      oldManifest.ownership,
+      newManifest.ownership
+    );
+    const plan = planStarterRuntimeSync(
+      oldStarterDir,
+      newStarterDir,
+      options.targetDir,
+      ownership
+    );
+    if (!options.apply) {
+      return {
+        previousRelease,
+        targetRelease,
+        plan,
+        isUpToDate: false,
+        applied: false
+      };
+    }
+    if (plan.conflictPaths.length > 0) {
+      throw new Error("Resolve starter synchronization conflicts before applying.");
+    }
+    if (readDownstreamManifest(options.targetDir, manifestPath) !== downstreamManifest) {
+      throw new Error("The project starter manifest changed during update planning.");
+    }
+    applyStarterRuntimeSyncPlan(
+      newStarterDir,
+      options.targetDir,
+      plan,
+      ownership,
+      {
+        confirmed: true,
+        provenance: {
+          sourcePath: join(newStarterDir, manifestPath),
+          targetPath: join(options.targetDir, manifestPath),
+          expectedSha256: previousRelease.source.manifestSha256
+        }
+      }
+    );
+    return {
+      previousRelease,
+      targetRelease,
+      plan,
+      isUpToDate: false,
+      applied: true
+    };
+  } finally {
+    rmSync(workspace, { recursive: true, force: true });
+  }
+}
+export {
+  resolveStarterReleaseFromManifest,
+  updateStarterProject
+};