canopycms 0.8.0 → 0.8.2

package/dist/branch-schema-cache.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { LRUCache } from 'lru-cache';
 import { resolveSchema, isValidSchema } from './schema/resolver.js';
 import { registryFingerprint } from './schema/registry-fingerprint.js';
 import { flattenSchema } from './config/flatten.js';
@@ -13,6 +14,8 @@ import { canopyLogWarn } from './utils/logger.js';
 const SCHEMA_CACHE_VERSION = 4;
 /** Minimum interval between mtime staleness checks (ms) */
 const MTIME_CHECK_DEBOUNCE_MS = 1000;
+/** Cap on the parsed snapshots one process keeps, counted in bytes of their files. */
+const SNAPSHOT_MEMO_MAX_BYTES = 64 * 1024 * 1024;
 /** File name of the schema cache inside {@link schemaCacheDir}. */
 export const SCHEMA_CACHE_FILE = 'schema-cache.json';
 /** resource-generation.ts resource key for the schema cache's marker. */
@@ -65,6 +68,13 @@ async function isStaleByMtime(dir, cachedAt) {
     }
     return false;
 }
+/**
+ * Names one version of a file. Every write of the schema cache renames a new temp file into
+ * place, so a rewrite always changes the inode, whatever token or content it carries.
+ */
+function fileIdentity(stat) {
+    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}`;
+}
 /**
  * Directory holding a branch's schema cache: `{branchRoot}/.git/canopycms` when
  * the branch root is a full clone (every canopycms branch workspace is), else
@@ -80,8 +90,15 @@ async function schemaCacheDir(branchRoot) {
     return isClone ? path.join(gitDir, 'canopycms') : path.join(branchRoot, CANOPY_META_DIR);
 }
 /**
- * Per-branch schema cache: one file in {@link schemaCacheDir} with no in-memory
- * layer, so it stays coherent across Lambda invocations.
+ * Per-branch schema cache: one file in {@link schemaCacheDir}, the only state
+ * shared across processes. Each process keeps the entries it parsed or wrote,
+ * keyed by the file's identity, so it parses an unchanged file once while the
+ * entry stays in its size-bounded memo. Every call still opens the file and
+ * runs every freshness check below on the entry, and the file is only ever
+ * replaced by rename (see {@link fileIdentity}), so a process is as fresh as if
+ * it re-read the file. The identity is fstat'ed on an open handle because NFS
+ * revalidates attributes on open (close-to-open), while a bare stat() may
+ * answer from its attribute cache.
  *
  * Freshness follows the generation-marker protocol owned by
  * resource-generation.ts, and this is one of that protocol's durable-snapshot
@@ -106,6 +123,19 @@ export class BranchSchemaCache {
     constructor(mode = 'prod') {
         /** Tracks when we last checked mtimes per contentRoot, to debounce rapid requests */
         this.lastMtimeCheck = new Map();
+        /** Parsed cache files, by absolute path; see the class doc. */
+        this.snapshots = new LRUCache({
+            maxSize: SNAPSHOT_MEMO_MAX_BYTES,
+            sizeCalculation: (snapshot) => Math.max(1, snapshot.bytes),
+        });
+        /**
+         * In-flight resolves of the checkout during a build, by content root and registry. A build
+         * reads a checkout that does not change under it, so those two are its whole input and the
+         * result needs no revalidation. Only {@link isBuildMode}: `CANOPY_BUILD_MODE` is a build and
+         * script switch, and a long-lived process setting it would see a schema edit only on
+         * restart. A rejected resolve is dropped, so a strict-mode failure fails every read.
+         */
+        this.buildResolves = new Map();
         this.devMode = mode === 'dev';
     }
     /**
@@ -135,17 +165,12 @@ export class BranchSchemaCache {
     async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
         const contentRoot = path.join(branchRoot, contentRootName);
         const fromCheckout = this.readsCheckout(branchRoot);
+        if (fromCheckout && isBuildMode()) {
+            return this.resolveForBuild(branchRoot, entrySchemaRegistry, contentRootName);
+        }
         if (!fromCheckout) {
             const cachePath = path.join(await schemaCacheDir(branchRoot), SCHEMA_CACHE_FILE);
-            let cacheData = null;
-            try {
-                const cacheContent = await fs.readFile(cachePath, 'utf-8');
-                cacheData = JSON.parse(cacheContent);
-            }
-            catch {
-                // Cache doesn't exist or can't be read
-                cacheData = null;
-            }
+            let cacheData = await this.readSnapshot(cachePath);
             // Strict version check, not truthiness: a snapshot from an older version
             // left on EFS by a rolling deploy has no `generation` field, and an
             // `undefined` token breaks the freshness comparison below.
@@ -187,6 +212,44 @@ export class BranchSchemaCache {
             fromCheckout,
         });
     }
+    resolveForBuild(branchRoot, entrySchemaRegistry, contentRootName) {
+        const key = `${path.resolve(branchRoot, contentRootName)}\0${registryFingerprint(entrySchemaRegistry)}`;
+        let pending = this.buildResolves.get(key);
+        if (!pending) {
+            pending = this.resolveFreshAndPersist(branchRoot, entrySchemaRegistry, contentRootName, {
+                fromCheckout: true,
+            });
+            this.buildResolves.set(key, pending);
+            pending.catch(() => this.buildResolves.delete(key));
+        }
+        return pending;
+    }
+    /** The parsed cache file, or null when it is absent or unreadable. */
+    async readSnapshot(cachePath) {
+        let handle;
+        try {
+            handle = await fs.open(cachePath, 'r');
+        }
+        catch {
+            return null;
+        }
+        try {
+            const stat = await handle.stat({ bigint: true });
+            const identity = fileIdentity(stat);
+            const memo = this.snapshots.get(cachePath);
+            if (memo?.identity === identity)
+                return memo.entry;
+            const entry = JSON.parse(await fs.readFile(handle, 'utf-8'));
+            this.snapshots.set(cachePath, { identity, entry, bytes: Number(stat.size) });
+            return entry;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            await handle.close().catch(() => { });
+        }
+    }
     /**
      * Resolve the schema fresh from disk and persist it (subject to the
      * skip-persist rule below), UNCONDITIONALLY -- never through the cache-read
@@ -241,16 +304,29 @@ export class BranchSchemaCache {
                 };
                 // Temp file then rename, with the temp file unlinked on a failed
                 // rename so a transient error leaves no stray `.tmp` beside the cache.
+                // The memo is seeded from the temp file's own identity, which the
+                // rename keeps: stat'ing cachePath afterwards could see a concurrent
+                // writer's file and pair it with this entry. It holds the parsed body,
+                // as every reader does, not the resolver's objects, which alias the
+                // registry and keep values JSON changes or drops.
                 await fs.mkdir(cacheDir, { recursive: true });
                 const tmpPath = path.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-                await fs.writeFile(tmpPath, JSON.stringify(newCache, null, 2), 'utf-8');
+                const body = JSON.stringify(newCache);
+                let identity;
                 try {
+                    await fs.writeFile(tmpPath, body, 'utf-8');
+                    identity = fileIdentity(await fs.stat(tmpPath, { bigint: true }));
                     await fs.rename(tmpPath, cachePath);
                 }
                 catch (err) {
                     await fs.unlink(tmpPath).catch(() => { });
                     throw err;
                 }
+                this.snapshots.set(cachePath, {
+                    identity,
+                    entry: JSON.parse(body),
+                    bytes: Buffer.byteLength(body),
+                });
             }
             // else: the marker read failed for a reason other than "never bumped",
             // so no token can be attributed to this resolve, and a snapshot stamped

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();
@@ -3405,6 +3405,7 @@ import path72 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs72 from "node:fs/promises";
 import path82 from "node:path";
+import { LRUCache } from "lru-cache";
 import { promises as fs62 } from "fs";
 import { join } from "pathe";
 import { z as z7 } from "zod";
@@ -5356,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;
@@ -5706,6 +5705,9 @@ async function isStaleByMtime(dir, cachedAt) {
   }
   return false;
 }
+function fileIdentity(stat) {
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}`;
+}
 async function schemaCacheDir(branchRoot) {
   const gitDir = path82.join(branchRoot, ".git");
   const isClone = await fs72.stat(gitDir).then((stat) => stat.isDirectory(), () => false);
@@ -8432,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, 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, 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";
@@ -10742,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();
@@ -10878,12 +10881,18 @@ var init_generate_ai_content = __esm({
     init_logger2();
     SCHEMA_CACHE_VERSION = 4;
     MTIME_CHECK_DEBOUNCE_MS = 1e3;
+    SNAPSHOT_MEMO_MAX_BYTES = 64 * 1024 * 1024;
     SCHEMA_CACHE_FILE = "schema-cache.json";
     SCHEMA_GENERATION_RESOURCE = "schema";
     reportedIssues = /* @__PURE__ */ new Set();
     BranchSchemaCache = class {
       constructor(mode = "prod") {
         this.lastMtimeCheck = /* @__PURE__ */ new Map();
+        this.snapshots = new LRUCache({
+          maxSize: SNAPSHOT_MEMO_MAX_BYTES,
+          sizeCalculation: (snapshot) => Math.max(1, snapshot.bytes)
+        });
+        this.buildResolves = /* @__PURE__ */ new Map();
         this.devMode = mode === "dev";
       }
       /**
@@ -10913,15 +10922,12 @@ var init_generate_ai_content = __esm({
       async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
         const contentRoot = path82.join(branchRoot, contentRootName);
         const fromCheckout = this.readsCheckout(branchRoot);
+        if (fromCheckout && isBuildMode()) {
+          return this.resolveForBuild(branchRoot, entrySchemaRegistry, contentRootName);
+        }
         if (!fromCheckout) {
           const cachePath = path82.join(await schemaCacheDir(branchRoot), SCHEMA_CACHE_FILE);
-          let cacheData = null;
-          try {
-            const cacheContent = await fs72.readFile(cachePath, "utf-8");
-            cacheData = JSON.parse(cacheContent);
-          } catch {
-            cacheData = null;
-          }
+          let cacheData = await this.readSnapshot(cachePath);
           if (cacheData && cacheData.version === SCHEMA_CACHE_VERSION && cacheData.registryFingerprint === registryFingerprint(entrySchemaRegistry)) {
             const read = await readResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE);
             if (isGenerationCurrent(cacheData.generation, read)) {
@@ -10951,6 +10957,42 @@ var init_generate_ai_content = __esm({
           fromCheckout
         });
       }
+      resolveForBuild(branchRoot, entrySchemaRegistry, contentRootName) {
+        const key = `${path82.resolve(branchRoot, contentRootName)}\0${registryFingerprint(entrySchemaRegistry)}`;
+        let pending = this.buildResolves.get(key);
+        if (!pending) {
+          pending = this.resolveFreshAndPersist(branchRoot, entrySchemaRegistry, contentRootName, {
+            fromCheckout: true
+          });
+          this.buildResolves.set(key, pending);
+          pending.catch(() => this.buildResolves.delete(key));
+        }
+        return pending;
+      }
+      /** The parsed cache file, or null when it is absent or unreadable. */
+      async readSnapshot(cachePath) {
+        let handle;
+        try {
+          handle = await fs72.open(cachePath, "r");
+        } catch {
+          return null;
+        }
+        try {
+          const stat = await handle.stat({ bigint: true });
+          const identity = fileIdentity(stat);
+          const memo = this.snapshots.get(cachePath);
+          if (memo?.identity === identity)
+            return memo.entry;
+          const entry = JSON.parse(await fs72.readFile(handle, "utf-8"));
+          this.snapshots.set(cachePath, { identity, entry, bytes: Number(stat.size) });
+          return entry;
+        } catch {
+          return null;
+        } finally {
+          await handle.close().catch(() => {
+          });
+        }
+      }
       /**
        * Resolve the schema fresh from disk and persist it (subject to the
        * skip-persist rule below), UNCONDITIONALLY -- never through the cache-read
@@ -10992,14 +11034,22 @@ var init_generate_ai_content = __esm({
             };
             await fs72.mkdir(cacheDir, { recursive: true });
             const tmpPath = path82.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-            await fs72.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
+            const body = JSON.stringify(newCache);
+            let identity;
             try {
+              await fs72.writeFile(tmpPath, body, "utf-8");
+              identity = fileIdentity(await fs72.stat(tmpPath, { bigint: true }));
               await fs72.rename(tmpPath, cachePath);
             } catch (err2) {
               await fs72.unlink(tmpPath).catch(() => {
               });
               throw err2;
             }
+            this.snapshots.set(cachePath, {
+              identity,
+              entry: JSON.parse(body),
+              bytes: Buffer.byteLength(body)
+            });
           }
         }
         reportSchemaIssues(issues);
@@ -12343,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"]),
@@ -17797,9 +17858,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;
@@ -17828,6 +17887,7 @@ var init_resource_generation = __esm({
     init_atomic_write3();
     init_error();
     init_debug2();
+    init_logger3();
     log11 = createDebugLogger3({ prefix: "ResourceGeneration" });
     META_DIR3 = ".canopy-meta";
   }
@@ -18064,10 +18124,12 @@ var init_meta_loader = __esm({
 });
 
 // dist/branch-schema-cache.js
-var SCHEMA_GENERATION_RESOURCE2;
+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";
   }
 });
@@ -19153,9 +19215,20 @@ var init_branch_metadata_file = __esm({
       mergedAt: z18.string().optional(),
       rebaseFailure: z18.object({ message: z18.string(), firstAt: z18.string(), lastAt: z18.string() }).optional(),
       historyRewrittenFrom: z18.string().optional(),
+      lastGitHubTip: z18.string().optional(),
+      keptOverGitHub: z18.array(z18.string()).optional(),
+      rewrittenOnGitHub: z18.string().optional(),
+      submitUnfinished: z18.boolean().optional(),
+      submitNotQueued: z18.boolean().optional(),
+      unpublishedAtMerge: z18.boolean().optional(),
       syncFailureReason: z18.string().optional(),
       editors: z18.array(z18.string()).optional(),
       uncommittedEditors: z18.array(z18.string()).optional(),
+      // Dropped when malformed: it only decorates the branch card, so it never fails a read.
+      pullRequestHold: z18.discriminatedUnion("kind", [
+        z18.object({ kind: z18.literal("conflicts") }),
+        z18.object({ kind: z18.literal("retargeted"), base: z18.string() })
+      ]).optional().catch(void 0),
       // Dropped when malformed: it only decorates the PR body, so it never fails a read.
       review: z18.object({
         state: z18.enum(["approved", "changes-requested"]),

package/dist/cli/generate-ai-content.js

@@ -4404,6 +4404,7 @@ init_error();
 import fs5 from "node:fs/promises";
 import path7 from "node:path";
 import { randomUUID } from "node:crypto";
+init_logger();
 var log4 = createDebugLogger({ prefix: "ResourceGeneration" });
 var META_DIR2 = ".canopy-meta";
 function resourceGenerationPath(root, resource) {
@@ -4415,9 +4416,7 @@ async function bumpResourceGeneration(root, resource, options) {
     await atomicWriteFile(resourceGenerationPath(root, resource), token);
     return token;
   } catch (err) {
-    log4.warn("generation", `Failed to bump ${resource} generation for ${root}`, {
-      error: getErrorMessage(err)
-    });
+    canopyLogWarn(`CanopyCMS: failed to bump ${resource} generation for ${root}:`, getErrorMessage(err));
     if (options?.mustSucceed)
       throw err;
     return null;
@@ -4443,6 +4442,7 @@ function isGenerationCurrent(snapshotToken, read) {
 // dist/branch-schema-cache.js
 import fs7 from "node:fs/promises";
 import path8 from "node:path";
+import { LRUCache } from "lru-cache";
 
 // dist/schema/meta-loader.js
 import { promises as fs6 } from "fs";
@@ -4902,6 +4902,7 @@ async function resolveBaseBranch(options) {
 init_logger();
 var SCHEMA_CACHE_VERSION = 4;
 var MTIME_CHECK_DEBOUNCE_MS = 1e3;
+var SNAPSHOT_MEMO_MAX_BYTES = 64 * 1024 * 1024;
 var SCHEMA_CACHE_FILE = "schema-cache.json";
 var SCHEMA_GENERATION_RESOURCE = "schema";
 var reportedIssues = /* @__PURE__ */ new Set();
@@ -4935,6 +4936,9 @@ async function isStaleByMtime(dir, cachedAt) {
   }
   return false;
 }
+function fileIdentity(stat) {
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}`;
+}
 async function schemaCacheDir(branchRoot) {
   const gitDir = path8.join(branchRoot, ".git");
   const isClone = await fs7.stat(gitDir).then((stat) => stat.isDirectory(), () => false);
@@ -4943,6 +4947,11 @@ async function schemaCacheDir(branchRoot) {
 var BranchSchemaCache = class {
   constructor(mode = "prod") {
     this.lastMtimeCheck = /* @__PURE__ */ new Map();
+    this.snapshots = new LRUCache({
+      maxSize: SNAPSHOT_MEMO_MAX_BYTES,
+      sizeCalculation: (snapshot) => Math.max(1, snapshot.bytes)
+    });
+    this.buildResolves = /* @__PURE__ */ new Map();
     this.devMode = mode === "dev";
   }
   /**
@@ -4972,15 +4981,12 @@ var BranchSchemaCache = class {
   async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
     const contentRoot = path8.join(branchRoot, contentRootName);
     const fromCheckout = this.readsCheckout(branchRoot);
+    if (fromCheckout && isBuildMode()) {
+      return this.resolveForBuild(branchRoot, entrySchemaRegistry, contentRootName);
+    }
     if (!fromCheckout) {
       const cachePath = path8.join(await schemaCacheDir(branchRoot), SCHEMA_CACHE_FILE);
-      let cacheData = null;
-      try {
-        const cacheContent = await fs7.readFile(cachePath, "utf-8");
-        cacheData = JSON.parse(cacheContent);
-      } catch {
-        cacheData = null;
-      }
+      let cacheData = await this.readSnapshot(cachePath);
       if (cacheData && cacheData.version === SCHEMA_CACHE_VERSION && cacheData.registryFingerprint === registryFingerprint(entrySchemaRegistry)) {
         const read = await readResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE);
         if (isGenerationCurrent(cacheData.generation, read)) {
@@ -5010,6 +5016,42 @@ var BranchSchemaCache = class {
       fromCheckout
     });
   }
+  resolveForBuild(branchRoot, entrySchemaRegistry, contentRootName) {
+    const key = `${path8.resolve(branchRoot, contentRootName)}\0${registryFingerprint(entrySchemaRegistry)}`;
+    let pending = this.buildResolves.get(key);
+    if (!pending) {
+      pending = this.resolveFreshAndPersist(branchRoot, entrySchemaRegistry, contentRootName, {
+        fromCheckout: true
+      });
+      this.buildResolves.set(key, pending);
+      pending.catch(() => this.buildResolves.delete(key));
+    }
+    return pending;
+  }
+  /** The parsed cache file, or null when it is absent or unreadable. */
+  async readSnapshot(cachePath) {
+    let handle;
+    try {
+      handle = await fs7.open(cachePath, "r");
+    } catch {
+      return null;
+    }
+    try {
+      const stat = await handle.stat({ bigint: true });
+      const identity = fileIdentity(stat);
+      const memo = this.snapshots.get(cachePath);
+      if (memo?.identity === identity)
+        return memo.entry;
+      const entry = JSON.parse(await fs7.readFile(handle, "utf-8"));
+      this.snapshots.set(cachePath, { identity, entry, bytes: Number(stat.size) });
+      return entry;
+    } catch {
+      return null;
+    } finally {
+      await handle.close().catch(() => {
+      });
+    }
+  }
   /**
    * Resolve the schema fresh from disk and persist it (subject to the
    * skip-persist rule below), UNCONDITIONALLY -- never through the cache-read
@@ -5051,14 +5093,22 @@ var BranchSchemaCache = class {
         };
         await fs7.mkdir(cacheDir, { recursive: true });
         const tmpPath = path8.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-        await fs7.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
+        const body = JSON.stringify(newCache);
+        let identity;
         try {
+          await fs7.writeFile(tmpPath, body, "utf-8");
+          identity = fileIdentity(await fs7.stat(tmpPath, { bigint: true }));
           await fs7.rename(tmpPath, cachePath);
         } catch (err) {
           await fs7.unlink(tmpPath).catch(() => {
           });
           throw err;
         }
+        this.snapshots.set(cachePath, {
+          identity,
+          entry: JSON.parse(body),
+          bytes: Buffer.byteLength(body)
+        });
       }
     }
     reportSchemaIssues(issues);
@@ -7797,9 +7847,20 @@ var branchMetadataShape = {
   mergedAt: z7.string().optional(),
   rebaseFailure: z7.object({ message: z7.string(), firstAt: z7.string(), lastAt: z7.string() }).optional(),
   historyRewrittenFrom: z7.string().optional(),
+  lastGitHubTip: z7.string().optional(),
+  keptOverGitHub: z7.array(z7.string()).optional(),
+  rewrittenOnGitHub: z7.string().optional(),
+  submitUnfinished: z7.boolean().optional(),
+  submitNotQueued: z7.boolean().optional(),
+  unpublishedAtMerge: z7.boolean().optional(),
   syncFailureReason: z7.string().optional(),
   editors: z7.array(z7.string()).optional(),
   uncommittedEditors: z7.array(z7.string()).optional(),
+  // Dropped when malformed: it only decorates the branch card, so it never fails a read.
+  pullRequestHold: z7.discriminatedUnion("kind", [
+    z7.object({ kind: z7.literal("conflicts") }),
+    z7.object({ kind: z7.literal("retargeted"), base: z7.string() })
+  ]).optional().catch(void 0),
   // Dropped when malformed: it only decorates the PR body, so it never fails a read.
   review: z7.object({
     state: z7.enum(["approved", "changes-requested"]),

package/dist/cli/init.js

@@ -1207,7 +1207,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`);
@@ -1228,7 +1228,7 @@ async function retryTask(taskDir, taskId, error, logger = nullLogger) {
     throw err;
   }
   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();

package/dist/content-reader.d.ts

@@ -89,20 +89,34 @@ export interface ContentReadMeta {
     /** The entry's URL path with no query, by the rule `listEntries` uses. */
     urlPath: string;
 }
+/** What a content read resolves to. */
+export interface ContentReadResult<T = unknown> {
+    data: T;
+    /**
+     * The requested `entryPath` and slug as a percent-encoded URL path, plus `?branch=<name>`.
+     * Through an entry-type `entryPath` it is not the entry's URL. Compare entries by
+     * `meta.urlPath`.
+     */
+    path: string;
+    meta: ContentReadMeta;
+}
 export interface ContentReader {
-    read: <T = unknown>(input: ReadContentInput, message?: string) => Promise<{
-        data: T;
-        /**
-         * The requested `entryPath` and slug as a percent-encoded URL path, plus `?branch=<name>`.
-         * Through an entry-type `entryPath` it is not the entry's URL. Compare entries by
-         * `meta.urlPath`.
-         */
-        path: string;
-        meta: ContentReadMeta;
-    }>;
+    read: <T = unknown>(input: ReadContentInput, message?: string) => Promise<ContentReadResult<T>>;
+}
+/** @internal The reader `CanopyContext` (context.ts) builds on. */
+export interface ContentReaderInternal extends ContentReader {
+    /**
+     * Read the first of `inputs` that resolves, against one store resolved once for their branch,
+     * so a lookup trying several paths resolves the branch and its schema once. Every input must
+     * name the same branch and user. An error `isMiss` accepts moves on to the next input; null
+     * when every input misses, or when resolving the branch itself throws a miss.
+     */
+    readFirst: <T = unknown>(inputs: readonly ReadContentInput[], isMiss: (err: unknown, input: ReadContentInput) => boolean) => Promise<ContentReadResult<T> | null>;
 }
 /**
  * Server-side helper to read content directly from a branch workspace. A branch with no workspace
  * reads as NOT_FOUND unless `allowCreateBranch` or a `getBranchContext` resolver says otherwise.
  */
 export declare const createContentReader: (options: ContentReaderOptions) => ContentReader;
+/** @internal {@link createContentReader} plus `readFirst`, for context.ts. */
+export declare const createContentReaderInternal: (options: ContentReaderOptions) => ContentReaderInternal;