canopycms 0.8.1 → 0.8.3

package/dist/cli/cli.js

@@ -562,7 +562,7 @@ async function failTask(taskDir, taskId, error, logger = nullLogger) {
   });
   logger.debug("Failed task", { id: taskId, error });
 }
-async function retryTask(taskDir, taskId, error, logger = nullLogger) {
+async function retryTask(taskDir, taskId, error, logger = nullLogger, options = {}) {
   const processingPath = path6.join(taskDir, "processing", `${taskId}.json`);
   const pendingDir = path6.join(taskDir, "pending");
   const pendingPath = path6.join(pendingDir, `${taskId}.json`);
@@ -583,7 +583,7 @@ async function retryTask(taskDir, taskId, error, logger = nullLogger) {
     throw err2;
   }
   const retryCount = (task.retryCount ?? 0) + 1;
-  const backoffMs = Math.min(5e3 * Math.pow(2, retryCount - 1), 6e4);
+  const backoffMs = options.delayMs ?? Math.min(5e3 * Math.pow(2, retryCount - 1), 6e4);
   task.status = "pending";
   task.retryCount = retryCount;
   task.retryAfter = new Date(Date.now() + backoffMs).toISOString();
@@ -5357,9 +5357,7 @@ async function bumpResourceGeneration(root, resource, options) {
     await atomicWriteFile2(resourceGenerationPath(root, resource), token);
     return token;
   } catch (err2) {
-    log4.warn("generation", `Failed to bump ${resource} generation for ${root}`, {
-      error: getErrorMessage3(err2)
-    });
+    canopyLogWarn2(`CanopyCMS: failed to bump ${resource} generation for ${root}:`, getErrorMessage3(err2));
     if (options?.mustSucceed)
       throw err2;
     return null;
@@ -7907,7 +7905,7 @@ async function resolveBranchRoot(config) {
     config: resolved,
     branchName: activeBranch,
     mode: config.mode,
-    createdBy: "canopycms-ai",
+    createdBy: AI_USER_ID,
     remoteUrl: config.defaultRemoteUrl
   });
   return context.branchRoot;
@@ -8436,7 +8434,7 @@ async function generateAIContentCLI(options) {
   console.log(`  Output: ${result.outputDir}
 `);
 }
-var __defProp3, __getOwnPropNames3, __esm3, __export3, init_error3, init_atomic_write2, init_field_traversal, ITEM_KEY, ITEM_KEY_PATTERN, isItemKey, BASE58, isListField, init_item_keys, active2, init_logger2, SENTINEL_BASE2, DOT_SEGMENT2, init_sanitize_href2, init_normalize, RESERVED_SETTINGS_BRANCH_PREFIX2, init_branch_name, BASE58_PATTERN2, CONTENT_ID_PATTERN2, PHYSICAL_SEGMENT_PATTERN2, MAX_BRANCH_NAME_LENGTH2, init_validation, ROOT_COLLECTION_ID, init_types2, normalizePathValue, flattenSchema, init_flatten, scalarFieldTypes2, markdownFieldTypes2, primitiveFieldTypes2, fieldTypes2, init_types22, SAFE_HTML_TAGS2, COMPONENT_NAME2, MDX_BINDINGS2, FORBIDDEN_ATTRIBUTES2, init_mdx_allowlist2, fieldBaseSchema2, selectOptionSchema2, referenceOptionSchema2, primitiveFieldSchema2, mdxPropAllowSchema2, mdxAllowlistSchema2, markdownFieldSchema2, ASPECT_RATIO_RE2, imageFieldSchema2, selectFieldSchema2, referenceSortFieldSchema2, referenceFieldSchema2, fieldHolder2, blockSchema2, blockFieldSchema2, objectFieldSchema2, inlineGroupFieldSchema2, customFieldSchema2, knownFieldSchema2, fieldSchema2, init_field2, relativePathSchema2, entryTypeSchema2, collectionSchema2, init_collection2, uploadTargetUrlSchema2, previewPrefixSchema2, editorUrlSchema2, init_url2, mediaSchema2, init_media2, defaultBranchAccessSchema2, defaultPathAccessLevelSchema2, defaultPathAccessLevelsSchema2, defaultPathAccessSchema2, defaultBaseBranchSchema2, defaultRemoteNameSchema2, defaultRemoteUrlSchema2, gitBotAuthorNameSchema2, gitBotAuthorEmailSchema2, githubTokenEnvVarSchema2, operatingModeSchema2, deployedAsSchema2, contentRootSchema2, sourceRootSchema2, basePathSchema2, deploymentNameSchema2, devContentSyncSchema2, devConfigSchema2, editorConfigSchema2, seoFieldNameSchema2, seoSchema2, CanopyConfigSchema2, DEFAULT_PROD_WORKSPACE2, init_config3, SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR, warned22, init_mode_env, forEachReferenceField, init_validation2, ProdClientSafeStrategy2, DevClientSafeStrategy2, clientStrategyCache, init_client_safe_strategy, warned3, VALID_DEPLOYMENT_NAME2, isValidDeploymentName2, init_deployment_name, warned4, DEPLOYMENT_PLACEHOLDER2, DEFAULT_BRANCH_NAMESPACE_TEMPLATE2, BRANCH_NAMESPACE_ENV2, init_branch_namespace, init_config22, ProdStrategy2, DevStrategy2, strategyCache2, init_client_unsafe_strategy, operating_mode_exports, init_operating_mode, task_queue_config_exports2, init_task_queue_config2, worker_status_exports, WORKER_STATUS_FILE, init_worker_status, BLOCK_DISCRIMINATOR_KEYS, BLOCK_STRUCTURAL_KEYS, envFlag2, LOG_LEVELS2, DebugLogger2, testLogger2, MARKDOWN_EXPORT_OPTIONS, BULLETS, DELIMITERS, EMPHASIS, STRONG, RULE, WORD_CHAR, GAP, Restyler, END, FRESH, LINE_WIDTH, MIN_LINE_WIDTH, SourceSplicer, log2, MAX_LCS_CELLS, Splicer, log22, EVIDENCE_MAX_DEPTH, log3, locks, PROVISIONING_LOCK_STALE_MS, sleep, META_DIR, CONTENT_WRITE_LOCK_NAME, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, ContentWriteLockBusyError, sleep2, CONTENT_WRITE_LOCK_STALE_MS, heldRoots, getFormatExtension, isDataOnlyFormat, asRecord, DEFAULT_SEO_FIELD_NAMES, asRecord2, asText, asFlag, asImageUrl, asOgType, asTwitterCard, RESTRICTED_REFERENCE_MARKER, SEO_GROUP_FIELDS, MAX_WARNED, warned5, SchemaUnavailableError, isValidId, parseTypedFilename, EMPTY_LOGICAL_PATH, ENTRY_EXTENSIONS, ContentIdIndex, CONTENT_EXTENSIONS, registry, finalization, log4, META_DIR2, entryTypeMetaSchema, collectionMetaSchema, rootCollectionMetaSchema, fingerprints, editDistance, closestName, forEachEntryType, collectEntryTypeNames, validateReferenceEntryTypes, isDeployedStatic, isBuildMode, readsFromCheckout, STATIC_DEPLOY_USER, storage, log5, BaseBranchUnresolvedError, NETWORK_SCHEME_PATTERN, TRANSPORT_HELPER_PATTERN, LEADING_OPTION_PATTERN, WINDOWS_DRIVE_PATTERN, COLON_BEFORE_SLASH_PATTERN, MISSING_REMOTE_REF_REASONS, CANOPY_META_DIR, SCHEMA_CACHE_VERSION, MTIME_CHECK_DEBOUNCE_MS, SNAPSHOT_MEMO_MAX_BYTES, SCHEMA_CACHE_FILE, SCHEMA_GENERATION_RESOURCE, reportedIssues, BranchSchemaCache, RESOURCE, BranchPathError, resolveContentBranchesRoot, ContentStoreError, ContentConflictError, EntryGoneError, BranchSyncingError, DuplicateContentIdError, UrlPathConflictError, isEmptyFieldValue, DEFAULT_INDEX_FRESHNESS_INTERVAL_MS, FORCED_REFRESH_MIN_INTERVAL_MS, STALE_LOOKUP, isMissingReference, createReferenceResolveCache, ContentStore, ATTR_CONTENT, BLOCK_PREFIX, BLOCK_SUFFIX, BLOCK_RESTORE_RE, INLINE_PREFIX, INLINE_SUFFIX, INLINE_RESTORE_RE, DEFAULT_REFERENCE_RENDERING, FLAT_CELL_TYPES, log6, BASE58_CHAR, ENTRY_LINK_PATTERN, INLINE_LINK_TARGET, BranchMetadataCorruptError, BRANCH_META_DIR, BRANCH_META_FILE, branchMetadataFilePath, UNKNOWN_TIME, enumOf, branchMetadataShape, branchMetadataSchema, branchMetadataFileSchema, log7, REGISTRY_FILE, REGISTRY_STALE_FILE, REGISTRY_TEMP_FILE, REGISTRY_VERSION, RESOURCE2, GET_MISS_REFRESH_MIN_INTERVAL_MS, snapshotSchema, reportedUnreadable, BranchRegistry, log8, OccWriteConflictError, CURRENT_SCHEMA_VERSION, BranchMetadataConflictError, BranchMetadataFileManager, loadBranchContext, GitProcessError, STDERR_CAP_BYTES, KILL_GRACE_MS, log9, GIT_ENV_PASSTHROUGH, FORCE_C_LOCALE, GIT_NETWORK_ENV_PASSTHROUGH, NO_AUTO_GC_CONFIG, HASH_INACTIVITY_TIMEOUT_MS, MAX_HASH_RUNS, LS_REMOTE_INACTIVITY_TIMEOUT_MS, symlinkBlobSha, REMOTE_GIT_CONFIG, REMOTE_GIT_MAX_LOOSE_OBJECTS, REMOTE_GIT_MAX_PACKS, PARALLEL_CHECKOUT_ARGS, remoteInitLocks, GITHUB_TRACKING_REF_PREFIX, BaseBranchMissingError, GitConflictError, GitRemoteRefMissingError, RemoteNotReadyError, SettingsRemoteUnreadableError, SettingsBranchDivergedError, SETTINGS_BRANCH_FILES, SettingsBranchHasContentHistoryError, GitManager, PUBLISH_LOCK_WAIT_MS, CREATE_RESIDUE_MIN_QUIET_MS, STAGING_MAX_AGE_MS, REPAIR_MAX_AGE_MS, DELETING_MAX_AGE_MS, SETTINGS_TRASH_MAX_AGE_MS, BranchProvisioningBusyError, BranchDirOccupiedError, STAGING_PREFIX, REPAIR_PREFIX, TRASH_PREFIX, stagingDirName, NO_GIT, RENAME_BLOCKED, SPARSE_CONE_RECORD, defaultSink, sink, ProvisionLog, testHooks, provisionsInFlight, BranchWorkspaceManager, log10, normalizePath, parseEntryParts, parseEntryData, readEntryData, createReferenceResolver, withoutUnavailableEntries, resolveCollectionItemReferences, looksLikeMalformedEntry, listCollectionEntries, MAX_INPUT_PIXELS, CROP_PRECISION, KNOWN_FIELD_TYPES, STRING_FIELD_TYPES, selectOptionValues, GENERATED_RECORD_FILENAME, SAFE_BUILD_ID, BUILD_ID_RULE, jiti;
+var __defProp3, __getOwnPropNames3, __esm3, __export3, init_error3, init_atomic_write2, init_field_traversal, ITEM_KEY, ITEM_KEY_PATTERN, isItemKey, BASE58, isListField, init_item_keys, active2, init_logger2, SENTINEL_BASE2, DOT_SEGMENT2, init_sanitize_href2, init_normalize, RESERVED_SETTINGS_BRANCH_PREFIX2, init_branch_name, BASE58_PATTERN2, CONTENT_ID_PATTERN2, PHYSICAL_SEGMENT_PATTERN2, MAX_BRANCH_NAME_LENGTH2, init_validation, ROOT_COLLECTION_ID, init_types2, normalizePathValue, flattenSchema, init_flatten, scalarFieldTypes2, markdownFieldTypes2, primitiveFieldTypes2, fieldTypes2, init_types22, SAFE_HTML_TAGS2, COMPONENT_NAME2, MDX_BINDINGS2, FORBIDDEN_ATTRIBUTES2, init_mdx_allowlist2, fieldBaseSchema2, selectOptionSchema2, referenceOptionSchema2, primitiveFieldSchema2, mdxPropAllowSchema2, mdxAllowlistSchema2, markdownFieldSchema2, ASPECT_RATIO_RE2, imageFieldSchema2, selectFieldSchema2, referenceSortFieldSchema2, referenceFieldSchema2, fieldHolder2, blockSchema2, blockFieldSchema2, objectFieldSchema2, inlineGroupFieldSchema2, customFieldSchema2, knownFieldSchema2, fieldSchema2, init_field2, relativePathSchema2, entryTypeSchema2, collectionSchema2, init_collection2, uploadTargetUrlSchema2, previewPrefixSchema2, editorUrlSchema2, init_url2, mediaSchema2, init_media2, defaultBranchAccessSchema2, defaultPathAccessLevelSchema2, defaultPathAccessLevelsSchema2, defaultPathAccessSchema2, defaultBaseBranchSchema2, defaultRemoteNameSchema2, defaultRemoteUrlSchema2, gitBotAuthorNameSchema2, gitBotAuthorEmailSchema2, githubTokenEnvVarSchema2, operatingModeSchema2, deployedAsSchema2, contentRootSchema2, sourceRootSchema2, basePathSchema2, deploymentNameSchema2, devContentSyncSchema2, devConfigSchema2, editorConfigSchema2, seoFieldNameSchema2, seoSchema2, CanopyConfigSchema2, DEFAULT_PROD_WORKSPACE2, init_config3, SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR, warned22, init_mode_env, forEachReferenceField, init_validation2, ProdClientSafeStrategy2, DevClientSafeStrategy2, clientStrategyCache, init_client_safe_strategy, warned3, VALID_DEPLOYMENT_NAME2, isValidDeploymentName2, init_deployment_name, warned4, DEPLOYMENT_PLACEHOLDER2, DEFAULT_BRANCH_NAMESPACE_TEMPLATE2, BRANCH_NAMESPACE_ENV2, init_branch_namespace, init_config22, ProdStrategy2, DevStrategy2, strategyCache2, init_client_unsafe_strategy, operating_mode_exports, init_operating_mode, task_queue_config_exports2, init_task_queue_config2, worker_status_exports, WORKER_STATUS_FILE, init_worker_status, BLOCK_DISCRIMINATOR_KEYS, BLOCK_STRUCTURAL_KEYS, envFlag2, LOG_LEVELS2, DebugLogger2, testLogger2, MARKDOWN_EXPORT_OPTIONS, BULLETS, DELIMITERS, EMPHASIS, STRONG, RULE, WORD_CHAR, GAP, Restyler, END, FRESH, LINE_WIDTH, MIN_LINE_WIDTH, SourceSplicer, log2, MAX_LCS_CELLS, Splicer, log22, EVIDENCE_MAX_DEPTH, log3, locks, PROVISIONING_LOCK_STALE_MS, sleep, META_DIR, CONTENT_WRITE_LOCK_NAME, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, ContentWriteLockBusyError, sleep2, CONTENT_WRITE_LOCK_STALE_MS, heldRoots, getFormatExtension, isDataOnlyFormat, asRecord, DEFAULT_SEO_FIELD_NAMES, asRecord2, asText, asFlag, asImageUrl, asOgType, asTwitterCard, RESTRICTED_REFERENCE_MARKER, SEO_GROUP_FIELDS, MAX_WARNED, warned5, SchemaUnavailableError, isValidId, parseTypedFilename, EMPTY_LOGICAL_PATH, ENTRY_EXTENSIONS, ContentIdIndex, CONTENT_EXTENSIONS, registry, finalization, log4, META_DIR2, entryTypeMetaSchema, collectionMetaSchema, rootCollectionMetaSchema, fingerprints, editDistance, closestName, forEachEntryType, collectEntryTypeNames, validateReferenceEntryTypes, isDeployedStatic, isBuildMode, readsFromCheckout, STATIC_DEPLOY_USER, storage, log5, BaseBranchUnresolvedError, NETWORK_SCHEME_PATTERN, TRANSPORT_HELPER_PATTERN, LEADING_OPTION_PATTERN, WINDOWS_DRIVE_PATTERN, COLON_BEFORE_SLASH_PATTERN, MISSING_REMOTE_REF_REASONS, CANOPY_META_DIR, SCHEMA_CACHE_VERSION, MTIME_CHECK_DEBOUNCE_MS, SNAPSHOT_MEMO_MAX_BYTES, SCHEMA_CACHE_FILE, SCHEMA_GENERATION_RESOURCE, reportedIssues, BranchSchemaCache, RESOURCE, BranchPathError, resolveContentBranchesRoot, ContentStoreError, ContentConflictError, EntryGoneError, BranchSyncingError, DuplicateContentIdError, UrlPathConflictError, isEmptyFieldValue, DEFAULT_INDEX_FRESHNESS_INTERVAL_MS, FORCED_REFRESH_MIN_INTERVAL_MS, STALE_LOOKUP, isMissingReference, createReferenceResolveCache, ContentStore, ATTR_CONTENT, BLOCK_PREFIX, BLOCK_SUFFIX, BLOCK_RESTORE_RE, INLINE_PREFIX, INLINE_SUFFIX, INLINE_RESTORE_RE, DEFAULT_REFERENCE_RENDERING, FLAT_CELL_TYPES, log6, BASE58_CHAR, ENTRY_LINK_PATTERN, INLINE_LINK_TARGET, BranchMetadataCorruptError, BRANCH_META_DIR, BRANCH_META_FILE, branchMetadataFilePath, UNKNOWN_TIME, enumOf, branchMetadataShape, branchMetadataSchema, branchMetadataFileSchema, log7, REGISTRY_FILE, REGISTRY_STALE_FILE, REGISTRY_TEMP_FILE, REGISTRY_VERSION, RESOURCE2, GET_MISS_REFRESH_MIN_INTERVAL_MS, snapshotSchema, reportedUnreadable, BranchRegistry, log8, OccWriteConflictError, CURRENT_SCHEMA_VERSION, BranchMetadataConflictError, BranchMetadataFileManager, loadBranchContext, GitProcessError, STDERR_CAP_BYTES, KILL_GRACE_MS, log9, GIT_ENV_PASSTHROUGH, FORCE_C_LOCALE, GIT_NETWORK_ENV_PASSTHROUGH, NO_AUTO_GC_CONFIG, HASH_INACTIVITY_TIMEOUT_MS, MAX_HASH_RUNS, LS_REMOTE_INACTIVITY_TIMEOUT_MS, symlinkBlobSha, REMOTE_GIT_CONFIG, REMOTE_GIT_MAX_LOOSE_OBJECTS, REMOTE_GIT_MAX_PACKS, PARALLEL_CHECKOUT_ARGS, remoteInitLocks, GITHUB_TRACKING_REF_PREFIX, BaseBranchMissingError, GitConflictError, GitRemoteRefMissingError, RemoteNotReadyError, SettingsRemoteUnreadableError, SettingsBranchDivergedError, SETTINGS_BRANCH_FILES, SettingsBranchHasContentHistoryError, GitManager, PUBLISH_LOCK_WAIT_MS, CREATE_RESIDUE_MIN_QUIET_MS, STAGING_MAX_AGE_MS, REPAIR_MAX_AGE_MS, DELETING_MAX_AGE_MS, SETTINGS_TRASH_MAX_AGE_MS, BranchProvisioningBusyError, BranchDirOccupiedError, STAGING_PREFIX, REPAIR_PREFIX, TRASH_PREFIX, stagingDirName, NO_GIT, RENAME_BLOCKED, SPARSE_CONE_RECORD, defaultSink, sink, ProvisionLog, testHooks, provisionsInFlight, BranchWorkspaceManager, AI_USER_ID, log10, normalizePath, parseEntryParts, parseEntryData, readEntryData, createReferenceResolver, withoutUnavailableEntries, resolveCollectionItemReferences, looksLikeMalformedEntry, listCollectionEntries, MAX_INPUT_PIXELS, CROP_PRECISION, KNOWN_FIELD_TYPES, STRING_FIELD_TYPES, selectOptionValues, GENERATED_RECORD_FILENAME, SAFE_BUILD_ID, BUILD_ID_RULE, jiti;
 var init_generate_ai_content = __esm({
   "dist/cli/generate-ai-content.js"() {
     "use strict";
@@ -10746,6 +10744,7 @@ var init_generate_ai_content = __esm({
     init_field_traversal();
     init_atomic_write2();
     init_error3();
+    init_logger2();
     log4 = createDebugLogger2({ prefix: "ResourceGeneration" });
     META_DIR2 = ".canopy-meta";
     init_logger2();
@@ -12394,9 +12393,20 @@ var init_generate_ai_content = __esm({
       mergedAt: z72.string().optional(),
       rebaseFailure: z72.object({ message: z72.string(), firstAt: z72.string(), lastAt: z72.string() }).optional(),
       historyRewrittenFrom: z72.string().optional(),
+      lastGitHubTip: z72.string().optional(),
+      keptOverGitHub: z72.array(z72.string()).optional(),
+      rewrittenOnGitHub: z72.string().optional(),
+      submitUnfinished: z72.boolean().optional(),
+      submitNotQueued: z72.boolean().optional(),
+      unpublishedAtMerge: z72.boolean().optional(),
       syncFailureReason: z72.string().optional(),
       editors: z72.array(z72.string()).optional(),
       uncommittedEditors: z72.array(z72.string()).optional(),
+      // Dropped when malformed: it only decorates the branch card, so it never fails a read.
+      pullRequestHold: z72.discriminatedUnion("kind", [
+        z72.object({ kind: z72.literal("conflicts") }),
+        z72.object({ kind: z72.literal("retargeted"), base: z72.string() })
+      ]).optional().catch(void 0),
       // Dropped when malformed: it only decorates the PR body, so it never fails a read.
       review: z72.object({
         state: z72.enum(["approved", "changes-requested"]),
@@ -14583,6 +14593,7 @@ var init_generate_ai_content = __esm({
         return { kind: "exists", context: { branch: meta.branch, branchRoot, baseRoot } };
       }
     };
+    AI_USER_ID = "canopycms-ai";
     init_error3();
     init_item_keys();
     log10 = createDebugLogger2({ prefix: "ContentListing" });
@@ -17035,6 +17046,10 @@ function sanitizeBranchName3(branchName) {
   const trimmedDots = squashed.replace(/^\.+/, "").replace(/(?<!\.)\.+$/, "");
   return trimmedDots || "branch";
 }
+function isSettingsBranchName2(branchName, settingsBranchName) {
+  const sanitized = sanitizeBranchName3(branchName);
+  return sanitized.startsWith(RESERVED_SETTINGS_BRANCH_PREFIX3) || settingsBranchName !== void 0 && sanitized === sanitizeBranchName3(settingsBranchName);
+}
 var RESERVED_SETTINGS_BRANCH_PREFIX3;
 var init_branch_name2 = __esm({
   "dist/paths/branch-name.js"() {
@@ -17047,6 +17062,18 @@ var init_branch_name2 = __esm({
 function isValidContentId2(id) {
   return CONTENT_ID_PATTERN3.test(id);
 }
+function isExactBranchForm(param) {
+  return param.startsWith(EXACT_BRANCH_MARK);
+}
+function exactBranchSegment(fullName) {
+  return `${EXACT_BRANCH_MARK}${fullName.replaceAll("/", EXACT_BRANCH_MARK)}`;
+}
+function exactBranchName(param) {
+  if (!isExactBranchForm(param) || param.includes("/"))
+    return null;
+  const named = parseBranchRef3(param.slice(EXACT_BRANCH_MARK.length).replaceAll(EXACT_BRANCH_MARK, "/"));
+  return named.ok ? named.name : null;
+}
 function parseBranchRef3(name) {
   if (!name || typeof name !== "string") {
     return { ok: false, error: "Branch name is required" };
@@ -17114,7 +17141,7 @@ function parseSlug2(slug) {
   }
   return { ok: true, slug: normalized };
 }
-var BASE58_PATTERN3, CONTENT_ID_PATTERN3, PHYSICAL_SEGMENT_PATTERN3, MAX_BRANCH_NAME_LENGTH3;
+var BASE58_PATTERN3, CONTENT_ID_PATTERN3, PHYSICAL_SEGMENT_PATTERN3, MAX_BRANCH_NAME_LENGTH3, EXACT_BRANCH_MARK;
 var init_validation3 = __esm({
   "dist/paths/validation.js"() {
     "use strict";
@@ -17122,6 +17149,7 @@ var init_validation3 = __esm({
     CONTENT_ID_PATTERN3 = new RegExp(`^${BASE58_PATTERN3}{12}$`);
     PHYSICAL_SEGMENT_PATTERN3 = new RegExp(`\\.${BASE58_PATTERN3}{12}(?:\\.[a-z]+)?$`);
     MAX_BRANCH_NAME_LENGTH3 = 250;
+    EXACT_BRANCH_MARK = "~";
   }
 });
 
@@ -17498,27 +17526,39 @@ var init_operating_mode2 = __esm({
   }
 });
 
-// dist/cli/configured-asset-store.js
-var configured_asset_store_exports = {};
-__export(configured_asset_store_exports, {
-  loadConfiguredAssetStore: () => loadConfiguredAssetStore
-});
+// dist/cli/site-config.js
 import path31 from "node:path";
 import { createJiti as createJiti3 } from "jiti";
-import { z as z15 } from "zod";
-async function loadConfiguredAssetStore(projectDir) {
+async function importSiteServerConfig(projectDir) {
   const configPath = path31.join(projectDir, "canopycms.config.ts");
   const jiti2 = createJiti3(import.meta.url);
   const mod = await jiti2.import(configPath);
   const configExport = mod.default ?? mod.config ?? mod;
   const server = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
+  return { configPath, server };
+}
+var init_site_config = __esm({
+  "dist/cli/site-config.js"() {
+    "use strict";
+  }
+});
+
+// dist/cli/configured-asset-store.js
+var configured_asset_store_exports = {};
+__export(configured_asset_store_exports, {
+  loadConfiguredAssetStore: () => loadConfiguredAssetStore
+});
+import path33 from "node:path";
+import { z as z15 } from "zod";
+async function loadConfiguredAssetStore(projectDir) {
+  const { configPath, server } = await importSiteServerConfig(projectDir);
   const parsed = serverConfigSchema.safeParse(server);
   if (!parsed.success) {
     throw new Error(`Invalid CanopyCMS config at ${configPath}: ${parsed.error.message}`);
   }
   const { mode, media } = parsed.data;
-  const devAssetsDir = mode === "dev" ? path31.join(operatingStrategy3(mode).getWorkspaceRoot(projectDir), "assets") : void 0;
-  const resolvedMedia = media?.adapter === "local" && media.directory ? { ...media, directory: path31.resolve(projectDir, media.directory) } : media;
+  const devAssetsDir = mode === "dev" ? path33.join(operatingStrategy3(mode).getWorkspaceRoot(projectDir), "assets") : void 0;
+  const resolvedMedia = media?.adapter === "local" && media.directory ? { ...media, directory: path33.resolve(projectDir, media.directory) } : media;
   const store = createAssetStore(resolvedMedia, { devAssetsDir });
   if (!store) {
     throw new Error(`No asset store is configured in ${configPath}: set \`media\` (an s3 adapter in prod).`);
@@ -17532,6 +17572,7 @@ var init_configured_asset_store = __esm({
     init_factory();
     init_media3();
     init_operating_mode2();
+    init_site_config();
     serverConfigSchema = z15.object({
       mode: z15.enum(["prod", "dev"]),
       media: mediaSchema3.optional()
@@ -17547,13 +17588,13 @@ __export(asset_refs_exports, {
   materializeAssetsCLI: () => materializeAssetsCLI
 });
 import fs27 from "node:fs/promises";
-import path33 from "node:path";
+import path34 from "node:path";
 async function collectAssetRefsCLI(options) {
   if (!options.outDir) {
     console.error("Usage: canopycms collect-asset-refs <outDir>");
     return 1;
   }
-  const outDir = path33.resolve(options.outDir);
+  const outDir = path34.resolve(options.outDir);
   try {
     if (!(await fs27.stat(outDir)).isDirectory()) {
       console.error(`Not a directory: ${outDir}`);
@@ -17648,19 +17689,19 @@ async function runMaterialize(options) {
     console.error("canopycms materialize-assets: --report needs a file");
     return MATERIALIZE_EXIT_CODES.error;
   }
-  if (options.reportPath && path33.resolve(options.reportPath) === path33.resolve(options.refsPath)) {
+  if (options.reportPath && path34.resolve(options.reportPath) === path34.resolve(options.refsPath)) {
     console.error("canopycms materialize-assets: --report must not be the --refs file");
     return MATERIALIZE_EXIT_CODES.error;
   }
   if (options.reportPath)
-    await fs27.rm(path33.resolve(options.reportPath), { force: true });
+    await fs27.rm(path34.resolve(options.reportPath), { force: true });
   const concurrency = parsePositiveInteger("--concurrency", options.concurrency);
   const transformConcurrency = parsePositiveInteger("--transform-concurrency", options.transformConcurrency);
   if (concurrency === null || transformConcurrency === null)
     return MATERIALIZE_EXIT_CODES.error;
   if (options.outputPrefix !== void 0)
     assertValidOutputPrefix(options.outputPrefix);
-  const refs = await readAssetRefsFile(path33.resolve(options.refsPath));
+  const refs = await readAssetRefsFile(path34.resolve(options.refsPath));
   const store = await resolveStore(options);
   if (!store)
     return MATERIALIZE_EXIT_CODES.error;
@@ -17674,7 +17715,7 @@ async function runMaterialize(options) {
   });
   printReport(report);
   if (options.reportPath) {
-    await atomicWriteFile3(path33.resolve(options.reportPath), `${JSON.stringify(report, null, 2)}
+    await atomicWriteFile3(path34.resolve(options.reportPath), `${JSON.stringify(report, null, 2)}
 `);
   }
   const { contentFailures, storeFailures } = report.summary;
@@ -17714,20 +17755,149 @@ var init_asset_refs2 = __esm({
   }
 });
 
-// dist/utils/git.js
-import { simpleGit as simpleGit4 } from "simple-git";
-function isCanopyInternalPath(repoRelativePath) {
-  return repoRelativePath === CANOPY_META_DIR2 || repoRelativePath.startsWith(`${CANOPY_META_DIR2}/`);
+// dist/branch-metadata-error.js
+var BranchMetadataCorruptError2;
+var init_branch_metadata_error = __esm({
+  "dist/branch-metadata-error.js"() {
+    "use strict";
+    BranchMetadataCorruptError2 = class extends Error {
+      constructor(branchRoot, cause) {
+        super(`Corrupt branch metadata in '${branchRoot}': ${cause}`);
+        this.name = "BranchMetadataCorruptError";
+        this.branchRoot = branchRoot;
+        this.parseCause = cause;
+      }
+    };
+  }
+});
+
+// dist/branch-metadata-file.js
+import fs28 from "node:fs/promises";
+import path35 from "node:path";
+import { z as z16 } from "zod";
+function describeSchemaIssues2(issues) {
+  const missing = /* @__PURE__ */ new Set();
+  const invalid = /* @__PURE__ */ new Set();
+  for (const issue of issues) {
+    const field = issue.path.length > 0 ? issue.path.join(".") : "the file";
+    const isMissing = issue.code === z16.ZodIssueCode.invalid_type && issue.received === z16.ZodParsedType.undefined;
+    (isMissing ? missing : invalid).add(field);
+  }
+  const parts = [];
+  if (missing.size > 0)
+    parts.push(`Missing: ${[...missing].join(", ")}`);
+  if (invalid.size > 0)
+    parts.push(`Invalid: ${[...invalid].join(", ")}`);
+  return `Not branch metadata. ${parts.join(". ")}`;
 }
-async function stageAllExceptCanopyState2(git) {
-  await git.raw(["add", "-A", "--sparse"]);
-  await git.raw(["reset", "-q", "--", CANOPY_META_DIR2]);
+async function readBranchMetadataFile2(branchRoot) {
+  const resolvedRoot = path35.resolve(branchRoot);
+  let raw;
+  try {
+    raw = await fs28.readFile(branchMetadataFilePath2(resolvedRoot), "utf8");
+  } catch (err2) {
+    if (isNotFoundError(err2)) {
+      return null;
+    }
+    throw err2;
+  }
+  return parseBranchMetadataFile2(resolvedRoot, raw);
 }
-var CANOPY_META_DIR2;
-var init_git = __esm({
-  "dist/utils/git.js"() {
+function parseBranchMetadataFile2(branchRoot, raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err2) {
+    throw new BranchMetadataCorruptError2(branchRoot, `Not valid JSON: ${getErrorMessage(err2)}`);
+  }
+  const result = branchMetadataFileSchema2.safeParse(json);
+  if (!result.success) {
+    throw new BranchMetadataCorruptError2(branchRoot, describeSchemaIssues2(result.error.issues));
+  }
+  const file = result.data;
+  return file;
+}
+var BRANCH_META_DIR2, BRANCH_META_FILE2, branchMetadataFilePath2, UNKNOWN_TIME2, enumOf2, branchMetadataShape2, branchMetadataSchema2, branchMetadataFileSchema2;
+var init_branch_metadata_file = __esm({
+  "dist/branch-metadata-file.js"() {
     "use strict";
-    CANOPY_META_DIR2 = ".canopy-meta";
+    init_error();
+    init_branch_metadata_error();
+    BRANCH_META_DIR2 = ".canopy-meta";
+    BRANCH_META_FILE2 = "branch.json";
+    branchMetadataFilePath2 = (branchRoot) => path35.join(path35.resolve(branchRoot), BRANCH_META_DIR2, BRANCH_META_FILE2);
+    UNKNOWN_TIME2 = (/* @__PURE__ */ new Date(0)).toISOString();
+    enumOf2 = (values) => z16.nativeEnum(values);
+    branchMetadataShape2 = {
+      name: z16.string().min(1),
+      title: z16.string().optional(),
+      description: z16.string().optional(),
+      status: enumOf2({
+        editing: "editing",
+        submitted: "submitted",
+        approved: "approved",
+        archived: "archived"
+      }),
+      access: z16.object({
+        allowedUsers: z16.array(z16.string()).optional(),
+        allowedGroups: z16.array(z16.string()).optional(),
+        managerOrAdminAllowed: z16.boolean().optional()
+      }).passthrough(),
+      createdBy: z16.string().default("unknown"),
+      createdAt: z16.string().default(UNKNOWN_TIME2),
+      updatedAt: z16.string().default(UNKNOWN_TIME2),
+      baseBranch: z16.string().optional(),
+      pullRequestUrl: z16.string().optional(),
+      pullRequestNumber: z16.number().int().optional(),
+      submittedAt: z16.string().optional(),
+      pushedToGitHubAt: z16.string().optional(),
+      editorUrl: z16.string().optional(),
+      syncStatus: enumOf2({
+        synced: "synced",
+        "pending-sync": "pending-sync",
+        "sync-failed": "sync-failed"
+      }).optional(),
+      conflictStatus: enumOf2({
+        clean: "clean",
+        "conflicts-detected": "conflicts-detected"
+      }).optional(),
+      conflictFiles: z16.array(z16.custom((v) => typeof v === "string")).optional(),
+      pullRequestState: enumOf2({
+        open: "open",
+        closed: "closed",
+        merged: "merged"
+      }).optional(),
+      mergedAt: z16.string().optional(),
+      rebaseFailure: z16.object({ message: z16.string(), firstAt: z16.string(), lastAt: z16.string() }).optional(),
+      historyRewrittenFrom: z16.string().optional(),
+      lastGitHubTip: z16.string().optional(),
+      keptOverGitHub: z16.array(z16.string()).optional(),
+      rewrittenOnGitHub: z16.string().optional(),
+      submitUnfinished: z16.boolean().optional(),
+      submitNotQueued: z16.boolean().optional(),
+      unpublishedAtMerge: z16.boolean().optional(),
+      syncFailureReason: z16.string().optional(),
+      editors: z16.array(z16.string()).optional(),
+      uncommittedEditors: z16.array(z16.string()).optional(),
+      // Dropped when malformed: it only decorates the branch card, so it never fails a read.
+      pullRequestHold: z16.discriminatedUnion("kind", [
+        z16.object({ kind: z16.literal("conflicts") }),
+        z16.object({ kind: z16.literal("retargeted"), base: z16.string() })
+      ]).optional().catch(void 0),
+      // Dropped when malformed: it only decorates the PR body, so it never fails a read.
+      review: z16.object({
+        state: z16.enum(["approved", "changes-requested"]),
+        by: z16.object({ userId: z16.string(), name: z16.string().optional() }),
+        at: z16.string()
+      }).optional().catch(void 0)
+    };
+    branchMetadataSchema2 = z16.object(branchMetadataShape2).passthrough();
+    branchMetadataFileSchema2 = z16.object({
+      schemaVersion: z16.number().int().default(1),
+      version: z16.number().int().nonnegative().default(0),
+      writeId: z16.string().optional(),
+      branch: branchMetadataSchema2
+    }).passthrough();
   }
 });
 
@@ -17836,11 +18006,11 @@ var init_debug2 = __esm({
 });
 
 // dist/resource-generation.js
-import fs28 from "node:fs/promises";
-import path34 from "node:path";
+import fs29 from "node:fs/promises";
+import path36 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 function resourceGenerationPath2(root, resource) {
-  return path34.resolve(root, META_DIR3, `${resource}.generation`);
+  return path36.resolve(root, META_DIR3, `${resource}.generation`);
 }
 async function bumpResourceGeneration2(root, resource, options) {
   const token = randomUUID5();
@@ -17848,9 +18018,7 @@ async function bumpResourceGeneration2(root, resource, options) {
     await atomicWriteFile3(resourceGenerationPath2(root, resource), token);
     return token;
   } catch (err2) {
-    log11.warn("generation", `Failed to bump ${resource} generation for ${root}`, {
-      error: getErrorMessage(err2)
-    });
+    canopyLogWarn3(`CanopyCMS: failed to bump ${resource} generation for ${root}:`, getErrorMessage(err2));
     if (options?.mustSucceed)
       throw err2;
     return null;
@@ -17858,7 +18026,7 @@ async function bumpResourceGeneration2(root, resource, options) {
 }
 async function readResourceGeneration2(root, resource) {
   try {
-    const token = await fs28.readFile(resourceGenerationPath2(root, resource), "utf-8");
+    const token = await fs29.readFile(resourceGenerationPath2(root, resource), "utf-8");
     return { ok: true, token };
   } catch (err2) {
     if (isNodeError(err2) && err2.code === "ENOENT")
@@ -17879,275 +18047,320 @@ var init_resource_generation = __esm({
     init_atomic_write3();
     init_error();
     init_debug2();
+    init_logger3();
     log11 = createDebugLogger3({ prefix: "ResourceGeneration" });
     META_DIR3 = ".canopy-meta";
   }
 });
 
-// dist/content-index-registry.js
-import path35 from "node:path";
-function invalidateContentIndexesForRoot2(root) {
-  const rootKey = path35.resolve(root);
-  const prefix = rootKey + path35.sep;
-  for (const [storeRoot, refs] of registry2) {
-    if (storeRoot !== rootKey && !storeRoot.startsWith(prefix))
-      continue;
-    for (const ref of refs) {
-      const target = ref.deref();
-      if (target) {
-        target.invalidateIndex();
-      } else {
-        refs.delete(ref);
-      }
-    }
-    if (refs.size === 0)
-      registry2.delete(storeRoot);
-  }
-}
-var registry2, finalization2;
-var init_content_index_registry = __esm({
-  "dist/content-index-registry.js"() {
+// dist/branch-registry.js
+import fs30 from "node:fs/promises";
+import path37 from "node:path";
+import { z as z17 } from "zod";
+var log12, REGISTRY_FILE2, REGISTRY_STALE_FILE2, REGISTRY_TEMP_FILE2, REGISTRY_VERSION2, RESOURCE3, GET_MISS_REFRESH_MIN_INTERVAL_MS2, snapshotSchema2, reportedUnreadable2, BranchRegistry2;
+var init_branch_registry = __esm({
+  "dist/branch-registry.js"() {
     "use strict";
-    registry2 = /* @__PURE__ */ new Map();
-    finalization2 = new FinalizationRegistry(({ rootKey, ref }) => {
-      const refs = registry2.get(rootKey);
-      if (!refs)
-        return;
-      refs.delete(ref);
-      if (refs.size === 0)
-        registry2.delete(rootKey);
+    init_branch_metadata_file();
+    init_error();
+    init_debug2();
+    init_logger3();
+    init_resource_generation();
+    log12 = createDebugLogger3({ prefix: "BranchRegistry" });
+    REGISTRY_FILE2 = "branches.json";
+    REGISTRY_STALE_FILE2 = "branches.stale.json";
+    REGISTRY_TEMP_FILE2 = "branches.tmp.json";
+    REGISTRY_VERSION2 = 2;
+    RESOURCE3 = "branch-registry";
+    GET_MISS_REFRESH_MIN_INTERVAL_MS2 = 5e3;
+    snapshotSchema2 = z17.object({
+      version: z17.literal(REGISTRY_VERSION2),
+      branches: z17.array(z17.object({ branch: branchMetadataSchema2, branchRoot: z17.string(), baseRoot: z17.string() })),
+      generation: z17.string().nullable()
     });
-  }
-});
-
-// dist/id.js
-import { generate as generate2 } from "short-uuid";
-function generateId2() {
-  const full = generate2();
-  return full.substring(0, 12);
-}
-var isValidId2;
-var init_id = __esm({
-  "dist/id.js"() {
-    "use strict";
-    init_validation3();
-    isValidId2 = isValidContentId2;
-  }
-});
-
-// dist/utils/format.js
-var getFormatExtension2;
-var init_format = __esm({
-  "dist/utils/format.js"() {
-    "use strict";
-    getFormatExtension2 = (format) => {
-      if (format === "md")
-        return ".md";
-      if (format === "mdx")
-        return ".mdx";
-      if (format === "yaml")
-        return ".yaml";
-      return ".json";
-    };
-  }
-});
-
-// dist/content-id-index.js
-function extractIdFromFilename2(filename) {
-  if (filename.startsWith(".")) {
-    return null;
-  }
-  const parts = filename.split(".");
-  if (parts.length >= 3) {
-    const candidate = parts[parts.length - 2];
-    if (isValidId2(candidate))
-      return candidate;
-  }
-  if (parts.length === 2) {
-    const candidate = parts[parts.length - 1];
-    if (isValidId2(candidate))
-      return candidate;
-  }
-  return null;
-}
-function extractSlugFromFilename2(filename, entryTypeName) {
-  const parts = filename.split(".");
-  if (parts.length >= 3) {
-    const possibleId = parts[parts.length - 2];
-    if (isValidId2(possibleId)) {
-      let slugParts = parts.slice(0, parts.length - 2);
-      if (entryTypeName && slugParts.length > 1 && slugParts[0] === entryTypeName) {
-        slugParts = slugParts.slice(1);
-      } else if (parts.length >= 4 && slugParts.length > 1) {
-        slugParts = slugParts.slice(1);
+    reportedUnreadable2 = /* @__PURE__ */ new Set();
+    BranchRegistry2 = class {
+      constructor(root) {
+        this.regenInFlight = null;
+        this.lastForcedRefreshMs = 0;
+        this.root = path37.resolve(root);
+        this.registryPath = path37.join(this.root, REGISTRY_FILE2);
+        this.stalePath = path37.join(this.root, REGISTRY_STALE_FILE2);
+        this.tempPath = path37.join(this.root, REGISTRY_TEMP_FILE2);
       }
-      return slugParts.join(".").toLowerCase();
-    }
+      /**
+       * Returns all branches. Uses the cached snapshot if its embedded generation
+       * token matches the live marker, regenerates otherwise.
+       *
+       * An unparseable or wrong-shaped snapshot is treated like an absent one: the
+       * snapshot is a cache of the branch directories, so rebuilding it loses
+       * nothing, while rethrowing would fail every editor's branch listing until
+       * someone deleted the file. Other read failures (permissions, IO) propagate.
+       */
+      async list() {
+        let raw;
+        try {
+          raw = await fs30.readFile(this.registryPath, "utf8");
+        } catch (err2) {
+          if (isNotFoundError(err2)) {
+            return await this.regenerate();
+          }
+          throw err2;
+        }
+        const parsed = this.parseSnapshot(raw);
+        if (!parsed)
+          return await this.regenerate();
+        const read = await readResourceGeneration2(this.root, RESOURCE3);
+        if (isGenerationCurrent2(parsed.generation, read)) {
+          return parsed.branches;
+        }
+        return await this.regenerate();
+      }
+      /** The snapshot in `raw`, or null when it must be rebuilt. */
+      parseSnapshot(raw) {
+        let json;
+        try {
+          json = JSON.parse(raw);
+        } catch (err2) {
+          this.reportUnreadable(getErrorMessage(err2));
+          return null;
+        }
+        if (typeof json === "object" && json !== null && "version" in json && typeof json.version === "number" && json.version !== REGISTRY_VERSION2) {
+          return null;
+        }
+        const result = snapshotSchema2.safeParse(json);
+        if (!result.success) {
+          this.reportUnreadable("it does not have the registry snapshot shape");
+          return null;
+        }
+        reportedUnreadable2.delete(this.registryPath);
+        const snapshot = result.data;
+        return snapshot;
+      }
+      reportUnreadable(reason) {
+        if (reportedUnreadable2.has(this.registryPath))
+          return;
+        reportedUnreadable2.add(this.registryPath);
+        canopyLogWarn3(`CanopyCMS: Branch registry snapshot ${this.registryPath} is unreadable (${reason}); regenerating it from the branch directories`);
+      }
+      /**
+       * Returns a single branch by name, from the cached snapshot when it is fresh.
+       *
+       * Suspicious-miss backstop: a `name` missing from the list is the signal that
+       * the snapshot may predate a branch that now exists, so force one fresh
+       * regeneration and re-search before giving up. Throttled per instance, so a
+       * genuinely-absent branch costs at most one extra scan per window.
+       */
+      async get(name) {
+        return this.find((b) => b.branch.name === name);
+      }
+      /**
+       * Returns the branch whose workspace directory is `key` (`sanitizeBranchName` of its ref),
+       * whatever its name, with {@link get}'s backstop.
+       */
+      async getByKey(key) {
+        return this.find((b) => path37.basename(b.branchRoot) === key);
+      }
+      async find(matches) {
+        const found = (await this.list()).find(matches);
+        if (found)
+          return found;
+        if (!this.shouldForceRefresh())
+          return void 0;
+        const refreshed = await this.regenerate();
+        return refreshed.find(matches);
+      }
+      shouldForceRefresh() {
+        const now = Date.now();
+        if (now - this.lastForcedRefreshMs < GET_MISS_REFRESH_MIN_INTERVAL_MS2)
+          return false;
+        this.lastForcedRefreshMs = now;
+        return true;
+      }
+      /**
+       * Marks the cache stale for every process sharing this root by bumping the
+       * marker, then eager-regenerates on this host. The bump must succeed —
+       * swallowing that failure leaves the registry stale indefinitely with no
+       * backstop. A failed eager regen must NOT fail the caller's save/delete: the
+       * bump alone already restored correctness for every future reader.
+       */
+      async invalidate() {
+        await bumpResourceGeneration2(this.root, RESOURCE3, { mustSucceed: true });
+        try {
+          if (this.regenInFlight)
+            await this.regenInFlight.catch(() => {
+            });
+          await this.regenerate();
+        } catch (err2) {
+          log12.warn("invalidate", "Eager regeneration after invalidate() failed", {
+            error: getErrorMessage(err2)
+          });
+        }
+      }
+      /**
+       * Scans branch directories and rebuilds the cache, deduping concurrent
+       * callers on this instance to a single underlying scan. Never loops waiting
+       * for the embedded token to match the marker — that livelocks under a bump
+       * storm; a caller wanting the very latest state calls list() again.
+       */
+      async regenerate() {
+        if (this.regenInFlight)
+          return this.regenInFlight;
+        const run = this.performRegenerate();
+        this.regenInFlight = run;
+        try {
+          return await run;
+        } finally {
+          this.regenInFlight = null;
+        }
+      }
+      async performRegenerate() {
+        const read = await readResourceGeneration2(this.root, RESOURCE3);
+        const branches = await this.scanBranchDirectories();
+        await fs30.unlink(this.stalePath).catch(() => {
+        });
+        if (!read.ok) {
+          return branches;
+        }
+        const snapshot = {
+          version: REGISTRY_VERSION2,
+          branches,
+          generation: read.token
+        };
+        const uniqueTempPath = `${this.tempPath}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+        await fs30.mkdir(this.root, { recursive: true });
+        await fs30.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+        try {
+          await fs30.rename(uniqueTempPath, this.registryPath);
+        } catch (err2) {
+          await fs30.unlink(uniqueTempPath).catch(() => {
+          });
+          throw err2;
+        }
+        return branches;
+      }
+      /**
+       * Scans the root directory for branch subdirectories with valid branch.json files.
+       * Protected (rather than exported as a test hook) so tests can subclass and
+       * override to simulate cross-process interleavings.
+       */
+      async scanBranchDirectories() {
+        const branches = [];
+        try {
+          const entries = await fs30.readdir(this.root, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".")) {
+              continue;
+            }
+            const branchRoot = path37.join(this.root, entry.name);
+            let meta;
+            try {
+              meta = await readBranchMetadataFile2(branchRoot);
+            } catch (err2) {
+              canopyLogWarn3(`CanopyCMS: Skipping branch directory '${entry.name}' during registry scan: ${getErrorMessage(err2)}`);
+              continue;
+            }
+            if (meta) {
+              branches.push({
+                branch: meta.branch,
+                branchRoot,
+                baseRoot: this.root
+              });
+            }
+          }
+        } catch (err2) {
+          if (isNotFoundError(err2)) {
+            return [];
+          }
+          throw err2;
+        }
+        return branches;
+      }
+    };
   }
-  if (parts.length === 2) {
-    const possibleId = parts[parts.length - 1];
-    if (isValidId2(possibleId)) {
-      return parts[0].toLowerCase();
-    }
+});
+
+// dist/paths/branch.js
+import path38 from "node:path";
+function namesNoWorkspace(err2) {
+  if (err2 instanceof BranchPathError2)
+    return true;
+  return isNodeError(err2) && (err2.code === "ENAMETOOLONG" || err2.code === "ENOTDIR");
+}
+function resolveBranchPath2(options) {
+  if (options.branchName.includes("..")) {
+    throw new BranchPathError2("Branch name cannot contain traversal segments");
   }
-  if (parts.length > 1) {
-    return parts.slice(0, -1).join(".").toLowerCase();
+  if (isSettingsBranchName2(options.branchName)) {
+    throw new BranchPathError2("Settings branches are not content branches");
   }
-  return filename.toLowerCase();
+  const safeBranch = sanitizeBranchName3(options.branchName);
+  const strategy = operatingStrategy3(options.mode);
+  const baseRoot = resolveContentBranchesRoot2(options.mode, options.basePathOverride);
+  const normalizedBase = path38.resolve(baseRoot);
+  const baseWithSep = normalizedBase.endsWith(path38.sep) ? normalizedBase : `${normalizedBase}${path38.sep}`;
+  const branchRoot = strategy.getContentBranchRoot(safeBranch, options.basePathOverride);
+  const withinBase = (target) => {
+    const resolved = path38.resolve(target);
+    return resolved === normalizedBase || resolved.startsWith(baseWithSep);
+  };
+  if (!withinBase(branchRoot)) {
+    throw new BranchPathError2("Branch path resolves outside the base root");
+  }
+  return { branchRoot, baseRoot: normalizedBase, branchName: safeBranch };
 }
-var ENTRY_EXTENSIONS2;
-var init_content_id_index = __esm({
-  "dist/content-id-index.js"() {
+var BranchPathError2, resolveContentBranchesRoot2;
+var init_branch = __esm({
+  "dist/paths/branch.js"() {
     "use strict";
-    init_id();
-    init_format();
-    ENTRY_EXTENSIONS2 = new Set(Object.keys({ md: true, mdx: true, json: true, yaml: true }).map((format) => getFormatExtension2(format)));
+    init_operating_mode2();
+    init_error();
+    init_branch_name2();
+    BranchPathError2 = class extends Error {
+    };
+    resolveContentBranchesRoot2 = (mode, override) => {
+      return operatingStrategy3(mode).getContentBranchesRoot(override);
+    };
   }
 });
 
-// dist/schema/meta-loader.js
-import { promises as fs29 } from "fs";
-import { join as join3 } from "pathe";
-import { z as z16 } from "zod";
-import chokidar2 from "chokidar";
-function stripEmbeddedIdFromName2(name) {
-  return extractSlugFromFilename2(name);
-}
-async function scanForCollectionMeta2(baseDir, relativePath = "") {
-  const collections = [];
+// dist/paths/index.js
+var init_paths = __esm({
+  "dist/paths/index.js"() {
+    "use strict";
+    init_validation3();
+    init_branch();
+  }
+});
+
+// dist/utils/async-mutex.js
+async function withLock2(key, fn) {
+  const prev = locks2.get(key) ?? Promise.resolve();
+  let resolve2;
+  const next = new Promise((r) => {
+    resolve2 = r;
+  });
+  locks2.set(key, next);
+  await prev;
   try {
-    const entries = await fs29.readdir(baseDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const folderName = entry.name;
-      const logicalName = stripEmbeddedIdFromName2(folderName);
-      const collectionContentId = extractIdFromFilename2(folderName) ?? void 0;
-      const folderPath = relativePath ? `${relativePath}/${logicalName}` : logicalName;
-      const absolutePath = join3(baseDir, folderName);
-      const metaPath = join3(absolutePath, ".collection.json");
-      try {
-        await fs29.access(metaPath);
-        const content = await fs29.readFile(metaPath, "utf-8");
-        const parsed = JSON.parse(content);
-        const meta = collectionMetaSchema2.parse(parsed);
-        collections.push({
-          ...meta,
-          path: folderPath,
-          contentId: collectionContentId
-        });
-        const nestedCollections = await scanForCollectionMeta2(absolutePath, folderPath);
-        collections.push(...nestedCollections);
-      } catch (err2) {
-        if (err2.code !== "ENOENT") {
-          canopyLogError2(`Error loading ${metaPath}:`, err2);
-          throw new Error(`Invalid .collection.json in ${folderPath}: ${err2.message}`);
-        }
-        const nestedCollections = await scanForCollectionMeta2(absolutePath, folderPath);
-        collections.push(...nestedCollections);
-      }
-    }
-    return collections;
-  } catch (err2) {
-    if (err2.code === "ENOENT") {
-      return [];
-    }
-    throw err2;
-  }
-}
-async function loadCollectionMetaFiles2(contentRoot) {
-  let root = null;
-  const rootMetaPath = join3(contentRoot, ".collection.json");
-  try {
-    await fs29.access(rootMetaPath);
-  } catch (err2) {
-    if (err2.code === "ENOENT") {
-    } else {
-      throw err2;
-    }
-  }
-  try {
-    const content = await fs29.readFile(rootMetaPath, "utf-8");
-    const parsed = JSON.parse(content);
-    root = rootCollectionMetaSchema2.parse(parsed);
-  } catch (err2) {
-    const errno = err2.code;
-    if (errno !== "ENOENT") {
-      throw new Error(`Invalid root .collection.json`);
-    }
-  }
-  const collections = await scanForCollectionMeta2(contentRoot);
-  return { root, collections };
-}
-var entryTypeMetaSchema2, collectionMetaSchema2, rootCollectionMetaSchema2;
-var init_meta_loader = __esm({
-  "dist/schema/meta-loader.js"() {
-    "use strict";
-    init_logger3();
-    init_content_id_index();
-    entryTypeMetaSchema2 = z16.object({
-      name: z16.string().min(1),
-      format: z16.enum(["md", "mdx", "json", "yaml"]),
-      schema: z16.string().min(1),
-      // Entry schema registry key (validated at resolution time)
-      label: z16.string().optional(),
-      description: z16.string().optional(),
-      default: z16.boolean().optional(),
-      maxItems: z16.number().int().positive().optional()
-    });
-    collectionMetaSchema2 = z16.object({
-      name: z16.string().min(1),
-      label: z16.string().optional(),
-      description: z16.string().optional(),
-      entries: z16.array(entryTypeMetaSchema2).optional(),
-      order: z16.array(z16.string()).default([])
-      // Embedded IDs for ordering; optional in the file, [] = alphabetical
-    }).refine((data) => data.entries && data.entries.length > 0, {
-      message: "Collection must have at least one entry type"
-    });
-    rootCollectionMetaSchema2 = z16.object({
-      label: z16.string().optional(),
-      entries: z16.array(entryTypeMetaSchema2).optional(),
-      order: z16.array(z16.string()).optional()
-      // Embedded IDs for ordering items
-    });
-  }
-});
-
-// dist/branch-schema-cache.js
-import { LRUCache as LRUCache2 } from "lru-cache";
-var SNAPSHOT_MEMO_MAX_BYTES2, SCHEMA_GENERATION_RESOURCE2;
-var init_branch_schema_cache = __esm({
-  "dist/branch-schema-cache.js"() {
-    "use strict";
-    SNAPSHOT_MEMO_MAX_BYTES2 = 64 * 1024 * 1024;
-    SCHEMA_GENERATION_RESOURCE2 = "schema";
+    return await fn();
+  } finally {
+    resolve2();
+    if (locks2.get(key) === next)
+      locks2.delete(key);
   }
-});
-
-// dist/content-index-generation.js
-async function bumpContentIndexGeneration2(root) {
-  return bumpResourceGeneration2(root, RESOURCE3);
-}
-async function invalidateBranchContentCaches2(root) {
-  await bumpContentIndexGeneration2(root);
-  await bumpResourceGeneration2(root, SCHEMA_GENERATION_RESOURCE2);
-  invalidateContentIndexesForRoot2(root);
 }
-var RESOURCE3;
-var init_content_index_generation = __esm({
-  "dist/content-index-generation.js"() {
+var locks2;
+var init_async_mutex = __esm({
+  "dist/utils/async-mutex.js"() {
     "use strict";
-    init_resource_generation();
-    init_content_index_registry();
-    init_branch_schema_cache();
-    RESOURCE3 = "content-index";
+    locks2 = /* @__PURE__ */ new Map();
   }
 });
 
 // dist/utils/provisioning-lock.js
-import fs30 from "node:fs/promises";
-import path36 from "node:path";
+import fs31 from "node:fs/promises";
+import path39 from "node:path";
 import lockfile3 from "proper-lockfile";
 function guardOnCompromised2(handler, lockPath) {
   return (err2) => {
@@ -18193,14 +18406,14 @@ function releaseIgnoringAlreadyReleased2(release, lockPath) {
 }
 async function tryAcquireProvisioningLock2(lockTargetDir3, lockName, onCompromised, staleMs = PROVISIONING_LOCK_STALE_MS2, createParents = true) {
   if (createParents) {
-    await fs30.mkdir(lockTargetDir3, { recursive: true });
+    await fs31.mkdir(lockTargetDir3, { recursive: true });
   } else {
-    await fs30.mkdir(lockTargetDir3).catch((err2) => {
+    await fs31.mkdir(lockTargetDir3).catch((err2) => {
       if (!isNodeError(err2) || err2.code !== "EEXIST")
         throw err2;
     });
   }
-  const lockPath = path36.join(lockTargetDir3, lockName);
+  const lockPath = path39.join(lockTargetDir3, lockName);
   const release = await lockfile3.lock(lockPath, provisioningLockOptions2(lockPath, 0, onCompromised, staleMs));
   return releaseIgnoringAlreadyReleased2(release, lockPath);
 }
@@ -18214,1462 +18427,1556 @@ var init_provisioning_lock = __esm({
   }
 });
 
-// dist/utils/content-write-lock.js
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
-import path37 from "node:path";
-function lockTargetDir2(branchRoot) {
-  return path37.join(path37.resolve(branchRoot), META_DIR4);
-}
-function tryAcquireContentWriteLock2(branchRoot, onCompromised) {
-  return tryAcquireProvisioningLock2(lockTargetDir2(branchRoot), CONTENT_WRITE_LOCK_NAME2, onCompromised, CONTENT_WRITE_LOCK_STALE_MS2, false);
+// dist/utils/occ-json-write.js
+import fs33 from "node:fs/promises";
+import path40 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import lockfile4 from "proper-lockfile";
+async function writeOccJsonFile2(filePath, payload, options) {
+  const { expectedVersion, settleMs = 50, trailingNewline = false } = options;
+  const newVersion = expectedVersion === null ? 1 : expectedVersion + 1;
+  const writeId = randomUUID6();
+  const data = { ...payload, version: newVersion, writeId };
+  const content = JSON.stringify(data, null, 2) + (trailingNewline ? "\n" : "");
+  const dir = path40.dirname(filePath);
+  await fs33.mkdir(dir, { recursive: true });
+  const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  await fs33.writeFile(tempPath, content, "utf-8");
+  if (expectedVersion === null) {
+    try {
+      await fs33.link(tempPath, filePath);
+    } catch (err2) {
+      await fs33.unlink(tempPath).catch(() => {
+      });
+      if (isFileExistsError(err2)) {
+        throw new OccWriteConflictError2();
+      }
+      throw err2;
+    }
+    await fs33.unlink(tempPath).catch(() => {
+    });
+    return { version: newVersion, writeId };
+  }
+  try {
+    let currentVersion = null;
+    try {
+      const current = JSON.parse(await fs33.readFile(filePath, "utf-8"));
+      currentVersion = current.version ?? 0;
+    } catch {
+      currentVersion = null;
+    }
+    if (currentVersion !== expectedVersion) {
+      throw new OccWriteConflictError2();
+    }
+    await fs33.rename(tempPath, filePath);
+    if (settleMs > 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, settleMs));
+    }
+    const afterWrite = JSON.parse(await fs33.readFile(filePath, "utf-8"));
+    if (afterWrite.writeId !== writeId) {
+      throw new OccWriteConflictError2();
+    }
+  } catch (err2) {
+    await fs33.unlink(tempPath).catch(() => {
+    });
+    throw err2;
+  }
+  return { version: newVersion, writeId };
 }
-async function acquireContentWriteLock2(branchRoot, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2, onCompromised) {
-  const startedAt = Date.now();
-  for (let attempt = 0; ; attempt++) {
+async function withOccRetry2(operation, options) {
+  const maxAttempts = options?.maxAttempts ?? 10;
+  const isRetryable = options?.isRetryable;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      return await tryAcquireContentWriteLock2(branchRoot, onCompromised);
+      return await operation();
     } catch (err2) {
-      if (!isNodeError(err2) || err2.code !== "ELOCKED")
-        throw err2;
-      const remaining = waitMs - (Date.now() - startedAt);
-      if (remaining <= 0)
-        throw new ContentWriteLockBusyError2();
-      const base = Math.min(40 * 2 ** attempt, 250);
-      await sleep3(Math.min(base * (0.5 + Math.random()), remaining));
+      const retryable = err2 instanceof OccWriteConflictError2 || (isRetryable?.(err2) ?? false);
+      if (retryable && attempt < maxAttempts) {
+        const baseDelay = Math.min(10 * Math.pow(2, attempt - 1), 100);
+        const jitter = Math.random() * baseDelay;
+        await new Promise((resolve2) => setTimeout(resolve2, baseDelay + jitter));
+        continue;
+      }
+      throw err2;
     }
   }
+  throw new Error("Unreachable");
 }
-async function withContentWriteLock2(branchRoot, fn, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2) {
-  let compromised = false;
-  const release = await acquireContentWriteLock2(branchRoot, waitMs, (err2) => {
-    compromised = true;
-    canopyLogWarn3(`[canopy] Content-write lock compromised mid-hold for ${branchRoot}:`, getErrorMessage(err2));
-  });
-  let result;
+async function withOccFileLock2(filePath, fn) {
   try {
-    const held = new Set(heldRoots2.getStore());
-    held.add(path37.resolve(branchRoot));
-    result = await heldRoots2.run(held, fn);
-  } finally {
-    await release();
+    await fs33.mkdir(path40.dirname(filePath));
+  } catch (err2) {
+    if (!isNodeError(err2) || err2.code !== "EEXIST") {
+      throw new OccWriteConflictError2(`Could not acquire file lock: ${getErrorMessage(err2)}`);
+    }
   }
-  if (compromised) {
-    throw new ContentWriteLockBusyError2("We couldn't confirm your change was saved because the branch was syncing at the same time. Reload to check before saving again (your unsaved edits will be lost).", "unknown");
+  const MAX_ATTEMPTS = 14;
+  let release = null;
+  for (let attempt = 1; release === null; attempt++) {
+    try {
+      release = await lockfile4.lock(filePath, {
+        lockfilePath: `${filePath}.lock`,
+        realpath: false,
+        stale: 1e4,
+        retries: 0,
+        // A compromised lock (the lock dir vanished or refresh failed mid-hold, e.g. the branch
+        // directory containing it was deleted, or an EFS waiter misread a cached mtime and took
+        // it over) must not crash the process, which is proper-lockfile's default. Our critical
+        // sections are short and idempotent-on-conflict (OCC verify inside); log and let the
+        // section finish.
+        onCompromised: guardOnCompromised2((err2) => canopyLogWarn3(`[canopy] OCC file lock compromised mid-hold for ${filePath}:`, getErrorMessage(err2)), filePath)
+      });
+    } catch (err2) {
+      const code = isNodeError(err2) ? err2.code : void 0;
+      const contended = code === "ELOCKED";
+      if (!contended || attempt >= MAX_ATTEMPTS) {
+        throw new OccWriteConflictError2(`Could not acquire file lock: ${getErrorMessage(err2)}`);
+      }
+      const baseDelay = Math.min(50 * Math.pow(1.6, attempt - 1), 2e3);
+      const jitter = Math.random() * baseDelay;
+      await new Promise((resolve2) => setTimeout(resolve2, baseDelay + jitter));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    await release().catch((err2) => {
+      if (isNodeError(err2) && err2.code === "ENOENT")
+        return;
+      log13.warn("lock", `Failed to release lock for ${filePath}`, { error: getErrorMessage(err2) });
+    });
   }
-  return result;
 }
-var META_DIR4, CONTENT_WRITE_LOCK_NAME2, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2, ContentWriteLockBusyError2, sleep3, CONTENT_WRITE_LOCK_STALE_MS2, heldRoots2;
-var init_content_write_lock = __esm({
-  "dist/utils/content-write-lock.js"() {
+var log13, OccWriteConflictError2;
+var init_occ_json_write = __esm({
+  "dist/utils/occ-json-write.js"() {
     "use strict";
     init_error();
+    init_debug2();
     init_logger3();
     init_provisioning_lock();
-    META_DIR4 = ".canopy-meta";
-    CONTENT_WRITE_LOCK_NAME2 = "content-write.lock";
-    DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2 = 2e3;
-    ContentWriteLockBusyError2 = class extends Error {
-      constructor(message = "This branch is busy syncing or saving another change, so your change was not saved. Try again in a moment.", outcome = "not-run") {
+    log13 = createDebugLogger3({ prefix: "OccJsonWrite" });
+    OccWriteConflictError2 = class extends Error {
+      constructor(message = "Concurrent modification detected") {
         super(message);
-        this.outcome = outcome;
-        this.name = "ContentWriteLockBusyError";
+        this.name = "OccWriteConflictError";
       }
     };
-    sleep3 = (ms) => new Promise((resolve2) => {
-      setTimeout(resolve2, ms);
-    });
-    CONTENT_WRITE_LOCK_STALE_MS2 = 3e4;
-    heldRoots2 = new AsyncLocalStorage3();
   }
 });
 
-// dist/sync-core.js
-import fs31 from "node:fs/promises";
-import path38 from "node:path";
-import { simpleGit as simpleGit5 } from "simple-git";
-function assertWithinDir(resolved, parent, label) {
-  const normalizedResolved = path38.resolve(resolved);
-  const normalizedParent = path38.resolve(parent);
-  if (!normalizedResolved.startsWith(normalizedParent + path38.sep) && normalizedResolved !== normalizedParent) {
-    throw new Error(`${label} escapes the expected directory: ${resolved}`);
-  }
+// dist/branch-metadata.js
+import fs34 from "node:fs/promises";
+import path41 from "node:path";
+function isRecordedEditor2(branch, userId) {
+  return (branch.editors?.includes(userId) ?? false) && (branch.uncommittedEditors?.includes(userId) ?? false);
 }
-async function safeReplaceDir(oldDir, newDir) {
-  const backupDir = `${oldDir}.sync-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const oldExists = await filePathExists(oldDir);
-  if (oldExists) {
-    await fs31.rename(oldDir, backupDir);
-  }
-  try {
-    await fs31.rename(newDir, oldDir);
-  } catch (err2) {
-    if (oldExists) {
-      await fs31.rename(backupDir, oldDir).catch(() => {
-      });
-    }
-    throw err2;
-  }
-  if (oldExists) {
-    await fs31.rm(backupDir, { recursive: true, force: true }).catch(() => {
-    });
-  }
-}
-async function listFilesRecursive(dir, prefix = "") {
-  const results = [];
-  let entries;
-  try {
-    entries = await fs31.readdir(dir, { withFileTypes: true });
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    if (entry.name === ".git")
-      continue;
-    if (entry.isSymbolicLink())
-      continue;
-    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      results.push(...await listFilesRecursive(path38.join(dir, entry.name), rel));
-    } else {
-      results.push(rel);
-    }
-  }
-  return results;
-}
-async function copyDir(src, dest) {
-  await fs31.mkdir(dest, { recursive: true });
-  const entries = await fs31.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === ".git")
-      continue;
-    if (entry.isSymbolicLink())
-      continue;
-    const srcPath = path38.join(src, entry.name);
-    const destPath = path38.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else {
-      await fs31.copyFile(srcPath, destPath);
-    }
-  }
-}
-async function pushContentToWorkspace(options) {
-  const { srcContentDir, branchPath, contentRoot } = options;
-  if (!await filePathExists(srcContentDir)) {
-    return { fileCount: 0, savedEditorState: false };
-  }
-  const wsContentDir = path38.join(branchPath, contentRoot);
-  assertWithinDir(wsContentDir, branchPath, "content-root");
-  return withContentWriteLock2(branchPath, () => replaceWorkspaceContent(options, wsContentDir));
+function withMember2(list, id) {
+  return list?.includes(id) ? [...list] : [...list ?? [], id];
 }
-async function replaceWorkspaceContent(options, wsContentDir) {
-  const { srcContentDir, branchPath, commitMessage, baseTag, saveEditorStateMessage } = options;
-  const wsGit = simpleGit5({ baseDir: branchPath });
-  let savedEditorState = false;
-  if (saveEditorStateMessage) {
-    const editorChanges = (await wsGit.status()).files.filter((f) => !isCanopyInternalPath(f.path));
-    if (editorChanges.length > 0) {
-      await stageAllExceptCanopyState2(wsGit);
-      await wsGit.commit(saveEditorStateMessage);
-      savedEditorState = true;
-    }
-  }
-  const tmpDir = `${wsContentDir}.sync-tmp-${Date.now()}`;
-  try {
-    await copyDir(srcContentDir, tmpDir);
-    await safeReplaceDir(wsContentDir, tmpDir);
-  } catch (err2) {
-    await fs31.rm(tmpDir, { recursive: true, force: true }).catch(() => {
-    });
-    throw err2;
-  }
-  try {
-    await stageAllExceptCanopyState2(wsGit);
-    const staged = (await wsGit.status()).files.filter((f) => !isCanopyInternalPath(f.path));
-    if (staged.length === 0) {
-      if (baseTag)
-        await wsGit.tag(["-f", baseTag]);
-      return { fileCount: 0, savedEditorState };
+function mergeBranchMetadata2(existing, version, incoming, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const defaults = {
+    name: "unknown",
+    status: "editing",
+    access: {},
+    createdBy: "unknown",
+    createdAt: now,
+    updatedAt: now
+  };
+  return {
+    // Envelope keys this code does not know survive, as unknown branch keys do below.
+    ...existing,
+    schemaVersion: CURRENT_SCHEMA_VERSION2,
+    version: version ?? 0,
+    branch: {
+      ...defaults,
+      ...existing?.branch,
+      ...incoming.branch,
+      access: {
+        ...existing?.branch?.access,
+        ...incoming.branch?.access
+      },
+      // Immutable after creation
+      createdBy: existing?.branch.createdBy ?? incoming.branch?.createdBy ?? defaults.createdBy,
+      createdAt: existing?.branch.createdAt ?? defaults.createdAt,
+      // Fork point is recorded once at creation; later saves must not move it
+      baseBranch: existing?.branch.baseBranch ?? incoming.branch?.baseBranch,
+      // Always stamped fresh; the spreads above would otherwise let the creation-time value win
+      // forever, freezing the timestamp the editor's Branches panel sorts and displays by
+      updatedAt: now
     }
-    await wsGit.commit(commitMessage ?? "sync: update content from working tree");
-    if (baseTag)
-      await wsGit.tag(["-f", baseTag]);
-    return { fileCount: staged.length, savedEditorState };
-  } finally {
-    await invalidateBranchContentCaches2(branchPath);
-  }
+  };
 }
-var SYNC_BASE_TAG;
-var init_sync_core = __esm({
-  "dist/sync-core.js"() {
+var CURRENT_SCHEMA_VERSION2, BranchMetadataConflictError2, BranchMetadataFileManager2, loadBranchContext2;
+var init_branch_metadata = __esm({
+  "dist/branch-metadata.js"() {
     "use strict";
-    init_content_index_generation();
-    init_content_write_lock();
-    init_fs();
-    init_git();
-    SYNC_BASE_TAG = "canopycms-sync-base";
+    init_branch_registry();
+    init_branch_metadata_file();
+    init_paths();
+    init_error();
+    init_async_mutex();
+    init_occ_json_write();
+    CURRENT_SCHEMA_VERSION2 = 1;
+    BranchMetadataConflictError2 = class extends Error {
+      constructor(message = "Concurrent modification detected in branch metadata") {
+        super(message);
+        this.name = "BranchMetadataConflictError";
+      }
+    };
+    BranchMetadataFileManager2 = class _BranchMetadataFileManager2 {
+      constructor(branchRoot, baseRoot, options) {
+        this.branchRoot = path41.resolve(branchRoot);
+        this.filePath = path41.join(this.branchRoot, BRANCH_META_DIR2, BRANCH_META_FILE2);
+        this.baseRoot = baseRoot;
+        this.settleMs = options?.settleMs;
+      }
+      /** Read-only load, needing no baseRoot: registry scanning, loadBranchContext. */
+      static async loadOnly(branchRoot) {
+        return readBranchMetadataFile2(branchRoot);
+      }
+      /**
+       * An instance wired for registry invalidation. API handlers use this, so the
+       * registry cache is invalidated on update.
+       */
+      static get(branchRoot, baseRoot, options) {
+        return new _BranchMetadataFileManager2(branchRoot, baseRoot, options);
+      }
+      /**
+       * The file the save cycle merges over. A corrupt one throws
+       * {@link BranchMetadataCorruptError} rather than reading as absent, so a save
+       * never lays defaults (status 'editing', no ACL) over a branch whose real
+       * state is unknown; repair-metadata archives the file before it saves.
+       */
+      async load() {
+        const meta = await readBranchMetadataFile2(this.branchRoot);
+        return { meta, version: meta?.version ?? null };
+      }
+      /**
+       * Write branch.json via the shared OCC helper, applying the schemaVersion
+       * default here since payload shaping is branch-metadata's concern.
+       *
+       * Throws the helper's raw {@link OccWriteConflictError}, which is what the
+       * surrounding {@link withOccRetry} in save() recognizes and retries;
+       * translating to the public `BranchMetadataConflictError` earlier than the
+       * save() boundary would make withOccRetry's predicate miss it.
+       *
+       * branch.json is written WITH a trailing newline (`trailingNewline: true`),
+       * unlike comments.json.
+       */
+      async write(meta, expectedVersion) {
+        const payload = {
+          ...meta,
+          schemaVersion: meta.schemaVersion ?? CURRENT_SCHEMA_VERSION2
+        };
+        return writeOccJsonFile2(this.filePath, payload, {
+          expectedVersion,
+          settleMs: this.settleMs,
+          trailingNewline: true
+        });
+      }
+      /**
+       * Run a save cycle under the full lock + OCC-retry stack (class doc). A
+       * conflict surviving every retry surfaces as `BranchMetadataConflictError`.
+       *
+       * The stat guards a phantom-resurrection race with branch deletion: a
+       * caller's branchContext can resolve BEFORE a concurrent deleteBranchHandler
+       * removes the branch directory, while the save reaches here after it, and
+       * write()'s `mkdir({recursive:true})` would then recreate `.canopy-meta/` and
+       * branch.json from defaults inside a tree nothing else refers to — a registry
+       * entry with no clone behind it. It runs BEFORE the lock stack so a doomed
+       * save fails fast instead of paying for a lock.
+       *
+       * A save that passes the check just before a delete still cannot write: the
+       * delete renames the tree away under the same lockfile, and that lockfile
+       * creates only its own directory (`withOccFileLock`), so the save fails there.
+       */
+      async save(incoming) {
+        const saved = await this.saveIf(incoming, () => true);
+        if (saved === null)
+          throw new Error("unreachable: an unconditional save was skipped");
+        return saved;
+      }
+      /**
+       * {@link save}, applied only when `onlyIf` accepts the metadata on disk; resolves null when it
+       * does not, having written nothing. `onlyIf` runs inside the lock stack against the version
+       * the write is checked against, so the decision and the write are one compare-and-set.
+       */
+      async saveIf(incoming, onlyIf) {
+        return this.update((existing) => onlyIf(existing) ? incoming : null);
+      }
+      /**
+       * A save whose update `compute` derives from the metadata on disk, inside the lock stack, so
+       * an update built from the existing value (adding to a list) cannot lose a concurrent one.
+       * `compute` returning null writes nothing and resolves null. `keepUpdatedAt` leaves
+       * `updatedAt` as it was, for bookkeeping writes that are not a change to the branch.
+       */
+      async update(compute, options = {}) {
+        try {
+          await fs34.stat(this.branchRoot);
+        } catch (err2) {
+          if (isNotFoundError(err2)) {
+            throw new BranchMetadataConflictError2("Branch no longer exists");
+          }
+          throw err2;
+        }
+        let saved;
+        try {
+          saved = await withLock2(this.filePath, () => withOccFileLock2(this.filePath, () => withOccRetry2(async () => {
+            const { meta: existing, version } = await this.load();
+            const incoming = compute(existing);
+            if (incoming === null)
+              return null;
+            const merged = mergeBranchMetadata2(existing, version, incoming);
+            if (options.keepUpdatedAt && existing)
+              merged.branch.updatedAt = existing.branch.updatedAt;
+            const written = await this.write(merged, version);
+            merged.version = written.version;
+            merged.writeId = written.writeId;
+            return merged;
+          })));
+        } catch (err2) {
+          if (err2 instanceof OccWriteConflictError2) {
+            throw new BranchMetadataConflictError2();
+          }
+          throw err2;
+        }
+        if (saved !== null)
+          await this.invalidateRegistry();
+        return saved;
+      }
+      /**
+       * Adds `userId` to `editors` and `uncommittedEditors`. A lock-free read skips the write when
+       * both already hold it, so only a user's first save since the last submit commit pays for the lock.
+       * Never creates branch.json.
+       */
+      async recordEditor(userId) {
+        const current = await readBranchMetadataFile2(this.branchRoot);
+        if (!current || isRecordedEditor2(current.branch, userId))
+          return;
+        await this.update((existing) => existing && !isRecordedEditor2(existing.branch, userId) ? {
+          branch: {
+            editors: withMember2(existing.branch.editors, userId),
+            uncommittedEditors: withMember2(existing.branch.uncommittedEditors, userId)
+          }
+        } : null, { keepUpdatedAt: true });
+      }
+      /**
+       * Removes `userIds` from `uncommittedEditors` once a submit commit's trailers name them. Ids
+       * recorded after the commit read them stay, so the next commit names them.
+       */
+      async markEditorsCommitted(userIds) {
+        const committed = new Set(userIds);
+        if (committed.size === 0)
+          return;
+        await this.update((existing) => {
+          const pending = existing?.branch.uncommittedEditors ?? [];
+          const remaining = pending.filter((id) => !committed.has(id));
+          if (remaining.length === pending.length)
+            return null;
+          return { branch: { uncommittedEditors: remaining.length > 0 ? remaining : void 0 } };
+        }, { keepUpdatedAt: true });
+      }
+      /** Invalidate the registry cache so the next list() regenerates. */
+      async invalidateRegistry() {
+        const registry3 = new BranchRegistry2(this.baseRoot);
+        await registry3.invalidate();
+      }
+    };
+    loadBranchContext2 = async (options) => {
+      const { branchRoot, baseRoot } = resolveBranchPath2({
+        branchName: options.branchName,
+        mode: options.mode,
+        basePathOverride: options.basePathOverride
+      });
+      const meta = await BranchMetadataFileManager2.loadOnly(branchRoot);
+      if (!meta) {
+        return null;
+      }
+      return {
+        branch: meta.branch,
+        branchRoot,
+        baseRoot
+      };
+    };
   }
 });
 
-// dist/git-manager.js
-import fs33 from "node:fs/promises";
-import path39 from "node:path";
-import { simpleGit as simpleGit6 } from "simple-git";
-async function ensureGitExcludePattern2(repoPath, pattern) {
-  const excludePath = path39.join(repoPath, ".git", "info", "exclude");
-  await fs33.mkdir(path39.dirname(excludePath), { recursive: true });
-  let content = "";
-  try {
-    content = await fs33.readFile(excludePath, "utf-8");
-  } catch (err2) {
-    if (!isNotFoundError(err2))
-      throw err2;
-  }
-  const lines = content.split("\n");
-  if (lines.some((line) => line.trim() === pattern)) {
-    log12.debug("git", "Pattern already in .git/info/exclude", { pattern });
-    return;
+// dist/utils/base-branch.js
+function baseBranchOf2(config) {
+  if (config.defaultBaseBranch)
+    return config.defaultBaseBranch;
+  if (config.mode === "prod") {
+    throw new BaseBranchUnresolvedError2("the prod base branch has not been resolved.");
   }
-  const needsLeadingNewline = content.length > 0 && !content.endsWith("\n");
-  const newContent = content + (needsLeadingNewline ? "\n" : "") + pattern + "\n";
-  await fs33.writeFile(excludePath, newContent, "utf-8");
-  log12.debug("git", "Added pattern to .git/info/exclude", { pattern });
+  return "main";
 }
-var log12;
-var init_git_manager = __esm({
-  "dist/git-manager.js"() {
+var BaseBranchUnresolvedError2;
+var init_base_branch = __esm({
+  "dist/utils/base-branch.js"() {
     "use strict";
-    init_debug2();
-    init_error();
-    log12 = createDebugLogger3({ prefix: "GitManager" });
+    BaseBranchUnresolvedError2 = class extends Error {
+      constructor(detail) {
+        super(`CanopyCMS: ${detail} Set defaultBaseBranch in your CanopyCMS config to the branch editing branches fork from.`);
+        this.name = "BaseBranchUnresolvedError";
+      }
+    };
   }
 });
 
-// dist/cli/sync.js
-var sync_exports = {};
-__export(sync_exports, {
-  sync: () => sync
-});
-import fs34 from "node:fs/promises";
-import path40 from "node:path";
-import { simpleGit as simpleGit7 } from "simple-git";
-import * as p2 from "@clack/prompts";
-function lockBusyAsSyncError(err2, branchName) {
-  if (!(err2 instanceof ContentWriteLockBusyError2))
-    return err2;
-  return new SyncError(err2.outcome === "not-run" ? `Branch workspace "${branchName}" is busy (the worker is syncing it, or an editor save is in flight); nothing was changed. Try again in a moment.` : `Branch workspace "${branchName}" was being synced during this run, so it may be partly updated. Check its state before running sync again.`);
-}
-async function withWorkspaceLock(branchPath, branchName, fn) {
+// dist/branch-param.js
+function cmsBranchNamespace2(config) {
   try {
-    return await withContentWriteLock2(branchPath, fn);
-  } catch (err2) {
-    throw lockBusyAsSyncError(err2, branchName);
+    return operatingStrategy3(config.mode).getBranchNamespace(config);
+  } catch {
+    return null;
   }
 }
-async function abortWorkspaceMerge(branchPath, branchName) {
-  return withWorkspaceLock(branchPath, branchName, async () => {
-    const wsGit = simpleGit7({ baseDir: branchPath });
-    if ((await wsGit.status()).conflicted.length === 0)
+function namesBaseOrActive2(param, config) {
+  let base;
+  try {
+    base = baseBranchOf2(config);
+  } catch (err2) {
+    if (err2 instanceof BaseBranchUnresolvedError2)
       return false;
-    await wsGit.merge(["--abort"]);
-    await invalidateBranchContentCaches2(branchPath);
-    return true;
-  });
-}
-async function detectCurrentBranch(projectDir) {
-  const git = simpleGit7({ baseDir: projectDir });
-  const branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
-  if (branch === "HEAD")
-    throw new Error("Detached HEAD \u2014 use --branch to specify a branch name");
-  return branch;
-}
-async function selectBranch(options, branchesDir) {
-  let branches = [];
-  if (await filePathExists(branchesDir)) {
-    const entries = await fs34.readdir(branchesDir, { withFileTypes: true });
-    branches = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-  }
-  let branchName = options.branch;
-  if (!branchName) {
-    try {
-      branchName = await detectCurrentBranch(options.projectDir);
-    } catch {
-    }
+    throw err2;
   }
-  if (!branchName) {
-    if (branches.length === 0) {
-      throw new SyncError("No branch workspaces found and could not detect current git branch. Use --branch to specify.");
-    }
-    if (branches.length === 1) {
-      branchName = branches[0];
-    } else {
-      const result = await p2.select({
-        message: "Which branch?",
-        options: branches.map((b) => ({ value: b, label: b }))
-      });
-      if (p2.isCancel(result)) {
-        p2.cancel("Sync cancelled.");
+  return param === base || param === (config.defaultActiveBranch ?? base);
+}
+async function resolveBranchParam(param, config, options = {}) {
+  const load = (branchName) => loadBranchContext2({ branchName, mode: config.mode, basePathOverride: options.basePathOverride });
+  if (isExactBranchForm(param)) {
+    const exact = exactBranchName(param);
+    if (exact === null)
+      return null;
+    const named = await load(exact);
+    return named?.branch.name === exact ? named : null;
+  }
+  if (namesBaseOrActive2(param, config))
+    return load(param);
+  const namespace = cmsBranchNamespace2(config);
+  if (namespace !== null && !param.includes("/")) {
+    const ref = `${namespace}${param}`;
+    const inNamespace = await load(ref).catch((err2) => {
+      if (namesNoWorkspace(err2))
         return null;
-      }
-      branchName = result;
-    }
-  }
-  const branchPath = path40.join(branchesDir, branchName);
-  assertWithinDir(branchPath, branchesDir, "--branch");
-  if (!branches.includes(branchName)) {
-    if (options.autoCreate) {
-      await fs34.mkdir(branchPath, { recursive: true });
-      const wsGit = simpleGit7({ baseDir: branchPath });
-      await wsGit.init();
-      await wsGit.checkoutLocalBranch(branchName);
-      await wsGit.raw(["commit", "--allow-empty", "-m", "init: workspace created by sync"]);
-      await ensureGitExcludePattern2(branchPath, operatingStrategy3("dev").getGitExcludePattern());
-      p2.log.info(`Created branch workspace: ${branchName}`);
-    } else {
-      const available = branches.length > 0 ? ` Available branches: ${branches.join(", ")}` : "";
-      throw new SyncError(`Branch workspace "${branchName}" not found.${available}`);
-    }
+      throw err2;
+    });
+    if (inNamespace?.branch.name === ref)
+      return inNamespace;
   }
-  return branchName;
+  const outside = await load(param);
+  return outside?.branch.name === param ? outside : null;
 }
-async function syncPush(options) {
-  const { projectDir } = options;
-  const contentRoot = options.contentRoot || "content";
-  const branchesDir = path40.join(projectDir, ".canopy-dev", "content-branches");
-  const srcContentDir = path40.join(projectDir, contentRoot);
-  assertWithinDir(srcContentDir, projectDir, "--content-root");
-  if (!await filePathExists(srcContentDir)) {
-    throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
-  }
-  const branchName = await selectBranch({ ...options, projectDir, autoCreate: true }, branchesDir);
-  if (!branchName)
-    return { fileCount: 0 };
-  const branchPath = path40.join(branchesDir, branchName);
-  assertWithinDir(branchPath, branchesDir, "--branch");
-  const wsGit = simpleGit7({ baseDir: branchPath });
-  const status = await wsGit.status();
-  if (status.conflicted.length > 0) {
-    p2.log.error("Branch workspace has unresolved merge conflicts.");
-    if (!options.force) {
-      const shouldAbort = await p2.confirm({
-        message: "Abort the merge and restore workspace to pre-merge state?",
-        initialValue: false
-      });
-      if (!p2.isCancel(shouldAbort) && shouldAbort) {
-        if (await abortWorkspaceMerge(branchPath, branchName)) {
-          p2.log.success("Merge aborted. Workspace restored to pre-merge state.");
-        }
-      }
-    }
-    return { fileCount: 0 };
-  }
-  const editorChanges = status.files.filter((f) => !isCanopyInternalPath(f.path));
-  if (editorChanges.length > 0 && !options.force) {
-    p2.log.warn(`Branch workspace has ${editorChanges.length} uncommitted change(s) that will be committed to history then overwritten:`);
-    for (const file of editorChanges.slice(0, 10)) {
-      p2.log.warn(`  ${file.path}`);
-    }
-    if (editorChanges.length > 10) {
-      p2.log.warn(`  ... and ${editorChanges.length - 10} more`);
-    }
-    const confirm5 = await p2.confirm({
-      message: "Continue? Editor changes will be preserved in git history.",
-      initialValue: false
-    });
-    if (p2.isCancel(confirm5) || !confirm5) {
-      p2.cancel("Push cancelled.");
-      return { fileCount: 0 };
-    }
+var init_branch_param = __esm({
+  "dist/branch-param.js"() {
+    "use strict";
+    init_branch_metadata();
+    init_operating_mode2();
+    init_branch();
+    init_validation3();
+    init_base_branch();
   }
-  p2.log.step(`Pushing content to branch workspace: ${branchName}`);
-  let fileCount;
+});
+
+// dist/utils/git.js
+import { simpleGit as simpleGit4 } from "simple-git";
+function isCanopyInternalPath(repoRelativePath) {
+  return repoRelativePath === CANOPY_META_DIR2 || repoRelativePath.startsWith(`${CANOPY_META_DIR2}/`);
+}
+async function stageAllExceptCanopyState2(git) {
+  await git.raw(["add", "-A", "--sparse"]);
+  await git.raw(["reset", "-q", "--", CANOPY_META_DIR2]);
+}
+async function detectHeadBranch2(repoRoot, fallback = "main") {
   try {
-    const result = await pushContentToWorkspace({
-      srcContentDir,
-      branchPath,
-      contentRoot,
-      baseTag: SYNC_BASE_TAG,
-      saveEditorStateMessage: "sync: save editor state before push"
-    });
-    fileCount = result.fileCount;
-    if (result.savedEditorState)
-      p2.log.info("Committed editor changes to history before push");
-  } catch (err2) {
-    throw lockBusyAsSyncError(err2, branchName);
-  }
-  if (fileCount === 0) {
-    p2.log.info("Content is already up to date \u2014 nothing to push");
-  } else {
-    p2.log.success(`Pushed ${fileCount} file change(s) to branch "${branchName}"`);
+    const git = simpleGit4({ baseDir: repoRoot });
+    const head = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+    return head && head !== "HEAD" ? head : fallback;
+  } catch {
+    return fallback;
   }
-  return { fileCount };
 }
-async function syncPull(options) {
-  const { projectDir } = options;
-  const contentRoot = options.contentRoot || "content";
-  const branchesDir = path40.join(projectDir, ".canopy-dev", "content-branches");
-  const branchName = await selectBranch({ ...options, projectDir }, branchesDir);
-  if (!branchName)
-    return { fileCount: 0 };
-  const branchPath = path40.join(branchesDir, branchName);
-  assertWithinDir(branchPath, branchesDir, "--branch");
-  const branchContentDir = path40.join(branchPath, contentRoot);
-  assertWithinDir(branchContentDir, branchPath, "--content-root");
-  if (!await filePathExists(branchContentDir)) {
-    throw new SyncError(`Content directory not found in branch workspace: ${branchName}/${contentRoot}`);
-  }
-  p2.log.step(`Pulling content from branch: ${branchName}`);
-  const destContentDir = path40.join(projectDir, contentRoot);
-  assertWithinDir(destContentDir, projectDir, "--content-root");
-  const sourceGit = simpleGit7({ baseDir: projectDir });
-  const status = await sourceGit.status();
-  const uncommittedContent = status.files.filter((f) => f.path.startsWith(contentRoot + "/") || f.path === contentRoot);
-  const untrackedLosses = [];
-  if (await filePathExists(destContentDir)) {
-    const localFiles = await listFilesRecursive(destContentDir);
-    const branchFiles = new Set(await listFilesRecursive(branchContentDir));
-    for (const file of localFiles) {
-      if (!branchFiles.has(file)) {
-        const relativePath = contentRoot + "/" + file;
-        if (!uncommittedContent.some((f) => f.path === relativePath)) {
-          untrackedLosses.push(relativePath);
-        }
-      }
-    }
+var CANOPY_META_DIR2;
+var init_git = __esm({
+  "dist/utils/git.js"() {
+    "use strict";
+    CANOPY_META_DIR2 = ".canopy-meta";
   }
-  const totalWarnings = uncommittedContent.length + untrackedLosses.length;
-  if (totalWarnings > 0 && !options.force) {
-    if (uncommittedContent.length > 0) {
-      p2.log.warn(`You have ${uncommittedContent.length} uncommitted change(s) in ${contentRoot}/:`);
-      for (const file of uncommittedContent.slice(0, 10)) {
-        p2.log.warn(`  ${file.path}`);
-      }
-      if (uncommittedContent.length > 10) {
-        p2.log.warn(`  ... and ${uncommittedContent.length - 10} more`);
-      }
-    }
-    if (untrackedLosses.length > 0) {
-      p2.log.warn(`${untrackedLosses.length} file(s) in ${contentRoot}/ not present in branch "${branchName}" will be deleted:`);
-      for (const file of untrackedLosses.slice(0, 10)) {
-        p2.log.warn(`  ${file}`);
-      }
-      if (untrackedLosses.length > 10) {
-        p2.log.warn(`  ... and ${untrackedLosses.length - 10} more`);
+});
+
+// dist/content-index-registry.js
+import path43 from "node:path";
+function invalidateContentIndexesForRoot2(root) {
+  const rootKey = path43.resolve(root);
+  const prefix = rootKey + path43.sep;
+  for (const [storeRoot, refs] of registry2) {
+    if (storeRoot !== rootKey && !storeRoot.startsWith(prefix))
+      continue;
+    for (const ref of refs) {
+      const target = ref.deref();
+      if (target) {
+        target.invalidateIndex();
+      } else {
+        refs.delete(ref);
       }
     }
-    const confirm5 = await p2.confirm({
-      message: "Overwrite content directory? Files listed above will be lost.",
-      initialValue: false
-    });
-    if (p2.isCancel(confirm5) || !confirm5) {
-      p2.cancel("Pull cancelled. Commit or stash your changes first.");
-      return { fileCount: 0 };
-    }
+    if (refs.size === 0)
+      registry2.delete(storeRoot);
   }
-  const tmpDestDir = `${destContentDir}.sync-tmp-${Date.now()}`;
-  try {
-    await copyDir(branchContentDir, tmpDestDir);
-    await safeReplaceDir(destContentDir, tmpDestDir);
-  } catch (err2) {
-    await fs34.rm(tmpDestDir, { recursive: true, force: true }).catch(() => {
+}
+var registry2, finalization2;
+var init_content_index_registry = __esm({
+  "dist/content-index-registry.js"() {
+    "use strict";
+    registry2 = /* @__PURE__ */ new Map();
+    finalization2 = new FinalizationRegistry(({ rootKey, ref }) => {
+      const refs = registry2.get(rootKey);
+      if (!refs)
+        return;
+      refs.delete(ref);
+      if (refs.size === 0)
+        registry2.delete(rootKey);
     });
-    throw err2;
-  }
-  const postStatus = await sourceGit.status();
-  const contentChanges = postStatus.files.filter((f) => f.path.startsWith(contentRoot + "/") || f.path === contentRoot);
-  if (contentChanges.length === 0) {
-    p2.log.info("Content is already up to date \u2014 nothing to pull");
-  } else {
-    p2.log.success(`Pulled ${contentChanges.length} changed file(s) from branch "${branchName}"`);
-    for (const file of contentChanges.slice(0, 20)) {
-      const indicator = file.working_dir === "?" ? "A" : file.working_dir || file.index;
-      p2.log.info(`  ${indicator} ${file.path}`);
-    }
-    if (contentChanges.length > 20) {
-      p2.log.info(`  ... and ${contentChanges.length - 20} more`);
-    }
-    p2.log.info("\nReview the changes, then git add and commit when ready.");
   }
-  return { fileCount: contentChanges.length };
+});
+
+// dist/id.js
+import { generate as generate2 } from "short-uuid";
+function generateId2() {
+  const full = generate2();
+  return full.substring(0, 12);
 }
-async function syncBoth(options) {
-  const { projectDir } = options;
-  const contentRoot = options.contentRoot || "content";
-  const branchesDir = path40.join(projectDir, ".canopy-dev", "content-branches");
-  const srcContentDir = path40.join(projectDir, contentRoot);
-  assertWithinDir(srcContentDir, projectDir, "--content-root");
-  if (!await filePathExists(srcContentDir)) {
-    throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
+var isValidId2;
+var init_id = __esm({
+  "dist/id.js"() {
+    "use strict";
+    init_validation3();
+    isValidId2 = isValidContentId2;
   }
-  const branchName = await selectBranch({ ...options, projectDir, autoCreate: true }, branchesDir);
-  if (!branchName)
-    return { pushed: 0, pulled: 0 };
-  const branchPath = path40.join(branchesDir, branchName);
-  assertWithinDir(branchPath, branchesDir, "--branch");
-  const wsGit = simpleGit7({ baseDir: branchPath });
-  const status = await wsGit.status();
-  if (status.conflicted.length > 0) {
-    p2.log.error("Branch workspace has unresolved merge conflicts.");
-    if (!options.force) {
-      const shouldAbort = await p2.confirm({
-        message: "Abort the merge and restore workspace to pre-merge state?",
-        initialValue: false
-      });
-      if (!p2.isCancel(shouldAbort) && shouldAbort) {
-        if (await abortWorkspaceMerge(branchPath, branchName)) {
-          p2.log.success("Merge aborted. Workspace restored to pre-merge state.");
-        }
+});
+
+// dist/utils/format.js
+var getFormatExtension2;
+var init_format = __esm({
+  "dist/utils/format.js"() {
+    "use strict";
+    getFormatExtension2 = (format) => {
+      if (format === "md")
+        return ".md";
+      if (format === "mdx")
+        return ".mdx";
+      if (format === "yaml")
+        return ".yaml";
+      return ".json";
+    };
+  }
+});
+
+// dist/content-id-index.js
+function extractIdFromFilename2(filename) {
+  if (filename.startsWith(".")) {
+    return null;
+  }
+  const parts = filename.split(".");
+  if (parts.length >= 3) {
+    const candidate = parts[parts.length - 2];
+    if (isValidId2(candidate))
+      return candidate;
+  }
+  if (parts.length === 2) {
+    const candidate = parts[parts.length - 1];
+    if (isValidId2(candidate))
+      return candidate;
+  }
+  return null;
+}
+function extractSlugFromFilename2(filename, entryTypeName) {
+  const parts = filename.split(".");
+  if (parts.length >= 3) {
+    const possibleId = parts[parts.length - 2];
+    if (isValidId2(possibleId)) {
+      let slugParts = parts.slice(0, parts.length - 2);
+      if (entryTypeName && slugParts.length > 1 && slugParts[0] === entryTypeName) {
+        slugParts = slugParts.slice(1);
+      } else if (parts.length >= 4 && slugParts.length > 1) {
+        slugParts = slugParts.slice(1);
       }
+      return slugParts.join(".").toLowerCase();
     }
-    return { pushed: 0, pulled: 0 };
   }
-  return withWorkspaceLock(branchPath, branchName, () => mergeIntoWorkspace(options, { branchName, branchPath, srcContentDir, contentRoot }));
-}
-async function mergeIntoWorkspace(options, ws) {
-  const { branchName, branchPath, srcContentDir, contentRoot } = ws;
-  const wsGit = simpleGit7({ baseDir: branchPath });
-  const status = await wsGit.status();
-  if (status.files.some((f) => !isCanopyInternalPath(f.path))) {
-    await stageAllExceptCanopyState2(wsGit);
-    await wsGit.commit("sync: save editor state before merge");
-    p2.log.info("Committed editor changes before merge");
+  if (parts.length === 2) {
+    const possibleId = parts[parts.length - 1];
+    if (isValidId2(possibleId)) {
+      return parts[0].toLowerCase();
+    }
   }
-  let baseRef;
-  try {
-    await wsGit.raw(["rev-parse", SYNC_BASE_TAG]);
-    baseRef = SYNC_BASE_TAG;
-  } catch {
-    baseRef = "HEAD";
+  if (parts.length > 1) {
+    return parts.slice(0, -1).join(".").toLowerCase();
   }
-  const currentBranch = (await wsGit.revparse(["--abbrev-ref", "HEAD"])).trim();
+  return filename.toLowerCase();
+}
+var ENTRY_EXTENSIONS2;
+var init_content_id_index = __esm({
+  "dist/content-id-index.js"() {
+    "use strict";
+    init_id();
+    init_format();
+    ENTRY_EXTENSIONS2 = new Set(Object.keys({ md: true, mdx: true, json: true, yaml: true }).map((format) => getFormatExtension2(format)));
+  }
+});
+
+// dist/schema/meta-loader.js
+import { promises as fs35 } from "fs";
+import { join as join3 } from "pathe";
+import { z as z18 } from "zod";
+import chokidar2 from "chokidar";
+function stripEmbeddedIdFromName2(name) {
+  return extractSlugFromFilename2(name);
+}
+async function scanForCollectionMeta2(baseDir, relativePath = "") {
+  const collections = [];
   try {
-    const incomingBranch = `sync-incoming-${Date.now()}`;
-    await wsGit.raw(["checkout", "-b", incomingBranch, baseRef]);
-    const wsContentDir = path40.join(branchPath, contentRoot);
-    assertWithinDir(wsContentDir, branchPath, "--content-root");
-    const tmpDir = `${wsContentDir}.sync-tmp-${Date.now()}`;
-    try {
-      await copyDir(srcContentDir, tmpDir);
-      await safeReplaceDir(wsContentDir, tmpDir);
-    } catch (err2) {
-      await fs34.rm(tmpDir, { recursive: true, force: true }).catch(() => {
-      });
-      await wsGit.checkout(currentBranch);
-      await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
-      });
-      throw err2;
-    }
-    await stageAllExceptCanopyState2(wsGit);
-    const incomingFiles = (await wsGit.status()).files.filter((f) => !isCanopyInternalPath(f.path));
-    if (incomingFiles.length === 0) {
-      await wsGit.checkout(currentBranch);
-      await wsGit.raw(["branch", "-D", incomingBranch]);
-      p2.log.info("No working-tree changes to merge \u2014 pulling editor changes only");
-      const pullResult2 = await syncPull({ ...options, branch: branchName, force: true });
-      return { pushed: 0, pulled: pullResult2.fileCount };
-    }
-    await wsGit.commit("sync: incoming working-tree changes");
-    await wsGit.checkout(currentBranch);
-    p2.log.step("Merging working-tree changes with editor changes...");
-    try {
-      await wsGit.merge([incomingBranch, "--no-edit"]);
-    } catch (mergeError) {
-      let mergeStatus;
+    const entries = await fs35.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const folderName = entry.name;
+      const logicalName = stripEmbeddedIdFromName2(folderName);
+      const collectionContentId = extractIdFromFilename2(folderName) ?? void 0;
+      const folderPath = relativePath ? `${relativePath}/${logicalName}` : logicalName;
+      const absolutePath = join3(baseDir, folderName);
+      const metaPath = join3(absolutePath, ".collection.json");
       try {
-        mergeStatus = await wsGit.status();
-      } catch {
-        await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
+        await fs35.access(metaPath);
+        const content = await fs35.readFile(metaPath, "utf-8");
+        const parsed = JSON.parse(content);
+        const meta = collectionMetaSchema2.parse(parsed);
+        collections.push({
+          ...meta,
+          path: folderPath,
+          contentId: collectionContentId
         });
-        throw mergeError;
-      }
-      if (mergeStatus.conflicted.length > 0) {
-        p2.log.error("Merge conflicts detected in the following files:");
-        for (const file of mergeStatus.conflicted) {
-          p2.log.error(`  ${file}`);
+        const nestedCollections = await scanForCollectionMeta2(absolutePath, folderPath);
+        collections.push(...nestedCollections);
+      } catch (err2) {
+        if (err2.code !== "ENOENT") {
+          canopyLogError2(`Error loading ${metaPath}:`, err2);
+          throw new Error(`Invalid .collection.json in ${folderPath}: ${err2.message}`);
         }
-        p2.log.info("The branch workspace is now in a merge state.");
-        p2.log.info("Resolve the conflicts in the workspace, then run: canopycms sync pull");
-        p2.log.info("Or abort the merge with: canopycms sync abort");
-        await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
-        });
-        return { pushed: 0, pulled: 0 };
+        const nestedCollections = await scanForCollectionMeta2(absolutePath, folderPath);
+        collections.push(...nestedCollections);
       }
-      await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
-      });
-      throw mergeError;
     }
-    await wsGit.raw(["branch", "-D", incomingBranch]);
-    await wsGit.tag(["-f", SYNC_BASE_TAG]);
-    p2.log.success("Merged working-tree changes with editor changes");
-    const pullResult = await syncPull({ ...options, branch: branchName, force: true });
-    return { pushed: incomingFiles.length, pulled: pullResult.fileCount };
-  } finally {
-    await invalidateBranchContentCaches2(branchPath);
+    return collections;
+  } catch (err2) {
+    if (err2.code === "ENOENT") {
+      return [];
+    }
+    throw err2;
   }
 }
-async function syncAbort(options) {
-  const { projectDir } = options;
-  const branchesDir = path40.join(projectDir, ".canopy-dev", "content-branches");
-  const branchName = await selectBranch({ ...options, projectDir }, branchesDir);
-  if (!branchName)
-    return;
-  const branchPath = path40.join(branchesDir, branchName);
-  assertWithinDir(branchPath, branchesDir, "--branch");
-  if (!await abortWorkspaceMerge(branchPath, branchName)) {
-    p2.log.info(`Branch workspace "${branchName}" is not in a merge state \u2014 nothing to abort.`);
-    return;
+async function loadCollectionMetaFiles2(contentRoot) {
+  let root = null;
+  const rootMetaPath = join3(contentRoot, ".collection.json");
+  try {
+    await fs35.access(rootMetaPath);
+  } catch (err2) {
+    if (err2.code === "ENOENT") {
+    } else {
+      throw err2;
+    }
   }
-  p2.log.success(`Merge aborted in branch workspace "${branchName}". Workspace restored to pre-merge state.`);
-}
-async function sync(options) {
-  p2.intro("CanopyCMS sync");
-  let pushed = 0;
-  let pulled = 0;
-  if (options.direction === "abort") {
-    await syncAbort(options);
-  } else if (options.direction === "both") {
-    const result = await syncBoth(options);
-    pushed = result.pushed;
-    pulled = result.pulled;
-  } else if (options.direction === "push") {
-    const result = await syncPush(options);
-    pushed = result.fileCount;
-  } else {
-    const result = await syncPull(options);
-    pulled = result.fileCount;
+  try {
+    const content = await fs35.readFile(rootMetaPath, "utf-8");
+    const parsed = JSON.parse(content);
+    root = rootCollectionMetaSchema2.parse(parsed);
+  } catch (err2) {
+    const errno = err2.code;
+    if (errno !== "ENOENT") {
+      throw new Error(`Invalid root .collection.json`);
+    }
   }
-  p2.outro("Done!");
-  return { pushed, pulled };
+  const collections = await scanForCollectionMeta2(contentRoot);
+  return { root, collections };
 }
-var SyncError;
-var init_sync = __esm({
-  "dist/cli/sync.js"() {
+var entryTypeMetaSchema2, collectionMetaSchema2, rootCollectionMetaSchema2;
+var init_meta_loader = __esm({
+  "dist/schema/meta-loader.js"() {
     "use strict";
-    init_fs();
-    init_git();
-    init_sync_core();
-    init_content_index_generation();
-    init_content_write_lock();
-    init_git_manager();
-    init_operating_mode2();
-    SyncError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "SyncError";
-      }
-    };
+    init_logger3();
+    init_content_id_index();
+    entryTypeMetaSchema2 = z18.object({
+      name: z18.string().min(1),
+      format: z18.enum(["md", "mdx", "json", "yaml"]),
+      schema: z18.string().min(1),
+      // Entry schema registry key (validated at resolution time)
+      label: z18.string().optional(),
+      description: z18.string().optional(),
+      default: z18.boolean().optional(),
+      maxItems: z18.number().int().positive().optional()
+    });
+    collectionMetaSchema2 = z18.object({
+      name: z18.string().min(1),
+      label: z18.string().optional(),
+      description: z18.string().optional(),
+      entries: z18.array(entryTypeMetaSchema2).optional(),
+      order: z18.array(z18.string()).default([])
+      // Embedded IDs for ordering; optional in the file, [] = alphabetical
+    }).refine((data) => data.entries && data.entries.length > 0, {
+      message: "Collection must have at least one entry type"
+    });
+    rootCollectionMetaSchema2 = z18.object({
+      label: z18.string().optional(),
+      entries: z18.array(entryTypeMetaSchema2).optional(),
+      order: z18.array(z18.string()).optional()
+      // Embedded IDs for ordering items
+    });
   }
 });
 
-// dist/paths/index.js
-var init_paths = __esm({
-  "dist/paths/index.js"() {
+// dist/branch-schema-cache.js
+import { LRUCache as LRUCache2 } from "lru-cache";
+var SNAPSHOT_MEMO_MAX_BYTES2, SCHEMA_GENERATION_RESOURCE2;
+var init_branch_schema_cache = __esm({
+  "dist/branch-schema-cache.js"() {
     "use strict";
-    init_validation3();
+    SNAPSHOT_MEMO_MAX_BYTES2 = 64 * 1024 * 1024;
+    SCHEMA_GENERATION_RESOURCE2 = "schema";
   }
 });
 
-// dist/schema/index.js
-var init_schema = __esm({
-  "dist/schema/index.js"() {
+// dist/content-index-generation.js
+async function bumpContentIndexGeneration2(root) {
+  return bumpResourceGeneration2(root, RESOURCE4);
+}
+async function invalidateBranchContentCaches2(root) {
+  await bumpContentIndexGeneration2(root);
+  await bumpResourceGeneration2(root, SCHEMA_GENERATION_RESOURCE2);
+  invalidateContentIndexesForRoot2(root);
+}
+var RESOURCE4;
+var init_content_index_generation = __esm({
+  "dist/content-index-generation.js"() {
     "use strict";
-    init_meta_loader();
+    init_resource_generation();
+    init_content_index_registry();
+    init_branch_schema_cache();
+    RESOURCE4 = "content-index";
   }
 });
 
-// dist/utils/occ-json-write.js
-import fs35 from "node:fs/promises";
-import path41 from "node:path";
-import { randomUUID as randomUUID6 } from "node:crypto";
-import lockfile4 from "proper-lockfile";
-async function writeOccJsonFile2(filePath, payload, options) {
-  const { expectedVersion, settleMs = 50, trailingNewline = false } = options;
-  const newVersion = expectedVersion === null ? 1 : expectedVersion + 1;
-  const writeId = randomUUID6();
-  const data = { ...payload, version: newVersion, writeId };
-  const content = JSON.stringify(data, null, 2) + (trailingNewline ? "\n" : "");
-  const dir = path41.dirname(filePath);
-  await fs35.mkdir(dir, { recursive: true });
-  const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  await fs35.writeFile(tempPath, content, "utf-8");
-  if (expectedVersion === null) {
+// dist/utils/content-write-lock.js
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import path44 from "node:path";
+function lockTargetDir2(branchRoot) {
+  return path44.join(path44.resolve(branchRoot), META_DIR4);
+}
+function tryAcquireContentWriteLock2(branchRoot, onCompromised) {
+  return tryAcquireProvisioningLock2(lockTargetDir2(branchRoot), CONTENT_WRITE_LOCK_NAME2, onCompromised, CONTENT_WRITE_LOCK_STALE_MS2, false);
+}
+async function acquireContentWriteLock2(branchRoot, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2, onCompromised) {
+  const startedAt = Date.now();
+  for (let attempt = 0; ; attempt++) {
     try {
-      await fs35.link(tempPath, filePath);
+      return await tryAcquireContentWriteLock2(branchRoot, onCompromised);
     } catch (err2) {
-      await fs35.unlink(tempPath).catch(() => {
-      });
-      if (isFileExistsError(err2)) {
-        throw new OccWriteConflictError2();
-      }
-      throw err2;
+      if (!isNodeError(err2) || err2.code !== "ELOCKED")
+        throw err2;
+      const remaining = waitMs - (Date.now() - startedAt);
+      if (remaining <= 0)
+        throw new ContentWriteLockBusyError2();
+      const base = Math.min(40 * 2 ** attempt, 250);
+      await sleep3(Math.min(base * (0.5 + Math.random()), remaining));
     }
-    await fs35.unlink(tempPath).catch(() => {
+  }
+}
+async function withContentWriteLock2(branchRoot, fn, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2) {
+  let compromised = false;
+  const release = await acquireContentWriteLock2(branchRoot, waitMs, (err2) => {
+    compromised = true;
+    canopyLogWarn3(`[canopy] Content-write lock compromised mid-hold for ${branchRoot}:`, getErrorMessage(err2));
+  });
+  let result;
+  try {
+    const held = new Set(heldRoots2.getStore());
+    held.add(path44.resolve(branchRoot));
+    result = await heldRoots2.run(held, fn);
+  } finally {
+    await release();
+  }
+  if (compromised) {
+    throw new ContentWriteLockBusyError2("We couldn't confirm your change was saved because the branch was syncing at the same time. Reload to check before saving again (your unsaved edits will be lost).", "unknown");
+  }
+  return result;
+}
+var META_DIR4, CONTENT_WRITE_LOCK_NAME2, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2, ContentWriteLockBusyError2, sleep3, CONTENT_WRITE_LOCK_STALE_MS2, heldRoots2;
+var init_content_write_lock = __esm({
+  "dist/utils/content-write-lock.js"() {
+    "use strict";
+    init_error();
+    init_logger3();
+    init_provisioning_lock();
+    META_DIR4 = ".canopy-meta";
+    CONTENT_WRITE_LOCK_NAME2 = "content-write.lock";
+    DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2 = 2e3;
+    ContentWriteLockBusyError2 = class extends Error {
+      constructor(message = "This branch is busy syncing or saving another change, so your change was not saved. Try again in a moment.", outcome = "not-run") {
+        super(message);
+        this.outcome = outcome;
+        this.name = "ContentWriteLockBusyError";
+      }
+    };
+    sleep3 = (ms) => new Promise((resolve2) => {
+      setTimeout(resolve2, ms);
     });
-    return { version: newVersion, writeId };
+    CONTENT_WRITE_LOCK_STALE_MS2 = 3e4;
+    heldRoots2 = new AsyncLocalStorage3();
+  }
+});
+
+// dist/sync-core.js
+import fs36 from "node:fs/promises";
+import path45 from "node:path";
+import { simpleGit as simpleGit5 } from "simple-git";
+function assertWithinDir(resolved, parent, label) {
+  const normalizedResolved = path45.resolve(resolved);
+  const normalizedParent = path45.resolve(parent);
+  if (!normalizedResolved.startsWith(normalizedParent + path45.sep) && normalizedResolved !== normalizedParent) {
+    throw new Error(`${label} escapes the expected directory: ${resolved}`);
+  }
+}
+async function safeReplaceDir(oldDir, newDir) {
+  const backupDir = `${oldDir}.sync-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const oldExists = await filePathExists(oldDir);
+  if (oldExists) {
+    await fs36.rename(oldDir, backupDir);
   }
   try {
-    let currentVersion = null;
-    try {
-      const current = JSON.parse(await fs35.readFile(filePath, "utf-8"));
-      currentVersion = current.version ?? 0;
-    } catch {
-      currentVersion = null;
-    }
-    if (currentVersion !== expectedVersion) {
-      throw new OccWriteConflictError2();
+    await fs36.rename(newDir, oldDir);
+  } catch (err2) {
+    if (oldExists) {
+      await fs36.rename(backupDir, oldDir).catch(() => {
+      });
     }
-    await fs35.rename(tempPath, filePath);
-    if (settleMs > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, settleMs));
+    throw err2;
+  }
+  if (oldExists) {
+    await fs36.rm(backupDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function listFilesRecursive(dir, prefix = "") {
+  const results = [];
+  let entries;
+  try {
+    entries = await fs36.readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.name === ".git")
+      continue;
+    if (entry.isSymbolicLink())
+      continue;
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...await listFilesRecursive(path45.join(dir, entry.name), rel));
+    } else {
+      results.push(rel);
     }
-    const afterWrite = JSON.parse(await fs35.readFile(filePath, "utf-8"));
-    if (afterWrite.writeId !== writeId) {
-      throw new OccWriteConflictError2();
+  }
+  return results;
+}
+async function copyDir(src, dest) {
+  await fs36.mkdir(dest, { recursive: true });
+  const entries = await fs36.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git")
+      continue;
+    if (entry.isSymbolicLink())
+      continue;
+    const srcPath = path45.join(src, entry.name);
+    const destPath = path45.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs36.copyFile(srcPath, destPath);
     }
-  } catch (err2) {
-    await fs35.unlink(tempPath).catch(() => {
-    });
-    throw err2;
   }
-  return { version: newVersion, writeId };
 }
-async function withOccRetry2(operation, options) {
-  const maxAttempts = options?.maxAttempts ?? 10;
-  const isRetryable = options?.isRetryable;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await operation();
-    } catch (err2) {
-      const retryable = err2 instanceof OccWriteConflictError2 || (isRetryable?.(err2) ?? false);
-      if (retryable && attempt < maxAttempts) {
-        const baseDelay = Math.min(10 * Math.pow(2, attempt - 1), 100);
-        const jitter = Math.random() * baseDelay;
-        await new Promise((resolve2) => setTimeout(resolve2, baseDelay + jitter));
-        continue;
-      }
-      throw err2;
+async function pushContentToWorkspace(options) {
+  const { srcContentDir, branchPath, contentRoot } = options;
+  if (!await filePathExists(srcContentDir)) {
+    return { fileCount: 0, savedEditorState: false };
+  }
+  const wsContentDir = path45.join(branchPath, contentRoot);
+  assertWithinDir(wsContentDir, branchPath, "content-root");
+  return withContentWriteLock2(branchPath, () => replaceWorkspaceContent(options, wsContentDir));
+}
+async function replaceWorkspaceContent(options, wsContentDir) {
+  const { srcContentDir, branchPath, commitMessage, baseTag, saveEditorStateMessage } = options;
+  const wsGit = simpleGit5({ baseDir: branchPath });
+  let savedEditorState = false;
+  if (saveEditorStateMessage) {
+    const editorChanges = (await wsGit.status()).files.filter((f) => !isCanopyInternalPath(f.path));
+    if (editorChanges.length > 0) {
+      await stageAllExceptCanopyState2(wsGit);
+      await wsGit.commit(saveEditorStateMessage);
+      savedEditorState = true;
     }
   }
-  throw new Error("Unreachable");
-}
-async function withOccFileLock2(filePath, fn) {
+  const tmpDir = `${wsContentDir}.sync-tmp-${Date.now()}`;
   try {
-    await fs35.mkdir(path41.dirname(filePath));
+    await copyDir(srcContentDir, tmpDir);
+    await safeReplaceDir(wsContentDir, tmpDir);
   } catch (err2) {
-    if (!isNodeError(err2) || err2.code !== "EEXIST") {
-      throw new OccWriteConflictError2(`Could not acquire file lock: ${getErrorMessage(err2)}`);
-    }
-  }
-  const MAX_ATTEMPTS = 14;
-  let release = null;
-  for (let attempt = 1; release === null; attempt++) {
-    try {
-      release = await lockfile4.lock(filePath, {
-        lockfilePath: `${filePath}.lock`,
-        realpath: false,
-        stale: 1e4,
-        retries: 0,
-        // A compromised lock (the lock dir vanished or refresh failed mid-hold, e.g. the branch
-        // directory containing it was deleted, or an EFS waiter misread a cached mtime and took
-        // it over) must not crash the process, which is proper-lockfile's default. Our critical
-        // sections are short and idempotent-on-conflict (OCC verify inside); log and let the
-        // section finish.
-        onCompromised: guardOnCompromised2((err2) => canopyLogWarn3(`[canopy] OCC file lock compromised mid-hold for ${filePath}:`, getErrorMessage(err2)), filePath)
-      });
-    } catch (err2) {
-      const code = isNodeError(err2) ? err2.code : void 0;
-      const contended = code === "ELOCKED";
-      if (!contended || attempt >= MAX_ATTEMPTS) {
-        throw new OccWriteConflictError2(`Could not acquire file lock: ${getErrorMessage(err2)}`);
-      }
-      const baseDelay = Math.min(50 * Math.pow(1.6, attempt - 1), 2e3);
-      const jitter = Math.random() * baseDelay;
-      await new Promise((resolve2) => setTimeout(resolve2, baseDelay + jitter));
-    }
+    await fs36.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw err2;
   }
   try {
-    return await fn();
+    await stageAllExceptCanopyState2(wsGit);
+    const staged = (await wsGit.status()).files.filter((f) => !isCanopyInternalPath(f.path));
+    if (staged.length === 0) {
+      if (baseTag)
+        await wsGit.tag(["-f", baseTag]);
+      return { fileCount: 0, savedEditorState };
+    }
+    await wsGit.commit(commitMessage ?? "sync: update content from working tree");
+    if (baseTag)
+      await wsGit.tag(["-f", baseTag]);
+    return { fileCount: staged.length, savedEditorState };
   } finally {
-    await release().catch((err2) => {
-      if (isNodeError(err2) && err2.code === "ENOENT")
-        return;
-      log14.warn("lock", `Failed to release lock for ${filePath}`, { error: getErrorMessage(err2) });
-    });
+    await invalidateBranchContentCaches2(branchPath);
   }
 }
-var log14, OccWriteConflictError2;
-var init_occ_json_write = __esm({
-  "dist/utils/occ-json-write.js"() {
+var SYNC_BASE_TAG;
+var init_sync_core = __esm({
+  "dist/sync-core.js"() {
     "use strict";
-    init_error();
-    init_debug2();
-    init_logger3();
-    init_provisioning_lock();
-    log14 = createDebugLogger3({ prefix: "OccJsonWrite" });
-    OccWriteConflictError2 = class extends Error {
-      constructor(message = "Concurrent modification detected") {
-        super(message);
-        this.name = "OccWriteConflictError";
-      }
-    };
+    init_content_index_generation();
+    init_content_write_lock();
+    init_fs();
+    init_git();
+    SYNC_BASE_TAG = "canopycms-sync-base";
   }
 });
 
-// dist/utils/async-mutex.js
-async function withLock2(key, fn) {
-  const prev = locks2.get(key) ?? Promise.resolve();
-  let resolve2;
-  const next = new Promise((r) => {
-    resolve2 = r;
-  });
-  locks2.set(key, next);
-  await prev;
+// dist/git-manager.js
+import fs37 from "node:fs/promises";
+import path46 from "node:path";
+import { simpleGit as simpleGit6 } from "simple-git";
+async function ensureGitExcludePattern2(repoPath, pattern) {
+  const excludePath = path46.join(repoPath, ".git", "info", "exclude");
+  await fs37.mkdir(path46.dirname(excludePath), { recursive: true });
+  let content = "";
   try {
-    return await fn();
-  } finally {
-    resolve2();
-    if (locks2.get(key) === next)
-      locks2.delete(key);
+    content = await fs37.readFile(excludePath, "utf-8");
+  } catch (err2) {
+    if (!isNotFoundError(err2))
+      throw err2;
   }
-}
-var locks2;
-var init_async_mutex = __esm({
-  "dist/utils/async-mutex.js"() {
-    "use strict";
-    locks2 = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  if (lines.some((line) => line.trim() === pattern)) {
+    log14.debug("git", "Pattern already in .git/info/exclude", { pattern });
+    return;
   }
-});
-
-// dist/schema/schema-store.js
-import path43 from "node:path";
-import { z as z17 } from "zod";
-async function withBranchSchemaLock(branchRoot, fn, contentWriteLockWaitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2) {
-  const schemaLockPath = path43.join(path43.resolve(branchRoot), ".canopy-meta", "schema");
-  return withContentWriteLock2(branchRoot, () => withLock2(schemaLockPath, () => withOccFileLock2(schemaLockPath, fn)), contentWriteLockWaitMs);
+  const needsLeadingNewline = content.length > 0 && !content.endsWith("\n");
+  const newContent = content + (needsLeadingNewline ? "\n" : "") + pattern + "\n";
+  await fs37.writeFile(excludePath, newContent, "utf-8");
+  log14.debug("git", "Added pattern to .git/info/exclude", { pattern });
 }
-var MAX_NAME_LENGTH, MAX_LABEL_LENGTH, SAFE_NAME_PATTERN, SAFE_NAME_MESSAGE, entryTypeInputSchema, createCollectionInputSchema, updateCollectionInputSchema, updateEntryTypeInputSchema, log15;
-var init_schema_store = __esm({
-  "dist/schema/schema-store.js"() {
+var log14;
+var init_git_manager = __esm({
+  "dist/git-manager.js"() {
     "use strict";
-    init_async_mutex();
     init_debug2();
-    init_content_write_lock();
-    init_occ_json_write();
-    MAX_NAME_LENGTH = 64;
-    MAX_LABEL_LENGTH = 128;
-    SAFE_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
-    SAFE_NAME_MESSAGE = "must start with a letter and contain only lowercase letters, numbers, and hyphens";
-    entryTypeInputSchema = z17.object({
-      name: z17.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Entry type name ${SAFE_NAME_MESSAGE}`),
-      label: z17.string().max(MAX_LABEL_LENGTH).optional(),
-      format: z17.enum(["md", "mdx", "json", "yaml"]),
-      schema: z17.string().min(1),
-      default: z17.boolean().optional(),
-      maxItems: z17.number().int().positive().optional()
-    });
-    createCollectionInputSchema = z17.object({
-      name: z17.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Collection name ${SAFE_NAME_MESSAGE}`),
-      label: z17.string().max(MAX_LABEL_LENGTH).optional(),
-      parentPath: z17.string().optional(),
-      entries: z17.array(entryTypeInputSchema).min(1, "Collection must have at least one entry type")
-    });
-    updateCollectionInputSchema = z17.object({
-      name: z17.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Collection name ${SAFE_NAME_MESSAGE}`).optional(),
-      label: z17.string().max(MAX_LABEL_LENGTH).optional(),
-      // Directory name (e.g., "posts" in "posts.{id}/")
-      slug: z17.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Slug ${SAFE_NAME_MESSAGE}`).optional(),
-      order: z17.array(z17.string()).optional()
-    });
-    updateEntryTypeInputSchema = z17.object({
-      label: z17.string().max(MAX_LABEL_LENGTH).optional(),
-      format: z17.enum(["md", "mdx", "json", "yaml"]).optional(),
-      schema: z17.string().min(1).optional(),
-      default: z17.boolean().optional(),
-      maxItems: z17.number().int().positive().optional()
-    });
-    log15 = createDebugLogger3({ prefix: "SchemaOps" });
+    init_error();
+    log14 = createDebugLogger3({ prefix: "GitManager" });
   }
 });
 
-// dist/branch-metadata-error.js
-var BranchMetadataCorruptError2;
-var init_branch_metadata_error = __esm({
-  "dist/branch-metadata-error.js"() {
-    "use strict";
-    BranchMetadataCorruptError2 = class extends Error {
-      constructor(branchRoot, cause) {
-        super(`Corrupt branch metadata in '${branchRoot}': ${cause}`);
-        this.name = "BranchMetadataCorruptError";
-        this.branchRoot = branchRoot;
-        this.parseCause = cause;
-      }
-    };
-  }
+// dist/cli/sync.js
+var sync_exports = {};
+__export(sync_exports, {
+  sync: () => sync
 });
-
-// dist/branch-metadata-file.js
-import fs36 from "node:fs/promises";
-import path44 from "node:path";
-import { z as z18 } from "zod";
-function describeSchemaIssues2(issues) {
-  const missing = /* @__PURE__ */ new Set();
-  const invalid = /* @__PURE__ */ new Set();
-  for (const issue of issues) {
-    const field = issue.path.length > 0 ? issue.path.join(".") : "the file";
-    const isMissing = issue.code === z18.ZodIssueCode.invalid_type && issue.received === z18.ZodParsedType.undefined;
-    (isMissing ? missing : invalid).add(field);
+import fs38 from "node:fs/promises";
+import path47 from "node:path";
+import { simpleGit as simpleGit7 } from "simple-git";
+import * as p2 from "@clack/prompts";
+import { z as z19 } from "zod";
+function lockBusyAsSyncError(err2, branchName) {
+  if (!(err2 instanceof ContentWriteLockBusyError2))
+    return err2;
+  return new SyncError(err2.outcome === "not-run" ? `Branch workspace "${branchName}" is busy (the worker is syncing it, or an editor save is in flight); nothing was changed. Try again in a moment.` : `Branch workspace "${branchName}" was being synced during this run, so it may be partly updated. Check its state before running sync again.`);
+}
+async function withWorkspaceLock(branchPath, branchName, fn) {
+  try {
+    return await withContentWriteLock2(branchPath, fn);
+  } catch (err2) {
+    throw lockBusyAsSyncError(err2, branchName);
   }
-  const parts = [];
-  if (missing.size > 0)
-    parts.push(`Missing: ${[...missing].join(", ")}`);
-  if (invalid.size > 0)
-    parts.push(`Invalid: ${[...invalid].join(", ")}`);
-  return `Not branch metadata. ${parts.join(". ")}`;
 }
-async function readBranchMetadataFile2(branchRoot) {
-  const resolvedRoot = path44.resolve(branchRoot);
-  let raw;
+async function abortWorkspaceMerge(branchPath, branchName) {
+  return withWorkspaceLock(branchPath, branchName, async () => {
+    const wsGit = simpleGit7({ baseDir: branchPath });
+    if ((await wsGit.status()).conflicted.length === 0)
+      return false;
+    await wsGit.merge(["--abort"]);
+    await invalidateBranchContentCaches2(branchPath);
+    return true;
+  });
+}
+async function detectCurrentBranch(projectDir) {
+  const git = simpleGit7({ baseDir: projectDir });
+  const branch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+  if (branch === "HEAD")
+    throw new Error("Detached HEAD \u2014 use --branch to specify a branch name");
+  return branch;
+}
+async function readBranchConfigFields(projectDir) {
+  if (!await filePathExists(path47.join(projectDir, "canopycms.config.ts")))
+    return {};
+  let why;
   try {
-    raw = await fs36.readFile(branchMetadataFilePath2(resolvedRoot), "utf8");
+    const parsed = branchConfigSchema.safeParse((await importSiteServerConfig(projectDir)).server);
+    if (parsed.success)
+      return parsed.data;
+    why = parsed.error.message;
   } catch (err2) {
-    if (isNotFoundError(err2)) {
+    why = getErrorMessage(err2);
+  }
+  p2.log.warn(`Could not use canopycms.config.ts (${why}); branch names resolve against the default branch settings.`);
+  return {};
+}
+async function loadBranchParamConfig(projectDir) {
+  const fields = await readBranchConfigFields(projectDir);
+  const head = await detectHeadBranch2(projectDir, fields.defaultBaseBranch ?? "main");
+  return {
+    ...fields,
+    mode: "dev",
+    defaultBaseBranch: fields.defaultBaseBranch ?? head,
+    defaultActiveBranch: fields.defaultActiveBranch ?? head
+  };
+}
+async function assertOwnRepository(branchPath) {
+  const top = await simpleGit7({ baseDir: branchPath }).revparse(["--show-toplevel"]).then((out) => out.trim()).catch(() => "");
+  if (top && await fs38.realpath(top) === await fs38.realpath(branchPath))
+    return;
+  throw new SyncError(`"${path47.basename(branchPath)}" under content-branches/ is not a branch workspace: git does not report it as the top of its own repository.`);
+}
+async function workspaceHead(branchPath) {
+  return simpleGit7({ baseDir: branchPath }).raw(["symbolic-ref", "--short", "-q", "HEAD"]).then((out) => out.trim() || null).catch(() => null);
+}
+async function keyWorkspace(key, projectDir) {
+  const branchPath = path47.join(operatingStrategy3("dev").getContentBranchesRoot(projectDir), key);
+  await assertOwnRepository(branchPath);
+  const meta = await readBranchMetadataFile2(branchPath);
+  return { branchName: meta?.branch.name ?? await workspaceHead(branchPath) ?? key, branchPath };
+}
+function refOf(name) {
+  if (!isExactBranchForm(name))
+    return name;
+  const ref = exactBranchName(name);
+  if (ref === null)
+    throw new SyncError(`"${name}" is not a valid branch name.`);
+  return ref;
+}
+async function resolveSyncWorkspace(name, projectDir, keys, byRef) {
+  const config = await loadBranchParamConfig(projectDir);
+  const param = byRef ? exactBranchSegment(name) : name;
+  const resolved = await resolveBranchParam(param, config, { basePathOverride: projectDir }).catch((err2) => {
+    if (namesNoWorkspace(err2))
+      return null;
+    throw err2;
+  });
+  if (resolved) {
+    const ref2 = refOf(name);
+    if (resolved.branch.name !== ref2 && resolved.branchRoot === refKeyPath(ref2, projectDir)) {
+      throw holdsAnotherBranch(resolved.branchRoot, resolved.branch.name, ref2);
+    }
+    await assertOwnRepository(resolved.branchRoot);
+    return { branchName: resolved.branch.name, branchPath: resolved.branchRoot };
+  }
+  if (!byRef && keys.includes(name))
+    return keyWorkspace(name, projectDir);
+  const ref = refOf(name);
+  const branchPath = refKeyPath(ref, projectDir);
+  const present = await filePathExists(branchPath).catch((err2) => {
+    if (namesNoWorkspace(err2))
+      throw new SyncError(`"${ref}" cannot name a branch workspace.`);
+    throw err2;
+  });
+  if (!present)
+    return null;
+  await assertOwnRepository(branchPath);
+  const meta = await readBranchMetadataFile2(branchPath);
+  const holder = meta ? meta.branch.name : await workspaceHead(branchPath);
+  if (holder !== ref)
+    throw holdsAnotherBranch(branchPath, holder, ref);
+  return { branchName: ref, branchPath };
+}
+function holdsAnotherBranch(branchPath, holder, ref) {
+  const recovery = holder?.startsWith("sync-incoming-") ? ` An interrupted "sync both" left it there: run "git checkout ${ref}" in that workspace.` : "";
+  return new SyncError(`Branch workspace "${path47.basename(branchPath)}" holds ${holder === null ? "a detached HEAD" : `branch "${holder}"`}, not "${ref}".${recovery}`);
+}
+function refKeyPath(name, projectDir) {
+  try {
+    return resolveBranchPath2({ mode: "dev", branchName: name, basePathOverride: projectDir }).branchRoot;
+  } catch (err2) {
+    if (namesNoWorkspace(err2))
+      throw new SyncError(`"${name}" cannot name a branch workspace.`);
+    throw err2;
+  }
+}
+async function createSyncWorkspace(name, projectDir) {
+  const ref = refOf(name);
+  const parsed = parseBranchRef3(ref);
+  if (!parsed.ok)
+    throw new SyncError(`"${ref}" is not a valid branch name: ${parsed.error}`);
+  const branchPath = refKeyPath(ref, projectDir);
+  await fs38.mkdir(branchPath, { recursive: true });
+  const wsGit = simpleGit7({ baseDir: branchPath });
+  await wsGit.init();
+  await wsGit.checkoutLocalBranch(ref);
+  await wsGit.raw(["commit", "--allow-empty", "-m", "init: workspace created by sync"]);
+  await ensureGitExcludePattern2(branchPath, operatingStrategy3("dev").getGitExcludePattern());
+  p2.log.info(`Created branch workspace: ${path47.basename(branchPath)}`);
+  return { branchName: ref, branchPath };
+}
+async function selectBranch(options) {
+  const branchesDir = operatingStrategy3("dev").getContentBranchesRoot(options.projectDir);
+  let branches = [];
+  if (await filePathExists(branchesDir)) {
+    const entries = await fs38.readdir(branchesDir, { withFileTypes: true });
+    branches = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  }
+  let branchName = options.branch;
+  const byRef = !branchName;
+  if (!branchName) {
+    try {
+      branchName = await detectCurrentBranch(options.projectDir);
+    } catch {
+    }
+  }
+  if (!branchName) {
+    if (branches.length === 0) {
+      throw new SyncError("No branch workspaces found and could not detect current git branch. Use --branch to specify.");
+    }
+    if (branches.length === 1)
+      return keyWorkspace(branches[0], options.projectDir);
+    const result = await p2.select({
+      message: "Which branch?",
+      options: branches.map((b) => ({ value: b, label: b }))
+    });
+    if (p2.isCancel(result)) {
+      p2.cancel("Sync cancelled.");
       return null;
     }
-    throw err2;
+    return keyWorkspace(result, options.projectDir);
   }
-  return parseBranchMetadataFile2(resolvedRoot, raw);
+  const existing = await resolveSyncWorkspace(branchName, options.projectDir, branches, byRef);
+  if (existing)
+    return existing;
+  if (options.autoCreate)
+    return createSyncWorkspace(branchName, options.projectDir);
+  const available = branches.length > 0 ? ` Available branches: ${branches.join(", ")}` : "";
+  throw new SyncError(`Branch workspace "${branchName}" not found.${available}`);
 }
-function parseBranchMetadataFile2(branchRoot, raw) {
-  let json;
+async function syncPush(options) {
+  const { projectDir } = options;
+  const contentRoot = options.contentRoot || "content";
+  const srcContentDir = path47.join(projectDir, contentRoot);
+  assertWithinDir(srcContentDir, projectDir, "--content-root");
+  if (!await filePathExists(srcContentDir)) {
+    throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
+  }
+  const ws = await selectBranch({ ...options, projectDir, autoCreate: true });
+  if (!ws)
+    return { fileCount: 0 };
+  const { branchName, branchPath } = ws;
+  const wsGit = simpleGit7({ baseDir: branchPath });
+  const status = await wsGit.status();
+  if (status.conflicted.length > 0) {
+    p2.log.error("Branch workspace has unresolved merge conflicts.");
+    if (!options.force) {
+      const shouldAbort = await p2.confirm({
+        message: "Abort the merge and restore workspace to pre-merge state?",
+        initialValue: false
+      });
+      if (!p2.isCancel(shouldAbort) && shouldAbort) {
+        if (await abortWorkspaceMerge(branchPath, branchName)) {
+          p2.log.success("Merge aborted. Workspace restored to pre-merge state.");
+        }
+      }
+    }
+    return { fileCount: 0 };
+  }
+  const editorChanges = status.files.filter((f) => !isCanopyInternalPath(f.path));
+  if (editorChanges.length > 0 && !options.force) {
+    p2.log.warn(`Branch workspace has ${editorChanges.length} uncommitted change(s) that will be committed to history then overwritten:`);
+    for (const file of editorChanges.slice(0, 10)) {
+      p2.log.warn(`  ${file.path}`);
+    }
+    if (editorChanges.length > 10) {
+      p2.log.warn(`  ... and ${editorChanges.length - 10} more`);
+    }
+    const confirm5 = await p2.confirm({
+      message: "Continue? Editor changes will be preserved in git history.",
+      initialValue: false
+    });
+    if (p2.isCancel(confirm5) || !confirm5) {
+      p2.cancel("Push cancelled.");
+      return { fileCount: 0 };
+    }
+  }
+  p2.log.step(`Pushing content to branch workspace: ${branchName}`);
+  let fileCount;
   try {
-    json = JSON.parse(raw);
+    const result = await pushContentToWorkspace({
+      srcContentDir,
+      branchPath,
+      contentRoot,
+      baseTag: SYNC_BASE_TAG,
+      saveEditorStateMessage: "sync: save editor state before push"
+    });
+    fileCount = result.fileCount;
+    if (result.savedEditorState)
+      p2.log.info("Committed editor changes to history before push");
   } catch (err2) {
-    throw new BranchMetadataCorruptError2(branchRoot, `Not valid JSON: ${getErrorMessage(err2)}`);
+    throw lockBusyAsSyncError(err2, branchName);
   }
-  const result = branchMetadataFileSchema2.safeParse(json);
-  if (!result.success) {
-    throw new BranchMetadataCorruptError2(branchRoot, describeSchemaIssues2(result.error.issues));
+  if (fileCount === 0) {
+    p2.log.info("Content is already up to date \u2014 nothing to push");
+  } else {
+    p2.log.success(`Pushed ${fileCount} file change(s) to branch "${branchName}"`);
   }
-  const file = result.data;
-  return file;
+  return { fileCount };
 }
-var BRANCH_META_DIR2, BRANCH_META_FILE2, branchMetadataFilePath2, UNKNOWN_TIME2, enumOf2, branchMetadataShape2, branchMetadataSchema2, branchMetadataFileSchema2;
-var init_branch_metadata_file = __esm({
-  "dist/branch-metadata-file.js"() {
-    "use strict";
-    init_error();
-    init_branch_metadata_error();
-    BRANCH_META_DIR2 = ".canopy-meta";
-    BRANCH_META_FILE2 = "branch.json";
-    branchMetadataFilePath2 = (branchRoot) => path44.join(path44.resolve(branchRoot), BRANCH_META_DIR2, BRANCH_META_FILE2);
-    UNKNOWN_TIME2 = (/* @__PURE__ */ new Date(0)).toISOString();
-    enumOf2 = (values) => z18.nativeEnum(values);
-    branchMetadataShape2 = {
-      name: z18.string().min(1),
-      title: z18.string().optional(),
-      description: z18.string().optional(),
-      status: enumOf2({
-        editing: "editing",
-        submitted: "submitted",
-        approved: "approved",
-        archived: "archived"
-      }),
-      access: z18.object({
-        allowedUsers: z18.array(z18.string()).optional(),
-        allowedGroups: z18.array(z18.string()).optional(),
-        managerOrAdminAllowed: z18.boolean().optional()
-      }).passthrough(),
-      createdBy: z18.string().default("unknown"),
-      createdAt: z18.string().default(UNKNOWN_TIME2),
-      updatedAt: z18.string().default(UNKNOWN_TIME2),
-      baseBranch: z18.string().optional(),
-      pullRequestUrl: z18.string().optional(),
-      pullRequestNumber: z18.number().int().optional(),
-      submittedAt: z18.string().optional(),
-      pushedToGitHubAt: z18.string().optional(),
-      editorUrl: z18.string().optional(),
-      syncStatus: enumOf2({
-        synced: "synced",
-        "pending-sync": "pending-sync",
-        "sync-failed": "sync-failed"
-      }).optional(),
-      conflictStatus: enumOf2({
-        clean: "clean",
-        "conflicts-detected": "conflicts-detected"
-      }).optional(),
-      conflictFiles: z18.array(z18.custom((v) => typeof v === "string")).optional(),
-      pullRequestState: enumOf2({
-        open: "open",
-        closed: "closed",
-        merged: "merged"
-      }).optional(),
-      mergedAt: z18.string().optional(),
-      rebaseFailure: z18.object({ message: z18.string(), firstAt: z18.string(), lastAt: z18.string() }).optional(),
-      historyRewrittenFrom: z18.string().optional(),
-      syncFailureReason: z18.string().optional(),
-      editors: z18.array(z18.string()).optional(),
-      uncommittedEditors: z18.array(z18.string()).optional(),
-      // Dropped when malformed: it only decorates the PR body, so it never fails a read.
-      review: z18.object({
-        state: z18.enum(["approved", "changes-requested"]),
-        by: z18.object({ userId: z18.string(), name: z18.string().optional() }),
-        at: z18.string()
-      }).optional().catch(void 0)
-    };
-    branchMetadataSchema2 = z18.object(branchMetadataShape2).passthrough();
-    branchMetadataFileSchema2 = z18.object({
-      schemaVersion: z18.number().int().default(1),
-      version: z18.number().int().nonnegative().default(0),
-      writeId: z18.string().optional(),
-      branch: branchMetadataSchema2
-    }).passthrough();
+async function syncPull(options) {
+  const ws = await selectBranch({ ...options, projectDir: options.projectDir });
+  if (!ws)
+    return { fileCount: 0 };
+  return pullFromWorkspace(options, ws);
+}
+async function pullFromWorkspace(options, ws) {
+  const { projectDir } = options;
+  const contentRoot = options.contentRoot || "content";
+  const { branchName, branchPath } = ws;
+  const branchContentDir = path47.join(branchPath, contentRoot);
+  assertWithinDir(branchContentDir, branchPath, "--content-root");
+  if (!await filePathExists(branchContentDir)) {
+    throw new SyncError(`Content directory not found in branch workspace: ${path47.basename(branchPath)}/${contentRoot}`);
   }
-});
-
-// dist/branch-registry.js
-import fs37 from "node:fs/promises";
-import path45 from "node:path";
-import { z as z19 } from "zod";
-var log16, REGISTRY_FILE2, REGISTRY_STALE_FILE2, REGISTRY_TEMP_FILE2, REGISTRY_VERSION2, RESOURCE4, GET_MISS_REFRESH_MIN_INTERVAL_MS2, snapshotSchema2, reportedUnreadable2, BranchRegistry2;
-var init_branch_registry = __esm({
-  "dist/branch-registry.js"() {
-    "use strict";
-    init_branch_metadata_file();
-    init_error();
-    init_debug2();
-    init_logger3();
-    init_resource_generation();
-    log16 = createDebugLogger3({ prefix: "BranchRegistry" });
-    REGISTRY_FILE2 = "branches.json";
-    REGISTRY_STALE_FILE2 = "branches.stale.json";
-    REGISTRY_TEMP_FILE2 = "branches.tmp.json";
-    REGISTRY_VERSION2 = 2;
-    RESOURCE4 = "branch-registry";
-    GET_MISS_REFRESH_MIN_INTERVAL_MS2 = 5e3;
-    snapshotSchema2 = z19.object({
-      version: z19.literal(REGISTRY_VERSION2),
-      branches: z19.array(z19.object({ branch: branchMetadataSchema2, branchRoot: z19.string(), baseRoot: z19.string() })),
-      generation: z19.string().nullable()
-    });
-    reportedUnreadable2 = /* @__PURE__ */ new Set();
-    BranchRegistry2 = class {
-      constructor(root) {
-        this.regenInFlight = null;
-        this.lastForcedRefreshMs = 0;
-        this.root = path45.resolve(root);
-        this.registryPath = path45.join(this.root, REGISTRY_FILE2);
-        this.stalePath = path45.join(this.root, REGISTRY_STALE_FILE2);
-        this.tempPath = path45.join(this.root, REGISTRY_TEMP_FILE2);
-      }
-      /**
-       * Returns all branches. Uses the cached snapshot if its embedded generation
-       * token matches the live marker, regenerates otherwise.
-       *
-       * An unparseable or wrong-shaped snapshot is treated like an absent one: the
-       * snapshot is a cache of the branch directories, so rebuilding it loses
-       * nothing, while rethrowing would fail every editor's branch listing until
-       * someone deleted the file. Other read failures (permissions, IO) propagate.
-       */
-      async list() {
-        let raw;
-        try {
-          raw = await fs37.readFile(this.registryPath, "utf8");
-        } catch (err2) {
-          if (isNotFoundError(err2)) {
-            return await this.regenerate();
-          }
-          throw err2;
-        }
-        const parsed = this.parseSnapshot(raw);
-        if (!parsed)
-          return await this.regenerate();
-        const read = await readResourceGeneration2(this.root, RESOURCE4);
-        if (isGenerationCurrent2(parsed.generation, read)) {
-          return parsed.branches;
-        }
-        return await this.regenerate();
-      }
-      /** The snapshot in `raw`, or null when it must be rebuilt. */
-      parseSnapshot(raw) {
-        let json;
-        try {
-          json = JSON.parse(raw);
-        } catch (err2) {
-          this.reportUnreadable(getErrorMessage(err2));
-          return null;
-        }
-        if (typeof json === "object" && json !== null && "version" in json && typeof json.version === "number" && json.version !== REGISTRY_VERSION2) {
-          return null;
-        }
-        const result = snapshotSchema2.safeParse(json);
-        if (!result.success) {
-          this.reportUnreadable("it does not have the registry snapshot shape");
-          return null;
+  p2.log.step(`Pulling content from branch: ${branchName}`);
+  const destContentDir = path47.join(projectDir, contentRoot);
+  assertWithinDir(destContentDir, projectDir, "--content-root");
+  const sourceGit = simpleGit7({ baseDir: projectDir });
+  const status = await sourceGit.status();
+  const uncommittedContent = status.files.filter((f) => f.path.startsWith(contentRoot + "/") || f.path === contentRoot);
+  const untrackedLosses = [];
+  if (await filePathExists(destContentDir)) {
+    const localFiles = await listFilesRecursive(destContentDir);
+    const branchFiles = new Set(await listFilesRecursive(branchContentDir));
+    for (const file of localFiles) {
+      if (!branchFiles.has(file)) {
+        const relativePath = contentRoot + "/" + file;
+        if (!uncommittedContent.some((f) => f.path === relativePath)) {
+          untrackedLosses.push(relativePath);
         }
-        reportedUnreadable2.delete(this.registryPath);
-        const snapshot = result.data;
-        return snapshot;
-      }
-      reportUnreadable(reason) {
-        if (reportedUnreadable2.has(this.registryPath))
-          return;
-        reportedUnreadable2.add(this.registryPath);
-        canopyLogWarn3(`CanopyCMS: Branch registry snapshot ${this.registryPath} is unreadable (${reason}); regenerating it from the branch directories`);
-      }
-      /**
-       * Returns a single branch by name, from the cached snapshot when it is fresh.
-       *
-       * Suspicious-miss backstop: a `name` missing from the list is the signal that
-       * the snapshot may predate a branch that now exists, so force one fresh
-       * regeneration and re-search before giving up. Throttled per instance, so a
-       * genuinely-absent branch costs at most one extra scan per window.
-       */
-      async get(name) {
-        return this.find((b) => b.branch.name === name);
-      }
-      /**
-       * Returns the branch whose workspace directory is `key` (`sanitizeBranchName` of its ref),
-       * whatever its name, with {@link get}'s backstop.
-       */
-      async getByKey(key) {
-        return this.find((b) => path45.basename(b.branchRoot) === key);
       }
-      async find(matches) {
-        const found = (await this.list()).find(matches);
-        if (found)
-          return found;
-        if (!this.shouldForceRefresh())
-          return void 0;
-        const refreshed = await this.regenerate();
-        return refreshed.find(matches);
+    }
+  }
+  const totalWarnings = uncommittedContent.length + untrackedLosses.length;
+  if (totalWarnings > 0 && !options.force) {
+    if (uncommittedContent.length > 0) {
+      p2.log.warn(`You have ${uncommittedContent.length} uncommitted change(s) in ${contentRoot}/:`);
+      for (const file of uncommittedContent.slice(0, 10)) {
+        p2.log.warn(`  ${file.path}`);
       }
-      shouldForceRefresh() {
-        const now = Date.now();
-        if (now - this.lastForcedRefreshMs < GET_MISS_REFRESH_MIN_INTERVAL_MS2)
-          return false;
-        this.lastForcedRefreshMs = now;
-        return true;
+      if (uncommittedContent.length > 10) {
+        p2.log.warn(`  ... and ${uncommittedContent.length - 10} more`);
       }
-      /**
-       * Marks the cache stale for every process sharing this root by bumping the
-       * marker, then eager-regenerates on this host. The bump must succeed —
-       * swallowing that failure leaves the registry stale indefinitely with no
-       * backstop. A failed eager regen must NOT fail the caller's save/delete: the
-       * bump alone already restored correctness for every future reader.
-       */
-      async invalidate() {
-        await bumpResourceGeneration2(this.root, RESOURCE4, { mustSucceed: true });
-        try {
-          if (this.regenInFlight)
-            await this.regenInFlight.catch(() => {
-            });
-          await this.regenerate();
-        } catch (err2) {
-          log16.warn("invalidate", "Eager regeneration after invalidate() failed", {
-            error: getErrorMessage(err2)
-          });
-        }
+    }
+    if (untrackedLosses.length > 0) {
+      p2.log.warn(`${untrackedLosses.length} file(s) in ${contentRoot}/ not present in branch "${branchName}" will be deleted:`);
+      for (const file of untrackedLosses.slice(0, 10)) {
+        p2.log.warn(`  ${file}`);
       }
-      /**
-       * Scans branch directories and rebuilds the cache, deduping concurrent
-       * callers on this instance to a single underlying scan. Never loops waiting
-       * for the embedded token to match the marker — that livelocks under a bump
-       * storm; a caller wanting the very latest state calls list() again.
-       */
-      async regenerate() {
-        if (this.regenInFlight)
-          return this.regenInFlight;
-        const run = this.performRegenerate();
-        this.regenInFlight = run;
-        try {
-          return await run;
-        } finally {
-          this.regenInFlight = null;
+      if (untrackedLosses.length > 10) {
+        p2.log.warn(`  ... and ${untrackedLosses.length - 10} more`);
+      }
+    }
+    const confirm5 = await p2.confirm({
+      message: "Overwrite content directory? Files listed above will be lost.",
+      initialValue: false
+    });
+    if (p2.isCancel(confirm5) || !confirm5) {
+      p2.cancel("Pull cancelled. Commit or stash your changes first.");
+      return { fileCount: 0 };
+    }
+  }
+  const tmpDestDir = `${destContentDir}.sync-tmp-${Date.now()}`;
+  try {
+    await copyDir(branchContentDir, tmpDestDir);
+    await safeReplaceDir(destContentDir, tmpDestDir);
+  } catch (err2) {
+    await fs38.rm(tmpDestDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw err2;
+  }
+  const postStatus = await sourceGit.status();
+  const contentChanges = postStatus.files.filter((f) => f.path.startsWith(contentRoot + "/") || f.path === contentRoot);
+  if (contentChanges.length === 0) {
+    p2.log.info("Content is already up to date \u2014 nothing to pull");
+  } else {
+    p2.log.success(`Pulled ${contentChanges.length} changed file(s) from branch "${branchName}"`);
+    for (const file of contentChanges.slice(0, 20)) {
+      const indicator = file.working_dir === "?" ? "A" : file.working_dir || file.index;
+      p2.log.info(`  ${indicator} ${file.path}`);
+    }
+    if (contentChanges.length > 20) {
+      p2.log.info(`  ... and ${contentChanges.length - 20} more`);
+    }
+    p2.log.info("\nReview the changes, then git add and commit when ready.");
+  }
+  return { fileCount: contentChanges.length };
+}
+async function syncBoth(options) {
+  const { projectDir } = options;
+  const contentRoot = options.contentRoot || "content";
+  const srcContentDir = path47.join(projectDir, contentRoot);
+  assertWithinDir(srcContentDir, projectDir, "--content-root");
+  if (!await filePathExists(srcContentDir)) {
+    throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
+  }
+  const ws = await selectBranch({ ...options, projectDir, autoCreate: true });
+  if (!ws)
+    return { pushed: 0, pulled: 0 };
+  const { branchName, branchPath } = ws;
+  const wsGit = simpleGit7({ baseDir: branchPath });
+  const status = await wsGit.status();
+  if (status.conflicted.length > 0) {
+    p2.log.error("Branch workspace has unresolved merge conflicts.");
+    if (!options.force) {
+      const shouldAbort = await p2.confirm({
+        message: "Abort the merge and restore workspace to pre-merge state?",
+        initialValue: false
+      });
+      if (!p2.isCancel(shouldAbort) && shouldAbort) {
+        if (await abortWorkspaceMerge(branchPath, branchName)) {
+          p2.log.success("Merge aborted. Workspace restored to pre-merge state.");
         }
       }
-      async performRegenerate() {
-        const read = await readResourceGeneration2(this.root, RESOURCE4);
-        const branches = await this.scanBranchDirectories();
-        await fs37.unlink(this.stalePath).catch(() => {
+    }
+    return { pushed: 0, pulled: 0 };
+  }
+  return withWorkspaceLock(branchPath, branchName, () => mergeIntoWorkspace(options, { branchName, branchPath, srcContentDir, contentRoot }));
+}
+async function mergeIntoWorkspace(options, ws) {
+  const { branchPath, srcContentDir, contentRoot } = ws;
+  const wsGit = simpleGit7({ baseDir: branchPath });
+  const status = await wsGit.status();
+  if (status.files.some((f) => !isCanopyInternalPath(f.path))) {
+    await stageAllExceptCanopyState2(wsGit);
+    await wsGit.commit("sync: save editor state before merge");
+    p2.log.info("Committed editor changes before merge");
+  }
+  let baseRef;
+  try {
+    await wsGit.raw(["rev-parse", SYNC_BASE_TAG]);
+    baseRef = SYNC_BASE_TAG;
+  } catch {
+    baseRef = "HEAD";
+  }
+  const currentBranch = (await wsGit.revparse(["--abbrev-ref", "HEAD"])).trim();
+  try {
+    const incomingBranch = `sync-incoming-${Date.now()}`;
+    await wsGit.raw(["checkout", "-b", incomingBranch, baseRef]);
+    const wsContentDir = path47.join(branchPath, contentRoot);
+    assertWithinDir(wsContentDir, branchPath, "--content-root");
+    const tmpDir = `${wsContentDir}.sync-tmp-${Date.now()}`;
+    try {
+      await copyDir(srcContentDir, tmpDir);
+      await safeReplaceDir(wsContentDir, tmpDir);
+    } catch (err2) {
+      await fs38.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
+      await wsGit.checkout(currentBranch);
+      await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
+      });
+      throw err2;
+    }
+    await stageAllExceptCanopyState2(wsGit);
+    const incomingFiles = (await wsGit.status()).files.filter((f) => !isCanopyInternalPath(f.path));
+    if (incomingFiles.length === 0) {
+      await wsGit.checkout(currentBranch);
+      await wsGit.raw(["branch", "-D", incomingBranch]);
+      p2.log.info("No working-tree changes to merge \u2014 pulling editor changes only");
+      const pullResult2 = await pullFromWorkspace({ ...options, force: true }, ws);
+      return { pushed: 0, pulled: pullResult2.fileCount };
+    }
+    await wsGit.commit("sync: incoming working-tree changes");
+    await wsGit.checkout(currentBranch);
+    p2.log.step("Merging working-tree changes with editor changes...");
+    try {
+      await wsGit.merge([incomingBranch, "--no-edit"]);
+    } catch (mergeError) {
+      let mergeStatus;
+      try {
+        mergeStatus = await wsGit.status();
+      } catch {
+        await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
         });
-        if (!read.ok) {
-          return branches;
-        }
-        const snapshot = {
-          version: REGISTRY_VERSION2,
-          branches,
-          generation: read.token
-        };
-        const uniqueTempPath = `${this.tempPath}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-        await fs37.mkdir(this.root, { recursive: true });
-        await fs37.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
-        try {
-          await fs37.rename(uniqueTempPath, this.registryPath);
-        } catch (err2) {
-          await fs37.unlink(uniqueTempPath).catch(() => {
-          });
-          throw err2;
-        }
-        return branches;
+        throw mergeError;
       }
-      /**
-       * Scans the root directory for branch subdirectories with valid branch.json files.
-       * Protected (rather than exported as a test hook) so tests can subclass and
-       * override to simulate cross-process interleavings.
-       */
-      async scanBranchDirectories() {
-        const branches = [];
-        try {
-          const entries = await fs37.readdir(this.root, { withFileTypes: true });
-          for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith(".")) {
-              continue;
-            }
-            const branchRoot = path45.join(this.root, entry.name);
-            let meta;
-            try {
-              meta = await readBranchMetadataFile2(branchRoot);
-            } catch (err2) {
-              canopyLogWarn3(`CanopyCMS: Skipping branch directory '${entry.name}' during registry scan: ${getErrorMessage(err2)}`);
-              continue;
-            }
-            if (meta) {
-              branches.push({
-                branch: meta.branch,
-                branchRoot,
-                baseRoot: this.root
-              });
-            }
-          }
-        } catch (err2) {
-          if (isNotFoundError(err2)) {
-            return [];
-          }
-          throw err2;
+      if (mergeStatus.conflicted.length > 0) {
+        p2.log.error("Merge conflicts detected in the following files:");
+        for (const file of mergeStatus.conflicted) {
+          p2.log.error(`  ${file}`);
         }
-        return branches;
+        p2.log.info("The branch workspace is now in a merge state.");
+        const branchFlag = options.branch ? ` --branch ${options.branch}` : "";
+        p2.log.info(`Resolve the conflicts in the workspace, then run: canopycms sync pull${branchFlag}`);
+        p2.log.info(`Or abort the merge with: canopycms sync abort${branchFlag}`);
+        await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
+        });
+        return { pushed: 0, pulled: 0 };
+      }
+      await wsGit.raw(["branch", "-D", incomingBranch]).catch(() => {
+      });
+      throw mergeError;
+    }
+    await wsGit.raw(["branch", "-D", incomingBranch]);
+    await wsGit.tag(["-f", SYNC_BASE_TAG]);
+    p2.log.success("Merged working-tree changes with editor changes");
+    const pullResult = await pullFromWorkspace({ ...options, force: true }, ws);
+    return { pushed: incomingFiles.length, pulled: pullResult.fileCount };
+  } finally {
+    await invalidateBranchContentCaches2(branchPath);
+  }
+}
+async function syncAbort(options) {
+  const ws = await selectBranch({ ...options, projectDir: options.projectDir });
+  if (!ws)
+    return;
+  const { branchName, branchPath } = ws;
+  if (!await abortWorkspaceMerge(branchPath, branchName)) {
+    p2.log.info(`Branch workspace "${branchName}" is not in a merge state \u2014 nothing to abort.`);
+    return;
+  }
+  p2.log.success(`Merge aborted in branch workspace "${branchName}". Workspace restored to pre-merge state.`);
+}
+async function sync(options) {
+  p2.intro("CanopyCMS sync");
+  let pushed = 0;
+  let pulled = 0;
+  if (options.direction === "abort") {
+    await syncAbort(options);
+  } else if (options.direction === "both") {
+    const result = await syncBoth(options);
+    pushed = result.pushed;
+    pulled = result.pulled;
+  } else if (options.direction === "push") {
+    const result = await syncPush(options);
+    pushed = result.fileCount;
+  } else {
+    const result = await syncPull(options);
+    pulled = result.fileCount;
+  }
+  p2.outro("Done!");
+  return { pushed, pulled };
+}
+var SyncError, branchConfigSchema;
+var init_sync = __esm({
+  "dist/cli/sync.js"() {
+    "use strict";
+    init_branch_param();
+    init_branch_metadata_file();
+    init_branch();
+    init_validation3();
+    init_error();
+    init_fs();
+    init_git();
+    init_sync_core();
+    init_content_index_generation();
+    init_content_write_lock();
+    init_git_manager();
+    init_operating_mode2();
+    init_site_config();
+    SyncError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SyncError";
       }
     };
+    branchConfigSchema = z19.object({
+      branchNamespace: z19.string().optional(),
+      deploymentName: z19.string().optional(),
+      defaultBaseBranch: z19.string().optional(),
+      defaultActiveBranch: z19.string().optional()
+    });
   }
 });
 
-// dist/branch-metadata.js
-import fs38 from "node:fs/promises";
-import path46 from "node:path";
-function isRecordedEditor2(branch, userId) {
-  return (branch.editors?.includes(userId) ?? false) && (branch.uncommittedEditors?.includes(userId) ?? false);
-}
-function withMember2(list, id) {
-  return list?.includes(id) ? [...list] : [...list ?? [], id];
-}
-function mergeBranchMetadata2(existing, version, incoming, now = (/* @__PURE__ */ new Date()).toISOString()) {
-  const defaults = {
-    name: "unknown",
-    status: "editing",
-    access: {},
-    createdBy: "unknown",
-    createdAt: now,
-    updatedAt: now
-  };
-  return {
-    // Envelope keys this code does not know survive, as unknown branch keys do below.
-    ...existing,
-    schemaVersion: CURRENT_SCHEMA_VERSION2,
-    version: version ?? 0,
-    branch: {
-      ...defaults,
-      ...existing?.branch,
-      ...incoming.branch,
-      access: {
-        ...existing?.branch?.access,
-        ...incoming.branch?.access
-      },
-      // Immutable after creation
-      createdBy: existing?.branch.createdBy ?? incoming.branch?.createdBy ?? defaults.createdBy,
-      createdAt: existing?.branch.createdAt ?? defaults.createdAt,
-      // Fork point is recorded once at creation; later saves must not move it
-      baseBranch: existing?.branch.baseBranch ?? incoming.branch?.baseBranch,
-      // Always stamped fresh; the spreads above would otherwise let the creation-time value win
-      // forever, freezing the timestamp the editor's Branches panel sorts and displays by
-      updatedAt: now
-    }
-  };
+// dist/schema/index.js
+var init_schema = __esm({
+  "dist/schema/index.js"() {
+    "use strict";
+    init_meta_loader();
+  }
+});
+
+// dist/schema/schema-store.js
+import path48 from "node:path";
+import { z as z20 } from "zod";
+async function withBranchSchemaLock(branchRoot, fn, contentWriteLockWaitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS2) {
+  const schemaLockPath = path48.join(path48.resolve(branchRoot), ".canopy-meta", "schema");
+  return withContentWriteLock2(branchRoot, () => withLock2(schemaLockPath, () => withOccFileLock2(schemaLockPath, fn)), contentWriteLockWaitMs);
 }
-var CURRENT_SCHEMA_VERSION2, BranchMetadataConflictError2, BranchMetadataFileManager2;
-var init_branch_metadata = __esm({
-  "dist/branch-metadata.js"() {
+var MAX_NAME_LENGTH, MAX_LABEL_LENGTH, SAFE_NAME_PATTERN, SAFE_NAME_MESSAGE, entryTypeInputSchema, createCollectionInputSchema, updateCollectionInputSchema, updateEntryTypeInputSchema, log16;
+var init_schema_store = __esm({
+  "dist/schema/schema-store.js"() {
     "use strict";
-    init_branch_registry();
-    init_branch_metadata_file();
-    init_error();
     init_async_mutex();
+    init_debug2();
+    init_content_write_lock();
     init_occ_json_write();
-    CURRENT_SCHEMA_VERSION2 = 1;
-    BranchMetadataConflictError2 = class extends Error {
-      constructor(message = "Concurrent modification detected in branch metadata") {
-        super(message);
-        this.name = "BranchMetadataConflictError";
-      }
-    };
-    BranchMetadataFileManager2 = class _BranchMetadataFileManager2 {
-      constructor(branchRoot, baseRoot, options) {
-        this.branchRoot = path46.resolve(branchRoot);
-        this.filePath = path46.join(this.branchRoot, BRANCH_META_DIR2, BRANCH_META_FILE2);
-        this.baseRoot = baseRoot;
-        this.settleMs = options?.settleMs;
-      }
-      /** Read-only load, needing no baseRoot: registry scanning, loadBranchContext. */
-      static async loadOnly(branchRoot) {
-        return readBranchMetadataFile2(branchRoot);
-      }
-      /**
-       * An instance wired for registry invalidation. API handlers use this, so the
-       * registry cache is invalidated on update.
-       */
-      static get(branchRoot, baseRoot, options) {
-        return new _BranchMetadataFileManager2(branchRoot, baseRoot, options);
-      }
-      /**
-       * The file the save cycle merges over. A corrupt one throws
-       * {@link BranchMetadataCorruptError} rather than reading as absent, so a save
-       * never lays defaults (status 'editing', no ACL) over a branch whose real
-       * state is unknown; repair-metadata archives the file before it saves.
-       */
-      async load() {
-        const meta = await readBranchMetadataFile2(this.branchRoot);
-        return { meta, version: meta?.version ?? null };
-      }
-      /**
-       * Write branch.json via the shared OCC helper, applying the schemaVersion
-       * default here since payload shaping is branch-metadata's concern.
-       *
-       * Throws the helper's raw {@link OccWriteConflictError}, which is what the
-       * surrounding {@link withOccRetry} in save() recognizes and retries;
-       * translating to the public `BranchMetadataConflictError` earlier than the
-       * save() boundary would make withOccRetry's predicate miss it.
-       *
-       * branch.json is written WITH a trailing newline (`trailingNewline: true`),
-       * unlike comments.json.
-       */
-      async write(meta, expectedVersion) {
-        const payload = {
-          ...meta,
-          schemaVersion: meta.schemaVersion ?? CURRENT_SCHEMA_VERSION2
-        };
-        return writeOccJsonFile2(this.filePath, payload, {
-          expectedVersion,
-          settleMs: this.settleMs,
-          trailingNewline: true
-        });
-      }
-      /**
-       * Run a save cycle under the full lock + OCC-retry stack (class doc). A
-       * conflict surviving every retry surfaces as `BranchMetadataConflictError`.
-       *
-       * The stat guards a phantom-resurrection race with branch deletion: a
-       * caller's branchContext can resolve BEFORE a concurrent deleteBranchHandler
-       * removes the branch directory, while the save reaches here after it, and
-       * write()'s `mkdir({recursive:true})` would then recreate `.canopy-meta/` and
-       * branch.json from defaults inside a tree nothing else refers to — a registry
-       * entry with no clone behind it. It runs BEFORE the lock stack so a doomed
-       * save fails fast instead of paying for a lock.
-       *
-       * A save that passes the check just before a delete still cannot write: the
-       * delete renames the tree away under the same lockfile, and that lockfile
-       * creates only its own directory (`withOccFileLock`), so the save fails there.
-       */
-      async save(incoming) {
-        const saved = await this.saveIf(incoming, () => true);
-        if (saved === null)
-          throw new Error("unreachable: an unconditional save was skipped");
-        return saved;
-      }
-      /**
-       * {@link save}, applied only when `onlyIf` accepts the metadata on disk; resolves null when it
-       * does not, having written nothing. `onlyIf` runs inside the lock stack against the version
-       * the write is checked against, so the decision and the write are one compare-and-set.
-       */
-      async saveIf(incoming, onlyIf) {
-        return this.update((existing) => onlyIf(existing) ? incoming : null);
-      }
-      /**
-       * A save whose update `compute` derives from the metadata on disk, inside the lock stack, so
-       * an update built from the existing value (adding to a list) cannot lose a concurrent one.
-       * `compute` returning null writes nothing and resolves null. `keepUpdatedAt` leaves
-       * `updatedAt` as it was, for bookkeeping writes that are not a change to the branch.
-       */
-      async update(compute, options = {}) {
-        try {
-          await fs38.stat(this.branchRoot);
-        } catch (err2) {
-          if (isNotFoundError(err2)) {
-            throw new BranchMetadataConflictError2("Branch no longer exists");
-          }
-          throw err2;
-        }
-        let saved;
-        try {
-          saved = await withLock2(this.filePath, () => withOccFileLock2(this.filePath, () => withOccRetry2(async () => {
-            const { meta: existing, version } = await this.load();
-            const incoming = compute(existing);
-            if (incoming === null)
-              return null;
-            const merged = mergeBranchMetadata2(existing, version, incoming);
-            if (options.keepUpdatedAt && existing)
-              merged.branch.updatedAt = existing.branch.updatedAt;
-            const written = await this.write(merged, version);
-            merged.version = written.version;
-            merged.writeId = written.writeId;
-            return merged;
-          })));
-        } catch (err2) {
-          if (err2 instanceof OccWriteConflictError2) {
-            throw new BranchMetadataConflictError2();
-          }
-          throw err2;
-        }
-        if (saved !== null)
-          await this.invalidateRegistry();
-        return saved;
-      }
-      /**
-       * Adds `userId` to `editors` and `uncommittedEditors`. A lock-free read skips the write when
-       * both already hold it, so only a user's first save since the last submit commit pays for the lock.
-       * Never creates branch.json.
-       */
-      async recordEditor(userId) {
-        const current = await readBranchMetadataFile2(this.branchRoot);
-        if (!current || isRecordedEditor2(current.branch, userId))
-          return;
-        await this.update((existing) => existing && !isRecordedEditor2(existing.branch, userId) ? {
-          branch: {
-            editors: withMember2(existing.branch.editors, userId),
-            uncommittedEditors: withMember2(existing.branch.uncommittedEditors, userId)
-          }
-        } : null, { keepUpdatedAt: true });
-      }
-      /**
-       * Removes `userIds` from `uncommittedEditors` once a submit commit's trailers name them. Ids
-       * recorded after the commit read them stay, so the next commit names them.
-       */
-      async markEditorsCommitted(userIds) {
-        const committed = new Set(userIds);
-        if (committed.size === 0)
-          return;
-        await this.update((existing) => {
-          const pending = existing?.branch.uncommittedEditors ?? [];
-          const remaining = pending.filter((id) => !committed.has(id));
-          if (remaining.length === pending.length)
-            return null;
-          return { branch: { uncommittedEditors: remaining.length > 0 ? remaining : void 0 } };
-        }, { keepUpdatedAt: true });
-      }
-      /** Invalidate the registry cache so the next list() regenerates. */
-      async invalidateRegistry() {
-        const registry3 = new BranchRegistry2(this.baseRoot);
-        await registry3.invalidate();
-      }
-    };
+    MAX_NAME_LENGTH = 64;
+    MAX_LABEL_LENGTH = 128;
+    SAFE_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+    SAFE_NAME_MESSAGE = "must start with a letter and contain only lowercase letters, numbers, and hyphens";
+    entryTypeInputSchema = z20.object({
+      name: z20.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Entry type name ${SAFE_NAME_MESSAGE}`),
+      label: z20.string().max(MAX_LABEL_LENGTH).optional(),
+      format: z20.enum(["md", "mdx", "json", "yaml"]),
+      schema: z20.string().min(1),
+      default: z20.boolean().optional(),
+      maxItems: z20.number().int().positive().optional()
+    });
+    createCollectionInputSchema = z20.object({
+      name: z20.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Collection name ${SAFE_NAME_MESSAGE}`),
+      label: z20.string().max(MAX_LABEL_LENGTH).optional(),
+      parentPath: z20.string().optional(),
+      entries: z20.array(entryTypeInputSchema).min(1, "Collection must have at least one entry type")
+    });
+    updateCollectionInputSchema = z20.object({
+      name: z20.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Collection name ${SAFE_NAME_MESSAGE}`).optional(),
+      label: z20.string().max(MAX_LABEL_LENGTH).optional(),
+      // Directory name (e.g., "posts" in "posts.{id}/")
+      slug: z20.string().min(1).max(MAX_NAME_LENGTH).regex(SAFE_NAME_PATTERN, `Slug ${SAFE_NAME_MESSAGE}`).optional(),
+      order: z20.array(z20.string()).optional()
+    });
+    updateEntryTypeInputSchema = z20.object({
+      label: z20.string().max(MAX_LABEL_LENGTH).optional(),
+      format: z20.enum(["md", "mdx", "json", "yaml"]).optional(),
+      schema: z20.string().min(1).optional(),
+      default: z20.boolean().optional(),
+      maxItems: z20.number().int().positive().optional()
+    });
+    log16 = createDebugLogger3({ prefix: "SchemaOps" });
   }
 });
 
@@ -19681,7 +19988,7 @@ __export(migrate_exports, {
   slugifyName: () => slugifyName
 });
 import fs39 from "node:fs/promises";
-import path47 from "node:path";
+import path49 from "node:path";
 import * as p3 from "@clack/prompts";
 function slugifyName(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
@@ -19715,7 +20022,7 @@ async function planDirectory(dirPath, isRoot, ctx) {
     if (entry.name.startsWith("."))
       continue;
     if (entry.isDirectory()) {
-      const subPath = path47.join(dirPath, entry.name);
+      const subPath = path49.join(dirPath, entry.name);
       const sub = await planDirectory(subPath, false, ctx);
       if (!sub.hasContent)
         continue;
@@ -19723,10 +20030,10 @@ async function planDirectory(dirPath, isRoot, ctx) {
       ops.push(...sub.ops);
       if (!extractIdFromFilename2(entry.name)) {
         const newName = `${toValidSlug(entry.name)}.${generateId2()}`;
-        ops.push({ kind: "rename", from: subPath, to: path47.join(dirPath, newName) });
+        ops.push({ kind: "rename", from: subPath, to: path49.join(dirPath, newName) });
       }
     } else if (entry.isFile()) {
-      const ext = path47.extname(entry.name).slice(1);
+      const ext = path49.extname(entry.name).slice(1);
       const matchesFormat = ext === ctx.format || ctx.format === "yaml" && ext === "yml";
       if (!matchesFormat)
         continue;
@@ -19737,17 +20044,17 @@ async function planDirectory(dirPath, isRoot, ctx) {
         const newName = `${ctx.entryType}.${toValidSlug(base)}.${generateId2()}.${ext}`;
         ops.push({
           kind: "rename",
-          from: path47.join(dirPath, entry.name),
-          to: path47.join(dirPath, newName)
+          from: path49.join(dirPath, entry.name),
+          to: path49.join(dirPath, newName)
         });
       }
     }
   }
   const needsMeta = isRoot ? hasOwnFiles : hasContent;
-  const metaPath = path47.join(dirPath, ".collection.json");
+  const metaPath = path49.join(dirPath, ".collection.json");
   if (needsMeta && !await filePathExists(metaPath)) {
     const entryTypeMeta = { name: ctx.entryType, format: ctx.format, schema: ctx.schema };
-    const meta = isRoot ? { entries: [entryTypeMeta] } : { name: toValidSlug(stripDirIdSuffix(path47.basename(dirPath))), entries: [entryTypeMeta] };
+    const meta = isRoot ? { entries: [entryTypeMeta] } : { name: toValidSlug(stripDirIdSuffix(path49.basename(dirPath))), entries: [entryTypeMeta] };
     ops.push({ kind: "write", filePath: metaPath, content: JSON.stringify(meta, null, 2) + "\n" });
   }
   return { ops, hasContent };
@@ -19756,7 +20063,7 @@ async function migrate(options) {
   const { projectDir } = options;
   const contentRoot = options.contentRoot || "content";
   p3.intro("CanopyCMS migrate");
-  const contentDir = path47.join(projectDir, contentRoot);
+  const contentDir = path49.join(projectDir, contentRoot);
   if (!await filePathExists(contentDir)) {
     throw new MigrateError(`Content directory not found: ${contentRoot}/ (expected at ${contentDir})`);
   }
@@ -19891,7 +20198,7 @@ var init_migrate = __esm({
         this.name = "MigrateError";
       }
     };
-    describeOp = (op, baseDir) => op.kind === "rename" ? `rename  ${path47.relative(baseDir, op.from)} \u2192 ${path47.basename(op.to)}` : `create  ${path47.relative(baseDir, op.filePath)}`;
+    describeOp = (op, baseDir) => op.kind === "rename" ? `rename  ${path49.relative(baseDir, op.from)} \u2192 ${path49.basename(op.to)}` : `create  ${path49.relative(baseDir, op.filePath)}`;
   }
 });