canopycms 0.0.67-int.90 → 0.0.67-int.91

package/README.md

@@ -2,6 +2,32 @@
 
 CanopyCMS is a schema-driven, branch-aware CMS for websites that store their content in GitHub repositories.
 
+## Which documentation matches this build
+
+This package ships code, not documentation. The guides — `docs/adopter-migration.md`,
+`docs/deploying-to-aws.md` and the project README — live in the repository and change
+alongside the code, so read them at the ref **your installed version was built from**, not at
+`main`. The npm provenance attestation records that ref exactly:
+
+```bash
+V=$(node -p "require('./node_modules/canopycms/package.json').version")
+curl -s "https://registry.npmjs.org/-/npm/v1/attestations/canopycms@$V" | node -e '
+let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{
+  const a=JSON.parse(s).attestations.find(x=>x.predicateType==="https://slsa.dev/provenance/v1")
+  const b=JSON.parse(Buffer.from(a.bundle.dsseEnvelope.payload,"base64")).predicate.buildDefinition
+  console.log(b.externalParameters.workflow.ref, b.resolvedDependencies[0].digest.gitCommit)
+})'
+```
+
+Then browse `https://github.com/safeinsights/canopycms/tree/<commit>/docs`.
+
+Check this whenever a documented behaviour does not match what you observe. It matters most on
+the `int` channel: a version like `0.0.67-int.90` is published from an integration branch that
+has **not** merged to `main`, so `main`'s guides describe the last stable release and simply do
+not contain the sections covering your build. A missing section reads exactly like a behaviour
+you misunderstood, which is why it is worth resolving the ref rather than guessing. Stable
+`X.Y.Z` builds are on `main`, at tag `vX.Y.Z`.
+
 ## What it does for you
 
 - Lets you keep your site code and content in one repo.
@@ -644,6 +670,7 @@ to enable the interactive crop step, or `altOptional: true` for decorative image
 
 For deployment, the `canopycms-cdk` package ships an `AssetSupport` construct that provisions
 the bucket, the transform Lambda and the CloudFront behaviors. Fuller documentation — every
-config option, the transform directive syntax, and the AWS wiring — is in the
-[project README](https://github.com/safeinsights/canopycms#media-configuration) and
-[docs/deploying-to-aws.md](https://github.com/safeinsights/canopycms/blob/main/docs/deploying-to-aws.md).
+config option, the transform directive syntax, and the AWS wiring — is in the project README's
+`#media-configuration` section and in `docs/deploying-to-aws.md`. Read both at the ref this
+build came from, not at `main` — see
+[Which documentation matches this build](#which-documentation-matches-this-build).

package/dist/ai/generate.js

@@ -24,9 +24,7 @@ import { resolveEntryLinksInText } from '../entry-link-resolver.js';
 export async function generateAIContent(options) {
     const { store, flatSchema, contentRoot, config, entryLinkUrl, generatedAt, buildId } = options;
     const files = new Map();
-    // Build content ID index for entry link resolution
     const idIndex = await store.idIndex();
-    // Build lookup maps from flat schema
     const collections = flatSchema.filter((item) => item.type === 'collection');
     // Track all entries for bundle filtering
     const allEntries = [];
@@ -34,12 +32,10 @@ export async function generateAIContent(options) {
     const manifestCollections = [];
     // Track root-level entries (entries in the content root, not in a subcollection)
     const rootEntries = [];
-    // Process each collection
     for (const collection of collections) {
         // Skip the content root itself — we process its children
         if (collection.logicalPath === contentRoot)
             continue;
-        // Check exclusion
         if (isCollectionExcluded(collection.logicalPath, contentRoot, config))
             continue;
         // Only process top-level collections and direct subcollections here
@@ -63,7 +59,6 @@ export async function generateAIContent(options) {
         }
         rootEntries.push(...rootResult.manifestEntries);
     }
-    // Process bundles
     const manifestBundles = [];
     if (config?.bundles) {
         for (const bundle of config.bundles) {
@@ -87,8 +82,6 @@ export async function generateAIContent(options) {
             }
         }
     }
-    // Build manifest.
-    //
     // `generated` is emitted unless the caller named an artifact but no timestamp: a build id says
     // "this content is identified by an artifact, not by when a runner happened to build it", and a
     // wall clock alongside it would be a claim the artifact cannot support months later. Key order
@@ -108,7 +101,6 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
     const entries = [];
     const cleanPath = stripContentRoot(collection.logicalPath, contentRoot);
     const manifestEntries = [];
-    // Read entries directly in this collection (not subcollections)
     const listed = await store.getCollectionEntryPaths(collection.logicalPath);
     // Filter to only entries in this exact collection (not subcollections)
     const directEntries = listed.filter((e) => e.collection === collection.logicalPath);
@@ -116,10 +108,8 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
         const entryTypeName = extractEntryTypeFromFilename(path.basename(listEntry.relativePath));
         if (!entryTypeName)
             continue;
-        // Check entry type exclusion
         if (config?.exclude?.entryTypes?.includes(entryTypeName))
             continue;
-        // Find the entry type config to get schema fields
         const entryTypeConfig = findEntryType(collection, entryTypeName);
         if (!entryTypeConfig)
             continue;
@@ -128,17 +118,14 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
                 resolveReferences: false,
             });
             const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, cleanPath);
-            // Resolve entry:ID links in body content
             if (aiEntry.body && idIndex) {
                 aiEntry.body = resolveEntryLinksInText(aiEntry.body, idIndex, contentRoot, entryLinkUrl);
             }
-            // Check predicate exclusion
             if (config?.exclude?.where?.(aiEntry))
                 continue;
             // Fold in adopter-supplied markdown (e.g. a colocated sibling artifact), once per entry
             await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path.basename(listEntry.relativePath)), config);
             entries.push(aiEntry);
