canopycms 0.0.63 → 0.0.65

package/dist/authorization/permissions/index.d.ts

@@ -1,6 +1,5 @@
 /**
  * Permissions module exports
  */
-export { PermissionsFileSchema, createDefaultPermissionsFile, type PermissionsFile } from './schema';
-export { loadPermissionsFile, loadPathPermissions, mutatePermissionsFile, ensurePermissionsFile, } from './loader';
-//# sourceMappingURL=index.d.ts.map
+export { PermissionsFileSchema, createDefaultPermissionsFile, type PermissionsFile } from './schema.js';
+export { loadPermissionsFile, loadPathPermissions, mutatePermissionsFile, ensurePermissionsFile, } from './loader.js';

package/dist/authorization/permissions/index.js

@@ -3,4 +3,3 @@
  */
 export { PermissionsFileSchema, createDefaultPermissionsFile } from './schema.js';
 export { loadPermissionsFile, loadPathPermissions, mutatePermissionsFile, ensurePermissionsFile, } from './loader.js';
-//# sourceMappingURL=index.js.map

package/dist/authorization/permissions/loader.d.ts

@@ -5,10 +5,10 @@
  * permissions.json under the cross-host layered lock in
  * authorization/settings-file-store.ts.
  */
-import type { PathPermission } from '../../config';
-import type { PermissionsFile } from './schema';
-import type { OperatingMode } from '../../operating-mode';
-import type { OccWriteResult } from '../../utils/occ-json-write';
+import type { PathPermission } from '../../config/index.js';
+import type { PermissionsFile } from './schema.js';
+import type { OperatingMode } from '../../operating-mode/index.js';
+import type { OccWriteResult } from '../../utils/occ-json-write.js';
 /**
  * Load full permissions file (for version checking)
  * Returns null if file doesn't exist.
@@ -44,4 +44,3 @@ export declare function mutatePermissionsFile(repoRoot: string, mode: OperatingM
  * already present (the mutator returns `null`, so no write happens).
  */
 export declare function ensurePermissionsFile(repoRoot: string, userId: string, mode: OperatingMode): Promise<void>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/authorization/permissions/loader.js

@@ -90,4 +90,3 @@ export async function ensurePermissionsFile(repoRoot, userId, mode) {
         };
     });
 }
-//# sourceMappingURL=loader.js.map

package/dist/authorization/permissions/schema.d.ts

@@ -2,8 +2,8 @@
  * Schema for permissions.json file
  */
 import { z } from 'zod';
-import type { CanopyUserId } from '../../types';
-import type { PermissionPath } from '../types';
+import type { CanopyUserId } from '../../types.js';
+import type { PermissionPath } from '../types.js';
 /**
  * Schema for .canopycms/permissions.json
  *
@@ -131,4 +131,3 @@ export type PermissionsFile = z.infer<typeof PermissionsFileSchema>;
  * (mutateSettingsJsonFile via writeOccJsonFile) manages those.
  */
 export declare function createDefaultPermissionsFile(userId: CanopyUserId): PermissionsFile;
-//# sourceMappingURL=schema.d.ts.map

package/dist/authorization/permissions/schema.js

@@ -57,4 +57,3 @@ export function createDefaultPermissionsFile(userId) {
         pathPermissions: [],
     };
 }
-//# sourceMappingURL=schema.js.map

package/dist/authorization/protected-branch.d.ts

@@ -8,8 +8,8 @@
  * "Protected Base Branch"). This is the single source of truth other modules
  * key off of; do not re-derive the comparison elsewhere.
  */
