canopycms 0.0.68-int.113 → 0.0.68-int.114

package/dist/ai/generate.d.ts

@@ -43,9 +43,9 @@ export interface GenerateResult {
  * and produces per-entry files, per-collection all.md files,
  * bundle files, and a manifest.
  *
- * A reference may only show a target that is itself exported, so every entry is read and
- * filtered first, which settles the exported set. Only then are references to anything outside
- * it masked, entry transforms run, and markdown rendered, in rounds that repeat while a render
- * fails (see the loop below).
+ * A reference or body `entry:` link may only show a target that is itself exported, so every
+ * entry is read and filtered first, which settles the exported set. Only then are body links
+ * resolved for output, references to anything outside the set masked, entry transforms run, and markdown
+ * rendered, in rounds that repeat while a render fails (see the loop below).
  */
 export declare function generateAIContent(options: GenerateOptions): Promise<GenerateResult>;

package/dist/ai/generate.js

@@ -15,6 +15,7 @@ import { getErrorMessage, isNodeError } from '../utils/error.js';
 import { entryToMarkdown, frontmatterTitle } from './json-to-markdown.js';
 import { createReferenceRendering, createReferenceTargetResolver, maskUnexportedTargets, resolveReferenceFields, } from './references.js';
 import { resolveEntryLinksInText } from '../entry-link-resolver.js';
+import { DEFAULT_SEO_FIELD_NAMES, isNoindexEntry } from '../static/seo.js';
 /**
  * Generate all AI content from the content store.
  *
@@ -22,13 +23,14 @@ import { resolveEntryLinksInText } from '../entry-link-resolver.js';
  * and produces per-entry files, per-collection all.md files,
  * bundle files, and a manifest.
  *
- * A reference may only show a target that is itself exported, so every entry is read and
- * filtered first, which settles the exported set. Only then are references to anything outside
- * it masked, entry transforms run, and markdown rendered, in rounds that repeat while a render
- * fails (see the loop below).
+ * A reference or body `entry:` link may only show a target that is itself exported, so every
+ * entry is read and filtered first, which settles the exported set. Only then are body links
+ * resolved for output, references to anything outside the set masked, entry transforms run, and markdown
+ * rendered, in rounds that repeat while a render fails (see the loop below).
  */
 export async function generateAIContent(options) {
     const { store, flatSchema, contentRoot, config, entryLinkUrl, generatedAt, buildId } = options;
+    assertValidNoindexConfig(config);
     const files = new Map();
     const idIndex = await store.idIndex();
     const read = {
@@ -69,13 +71,23 @@ export async function generateAIContent(options) {
         mountPath: config?.mountPath ?? '/ai',
         files: exported,
     });
-    // An entry whose render throws is not in the export after all, so references to it are masked
-    // like any other left-out target, and the entries that changed run their transforms and render
-    // again. That can fail another entry, so this repeats until a round fails none; each round
-    // removes at least one entry, so it ends.
+    // An entry whose render throws is not in the export after all, so references and body links to
+    // it are withheld like any other left-out target, and the entries that changed run their
+    // transforms and render again. That can fail another entry, so this repeats until a round fails
+    // none; each round removes at least one entry, so it ends.
     let round = allPending;
     for (;;) {
         for (const pending of round) {
+            if (pending.body !== undefined) {
+                const linked = new Set();
+                pending.entry.body = resolveEntryLinksInText(pending.body, idIndex, contentRoot, entryLinkUrl, {
+                    isLinkable: (id) => {
+                        linked.add(id);
+                        return exported.has(id);
+                    },
+                });
+                pending.linkedIds = [...linked];
+            }
             maskUnexportedTargets(pending.entry, exported);
             // Fold in adopter-supplied markdown (e.g. a colocated sibling artifact), on data as masked
             pending.entry.appendedSections = undefined;
@@ -84,11 +96,19 @@ export async function generateAIContent(options) {
         const failed = renderAll(round, config, references);
         if (failed.length === 0)
             break;
+        const failedIds = new Set();
         for (const pending of failed) {
-            if (pending.contentId !== null)
-                exported.delete(pending.contentId);
+            if (pending.contentId === null)
+                continue;
+            exported.delete(pending.contentId);
+            failedIds.add(pending.contentId);
         }
-        round = allPending.filter((pending) => isRendered(pending) && maskUnexportedTargets(pending.entry, exported));
+        round = allPending.filter((pending) => {
+            if (!isRendered(pending))
+                return false;
+            const masked = maskUnexportedTargets(pending.entry, exported);
+            return masked || pending.linkedIds.some((id) => failedIds.has(id));
+        });
     }
     const manifestCollections = collectionNodes.map((node) => emitCollection(node, files));
     const manifestRootEntries = emitEntries(rootEntries, files);
@@ -166,6 +186,7 @@ async function collectCollection(read, collection, flatSchema) {
 /** Read, resolve and filter the entries directly in `collection` (not its subcollections). */
 async function collectEntries(read, collection, cleanPath) {
     const { store, contentRoot, config, idIndex, entryLinkUrl, resolveTarget } = read;
+    const skipNoindex = config?.exclude?.noindex !== false;
     const pending = [];
     const listed = await store.getCollectionEntryPaths(collection.logicalPath);
     // Filter to only entries in this exact collection (not subcollections)
@@ -183,15 +204,21 @@ async function collectEntries(read, collection, cleanPath) {
             const doc = await store.read(listEntry.collection, listEntry.slug, {
                 resolveReferences: false,
             });
+            // AI content advertises an entry, so `noindex` leaves it out here as it does the sitemap.
+            if (skipNoindex && isNoindexEntry(doc.data, config?.seo))
+                continue;
             doc.data = await resolveReferenceFields(doc.data, entryTypeConfig.schema, resolveTarget);
             const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, cleanPath);
-            if (aiEntry.body) {
-                aiEntry.body = resolveEntryLinksInText(aiEntry.body, idIndex, contentRoot, entryLinkUrl);
-            }
+            const body = aiEntry.body;
+            // `where` sees every link resolved; the export's own rendering re-resolves from `body`
+            if (body)
+                aiEntry.body = resolveEntryLinksInText(body, idIndex, contentRoot, entryLinkUrl);
             if (config?.exclude?.where?.(aiEntry))
                 continue;
             pending.push({
                 entry: aiEntry,
+                body,
+                linkedIds: [],
                 contentId: extractIdFromFilename(path.basename(listEntry.relativePath)),
                 absolutePath: doc.absolutePath,
                 collectionPath: collection.logicalPath,
@@ -236,6 +263,40 @@ function emitCollection(node, files) {
         subcollections: manifestSubcollections.length > 0 ? manifestSubcollections : undefined,
     };
 }
+/**
+ * Refuse an `exclude.noindex` or `seo` the noindex gate would misread. A non-boolean
+ * `noindex: 'false'` would leave the gate on while the adopter believes it is off, and a
+ * misshapen `seo` reads the flag from a field no entry sets, so every noindex entry ships.
+ */
+function assertValidNoindexConfig(config) {
+    const noindex = config?.exclude?.noindex;
+    if (noindex !== undefined && typeof noindex !== 'boolean') {
+        throw new Error(`AI content config: exclude.noindex must be a boolean, got ${typeof noindex}`);
+    }
+    const seo = config?.seo;
+    if (seo === undefined)
+        return;
+    if (typeof seo !== 'object' || seo === null || Array.isArray(seo)) {
+        throw new Error('AI content config: seo must be an object of { group?, fields? }');
+    }
+    const { group, fields } = seo;
+    if (group !== undefined && typeof group !== 'string') {
+        throw new Error('AI content config: seo.group must be a string');
+    }
+    if (fields === undefined)
+        return;
+    if (typeof fields !== 'object' ||
+        fields === null ||
+        Array.isArray(fields) ||
+        Object.values(fields).some((name) => typeof name !== 'string')) {
+        throw new Error('AI content config: seo.fields must map SEO fields to field-name strings');
+    }
+    // An unknown key (`noIndex`) would leave the gate reading the default field name
+    const unknown = Object.keys(fields).filter((key) => !(key in DEFAULT_SEO_FIELD_NAMES));
+    if (unknown.length > 0) {
+        throw new Error(`AI content config: unknown seo.fields key(s): ${unknown.join(', ')}`);
+    }
+}
 function stripContentRoot(logicalPath, contentRoot) {
     if (logicalPath.startsWith(contentRoot + '/')) {
         return logicalPath.slice(contentRoot.length + 1);

package/dist/ai/types.d.ts

@@ -6,6 +6,7 @@
  */
 import type { FieldConfig } from '../config/index.js';
 import type { MissingReference, ResolvedReferenceMeta } from '../entry-schema.js';
+import type { SeoFieldLocation } from '../static/seo.js';
 /** A reference whose target this export shows: the target's own data plus where it lives. */
 export type AIResolvedReference = Record<string, unknown> & ResolvedReferenceMeta & {
     unavailable?: undefined;
@@ -60,6 +61,12 @@ export interface ExcludeConfig {
     entryTypes?: string[];
     /** Custom predicate — return true to exclude the entry */
     where?: (entry: AIEntryMeta) => boolean;
+    /**
+     * Leave out entries marked `noindex`, read through `isNoindexEntry` at
+     * {@link AIContentConfig.seo}, the predicate the sitemap and robots metadata use. Default
+     * `true`; `false` exports them.
+     */
+    noindex?: boolean;
 }
 /**
  * Filter criteria for bundles. Filters are AND'd when combined.
@@ -211,6 +218,11 @@ export interface AIContentConfig {
     mountPath?: string;
     /** Opt-out exclusions — content to skip */
     exclude?: ExcludeConfig;
+    /**
+     * Where entries keep their SEO fields, when not the flat defaults. Drives the `noindex` read,
+     * so pass the same object as `createNextCanopyContext({ seo })`, or the two can disagree.
+     */
+    seo?: SeoFieldLocation;
     /** Custom bundles — filtered content subsets */
     bundles?: BundleConfig[];
     /** Per-entry-type, per-field markdown overrides */

package/dist/api/branch.js

@@ -202,7 +202,7 @@ export const createBranchHandler = async (ctx, req, body) => {
         // is BOTH this deployment's local git origin AND a mirror of GitHub's
         // view of the repo: worker/git-sync.ts's syncGit() fetches GitHub into it
         // (see GITHUB_TRACKING_REF_PREFIX's doc comment in git-manager.ts) and
-        // then reconciles refs/heads/* non-destructively, so it carries both
+        // then reconciles refs/heads/* without touching editor work, so it carries both
         // this deployment's local heads and GitHub's view -- readable offline by
         // this same Lambda, since it resolves to the same EFS inode the worker
         // uses. Reading it here catches a sanitized-name collision with a branch
@@ -264,14 +264,14 @@ export const createBranchHandler = async (ctx, req, body) => {
                 // deleteBranchHandler's cleanup (below) handles the common case, but
                 // cannot cover every ordering: when the branch still existed on
                 // GitHub at editor-delete time, the sync loop's reconcile re-creates
-                // the local head from the tracking ref within a cycle, and once the
-                // GitHub side is later deleted (pruning the tracking ref) that
-                // re-created head is orphaned with no registry entry left for the
-                // delete path to ever run against. Healing at REUSE time covers
-                // every ordering, however the head got orphaned: the registry check
-                // above already proved no live branch owns this name, and the
-                // tracking check just proved GitHub doesn't either, so a remaining
-                // local head is stale by definition. Best-effort (old-value-guarded
+                // the local head from GitHub's branch within a cycle, and once the
+                // GitHub side is later deleted that re-created head stays until the
+                // sync loop's next prune, with no registry entry left for the delete
+                // path to run against. Healing at REUSE time covers every ordering,
+                // however the head got orphaned: the registry check above already
+                // proved no live branch owns this name, and the tracking check just
+                // proved GitHub doesn't either, so a remaining local head is stale by
+                // definition. Best-effort (old-value-guarded
                 // against a concurrent push): on failure, creation still proceeds --
                 // that is today's status quo, and the publish-time 409 message names
                 // this cause.
@@ -532,10 +532,10 @@ export const deleteBranchHandler = async (ctx, req, params) => {
     if (deletingPath)
         await removeLeftoverDir(deletingPath);
     // Also delete the branch's local head from the remote.git mirror (the
-    // deployment's local origin). The sync loop deliberately never deletes a
-    // local head (see reconcileTrackedBranches), so THIS is the one explicit
-    // path that removes it -- without this, the head outlives the branch
-    // forever, and reusing the name after the GitHub side is gone (e.g. a
+    // deployment's local origin). The sync loop's reconcileTrackedBranches
+    // removes a head only once GitHub no longer has its branch, so while GitHub
+    // does, THIS is the path that removes it -- without this, the head outlives
+    // the branch, and reusing the name after the GitHub side is gone (e.g. a
     // squash-merged PR with auto-delete) has the reused branch's first publish
     // rejected non-fast-forward against the stale old tip: a permanent,
     // misleading 409 -- and a retried submit would then ship the STALE head to

package/dist/auth/cache.d.ts

@@ -2,5 +2,5 @@
  * Server-only: these use node:fs/promises and must NOT reach a client bundle.
  * Import them as 'canopycms/auth/cache'.
  */
-export { FileBasedAuthCache, writeAuthCacheSnapshot } from './file-based-auth-cache.js';
+export { FileBasedAuthCache, writeAuthCacheSnapshot, writeAuthSnapshot, type AuthCacheSnapshot, } from './file-based-auth-cache.js';
 export { CachingAuthPlugin } from './caching-auth-plugin.js';

package/dist/auth/cache.js

@@ -2,5 +2,5 @@
  * Server-only: these use node:fs/promises and must NOT reach a client bundle.
  * Import them as 'canopycms/auth/cache'.
  */
-export { FileBasedAuthCache, writeAuthCacheSnapshot } from './file-based-auth-cache.js';
+export { FileBasedAuthCache, writeAuthCacheSnapshot, writeAuthSnapshot, } from './file-based-auth-cache.js';
 export { CachingAuthPlugin } from './caching-auth-plugin.js';

package/dist/auth/file-based-auth-cache.d.ts

@@ -32,3 +32,11 @@ export declare class FileBasedAuthCache implements AuthCacheProvider {
  * recent snapshot directories are kept.
  */
 export declare function writeAuthCacheSnapshot(cachePath: string, files: Record<string, unknown>): Promise<string>;
+/** One auth provider's users, groups and memberships: what an auth-cache refresh writes. */
+export interface AuthCacheSnapshot {
+    users: UserSearchResult[];
+    groups: GroupMetadata[];
+    memberships: Record<CanopyUserId, CanopyGroupId[]>;
+}
+/** Write `snapshot` as the three files FileBasedAuthCache reads (users.json, orgs.json, memberships.json). */
+export declare function writeAuthSnapshot(cachePath: string, snapshot: AuthCacheSnapshot): Promise<string>;

package/dist/auth/file-based-auth-cache.js

@@ -182,6 +182,17 @@ export async function writeAuthCacheSnapshot(cachePath, files) {
     await cleanupOldSnapshots(cachePath, 2);
     return snapshotDir;
 }
+/** Write `snapshot` as the three files FileBasedAuthCache reads (users.json, orgs.json, memberships.json). */
+export async function writeAuthSnapshot(cachePath, snapshot) {
+    const users = { users: snapshot.users };
+    const groups = { groups: snapshot.groups };
+    const memberships = { memberships: snapshot.memberships };
+    return writeAuthCacheSnapshot(cachePath, {
+        'users.json': users,
+        'orgs.json': groups,
+        'memberships.json': memberships,
+    });
+}
 async function cleanupOldSnapshots(cachePath, keepCount) {
     let entries;
     try {

package/dist/authorization/branch.d.ts

@@ -50,7 +50,7 @@ export declare function createCheckBranchAccess(defaultAccess?: DefaultBranchAcc
 export interface WorkflowActionOptions {
     /**
      * When true, disables the system-branch grant below. The protected base
-     * branch is auto-provisioned with `createdBy: 'canopycms-system'`, which
+     * branch is auto-provisioned with `createdBy: SYSTEM_USER_ID`, which
      * would otherwise let anyone with general branch access submit/withdraw it
      * -- pass `getBranchProtection(...).isProtected` here so only
      * admins/reviewers/explicit-ACL users retain workflow rights on it.

package/dist/authorization/branch.js

@@ -1,5 +1,6 @@
 import { isAdmin, isReviewer } from './helpers.js';
 import { getBranchProtection } from './protected-branch.js';
+import { SYSTEM_USER_ID } from '../system-users.js';
 /**
  * Check if user has access to a branch with explicit default behavior.
  *
@@ -80,7 +81,7 @@ export function canPerformWorkflowAction(context, user, defaultAccess = 'deny',
         return false;
     }
     const userIsCreator = context.branch.createdBy === user.userId;
-    const isSystemBranch = !options?.isProtectedBranch && context.branch.createdBy === 'canopycms-system';
+    const isSystemBranch = !options?.isProtectedBranch && context.branch.createdBy === SYSTEM_USER_ID;
     return (userIsCreator ||
         accessResult.reason === 'privileged' ||
         accessResult.reason === 'allowed_by_acl' ||