-            // Write individual entry file
             const entryFilePath = `${cleanPath}/${listEntry.slug}.md`;
             const entryMarkdown = entryToMarkdown(aiEntry, config);
             files.set(entryFilePath, entryMarkdown);
@@ -153,7 +140,6 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
             continue;
         }
     }
-    // Process subcollections
     const subcollections = flatSchema.filter((item) => item.type === 'collection' && item.parentPath === collection.logicalPath);
     const manifestSubcollections = [];
     for (const sub of subcollections) {
@@ -205,7 +191,6 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
                 resolveReferences: false,
             });
             const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, '');
-            // Resolve entry:ID links in body content
             if (aiEntry.body && idIndex) {
                 aiEntry.body = resolveEntryLinksInText(aiEntry.body, idIndex, contentRoot, entryLinkUrl);
             }
@@ -230,17 +215,12 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
     }
     return { entries, files, manifestEntries };
 }
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Strip contentRoot prefix from a logical path */
 function stripContentRoot(logicalPath, contentRoot) {
     if (logicalPath.startsWith(contentRoot + '/')) {
         return logicalPath.slice(contentRoot.length + 1);
     }
     return logicalPath;
 }
-/** Check if a collection is excluded by path */
 function isCollectionExcluded(logicalPath, contentRoot, config) {
     if (!config?.exclude?.collections)
         return false;
@@ -249,11 +229,9 @@ function isCollectionExcluded(logicalPath, contentRoot, config) {
     // Match against clean path or full logical path
     minimatch(cleanPath, pattern) || minimatch(logicalPath, pattern));
 }
-/** Find an entry type config by name within a collection */
 function findEntryType(collection, entryTypeName) {
     return collection.entries?.find((e) => e.name === entryTypeName);
 }