-import type { CanopyConfig } from '../config';
-import type { BranchStatus } from '../types';
+import type { CanopyConfig } from '../config/index.js';
+import type { BranchStatus } from '../types.js';
 export interface BranchProtection {
     /** True when branchName resolves to the configured base branch. */
     isProtected: boolean;
@@ -111,4 +111,3 @@ export declare function getBranchProtection(config: Pick<CanopyConfig, 'mode' |
  * call {@link getBranchProtection} instead and get no `writeBlocked` at all.
  */
 export declare function getBranchWriteProtection(config: Pick<CanopyConfig, 'mode' | 'defaultBaseBranch'>, branchName: string, recordedBaseBranch: string | undefined, status: BranchStatus | undefined): BranchWriteProtection;
-//# sourceMappingURL=protected-branch.d.ts.map

package/dist/authorization/protected-branch.js

@@ -79,4 +79,3 @@ export function getBranchWriteProtection(config, branchName, recordedBaseBranch,
         submitBlockedIncludingStatus: protection.submitBlocked || status !== 'editing',
     };
 }
-//# sourceMappingURL=protected-branch.js.map

package/dist/authorization/settings-file-store.d.ts

@@ -60,7 +60,7 @@
  *     commit" on STDOUT only, so `git.commit()` resolves rather than
  *     throwing. Re-verify this on any simple-git upgrade.
  */
-import { type OccWriteResult } from '../utils/occ-json-write';
+import { type OccWriteResult } from '../utils/occ-json-write.js';
 /**
  * Thrown when the lock/OCC-retry stack in {@link mutateSettingsJsonFile}
  * exhausts every attempt without landing a write — the file is busy with
@@ -124,4 +124,3 @@ export interface MutateSettingsFileOptions<TFile extends VersionedSettingsFile>
  */
 export declare function mutateSettingsJsonFile<TFile extends VersionedSettingsFile>(opts: MutateSettingsFileOptions<TFile>): Promise<OccWriteResult | null>;
 export {};
-//# sourceMappingURL=settings-file-store.d.ts.map

package/dist/authorization/settings-file-store.js

@@ -153,4 +153,3 @@ export async function mutateSettingsJsonFile(opts) {
         throw err;
     }
 }
-//# sourceMappingURL=settings-file-store.js.map

package/dist/authorization/types.d.ts

@@ -4,7 +4,7 @@
  * This module exports all types related to authorization including
  * branch access, path permissions, and content access results.
  */
