canopycms 0.0.68-int.98 → 0.1.0

package/dist/api/entries.d.ts

@@ -5,7 +5,7 @@ import type { LogicalPath, PhysicalPath, Slug, ContentId } from '../paths/types.
 /**
  * Summary of an entry type for client display.
  * Simplified from EntryTypeConfig - doesn't include full field definitions.
- * @internal No importer; deletion candidate in knip-no-importer-deletion-candidates.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#725.
  */
 export interface EntryTypeSummary {
     name: string;
@@ -28,7 +28,7 @@ export interface CollectionItem {
     exists?: boolean;
     canEdit?: boolean;
 }
-/** @internal No importer; deletion candidate in knip-no-importer-deletion-candidates.md. */
+/** @internal No importer; deletion candidate in safeinsights/canopycms#725. */
 export interface ListEntriesParams {
     branch: string;
     collection?: LogicalPath;
@@ -37,8 +37,15 @@ export interface ListEntriesParams {
     q?: string;
     recursive?: boolean;
 }
+/** Whether the caller may add an entry to a listed collection. */
+export interface CollectionAccess {
+    logicalPath: LogicalPath;
+    canAddEntry: boolean;
+}
 export interface ListEntriesResponse {
     entries: CollectionItem[];
+    /** One per listed collection, on every page. */
+    collectionAccess?: CollectionAccess[];
     pagination: {
         cursor?: string;
         hasMore: boolean;
@@ -78,10 +85,32 @@ export declare const listEntries: import("./route-builder.js").RouteDefinition<z
     cursor?: string | undefined;
     limit?: number | undefined;
 }>, undefined, EntriesResponse>;
+/** A readable entry that references the entry a delete targets. */
+interface ReferencingEntrySummary {
+    entryPath: LogicalPath;
+    contentId: ContentId;
+    title: string;
+    /** Reference fields holding the target's id, e.g. `author` or `blocks[0].cta.target`. */
+    fields: string[];
+    /** Where its strings, the md/mdx body included, link to the target with `entry:<id>`. */
+    links: string[];
+}
+/** Who references an entry, as far as the requesting user may know. */
+export interface EntryReferencedBy {
+    entries: ReferencingEntrySummary[];
+    /** Referencing entries the user may not read: counted, never described. */
+    hiddenCount: number;
+}
 /** Response type for deleting an entry */
 export type DeleteEntryResponse = ApiResponse<{
     deleted: boolean;
     contentId?: string;
+    /**
+     * Set, with status 409 and `deleted: false`, when other entries reference this one and the
+     * request did not pass `confirmReferenced`. Its presence is what tells this 409 apart from
+     * an edit conflict. Re-sending with `confirmReferenced=true` deletes anyway.
+     */
+    referencedBy?: EntryReferencedBy;
     /**
      * Set when the entry deleted successfully but the collection's order array couldn't be updated
      * afterward (C6: best-effort hygiene after the delete, so its failure must not present as a
@@ -94,6 +123,8 @@ export type DeleteEntryResponse = ApiResponse<{
 export declare const deleteEntry: import("./route-builder.js").RouteDefinition<z.ZodObject<{
     branch: z.ZodType<import("../paths/index.js").BranchName, z.ZodTypeDef, import("../paths/index.js").BranchName>;
     entryPath: z.ZodType<LogicalPath, z.ZodTypeDef, LogicalPath>;
+    /** Delete even though other entries reference this one (query param). */
+    confirmReferenced: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>;
 }, "strip", z.ZodTypeAny, {
     branch: string & {
         readonly __brand: "BranchName";
@@ -101,6 +132,7 @@ export declare const deleteEntry: import("./route-builder.js").RouteDefinition<z
     entryPath: string & {
         readonly __brand: "LogicalPath";
     };
+    confirmReferenced?: boolean | undefined;
 }, {
     branch: string & {
         readonly __brand: "BranchName";
@@ -108,6 +140,7 @@ export declare const deleteEntry: import("./route-builder.js").RouteDefinition<z
     entryPath: string & {
         readonly __brand: "LogicalPath";
     };
+    confirmReferenced?: boolean | "true" | "false" | undefined;
 }>, undefined, DeleteEntryResponse>;
 /**
  * Exported routes for router registration
@@ -142,6 +175,8 @@ export declare const ENTRY_ROUTES: {
     readonly delete: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         branch: z.ZodType<import("../paths/index.js").BranchName, z.ZodTypeDef, import("../paths/index.js").BranchName>;
         entryPath: z.ZodType<LogicalPath, z.ZodTypeDef, LogicalPath>;
+        /** Delete even though other entries reference this one (query param). */
+        confirmReferenced: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>;
     }, "strip", z.ZodTypeAny, {
         branch: string & {
             readonly __brand: "BranchName";
@@ -149,6 +184,7 @@ export declare const ENTRY_ROUTES: {
         entryPath: string & {
             readonly __brand: "LogicalPath";
         };
+        confirmReferenced?: boolean | undefined;
     }, {
         branch: string & {
             readonly __brand: "BranchName";
@@ -156,5 +192,7 @@ export declare const ENTRY_ROUTES: {
         entryPath: string & {
             readonly __brand: "LogicalPath";
         };
+        confirmReferenced?: boolean | "true" | "false" | undefined;
     }>, undefined, DeleteEntryResponse>;
 };
+export {};

package/dist/api/entries.js

@@ -7,9 +7,10 @@ import { getErrorMessage, isNotFoundError, sanitizeErrorMessage } from '../utils
 import { createDebugLogger } from '../utils/debug.js';
 import { resolveEntryTitle } from '../utils/title-field.js';
 import { branchNameSchema, logicalPathSchema, queryBooleanSchema } from './validators.js';
-import { MAX_ENTRIES_PER_PAGE, DEFAULT_ENTRIES_LIMIT } from './entries-constants.js';
+import { MAX_ENTRIES_PER_PAGE, DEFAULT_ENTRIES_LIMIT, ENTRY_CHANGED_MESSAGE, } from './entries-constants.js';
 import { SchemaOps, SchemaStoreBusyError } from '../schema/schema-store.js';
-import { listCollectionEntries as listCollectionEntriesShared, sortByOrder, } from '../content-listing.js';
+import { listCollectionEntries as listCollectionEntriesShared, listEntries as listContentEntries, sortByOrder, } from '../content-listing.js';
+import { findReferencingEntries } from '../validation/deletion-checker.js';
 // Re-export pagination constants from the dependency-free module so they remain
 // part of the entries API surface without pulling server deps into client bundles.
 const log = createDebugLogger({ prefix: 'EntriesAPI' });
@@ -122,11 +123,20 @@ const listEntriesHandler = async (gc, ctx, req, params) => {
     const search = params.q?.toLowerCase();
     const recursive = params.recursive ?? false;
     let entries = [];
+    let collectionAccess = [];
     try {
         // Build the access checker once per request: permissions (and, in modes with a
         // separate settings branch, the settings workspace) are loaded a single time and
         // reused for every entry, instead of re-loading per entry inside the loop.
         const checkAccess = await ctx.services.createContentAccessChecker(branchContext, root, req.user);
+        // A new entry's slug is unknown, so the probe is one no slug can be: a rule for the whole
+        // collection decides, never one for a particular entry. The create itself is checked again.
+        collectionAccess = targetCollections
+            .filter((item) => item.type === 'collection')
+            .map((item) => ({
+            logicalPath: item.logicalPath,
+            canAddEntry: checkAccess(`${item.logicalPath}/*`, 'edit').allowed,
+        }));
         if (recursive && targetPath) {
             // Recursive mode: list entries from target collection and all its children
             const items = await listCollectionEntriesRecursive(root, targetPath, flatCollections);
@@ -164,6 +174,7 @@ const listEntriesHandler = async (gc, ctx, req, params) => {
         status: 200,
         data: {
             entries: paged,
+            collectionAccess,
             pagination: {
                 cursor: nextCursor,
                 hasMore: Boolean(nextCursor),
@@ -198,9 +209,66 @@ export const listEntries = defineEndpoint({
 const deleteEntryParamsSchema = z.object({
     branch: branchNameSchema,
     entryPath: logicalPathSchema, // Format: collectionPath/slug
+    /** Delete even though other entries reference this one (query param). */
+    confirmReferenced: queryBooleanSchema.optional(),
 });
+/** Every entry of an `unavailable` entry type on the branch. */
+const listUnavailableEntries = async (branchRoot, flatSchema) => {
+    const collections = flatSchema.filter((item) => item.type === 'collection' && item.entries?.some((e) => e.unavailable));
+    const listed = await Promise.all(collections.map((collection) => listCollectionEntriesShared(branchRoot, collection)));
+    return listed.flat().filter((item) => {
+        const collection = collections.find((c) => c.logicalPath === item.collectionPath);
+        return (collection?.type === 'collection' &&
+            collection.entries?.some((e) => e.name === item.entryType && e.unavailable));
+    });
+};
 /**
- * Delete an entry and update the collection's order array.
+ * Every entry on the branch that references `contentId`, split by whether `user` may read it.
+ * A full raw scan of the branch's content: references are stored only on the referencing
+ * side, so there is no index to ask. Null when nothing references it.
+ */
+const findReferencedBy = async (branchContext, ctx, req, contentId) => {
+    const { branchRoot, flatSchema } = branchContext;
+    const listed = await listContentEntries(branchRoot, flatSchema, ctx.services.config.contentRoot || 'content');
+    // listEntries leaves out entries of an unavailable type; scanned raw, they still count.
+    const unavailable = await listUnavailableEntries(branchRoot, flatSchema);
+    const entries = [
+        ...listed,
+        ...unavailable.map((item) => ({
+            entryPath: item.logicalPath,
+            entryId: item.contentId,
+            slug: item.slug,
+            collectionPath: item.collectionPath,
+            entryType: item.entryType,
+            data: item.data,
+            schemaUnavailable: true,
+        })),
+    ];
+    const referencing = findReferencingEntries(entries, contentId);
+    if (referencing.length === 0)
+        return null;
+    const canAccess = await ctx.services.createContentAccessChecker(branchContext, branchRoot, req.user);
+    const visible = [];
+    for (const { entry, fields, links } of referencing) {
+        if (!canAccess(entry.entryPath, 'read').allowed)
+            continue;
+        const collection = flatSchema.find((item) => item.type === 'collection' && item.logicalPath === entry.collectionPath);
+        const entryType = collection?.type === 'collection'
+            ? collection.entries?.find((e) => e.name === entry.entryType)
+            : undefined;
+        visible.push({
+            entryPath: entry.entryPath,
+            contentId: entry.entryId,
+            title: extractTitle(entry.data, entryType, entry.slug),
+            fields,
+            links,
+        });
+    }
+    return { entries: visible, hiddenCount: referencing.length - visible.length };
+};
+/**
+ * Delete an entry and update the collection's order array. An entry other entries reference
+ * is deleted only with `confirmReferenced`; without it the response is a 409 naming them.
  * DELETE /:branch/entries/...entryPath
  * Note: Uses catch-all to support paths with slashes (e.g., content/posts/hello-world)
  */
@@ -278,10 +346,40 @@ const deleteEntryHandler = async (gc, ctx, req, params) => {
             error: 'Edit permission required to delete entry',
         };
     }
+    // Before the reference scan, whose 409 would otherwise answer first; mapped to a 503.
+    await contentStore.assertEntryAvailable(collectionLogicalPath, entrySlug);
     let orderCleanupWarning;
     try {
         // Get the entry's content ID before deleting (for order update)
         const contentId = await contentStore.getIdForEntry(collectionLogicalPath, entrySlug);
+        // Advisory: a reference saved between this scan and the delete below still dangles.
+        if (contentId && !params.confirmReferenced) {
+            let referencedBy;
+            try {
+                referencedBy = await findReferencedBy(branchContext, ctx, req, contentId);
+            }
+            catch (err) {
+                // Outside the catch below, which would report a file vanishing mid-scan as this entry.
+                log.warn('delete-entry', 'Reference scan failed', {
+                    entryPath,
+                    error: getErrorMessage(err),
+                });
+                return {
+                    ok: false,
+                    status: 500,
+                    error: 'Could not check which entries reference this one; try again',
+                };
+            }
+            if (referencedBy) {
+                const count = referencedBy.entries.length + referencedBy.hiddenCount;
+                return {
+                    ok: false,
+                    status: 409,
+                    error: `Entry is referenced by ${count} other ${count === 1 ? 'entry' : 'entries'}`,
+                    data: { deleted: false, contentId, referencedBy },
+                };
+            }
+        }
         await contentStore.delete(collectionLogicalPath, entrySlug);
         // Construct exactly like api/schema.ts's getSchemaOps (content root, registry, services,
         // branch root) so updateOrder's write bumps the schema generation marker — without it, every
@@ -328,9 +426,7 @@ const deleteEntryHandler = async (gc, ctx, req, params) => {
             return {
                 ok: false,
                 status: 409,
-                error: err instanceof BranchSyncingError
-                    ? err.message
-                    : 'Content conflict: entry was modified by another editor',
+                error: err instanceof BranchSyncingError ? err.message : ENTRY_CHANGED_MESSAGE,
             };
         }
         return {

package/dist/api/github-sync.d.ts

@@ -8,11 +8,21 @@ export interface GitHubSyncResult {
     prUrl?: string;
     prNumber?: number;
     syncStatus?: SyncStatus;
+    /** Client-safe reason a direct GitHub call failed, recorded as the branch's syncFailureReason. */
+    syncFailureReason?: string;
+    /** GitHub refused the PR because the pushed branch has no commits its base lacks. */
+    nothingToSubmit?: boolean;
+    /** The direct path, whose submit pushes to GitHub itself: the branch is there whatever the PR call did. */
+    pushedToGitHub?: boolean;
 }
 /** What the PR body records about a submit. */
 export interface SubmissionRecord {
     submitter?: SubmissionEditor;
+    /** Every recorded editor of the branch; the PR body lists those other than the submitter. */
+    editors?: readonly SubmissionEditor[];
     changedPaths: readonly string[];
+    /** The submit's `submittedAt`, carried to the worker so its failure handling targets this submit. */
+    submittedAt?: string;
 }
 /**
  * Uses githubService directly if available, otherwise queues a task for the worker.
@@ -26,3 +36,12 @@ export declare function syncSubmitPr(ctx: ApiContext, context: BranchContext, su
  * available, otherwise queues a task.
  */
 export declare function syncConvertToDraft(ctx: ApiContext, context: BranchContext): Promise<void>;
+/**
+ * Used by delete, after the local delete succeeded. Deletes the branch on GitHub when the CMS
+ * put it there: a recorded PR number or `pushedToGitHubAt` stamp is the proof (a submit whose PR
+ * GitHub refused pushed the branch but has no PR number). Without either, a same-named GitHub
+ * branch is someone else's (the create-time collision check is best-effort) and is never touched.
+ *
+ * Returns a client-facing warning when the delete could not be done or queued; never throws.
+ */
+export declare function syncDeleteRemoteBranch(ctx: ApiContext, context: BranchContext): Promise<string | undefined>;

package/dist/api/github-sync.js

@@ -1,9 +1,11 @@
 import { enqueueTask } from '../task-queue/cms-task-queue.js';
 import { getTaskQueueDir } from '../task-queue/task-queue-config.js';
 import { clientOperatingStrategy } from '../operating-mode/index.js';
-import { getErrorMessage } from '../utils/error.js';
+import { getErrorMessage, sanitizeErrorMessage } from '../utils/error.js';
 import { sanitizeBranchName } from '../paths/branch-name.js';
 import { buildPrSection, mergePrSection } from '../submission-attribution.js';
+import { isNoCommitsBetweenError, isRefAlreadyGoneError } from '../github-service.js';
+import { baseBranchOf } from '../utils/base-branch.js';
 /**
  * Uses githubService directly if available, otherwise queues a task for the worker.
  *
@@ -17,10 +19,11 @@ export async function syncSubmitPr(ctx, context, submission) {
     const prSection = buildPrSection({
         description: context.branch.description,
         submitter: submission.submitter,
+        editors: submission.editors,
         changedPaths: submission.changedPaths,
     });
     // Target the fork point recorded at branch creation when available.
-    const baseBranch = context.branch.baseBranch ?? ctx.services.config.defaultBaseBranch ?? 'main';
+    const baseBranch = context.branch.baseBranch ?? baseBranchOf(ctx.services.config);
     if (!clientOperatingStrategy(mode).supportsPullRequests()) {
         return {};
     }
@@ -64,6 +67,7 @@ export async function syncSubmitPr(ctx, context, submission) {
                     prUrl: context.branch.pullRequestUrl,
                     prNumber: context.branch.pullRequestNumber,
                     syncStatus: 'synced',
+                    pushedToGitHub: true,
                 };
             }
             else {
@@ -91,16 +95,21 @@ export async function syncSubmitPr(ctx, context, submission) {
                     prUrl: result.url,
                     prNumber: result.number,
                     syncStatus: 'synced',
+                    pushedToGitHub: true,
                 };
             }
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
+            const message = getErrorMessage(err);
             console.error(`CanopyCMS: Failed to create/update PR for ${context.branch.name}:`, message);
+            if (isNoCommitsBetweenError(err))
+                return { nothingToSubmit: true, pushedToGitHub: true };
             return {
                 prUrl: context.branch.pullRequestUrl,
                 prNumber: context.branch.pullRequestNumber,
                 syncStatus: 'sync-failed',
+                syncFailureReason: sanitizeErrorMessage(message),
+                pushedToGitHub: true,
             };
         }
     }
@@ -123,6 +132,7 @@ export async function syncSubmitPr(ctx, context, submission) {
             // A content submit is an explicit "ready for review" action: convert a
             // pre-existing draft PR to ready.
             markReadyIfDraft: true,
+            submittedAt: submission.submittedAt,
         },
     });
 }
@@ -156,6 +166,43 @@ export async function syncConvertToDraft(ctx, context) {
         });
     }
 }
+/**
+ * Used by delete, after the local delete succeeded. Deletes the branch on GitHub when the CMS
+ * put it there: a recorded PR number or `pushedToGitHubAt` stamp is the proof (a submit whose PR
+ * GitHub refused pushed the branch but has no PR number). Without either, a same-named GitHub
+ * branch is someone else's (the create-time collision check is best-effort) and is never touched.
+ *
+ * Returns a client-facing warning when the delete could not be done or queued; never throws.
+ */
+export async function syncDeleteRemoteBranch(ctx, context) {
+    const { pullRequestNumber, pushedToGitHubAt } = context.branch;
+    if (!pullRequestNumber && !pushedToGitHubAt)
+        return undefined;
+    const { githubService } = ctx.services;
+    const branch = context.branch.name;
+    if (githubService) {
+        try {
+            await githubService.deleteBranch(branch);
+        }
+        catch (err) {
+            if (isRefAlreadyGoneError(err))
+                return undefined;
+            console.error(`CanopyCMS: Failed to delete GitHub branch for ${branch}:`, getErrorMessage(err));
+            return 'The branch could not be deleted on GitHub; delete it there by hand';
+        }
+        return undefined;
+    }
+    const mode = ctx.services.config.mode;
+    if (!clientOperatingStrategy(mode).supportsPullRequests())
+        return undefined;
+    const result = await enqueueGitHubTask(ctx, context, {
+        action: 'delete-remote-branch',
+        payload: { branch, pullRequestNumber, pushedToGitHubAt },
+    });
+    return result.syncStatus === 'sync-failed'
+        ? 'Deleting the branch on GitHub could not be queued; delete it there by hand'
+        : undefined;
+}
 async function enqueueGitHubTask(ctx, context, task) {
     const taskDir = getTaskQueueDir(ctx.services.config);
     try {

package/dist/api/groups.d.ts

@@ -59,29 +59,29 @@ export declare const GROUP_ROUTES: {
             members: z.ZodArray<z.ZodString, "many">;
         }, "strip", z.ZodTypeAny, {
             name: string;
-            members: string[];
             id: string;
+            members: string[];
             description?: string | undefined;
         }, {
             name: string;
-            members: string[];
             id: string;
+            members: string[];
             description?: string | undefined;
         }>, "many">;
         expectedContentVersion: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         groups: {
             name: string;
-            members: string[];
             id: string;
+            members: string[];
             description?: string | undefined;
         }[];
         expectedContentVersion?: number | undefined;
     }, {
         groups: {
             name: string;
-            members: string[];
             id: string;
+            members: string[];
             description?: string | undefined;
         }[];
         expectedContentVersion?: number | undefined;

package/dist/api/groups.js

@@ -180,6 +180,7 @@ const updateInternalGroupsHandler = async (_gc, ctx, req, body) => {
             branchRoot: context.branchRoot,
             fileName: 'groups.json',
             message: 'Update internal groups',
+            actor: req.user,
             mode,
         });
         if (!commitResult.pushed) {
@@ -193,7 +194,7 @@ const updateInternalGroupsHandler = async (_gc, ctx, req, body) => {
     }
     catch (error) {
         if (error instanceof SettingsVersionConflictError) {
-            return { ok: false, status: 409, error: error.message };
+            return { ok: false, status: 409, error: error.message, code: 'SETTINGS_CHANGED' };
         }
         if (error instanceof SettingsFileConflictError) {
             return { ok: false, status: 409, error: 'Settings are busy, please try again.' };

package/dist/api/guards.js

@@ -3,6 +3,8 @@
  * error response (404/403/500) to short-circuit, or produce a guard context (e.g. branch context
  * with schema) for the handler. See api/AGENTS.md for the full guard reference.
  */
+import { BRANCH_METADATA_CORRUPT_MESSAGE, BranchMetadataCorruptError, } from '../branch-metadata-error.js';
+import { canopyLogError } from '../utils/logger.js';
 import { isAdmin, isReviewer, isPrivileged } from '../authorization/helpers.js';
 import { getBranchProtection, getBranchWriteProtection } from '../authorization/protected-branch.js';
 function extractBranchName(params) {
@@ -92,6 +94,10 @@ const runBranchAccessWithSchemaGuard = async (ctx, req, params, accumulated) =>
     }
     return { ok: true, context: { branchContext: context } };
 };
+/**
+ * A success records the user as an editor the next submit credits (route-builder.ts), so give
+ * this guard only to endpoints that change the branch's working tree.
+ */
 const runWritableBranchGuard = async (ctx, _req, params, accumulated) => {
     const branch = extractBranchName(params);
     if (typeof branch !== 'string')
@@ -117,8 +123,8 @@ const runWritableBranchGuard = async (ctx, _req, params, accumulated) => {
         const branchStatus = context.branch.status;
         const error = branchStatus === 'submitted'
             ? `Branch "${context.branch.name}" is submitted for review and cannot be edited. Withdraw it or request changes to resume editing.`
-            : // Unreadable status: branch.json parses without schema validation, so a
-                // damaged file reaches here with no status. Refuse rather than guess.
+            : // A branch.json without a status is refused as corrupt before this
+                // point; a context built elsewhere can still lack one. Refuse rather than guess.
                 branchStatus === undefined
                     ? `Branch "${context.branch.name}" has no readable workflow status and cannot be edited until its metadata is repaired.`
                     : `Branch "${context.branch.name}" is ${branchStatus} and cannot be edited.`;
@@ -196,7 +202,21 @@ export async function executeGuards(guards, ctx, req, params) {
     const accumulated = {};
     for (const guardId of guards) {
         const runner = GUARD_RUNNERS[guardId];
-        const result = await runner(ctx, req, params, accumulated);
+        let result;
+        try {
+            result = await runner(ctx, req, params, accumulated);
+        }
+        catch (err) {
+            // Every branch guard resolves the branch from its branch.json, and a
+            // corrupt one has no status or ACL anyone can trust: deny, whatever the guard.
+            if (!(err instanceof BranchMetadataCorruptError))
+                throw err;
+            canopyLogError(`CanopyCMS: ${err.message}`);
+            return {
+                ok: false,
+                response: { ok: false, status: 500, error: BRANCH_METADATA_CORRUPT_MESSAGE },
+            };
+        }
         if (!result.ok) {
             return { ok: false, response: result.response };
         }

package/dist/api/index.d.ts

@@ -1,5 +1,5 @@
 export type { ApiResponse, ApiRequest, ApiContext } from './types.js';
-export type { BranchResponse, BranchCreateResponse, BranchListResponse, BranchDeleteResponse, CreateBranchBody, UpdateBranchAccessBody, } from './branch.js';
+export type { BranchListItemResponse, BranchListResponse, BranchDeleteResponse, CreateBranchBody, UpdateBranchAccessBody, } from './branch.js';
 export type { BranchMergeResponse } from './branch-merge.js';
 export type { CommentsResponse, AddCommentResponse, ResolveCommentResponse } from './comments.js';
 export type { EntriesResponse, ListEntriesResponse, CollectionItem, ListEntriesParams, DeleteEntryResponse, } from './entries.js';
@@ -16,3 +16,5 @@ export type { AdminStatusResponse, AdminStatusData, AdminTasksResponse, AdminTas
 export { USER_ROUTES } from './user.js';
 export { CanopyApiClient, createApiClient } from './client.js';
 export type { ApiClientOptions } from './client.js';
+export { ApiTimeoutError, isApiTimeoutError } from './request-deadline.js';
+export type { RequestOptions } from './request-deadline.js';

package/dist/api/index.js

@@ -4,3 +4,4 @@ export { USER_ROUTES } from './user.js';
 // Import it directly from './schema.js' in server-side code when needed.
 // Export client
 export { CanopyApiClient, createApiClient } from './client.js';
+export { ApiTimeoutError, isApiTimeoutError } from './request-deadline.js';

package/dist/api/permissions.d.ts

@@ -19,6 +19,10 @@ export type ListGroupsResponse = ApiResponse<{
 export type GetUserMetadataResponse = ApiResponse<{
     user: UserSearchResult | null;
 }>;
+/** Response type for batch user metadata: the users found, in no guaranteed order; unknown ids are absent */
+export type BatchGetUserMetadataResponse = ApiResponse<{
+    users: UserSearchResult[];
+}>;
 declare const updatePermissionsBodySchema: z.ZodObject<{
     permissions: z.ZodArray<z.ZodObject<{
         path: z.ZodType<import("../authorization/index.js").PermissionPath, z.ZodTypeDef, import("../authorization/index.js").PermissionPath>;
@@ -142,10 +146,18 @@ declare const getUserMetadataParamsSchema: z.ZodObject<{
 }, {
     userId: string;
 }>;
+declare const batchGetUserMetadataBodySchema: z.ZodObject<{
+    userIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    userIds: string[];
+}, {
+    userIds: string[];
+}>;
 export type UpdatePermissionsBody = z.infer<typeof updatePermissionsBodySchema>;
-/** @internal No importer; deletion candidate in knip-no-importer-deletion-candidates.md. */
+/** @internal No importer; deletion candidate in safeinsights/canopycms#725. */
 export type SearchUsersParams = z.infer<typeof searchUsersParamsSchema>;
-/** @internal No importer; deletion candidate in knip-no-importer-deletion-candidates.md. */
+export type BatchGetUserMetadataBody = z.infer<typeof batchGetUserMetadataBodySchema>;
+/** @internal No importer; deletion candidate in safeinsights/canopycms#725. */
 export type GetUserMetadataParams = z.infer<typeof getUserMetadataParamsSchema>;
 /**
  * Exported routes for router registration
@@ -276,5 +288,12 @@ export declare const PERMISSION_ROUTES: {
     }, {
         userId: string;
     }>, undefined, GetUserMetadataResponse>;
+    readonly batchGetUserMetadata: import("./route-builder.js").RouteDefinition<undefined, z.ZodObject<{
+        userIds: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        userIds: string[];
+    }, {
+        userIds: string[];
+    }>, BatchGetUserMetadataResponse>;
 };
 export {};