-/** Convert a ContentDocument to an AIEntry */
 function docToAIEntry(doc, slug, entryTypeName, entryTypeConfig, cleanCollectionPath) {
     return {
         slug,
@@ -326,9 +304,8 @@ async function runEntryTransform(entry, absolutePath, contentId, config) {
         console.warn(`AI content: entry transform for "${entry.slug}" (${entry.entryType}) failed:`, getErrorMessage(err));
     }
 }
-/** Check if an entry matches a bundle filter (filters are AND'd) */
+/** Filters are AND'd: an entry must satisfy every filter field that's set. */
 function matchesBundleFilter(entry, filter, contentRoot) {
-    // Collections filter
     if (filter.collections) {
         const matches = filter.collections.some((pattern) => {
             const cleanPattern = stripContentRoot(pattern, contentRoot);
@@ -339,19 +316,16 @@ function matchesBundleFilter(entry, filter, contentRoot) {
         if (!matches)
             return false;
     }
-    // Entry types filter
     if (filter.entryTypes) {
         if (!filter.entryTypes.includes(entry.entryType))
             return false;
     }
-    // Path glob filter
     if (filter.paths) {
         const entryPath = entry.collection ? `${entry.collection}/${entry.slug}` : entry.slug;
         const matches = filter.paths.some((pattern) => minimatch(entryPath, pattern));
         if (!matches)
             return false;
     }
-    // Predicate filter
     if (filter.where) {
         if (!filter.where(entry))
             return false;

package/dist/ai/handler.d.ts

@@ -21,10 +21,6 @@ export interface AIContentHandlerOptions {
     _testFlatSchema?: FlatSchemaItem[];
 }
 /**
- * Create a Next.js GET handler for serving AI content.
- *
- * Returns a function compatible with Next.js route handlers.
- *
  * Caching strategy:
  * - Dev mode: regenerates on every request (content changes without deploys)
  * - Prod: generates once per process lifetime (Lambda instances are recycled on deploy,

package/dist/ai/handler.js

@@ -16,10 +16,6 @@ import { getErrorMessage } from '../utils/error.js';
 import { generateAIContent } from './generate.js';
 import { resolveBranchRoot } from './resolve-branch.js';
 /**
- * Create a Next.js GET handler for serving AI content.
- *
- * Returns a function compatible with Next.js route handlers.
- *
  * Caching strategy:
  * - Dev mode: regenerates on every request (content changes without deploys)
  * - Prod: generates once per process lifetime (Lambda instances are recycled on deploy,
@@ -30,19 +26,15 @@ export function createAIContentHandler(options) {
     const schemaCache = new BranchSchemaCache(config.mode);
     let cachedResult = null;
     const generate = async () => {
-        // In dev mode, always regenerate (content changes without deploys)
         if (config.mode !== 'prod') {
             cachedResult = null;
         }
         if (cachedResult)
             return cachedResult;
-        // Resolve branch root
         const branchRoot = await resolveBranchRoot(config);
         const contentRootName = config.contentRoot || 'content';
-        // Load schema (use test override if provided)
         const flatSchema = _testFlatSchema ??
             (await schemaCache.getSchema(branchRoot, entrySchemaRegistry, contentRootName)).flatSchema;
-        // Create store and generate
         const store = new ContentStore(branchRoot, flatSchema, { contentRootName });
         const result = await generateAIContent({
             store,
@@ -58,9 +50,7 @@ export function createAIContentHandler(options) {
         try {
             const { path: pathSegments } = await ctx.params;
             const result = await generate();
-            // Join path segments to get the file key
             const requestPath = pathSegments.join('/');
-            // Check for manifest
             if (requestPath === 'manifest.json') {
                 return new Response(result.files.get('manifest.json'), {
                     headers: {
@@ -69,7 +59,6 @@ export function createAIContentHandler(options) {
                     },
                 });
             }
-            // Check for generated file
             const content = result.files.get(requestPath);
             if (content) {
                 return new Response(content, {

package/dist/ai/index.d.ts

@@ -7,14 +7,7 @@
 export { defineAIContentConfig } from './types.js';
 export { createAIContentHandler } from './handler.js';
 export { generateAIContent } from './generate.js';
-/**
- * Convert MDX/Markdown body content to plain prose text (for a search index
- * or any other "just the words" consumer). Distinct from the AI-content
- * pipeline above: this strips markup down to human-readable text rather
- * than preparing MDX for model consumption. See the source JSDoc for the
- * full pipeline and why paired custom components keep their inner text
- * while losing their tags.
- */
+/** See `to-plain-text.ts`'s module doc for the pipeline and why it differs from the AI-content path above. */
 export { toPlainText } from './to-plain-text.js';
 export type { AIContentConfig, ExcludeConfig, BundleConfig, BundleFilter, FieldTransformFn, FieldTransforms, ComponentProps, ComponentTransformFn, ComponentTransforms, BodyTransformFn, BodyTransforms, EntryTransformFn, EntryTransforms, EntryTransformContext, AIManifest, AIManifestCollection, AIManifestEntry, AIManifestBundle, AIEntry, AIEntryMeta, } from './types.js';
 export type { AIContentHandlerOptions } from './handler.js';

package/dist/ai/index.js

@@ -7,12 +7,5 @@
 export { defineAIContentConfig } from './types.js';
 export { createAIContentHandler } from './handler.js';
 export { generateAIContent } from './generate.js';
-/**
- * Convert MDX/Markdown body content to plain prose text (for a search index
- * or any other "just the words" consumer). Distinct from the AI-content
- * pipeline above: this strips markup down to human-readable text rather
- * than preparing MDX for model consumption. See the source JSDoc for the
- * full pipeline and why paired custom components keep their inner text
- * while losing their tags.
- */
+/** See `to-plain-text.ts`'s module doc for the pipeline and why it differs from the AI-content path above. */
 export { toPlainText } from './to-plain-text.js';

package/dist/ai/json-to-markdown.js

@@ -15,7 +15,6 @@ import { applyComponentTransforms } from './transform-components.js';
  */
 export function entryToMarkdown(entry, config) {
     const parts = [];
-    // Entry header with YAML-style frontmatter
     parts.push('---');
     if (entry.data.title) {
         parts.push(`title: ${yamlValue(String(entry.data.title))}`);
@@ -30,11 +29,9 @@ export function entryToMarkdown(entry, config) {
     if (entry.data.title)
         skipFields.add('title');
     if (entry.format === 'md' || entry.format === 'mdx') {
-        // For MD/MDX: render non-body fields as metadata, then body verbatim
         parts.push(...renderMarkdownEntry(entry, config, skipFields));
     }
     else {
-        // For data-only formats (JSON/YAML): full schema-driven conversion
         parts.push(...renderJsonEntry(entry, config, skipFields));
     }
     // Markdown appended by an entry transform (e.g. a folded-in sibling artifact). Computed once
@@ -57,21 +54,18 @@ function renderMarkdownEntry(entry, config, skipFields) {
         const value = entry.data[field.name];
         if (value === undefined || value === null)
             continue;
-        // Check for field transform
         const transformed = applyFieldTransform(entry, field, value, config);
         if (transformed !== undefined) {
             parts.push(transformed);
             parts.push('');
             continue;
         }
-        // Simple inline rendering for metadata
         const label = field.label || field.name;
         parts.push(`**${label}:** ${formatInlineValue(field, value)}`);
     }
     if (parts.length > 0) {
         parts.push('');
     }
-    // Append body — pipeline: stripMdxImports → componentTransforms → bodyTransforms
     if (entry.body) {
         let body = entry.format === 'mdx' ? stripMdxImports(entry.body) : entry.body;
         if (config?.componentTransforms && Object.keys(config.componentTransforms).length > 0) {
@@ -108,14 +102,9 @@ function renderJsonEntry(entry, config, skipFields) {
 /**
  * Render a single field to markdown.
  *
- * @param field - Field configuration from schema
- * @param value - The field's value
  * @param depth - Heading depth (2 = ##, 3 = ###, etc.)
- * @param entry - The parent entry (for transform lookups)
- * @param config - AI content config (for field transforms)
  */
 function renderField(field, value, depth, entry, config) {
-    // Check for field transform override
     const transformed = applyFieldTransform(entry, field, value, config);
     if (transformed !== undefined) {
         return transformed;
@@ -127,7 +116,6 @@ function renderField(field, value, depth, entry, config) {
     // Adopters run this output through their own formatting, so emitting the form Prettier
     // already agrees with is what keeps a regenerated bundle diff-free.
     const descriptionLine = 'description' in field && field.description ? `\n\n_${field.description}_` : '';
-    // Handle list fields
     if ('list' in field && field.list && Array.isArray(value)) {
         return renderListField(field, value, depth, label, heading, descriptionLine, entry, config);
     }
@@ -154,7 +142,6 @@ function renderField(field, value, depth, entry, config) {
         case 'block':
             return renderBlockField(field, value, depth, heading, label, descriptionLine, entry, config);
         default:
-            // Custom or unknown field type — render as string
             return `${heading} ${label}${descriptionLine}\n\n${String(value)}`;
     }
 }
@@ -173,7 +160,6 @@ function renderListField(field, values, depth, label, heading, descriptionLine,
     }
     const isComplex = field.type === 'object' || field.type === 'block';
     if (isComplex) {
-        // For complex types, render each item as a subsection
         const items = values
             .map((item, i) => {
             const itemLabel = `${label} ${i + 1}`;
@@ -195,7 +181,6 @@ function renderListField(field, values, depth, label, heading, descriptionLine,
             .filter(Boolean);
         return `${heading} ${label}${descriptionLine}\n\n${items.join('\n\n')}`;
     }
-    // For primitive types, render as markdown list
     const items = values.map((v) => `- ${formatInlineValue(field, v)}`).join('\n');
     return `${heading} ${label}${descriptionLine}\n\n${items}`;
 }
@@ -275,9 +260,6 @@ function escapeTableCell(value) {
         .replace(/\r?\n+/g, ' ')
         .trim();
 }
-/**
- * Render a select field.
- */
 function renderSelectField(field, value, heading, label, descriptionLine) {
     if (Array.isArray(value)) {
         return `${heading} ${label}${descriptionLine}\n\n${value.map((v) => resolveSelectLabel(field, v)).join(', ')}`;
@@ -301,9 +283,6 @@ function resolveSelectLabel(field, value) {
     }
     return strValue;
 }
-/**
- * Render a reference field.
- */
 function renderReferenceField(value, heading, label, descriptionLine) {
     if (Array.isArray(value)) {
         const items = value.map((v) => `- ${formatReference(v)}`).join('\n');
@@ -311,7 +290,6 @@ function renderReferenceField(value, heading, label, descriptionLine) {
     }
     return `${heading} ${label}${descriptionLine}\n\n${formatReference(value)}`;
 }
-/** True for a plain object (not null, not an array) with a string `src`. */
 function isImageValueLike(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -319,18 +297,11 @@ function isImageValueLike(value) {
         typeof value.src === 'string');
 }
 /**
- * Sanitize `alt` for the `[...]` link-text span of `![alt](src)`. `alt` is
- * user free-text, so a crafted value like `x](/a) [pwn](https://evil.com)`
- * could otherwise inject a second, attacker-chosen link/image right next to
- * the intended one. Strips (rather than backslash-escapes) `[`, `]`, and any
- * backslash: alt is a human-readable description, so losing a stray literal
- * bracket from it is a non-issue, and stripping sidesteps a real composability
- * bug backslash-escaping would have - `renderObjectListTable`'s
- * `escapeTableCell` blindly DOUBLES every backslash in a cell's final text
- * (to protect its own `|`-splitting), which would silently unescape a
- * `\[`/`\]` produced here the moment this markdown lands in a table cell
- * (formatCellValue's image case, below). Newlines collapse to spaces for the
- * same "can't break out of the link-text span" reason.
+ * Sanitizes `alt` for the `[...]` span of `![alt](src)`: unescaped, a crafted alt like
+ * `x](/a) [pwn](https://evil.com)` injects a second attacker-chosen link/image. Strips
+ * (rather than escapes) `[`, `]`, backslash, and newlines — losing a stray bracket from
+ * descriptive text is harmless, and escaping would break under `escapeTableCell`'s blind
+ * backslash-doubling once this lands in a table cell (formatCellValue's image case).
  */
 function sanitizeMarkdownAltText(text) {
     return text
@@ -339,13 +310,11 @@ function sanitizeMarkdownAltText(text) {
         .trim();
 }
 /**
- * Percent-encode the handful of characters that would otherwise break a
- * bare, unbracketed markdown link destination `(src)`: a literal `)` closes
- * the destination early, and a space or `(` confuses where it ends. Percent-
- * encoding (rather than wrapping in `<...>` or backslash-escaping) is used
- * deliberately: it introduces no backslash of its own, so - like
- * `sanitizeMarkdownAltText` above - it survives `escapeTableCell`'s blind
- * backslash-doubling unchanged when this lands in a table cell.
+ * Percent-encodes the characters that would break a bare markdown link destination
+ * `(src)`: `)` closes it early, a space or `(` confuses where it ends. Percent-encoding
+ * (not `<...>` wrapping or backslash-escaping) introduces no backslash, so — like
+ * `sanitizeMarkdownAltText` above — it survives `escapeTableCell`'s blind backslash-doubling
+ * in a table cell.
  */
 function encodeMarkdownLinkDestination(src) {
     return src
@@ -355,14 +324,11 @@ function encodeMarkdownLinkDestination(src) {
         .replace(/\)/g, '%29');
 }
 /**
- * Format an `image` field value as markdown image syntax: `![alt](src)`.
- * Uses the value's own `alt` when non-empty, otherwise `altFallback`. Both
- * `alt` and `src` are sanitized for their respective markdown contexts (see
- * `sanitizeMarkdownAltText`/`encodeMarkdownLinkDestination`) since `alt` is
- * user free-text and `src` may contain characters unsafe in a bare link
- * destination. Malformed values (not a `{ src, alt }`-shaped object — e.g. a
- * legacy bare URL string) degrade to a plain string, matching how neighboring
- * field serializers (e.g. renderObjectField, formatReference) handle
+ * Formats an `image` field as `![alt](src)`, using `value.alt` when non-empty else
+ * `altFallback`. Both are sanitized (see `sanitizeMarkdownAltText` /
+ * `encodeMarkdownLinkDestination`) since `alt` is free text and `src` may contain
+ * link-breaking characters. A malformed value (not `{ src, alt }`, e.g. a legacy bare URL
+ * string) degrades to a plain string, matching other field serializers' handling of
  * unexpected shapes.
  */
 function formatImageMarkdown(value, altFallback) {
@@ -373,7 +339,6 @@ function formatImageMarkdown(value, altFallback) {
     return `![${sanitizeMarkdownAltText(alt)}](${encodeMarkdownLinkDestination(value.src)})`;
 }
 /**
- * Format a single reference value.
  * References may be resolved (objects with data) or unresolved (string IDs).
  */
 function formatReference(value) {
@@ -387,9 +352,6 @@ function formatReference(value) {
     // Unresolved — raw ID or string
     return String(value);
 }
-/**
- * Render an object field with nested fields.
- */
 function renderObjectField(field, value, depth, heading, label, descriptionLine, entry, config) {
     if (typeof value !== 'object' || value === null) {
         return `${heading} ${label}${descriptionLine}\n\n${String(value)}`;
@@ -444,10 +406,6 @@ function renderBlockField(field, value, depth, heading, label, descriptionLine,
         return '';
     return `${heading} ${label}${descriptionLine}\n\n${items.join('\n\n')}`;
 }
-/**
- * Apply a field transform if one exists for this entry type + field name.
- * Returns undefined if no transform applies.
- */
 function applyFieldTransform(entry, field, value, config) {
     if (!config?.fieldTransforms)
         return undefined;
@@ -478,7 +436,6 @@ function formatInlineValue(field, value) {
     return String(value);
 }
 /**
- * Escape a value for YAML frontmatter.
  * Wraps in quotes if value contains special characters.
  */
 function yamlValue(value) {

package/dist/ai/resolve-branch.d.ts

@@ -6,12 +6,7 @@ import type { CanopyConfig } from '../config/index.js';
 /**
  * Resolve the branch root directory for reading content.
  *
- * - Static deployment, or any build: current working directory (content is in the checkout)
- * - Server (prod/dev) at run time: load or create the default active branch workspace
- *
- * Branch resolution priority (mirrors createActiveBranchDetector in services.ts):
- * 1. Explicit `defaultActiveBranch` in config
- * 2. In dev mode, auto-detect from git HEAD
- * 3. Fall back to `defaultBaseBranch` or 'main'
+ * The active-branch priority below mirrors `createActiveBranchDetector` in services.ts —
+ * keep the two in sync if either changes.
  */
 export declare function resolveBranchRoot(config: CanopyConfig): Promise<string>;

package/dist/ai/resolve-branch.js

@@ -8,16 +8,10 @@ import { detectHeadBranch } from '../utils/git.js';
 /**
  * Resolve the branch root directory for reading content.
  *
- * - Static deployment, or any build: current working directory (content is in the checkout)
- * - Server (prod/dev) at run time: load or create the default active branch workspace
- *
- * Branch resolution priority (mirrors createActiveBranchDetector in services.ts):
- * 1. Explicit `defaultActiveBranch` in config
- * 2. In dev mode, auto-detect from git HEAD
- * 3. Fall back to `defaultBaseBranch` or 'main'
+ * The active-branch priority below mirrors `createActiveBranchDetector` in services.ts —
+ * keep the two in sync if either changes.
  */
 export async function resolveBranchRoot(config) {
-    // Static deployments and builds read content directly from the checkout — no branch workspace needed
     if (readsFromCheckout(config)) {
         return process.cwd();
     }

package/dist/ai/strip-mdx.d.ts

@@ -1,18 +1,10 @@
 /**
  * Strip MDX-specific syntax from body content for AI consumption.
  *
- * Removes import/export statements (pure code, no content value).
- * Leaves JSX components intact — many carry semantic data in props
- * (e.g., <MatrixRow label="..." matches="1, 3" />) that would be lost
- * if stripped. AI models handle JSX props well for RAG.
- *
- * Handles:
- * - Single-line and multi-line import/export statements (brace tracking)
- * - Fenced code blocks (``` / ~~~) are preserved — imports/exports inside
- *   code blocks are not stripped
- */
-/**
- * Remove import/export statements and collapse resulting blank lines.
- * Preserves content inside fenced code blocks.
+ * Removes import/export statements (pure code, no content value) and collapses the blank
+ * lines left behind. Leaves JSX components intact — many carry semantic data in props (e.g.,
+ * <MatrixRow label="..." matches="1, 3" />) that would be lost if stripped; AI models handle
+ * JSX props well for RAG. Handles both single-line and multi-line (brace-tracked) statements;
+ * fenced code blocks (``` / ~~~) are preserved untouched.
  */
 export declare function stripMdxImports(body: string): string;

package/dist/ai/strip-mdx.js

@@ -1,19 +1,11 @@
 /**
  * Strip MDX-specific syntax from body content for AI consumption.
  *
- * Removes import/export statements (pure code, no content value).
- * Leaves JSX components intact — many carry semantic data in props
- * (e.g., <MatrixRow label="..." matches="1, 3" />) that would be lost
- * if stripped. AI models handle JSX props well for RAG.
- *
- * Handles:
- * - Single-line and multi-line import/export statements (brace tracking)
- * - Fenced code blocks (``` / ~~~) are preserved — imports/exports inside
- *   code blocks are not stripped
- */
-/**
- * Remove import/export statements and collapse resulting blank lines.
- * Preserves content inside fenced code blocks.
+ * Removes import/export statements (pure code, no content value) and collapses the blank
+ * lines left behind. Leaves JSX components intact — many carry semantic data in props (e.g.,
+ * <MatrixRow label="..." matches="1, 3" />) that would be lost if stripped; AI models handle
+ * JSX props well for RAG. Handles both single-line and multi-line (brace-tracked) statements;
+ * fenced code blocks (``` / ~~~) are preserved untouched.
  */
 export function stripMdxImports(body) {
     const lines = body.split('\n');
@@ -23,13 +15,11 @@ export function stripMdxImports(body) {
     let depth = 0;
     for (const line of lines) {
         const trimmed = line.trim();
-        // Track fenced code blocks (``` or ~~~)
         if (trimmed.startsWith('```') || trimmed.startsWith('~~~')) {
             inCodeBlock = !inCodeBlock;
             result.push(line);
             continue;
         }
-        // Inside code blocks: keep everything
         if (inCodeBlock) {
             result.push(line);
             continue;
@@ -48,9 +38,7 @@ export function stripMdxImports(body) {
             }
             continue;
         }
-        // Detect top-level import/export statements
         if (/^import\s/.test(trimmed) || /^export\s/.test(trimmed)) {
-            // Count open/close braces to detect multi-line statements
             depth = 0;
             for (const ch of line) {
                 if (ch === '{' || ch === '(')