-import type { CanopyUserId, CanopyGroupId } from '../types';
+import type { CanopyUserId, CanopyGroupId } from '../types.js';
 export type { CanopyUserId, CanopyGroupId };
 /**
  * A path used in permission rules.
@@ -26,7 +26,7 @@ export interface BranchAccessResult {
  */
 export interface PathPermissionResult {
     allowed: boolean;
-    matchedRule?: import('../config').PathPermission;
+    matchedRule?: import('../config/index.js').PathPermission;
     reason?: string;
 }
 /**
@@ -41,10 +41,10 @@ export interface ContentAccessResult {
  * Dependencies for content access checking
  */
 export interface ContentAccessDeps {
-    checkBranchAccess: (context: import('../types').BranchContext, user: import('../user').CanopyUser) => BranchAccessResult;
-    loadPathPermissions: (branchRoot: string, mode: import('../operating-mode').OperatingMode) => Promise<import('../config').PathPermission[]>;
-    defaultPathAccess: import('../config').DefaultPathAccess;
-    mode: import('../operating-mode').OperatingMode;
+    checkBranchAccess: (context: import('../types.js').BranchContext, user: import('../user.js').CanopyUser) => BranchAccessResult;
+    loadPathPermissions: (branchRoot: string, mode: import('../operating-mode/index.js').OperatingMode) => Promise<import('../config/index.js').PathPermission[]>;
+    defaultPathAccess: import('../config/index.js').DefaultPathAccess;
+    mode: import('../operating-mode/index.js').OperatingMode;
     /**
      * Get the settings branch root path for loading centralized permissions.
      * Used in modes with a separate settings branch.
@@ -52,4 +52,3 @@ export interface ContentAccessDeps {
      */
     getSettingsBranchRoot?: () => Promise<string>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/authorization/types.js

@@ -5,4 +5,3 @@
  * branch access, path permissions, and content access results.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/authorization/validation.d.ts

@@ -4,7 +4,7 @@
  * SECURITY CRITICAL: These functions validate permission paths
  * to prevent path traversal attacks.
  */
-import type { PermissionPath } from './types';
+import type { PermissionPath } from './types.js';
 /**
  * Parse and validate a PermissionPath.
  *
@@ -29,4 +29,3 @@ export declare function parsePermissionPath(path: string): {
     ok: false;
     error: string;
 };
-//# sourceMappingURL=validation.d.ts.map

package/dist/authorization/validation.js

@@ -50,4 +50,3 @@ export function parsePermissionPath(path) {
     }
     return { ok: true, path: normalized };
 }
-//# sourceMappingURL=validation.js.map

package/dist/branch-health.d.ts

@@ -1,5 +1,5 @@
-import type { BranchMetadata } from './types';
-import { type DuplicateContentId } from './content-id-index';
+import type { BranchMetadata } from './types.js';
+import { type DuplicateContentId } from './content-id-index.js';
 /**
  * Admin-facing health classification of every directory under a branches
  * root (`baseRoot`), including ones the {@link BranchRegistry} quarantines
@@ -34,6 +34,26 @@ export interface BranchHealthEntry {
      * repair-content-duplicates admin action.
      */
     duplicateContentIds?: DuplicateContentId[];
+    /**
+     * healthy only, and only when true: this clone has an interrupted rebase on
+     * disk (`.git/rebase-merge` / `.git/rebase-apply`).
+     *
+     * Deliberately an advisory flag on `healthy` rather than its own
+     * `BranchHealthKind`, for the same reason `duplicateContentIds` is: the
+     * branch's metadata is intact and the state is USUALLY transient -- the
+     * worker's sync loop aborts an interrupted rebase at the top of its next
+     * per-branch pass. What this flag buys is visibility in the window BEFORE
+     * that pass runs, where the branch otherwise scanned as unqualified
+     * `healthy` while being skipped as dirty every cycle.
+     *
+     * NOT self-recovering in every case, so a persisting value is the real
+     * signal and needs an operator. Two ways it sticks: the abort itself keeps
+     * failing, or the branch's status moved off `editing` after it wedged --
+     * the rebase loop filters by status BEFORE reaching the recovery step, so a
+     * clone that crashed mid-rebase and was then submitted or archived is never
+     * revisited, and this flag is the only thing that surfaces it.
+     */
+    rebaseInProgress?: boolean;
     /** corrupt-metadata only: message describing why the file failed to load. */
     parseError?: string;
     /** corrupt-metadata only: branch.json's mtime, ISO. Omitted if branch.json itself couldn't be stat'd. */
@@ -88,4 +108,3 @@ export declare function scanBranchHealth(baseRoot: string, opts: {
     baseBranchName: string;
     contentRootName?: string;
 }): Promise<BranchHealthEntry[]>;
-//# sourceMappingURL=branch-health.d.ts.map

package/dist/branch-health.js

@@ -4,6 +4,7 @@ import { BranchMetadataFileManager, BranchMetadataCorruptError } from './branch-
 import { ContentIdIndex } from './content-id-index.js';
 import { sanitizeBranchName } from './paths/branch-name.js';
 import { getErrorMessage, isNodeError, isNotFoundError } from './utils/error.js';
+import { isRebaseInProgress } from './utils/git.js';
 /**
  * The on-disk path of the cross-process provisioning lock marker for a
  * given branch directory, matching `branch-workspace.ts`'s
@@ -139,13 +140,17 @@ export async function scanBranchHealth(baseRoot, opts) {
             continue;
         }
         if (meta) {
-            const duplicateContentIds = await scanDuplicateContentIds(branchRoot, contentRootName);
+            const [duplicateContentIds, rebaseInProgress] = await Promise.all([
+                scanDuplicateContentIds(branchRoot, contentRootName),
+                isRebaseInProgress(branchRoot),
+            ]);
             entries.push({
                 dirName,
                 kind: 'healthy',
                 ...(isBaseBranch ? { isBaseBranch } : {}),
                 branch: meta.branch,
                 ...(duplicateContentIds.length ? { duplicateContentIds } : {}),
+                ...(rebaseInProgress ? { rebaseInProgress } : {}),
             });
             continue;
         }
@@ -171,4 +176,3 @@ export async function scanBranchHealth(baseRoot, opts) {
     }
     return entries;
 }
-//# sourceMappingURL=branch-health.js.map

package/dist/branch-metadata.d.ts

@@ -1,5 +1,5 @@
-import type { BranchContext, BranchMetadata } from './types';
-import { type OperatingMode } from './operating-mode';
+import type { BranchContext, BranchMetadata } from './types.js';
+import { type OperatingMode } from './operating-mode/index.js';
 export interface BranchMetadataFile {
     schemaVersion: number;
     version: number;
@@ -155,4 +155,3 @@ export declare const loadBranchContext: (options: {
     mode: OperatingMode;
     basePathOverride?: string;
 }) => Promise<BranchContext | null>;
-//# sourceMappingURL=branch-metadata.d.ts.map

package/dist/branch-metadata.js

@@ -273,4 +273,3 @@ export const loadBranchContext = async (options) => {
         baseRoot,
     };
 };
-//# sourceMappingURL=branch-metadata.js.map

package/dist/branch-registry.d.ts

@@ -1,4 +1,4 @@
-import type { BranchContext } from './types';
+import type { BranchContext } from './types.js';
 export interface BranchRegistrySnapshot {
     version: number;
     branches: BranchContext[];
@@ -110,4 +110,3 @@ export declare class BranchRegistry {
      */
     protected scanBranchDirectories(): Promise<BranchContext[]>;
 }
-//# sourceMappingURL=branch-registry.d.ts.map

package/dist/branch-registry.js

@@ -268,4 +268,3 @@ export class BranchRegistry {
         return branches;
     }
 }
-//# sourceMappingURL=branch-registry.js.map

package/dist/branch-schema-cache.d.ts

@@ -1,7 +1,7 @@
-import type { RootCollectionConfig } from './config';
-import type { FlatSchemaItem } from './config/types';
-import type { OperatingMode } from './operating-mode';
-import type { EntrySchemaRegistry, SchemaResolutionResult } from './schema/types';
+import type { RootCollectionConfig } from './config/index.js';
+import type { FlatSchemaItem } from './config/types.js';
+import type { OperatingMode } from './operating-mode/index.js';
+import type { EntrySchemaRegistry, SchemaResolutionResult } from './schema/types.js';
 /** resource-generation.ts resource key for the schema cache's marker. */
 export declare const SCHEMA_GENERATION_RESOURCE = "schema";
 /**
@@ -177,4 +177,3 @@ export declare class BranchSchemaCache {
      */
     invalidate(branchRoot: string): Promise<void>;
 }
-//# sourceMappingURL=branch-schema-cache.d.ts.map

package/dist/branch-schema-cache.js

@@ -334,4 +334,3 @@ export class BranchSchemaCache {
         await bumpResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE, { mustSucceed: true });
     }
 }
-//# sourceMappingURL=branch-schema-cache.js.map

package/dist/branch-workspace.d.ts

@@ -1,6 +1,6 @@
-import type { CanopyConfig } from './config';
-import type { BranchAccessControl, BranchContext, CanopyUserId } from './types';
-import type { OperatingMode } from './operating-mode';
+import type { CanopyConfig } from './config/index.js';
+import type { BranchAccessControl, BranchContext, CanopyUserId } from './types.js';
+import type { OperatingMode } from './operating-mode/index.js';
 export interface OpenBranchOptions {
     branchName: string;
     mode: OperatingMode;
@@ -21,7 +21,7 @@ export declare class BranchWorkspaceManager {
     private ensureGitWorkspace;
     openOrCreateBranch(options: OpenBranchOptions): Promise<BranchContext>;
 }
-export { loadBranchContext } from './branch-metadata';
+export { loadBranchContext } from './branch-metadata.js';
 /**
  * Load an existing branch context, or create the workspace if it doesn't exist yet.
  *
@@ -36,4 +36,3 @@ export declare function loadOrCreateBranchContext(options: {
     createdBy: CanopyUserId;
     remoteUrl?: string;
 }): Promise<BranchContext>;
-//# sourceMappingURL=branch-workspace.d.ts.map

package/dist/branch-workspace.js

@@ -158,4 +158,3 @@ export async function loadOrCreateBranchContext(options) {
         remoteUrl: options.remoteUrl,
     });
 }
-//# sourceMappingURL=branch-workspace.js.map

package/dist/build/generate-ai-content.d.ts

@@ -4,9 +4,20 @@
  * Writes generated AI content to disk as static files.
  * Used during `npm run build` or via the CLI.
  */
-import type { CanopyConfig, FlatSchemaItem } from '../config';
-import type { EntrySchemaRegistry } from '../schema/types';
-import type { AIContentConfig } from '../ai/types';
+import type { CanopyConfig, FlatSchemaItem } from '../config/index.js';
+import type { EntrySchemaRegistry } from '../schema/types.js';
+import type { AIContentConfig } from '../ai/types.js';
+/**
+ * Bookkeeping record of what the previous run wrote, so a later run can remove files it no
+ * longer produces.
+ *
+ * Deliberately NOT the `manifest.json` that `generateAIContent` emits: that one is a published
+ * artifact with a defined shape (`AIManifest`) describing entries, collections and bundles for AI
+ * consumers. Overloading it with a build-time file list would change a contract adopters read.
+ *
+ * Dot-prefixed so it sorts out of the way and reads as machine bookkeeping rather than content.
+ */
+export declare const GENERATED_RECORD_FILENAME = ".canopy-generated.json";
 export interface GenerateAIContentFilesOptions {
     config: CanopyConfig;
     entrySchemaRegistry: EntrySchemaRegistry;
@@ -19,10 +30,15 @@ export interface GenerateAIContentFilesOptions {
 /**
  * Generate AI content files and write them to disk.
  *
- * @returns Count of files written and the output directory.
+ * Output written by a previous run that this run no longer produces is removed, so a renamed or
+ * re-modelled entry does not leave a stale file behind advertising a URL the site no longer
+ * serves. Only files recorded by a previous run are eligible for removal — see
+ * `GENERATED_RECORD_FILENAME`.
+ *
+ * @returns Count of files written, count removed, and the output directory.
  */
 export declare function generateAIContentFiles(options: GenerateAIContentFilesOptions): Promise<{
     fileCount: number;
+    removedCount: number;
     outputDir: string;
 }>;
-//# sourceMappingURL=generate-ai-content.d.ts.map

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

@@ -6,16 +6,76 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { isNodeError } from '../utils/error.js';
 import { ContentStore } from '../content-store.js';
 import { BranchSchemaCache } from '../branch-schema-cache.js';
 import { generateAIContent } from '../ai/generate.js';
 import { resolveBranchRoot } from '../ai/resolve-branch.js';
 import { listEntries } from '../content-listing.js';
 import { assertBuildEntriesValid } from '../static/index.js';
+/**
+ * Bookkeeping record of what the previous run wrote, so a later run can remove files it no
+ * longer produces.
+ *
+ * Deliberately NOT the `manifest.json` that `generateAIContent` emits: that one is a published
+ * artifact with a defined shape (`AIManifest`) describing entries, collections and bundles for AI
+ * consumers. Overloading it with a build-time file list would change a contract adopters read.
+ *
+ * Dot-prefixed so it sorts out of the way and reads as machine bookkeeping rather than content.
+ */
+export const GENERATED_RECORD_FILENAME = '.canopy-generated.json';
+/** Read the previous run's record. A missing, unreadable or malformed record means "know nothing". */
+async function readGeneratedRecord(outputDir) {
+    try {
+        const raw = await fs.readFile(path.join(outputDir, GENERATED_RECORD_FILENAME), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || !('files' in parsed))
+            return [];
+        const { files } = parsed;
+        if (!Array.isArray(files))
+            return [];
+        return files.filter((entry) => typeof entry === 'string');
+    }
+    catch {
+        // Absent (first run), unreadable, or hand-edited into nonsense. Pruning is an optimisation;
+        // never fail a build over the bookkeeping file. The cost of not knowing is a stale file, which
+        // is exactly the pre-existing behaviour.
+        return [];
+    }
+}
+async function writeGeneratedRecord(outputDir, files) {
+    const record = { files: [...files].sort() };
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.writeFile(path.join(outputDir, GENERATED_RECORD_FILENAME), `${JSON.stringify(record, null, 2)}\n`, 'utf-8');
+}
+/**
+ * Remove directories left empty by a prune, walking up from `startDir` towards `stopAt`.
+ *
+ * `stopAt` (the output directory) is never removed: the adopter created it, or their framework
+ * expects it to exist. Any non-empty directory ends the walk.
+ */
+async function removeEmptyDirsUpward(startDir, stopAt) {
+    let current = startDir;
+    while (current.startsWith(stopAt) && current !== stopAt) {
+        try {
+            await fs.rmdir(current);
+        }
+        catch {
+            // ENOTEMPTY (something else lives here) or ENOENT (already gone) — either way, stop.
+            return;
+        }
+        current = path.dirname(current);
+    }
+}
 /**
  * Generate AI content files and write them to disk.
  *
- * @returns Count of files written and the output directory.
+ * Output written by a previous run that this run no longer produces is removed, so a renamed or
+ * re-modelled entry does not leave a stale file behind advertising a URL the site no longer
+ * serves. Only files recorded by a previous run are eligible for removal — see
+ * `GENERATED_RECORD_FILENAME`.
+ *
+ * @returns Count of files written, count removed, and the output directory.
  */
 export async function generateAIContentFiles(options) {
     const { config, entrySchemaRegistry, outputDir, aiConfig, _testFlatSchema } = options;
@@ -48,17 +108,49 @@ export async function generateAIContentFiles(options) {
     });
     // Write files to disk
     const absoluteOutputDir = path.resolve(outputDir) + path.sep;
-    let fileCount = 0;
-    for (const [filePath, content] of result.files) {
+    /** Resolve an output-relative path, refusing anything that escapes the output directory. */
+    const resolveOutputPath = (filePath) => {
         const absolutePath = path.resolve(path.join(absoluteOutputDir, filePath));
-        // Security: prevent path traversal in output (e.g., malicious bundle names)
+        // Security: prevent path traversal in output (e.g., malicious bundle names). Applied to
+        // RECORDED paths too, not just freshly generated ones — the record is a file on disk that a
+        // person or another tool can edit, and it drives deletions.
         if (!absolutePath.startsWith(absoluteOutputDir)) {
             throw new Error(`Path traversal detected in AI content output: ${filePath}`);
         }
+        return absolutePath;
+    };
+    const previousFiles = await readGeneratedRecord(absoluteOutputDir);
+    const currentFiles = [...result.files.keys()];
+    // Record the UNION before writing anything. If the run dies part-way through, the record on disk
+    // is a superset of what exists, so the next run still knows to clean up whatever did land. The
+    // opposite order would strand partially-written files outside any record, permanently.
+    await writeGeneratedRecord(absoluteOutputDir, [...new Set([...previousFiles, ...currentFiles])]);
+    let fileCount = 0;
+    for (const [filePath, content] of result.files) {
+        const absolutePath = resolveOutputPath(filePath);
         await fs.mkdir(path.dirname(absolutePath), { recursive: true });
         await fs.writeFile(absolutePath, content, 'utf-8');
         fileCount++;
     }
-    return { fileCount, outputDir: absoluteOutputDir };
+    // Prune what this run no longer produces. Only files a PREVIOUS RUN OF THIS TOOL recorded are
+    // eligible: the output directory belongs to the adopter, and a package must not delete things it
+    // cannot prove it created. That is also why this is not a `rm -rf` of the directory.
+    const currentSet = new Set(currentFiles);
+    const stale = previousFiles.filter((filePath) => !currentSet.has(filePath));
+    let removedCount = 0;
+    for (const filePath of stale) {
+        const absolutePath = resolveOutputPath(filePath);
+        try {
+            await fs.unlink(absolutePath);
+            removedCount++;
+        }
+        catch (err) {
+            // Already gone (hand-deleted, or a previous partial prune) is success, not failure.
+            if (!isNodeError(err) || err.code !== 'ENOENT')
+                throw err;
+        }
+        await removeEmptyDirsUpward(path.dirname(absolutePath), absoluteOutputDir);
+    }
+    await writeGeneratedRecord(absoluteOutputDir, currentFiles);
+    return { fileCount, removedCount, outputDir: absoluteOutputDir };
 }
-//# sourceMappingURL=generate-ai-content.js.map

package/dist/build/index.d.ts

@@ -3,6 +3,5 @@
  *
  * Provides static build utilities for pre-generating content.
  */
-export { generateAIContentFiles } from './generate-ai-content';
-export type { GenerateAIContentFilesOptions } from './generate-ai-content';
-//# sourceMappingURL=index.d.ts.map
+export { generateAIContentFiles } from './generate-ai-content.js';
+export type { GenerateAIContentFilesOptions } from './generate-ai-content.js';

package/dist/build/index.js

@@ -4,4 +4,3 @@
  * Provides static build utilities for pre-generating content.
  */
 export { generateAIContentFiles } from './generate-ai-content.js';
-//# sourceMappingURL=index.js.map

package/dist/build-canopy.d.ts

@@ -1,6 +1,6 @@
-import type { CanopyConfig } from './config';
-import type { EntrySchemaRegistry } from './schema/types';
-import { type CanopyBuildContext } from './context';
+import type { CanopyConfig } from './config/index.js';
+import type { EntrySchemaRegistry } from './schema/types.js';
+import { type CanopyBuildContext } from './context.js';
 export interface CreateBuildCanopyOptions {
     /**
      * Entry schema registry for resolving `.collection.json` references.
@@ -38,12 +38,11 @@ export interface CreateBuildCanopyOptions {
  * ```ts
  * // scripts/build-search-index.ts
  * import { createBuildCanopy } from 'canopycms/server'
- * import config from '../canopycms.config'
- * import { entrySchemaRegistry } from '../src/schemas'
+ * import config from '../canopycms.config.js'
+ * import { entrySchemaRegistry } from '../src/schemas.js'
  *
  * const canopy = await createBuildCanopy(config.server, { entrySchemaRegistry })
  * const entries = await canopy.listEntries()
  * ```
  */
 export declare function createBuildCanopy(config: CanopyConfig, options?: CreateBuildCanopyOptions): Promise<CanopyBuildContext>;
-//# sourceMappingURL=build-canopy.d.ts.map

package/dist/build-canopy.js

@@ -48,4 +48,3 @@ export async function createBuildCanopy(config, options = {}) {
     }).getContext();
     return { buildContentTree, listEntries, read, readByUrlPath, services: contextServices };
 }
-//# sourceMappingURL=build-canopy.js.map

package/dist/build-mode.d.ts

@@ -1,4 +1,4 @@
-import type { AuthenticatedUser } from './user';
+import type { AuthenticatedUser } from './user.js';
 /**
  * Check if this deployment is static (no request context, no auth).
  * When true: STATIC_DEPLOY_USER is used, permissions are skipped.
@@ -19,4 +19,3 @@ export declare const isBuildMode: () => boolean;
  * Has Admin privileges — all content is readable, permissions are skipped.
  */
 export declare const STATIC_DEPLOY_USER: AuthenticatedUser;
-//# sourceMappingURL=build-mode.d.ts.map

package/dist/build-mode.js

@@ -32,4 +32,3 @@ export const STATIC_DEPLOY_USER = Object.freeze({
     email: 'static-deploy@canopycms',
     name: 'Static Deploy',
 });
-//# sourceMappingURL=build-mode.js.map

package/dist/cli/cli.d.ts

@@ -9,7 +9,7 @@
  * and are dynamically imported to keep startup fast.
  */
 import minimist from 'minimist';
-import type { AuthProvider } from './init';
+import type { AuthProvider } from './init.js';
 /** Parse raw CLI args into structured flags and positional command. Exported for testing. */
 export declare function parseArgs(rawArgs: string[]): {
     argv: minimist.ParsedArgs;
@@ -37,7 +37,23 @@ export declare function parseAuthFlag(value: string | boolean | undefined): Auth
 export declare function parseDualBuildFlag(value: unknown): boolean | undefined;
 declare const SYNC_SUBCOMMANDS: readonly ["push", "pull", "both", "abort"];
 type SyncSubcommand = (typeof SYNC_SUBCOMMANDS)[number];
+/** The auth modes `worker run-once` knows how to build a plugin for. */
+export declare const KNOWN_AUTH_MODES: readonly ["clerk", "dev"];
+export type KnownAuthMode = (typeof KNOWN_AUTH_MODES)[number];
+/**
+ * Whether `CANOPY_AUTH_MODE` names a provider the CLI can actually construct.
+ *
+ * Pure and exported so it is testable: the dispatch below branches on 'clerk'
+ * and 'dev' only, and the catch around plugin loading fires solely on an
+ * IMPORT failure -- so before this guard existed, any other value (a typo,
+ * wrong casing like 'Clerk', a stale value from another system) selected no
+ * plugin, skipped the auth refresh entirely, and let the command run to "Done"
+ * with exit code 0. A cron'd `CANOPY_AUTH_MODE=clerk canopycms worker
+ * run-once` that became `Clerk` refreshed nothing for as long as the typo
+ * survived, while the cache aged and a user removed from the Clerk org kept
+ * editor access.
+ */
+export declare function isKnownAuthMode(value: string): value is KnownAuthMode;
 /** Resolve sync subcommand from positional arg. Returns null if missing or invalid. Exported for testing. */
 export declare function resolveSyncSubcommand(sub: string | undefined): SyncSubcommand | null;
 export {};
-//# sourceMappingURL=cli.d.ts.map