canopycms 0.0.67-int.90 → 0.0.67

package/dist/editor/FormRenderer.js

@@ -27,7 +27,6 @@ const normalizeOptions = (options) => {
 };
 const fieldKey = (path) => formatCanopyPath(path);
 export const FormRenderer = ({ fields, value, onChange, customRenderers, branch = 'main', comments = [], currentEntryPath, currentUserId, canResolve = false, focusedFieldPath, highlightThreadId, onAddComment, onResolveThread, onResolvedValueChange, onLoadingStateChange, conflictNotice = false, fieldErrors, }) => {
-    // Use the extracted reference resolution hook for live preview
     useReferenceResolution({
         value,
         fields,
@@ -47,7 +46,6 @@ export const FormRenderer = ({ fields, value, onChange, customRenderers, branch
     const renderFieldControl = (field, currentValue, update, path) => {
         const fieldId = `field-${fieldKey(path).replace(/[^a-zA-Z0-9_-]/g, '-')}`;
         const canopyPath = normalizeCanopyPath(path);
-        // Filter comments for this specific field
         const fieldThreads = currentEntryPath && onAddComment
             ? comments.filter((thread) => thread.type === 'field' &&
                 thread.entryPath === currentEntryPath &&
@@ -62,14 +60,12 @@ export const FormRenderer = ({ fields, value, onChange, customRenderers, branch
                     path,
                     id: fieldId,
                 }) }, fieldKey(path)));
-            // Wrap custom fields with FieldWrapper if comments enabled
             if (currentEntryPath && currentUserId && onAddComment && onResolveThread) {
                 return (_jsx(FieldWrapper, { canopyPath: canopyPath, entryPath: currentEntryPath, threads: fieldThreads, autoFocus: focusedFieldPath === canopyPath, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, children: renderedField }, fieldKey(path)));
             }
             return renderedField;
         }
         const label = field.label ?? field.name;
-        // Helper to wrap field with FieldWrapper if comments enabled
         const wrapWithComments = (renderedField) => {
             if (currentEntryPath && currentUserId && onAddComment && onResolveThread) {
                 return (_jsx(FieldWrapper, { canopyPath: canopyPath, entryPath: currentEntryPath, threads: fieldThreads, autoFocus: focusedFieldPath === canopyPath, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, children: renderedField }));
@@ -145,24 +141,14 @@ export const FormRenderer = ({ fields, value, onChange, customRenderers, branch
                                                             update(nextItems);
                                                         }, renderField: renderField, path: [...path, idx], dataCanopyField: normalizeCanopyPath([...path, idx]) })] }) }, fieldKey([...path, idx])))), items.length === 0 && (_jsx(Text, { size: "xs", c: "dimmed", children: "No items yet. Add one to get started." }))] })] }) }, fieldKey(path)));
                 }
-                // Non-list object: unlike the list branch above (where each item has
-                // its own Remove button), this field had no way to return to
-                // `undefined` once given a value. That mattered because a required
-                // child field inside it can be filled and then cleared back to `''`,
-                // which `isEmptyForRequired` treats as empty (entry-validator.ts) --
-                // but the object as a whole only reads as "absent" when it is
-                // `undefined`/`null`, not when its children are individually empty.
-                // Without a way to unset the object, that state was permanently
-                // invalid. The Clear button (wired through ObjectField's onRemove)
-                // fixes that by resetting to `undefined`, never `{}` (which would
-                // still carry a required-but-empty child into validation).
-                //
-                // Shown only when the field is optional (a required object should
-                // not be clearable back to a missing state) and only once it
-                // actually has a value (nothing to clear otherwise). Labeled
-                // "Clear" rather than "Remove" so it doesn't read as deleting the
-                // field from the schema, the way "Remove" correctly does for a list
-                // item above.
+                // Unlike the list branch above (each item has its own Remove button), a
+                // non-list object has no other way back to `undefined`: a required child
+                // filled and cleared to `''` reads as empty via `isEmptyForRequired`
+                // (entry-validator.ts), but the object itself only reads "absent" when
+                // `undefined`/`null`. The Clear button (ObjectField's `onRemove`) resets to
+                // `undefined`, never `{}` -- shown only when the field is optional and
+                // already has a value, and labeled "Clear" rather than "Remove" so it
+                // doesn't read as deleting the field from the schema.
                 const hasValue = currentValue !== undefined && currentValue !== null;
                 const canClear = objectField.required !== true && hasValue;
                 return wrapWithComments(_jsx(ObjectField, { label: label, fields: objectField.fields, value: currentValue, onChange: (next) => update(next), onRemove: canClear ? () => update(undefined) : undefined, renderField: renderField, path: path, dataCanopyField: normalizeCanopyPath(path) }, fieldKey(path)));
@@ -184,4 +170,3 @@ export const FormRenderer = ({ fields, value, onChange, customRenderers, branch
                 return (_jsx("div", { children: renderField(field, val, (next) => onChange({ ...value, [field.name]: next }), path) }, fieldKey(path)));
             })] }));
 };
-export default FormRenderer;

package/dist/editor/admin/SystemHealthPanel.js

@@ -1,14 +1,13 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
- * SystemHealthPanel - Admin-only modal surfacing the observability
- * endpoints from PR-A1..A4: task-queue/worker liveness (Overview), task
- * recovery (Tasks), and branch-directory recovery (Branches).
+ * SystemHealthPanel - Admin-only modal surfacing observability endpoints:
+ * task-queue/worker liveness (Overview), task recovery (Tasks), and
+ * branch-directory recovery (Branches).
  *
- * Visibility is entirely the caller's responsibility -- Editor.tsx only
- * renders/opens this for admins (see isAdmin(userContext?.groups) there).
- * This component does not re-check that itself, same as GroupManager and
- * PermissionManager rely on their callers for that gate.
+ * Visibility is the caller's responsibility: Editor.tsx renders/opens this
+ * only for admins (see isAdmin(userContext?.groups)); this component does not
+ * re-check that itself, same as GroupManager and PermissionManager.
  */
 import { Alert, Badge, Button, Code, Group, Loader, Modal, Paper, SegmentedControl, SimpleGrid, Spoiler, Stack, Table, Tabs, Text, ThemeIcon, Tooltip, } from '@mantine/core';
 import { IconAlertCircle, IconAlertTriangle } from '@tabler/icons-react';
@@ -37,20 +36,16 @@ function formatAgeMs(ms) {
     return `${totalDays}d ${totalHours % 24}h`;
 }
 /**
- * Whether the Purge button should be disabled for a corrupt-metadata
- * or orphan row, and the tooltip explaining why.
- * - Base branch: never purgeable -- the server already 400s
- *   ('The base branch directory can never be purged', see
- *   purgeBranchDirHandler in api/admin-branch-health.ts); this is UX
- *   honesty, not a new rail.
- * - Fresh provisioning lock: provisioning may genuinely be in progress
- *   (mirrors the server's [H1] freshness rail) -- applies to BOTH kinds,
- *   not just orphans.
+ * Whether the Purge button should be disabled for this row, and why (tooltip).
+ * - Base branch: never purgeable — the server already 400s this (UX
+ *   consistency, not a new rail); see purgeBranchDirHandler in
+ *   api/admin-branch-health.ts.
+ * - Fresh provisioning lock ([H1] freshness rail): provisioning may
+ *   genuinely be in progress, for either row kind.
  * - Orphan-only youth rail: a directory younger than
- *   ORPHAN_YOUTH_THRESHOLD_MS may still be a clone in progress that hasn't
- *   written branch.json yet. Corrupt-metadata dirs are exempt from this
- *   server-side (a parseable-then-corrupted file isn't a mid-clone
- *   signature), so they're exempt here too.
+ *   ORPHAN_YOUTH_THRESHOLD_MS may still be mid-clone, before branch.json is
+ *   written. Corrupt-metadata dirs are exempt server-side too (a
+ *   parseable-then-corrupted file isn't a mid-clone signature).
  */
 function purgeGateFor(entry) {
     if (entry.isBaseBranch) {
@@ -99,10 +94,8 @@ const TASK_STATUS_VALUES = TASK_STATUS_OPTIONS.map((o) => o.value);
 function isAdminTaskStatus(value) {
     return TASK_STATUS_VALUES.includes(value);
 }
-// ============================================================================
 // Confirm-modal copy (races/limitations these actions accept -- see
 // api/admin.ts and api/admin-branch-health.ts's handler docstrings)
-// ============================================================================
 const RETRY_CONFIRM_TEXT = 'Retrying may duplicate work if the task also runs another way; task actions are safe to run twice.';
 function deleteConfirmText(status) {
     if (status === 'pending') {
@@ -117,9 +110,6 @@ export function SystemHealthPanel({ opened, onClose }) {
     const health = useSystemHealth({ isOpen: opened });
     return (_jsx(Modal, { opened: opened, onClose: onClose, title: "System health", size: "xl", children: _jsxs(Tabs, { defaultValue: "overview", children: [_jsxs(Tabs.List, { children: [_jsx(Tabs.Tab, { value: "overview", children: "Overview" }), _jsx(Tabs.Tab, { value: "tasks", children: "Tasks" }), _jsx(Tabs.Tab, { value: "branches", children: "Branches" })] }), _jsx(Tabs.Panel, { value: "overview", pt: "md", children: _jsx(OverviewTab, { health: health }) }), _jsx(Tabs.Panel, { value: "tasks", pt: "md", children: _jsx(TasksTab, { health: health }) }), _jsx(Tabs.Panel, { value: "branches", pt: "md", children: _jsx(BranchesTab, { health: health }) })] }) }));
 }
-// ============================================================================
-// Overview tab
-// ============================================================================
 function OverviewTab({ health }) {
     const { status, statusLoading, isRecentFatalError, error, refresh } = health;
     if (!status && statusLoading) {
@@ -135,9 +125,6 @@ function OverviewTab({ health }) {
                                 ? ` · ${lastGitSync.skippedLocked.length} skipped (content write in progress)`
                                 : ''] }), lastGitSync.failed.length > 0 && (_jsx(Spoiler, { maxHeight: 0, showLabel: `${lastGitSync.failed.length} failed — show details`, hideLabel: "Hide", children: _jsx(Stack, { gap: 4, mt: 4, children: lastGitSync.failed.map((f) => (_jsxs(Text, { size: "xs", c: "red", children: [f.branch, ": ", f.error] }, f.branch))) }) }))] })), _jsx(SimpleGrid, { cols: 5, spacing: "xs", children: ['pending', 'processing', 'completed', 'failed', 'corrupt'].map((key) => (_jsxs(Paper, { withBorder: true, p: "xs", radius: "md", ta: "center", children: [_jsx(Text, { size: "xs", c: "dimmed", tt: "capitalize", children: key }), _jsx(Text, { size: "lg", fw: 700, c: (key === 'failed' || key === 'corrupt') && status.queue[key] > 0 ? 'red' : undefined, children: status.queue[key] })] }, key))) }), status.queue.oldestPendingAgeMs !== undefined && (_jsxs(Text, { size: "xs", c: "dimmed", children: ["Oldest pending task: ", formatAgeMs(status.queue.oldestPendingAgeMs), " old"] })), _jsxs(Group, { justify: "space-between", align: "center", children: [_jsxs(Text, { size: "xs", c: "dimmed", children: ["Generated at ", status.generatedAt] }), _jsx(Button, { size: "xs", variant: "light", onClick: () => refresh(), loading: statusLoading, children: "Refresh" })] }), _jsx(Text, { size: "xs", c: "dimmed", children: "Data may lag up to ~60s (shared-filesystem caching)" })] }));
 }
-// ============================================================================
-// Tasks tab
-// ============================================================================
 function TasksTab({ health }) {
     const { taskStatus, setTaskStatus, tasks, tasksLoading } = health;
     const isCorrupt = taskStatus === 'corrupt';
@@ -170,9 +157,6 @@ function TasksTab({ health }) {
                                 ? corruptRows.map((file) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: file.fileName, children: truncate(file.fileName, 30) }) }), _jsxs(Table.Td, { children: [file.size, " bytes"] }), _jsx(Table.Td, { children: file.mtime }), _jsx(Table.Td, { children: _jsx(Code, { block: true, style: { maxWidth: 320, whiteSpace: 'pre-wrap' }, children: file.rawSnippet }) }), _jsx(Table.Td, { children: _jsx(Button, { size: "xs", variant: "light", color: "red", "data-testid": `delete-task-${file.fileName}`, onClick: () => handleDeleteClick('corrupt', file.fileName), children: "Delete" }) })] }, file.fileName)))
                                 : taskRows.map((task) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: task.id, children: truncate(task.id, 12) }) }), _jsx(Table.Td, { children: task.action }), _jsx(Table.Td, { children: task.createdAt }), _jsx(Table.Td, { children: task.retryCount ?? 0 }), _jsx(Table.Td, { children: task.error ? (_jsx(Tooltip, { label: task.error, multiline: true, maw: 400, children: _jsx(Text, { size: "xs", style: { cursor: 'help' }, children: truncate(task.error, 50) }) })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: _jsxs(Group, { gap: "xs", children: [taskStatus === 'failed' && (_jsx(Button, { size: "xs", variant: "light", "data-testid": `retry-task-${task.id}`, onClick: () => handleRetryClick(task), children: "Retry" })), canDelete && (_jsx(Button, { size: "xs", variant: "light", color: "red", "data-testid": `delete-task-${task.id}`, onClick: () => handleDeleteClick(taskStatus, `${task.id}.json`), children: "Delete" }))] }) })] }, task.id))) })] }) }))] }));
 }
-// ============================================================================
-// Branches tab
-// ============================================================================
 function BranchesTab({ health }) {
     const { branchHealth, branchHealthLoading } = health;
     const entries = branchHealth?.entries ?? [];
@@ -214,12 +198,11 @@ function BranchesTab({ health }) {
 function BranchHealthRow({ entry, onMarkMerged, onRepair, onPurge, }) {
     if (entry.kind === 'healthy' && entry.branch) {
         const b = entry.branch;
-        // Mirror the rebase loop's skip logic (worker/rebase.ts):
-        // the worker rebases every branch except 'submitted'/'approved' (under an
-        // active PR) and 'archived' (already merged). Stated as an exclusion list
-        // rather than `status === 'editing'` so that a status added later shows its
-        // rebase failures by default instead of silently hiding them -- the bug
-        // this replaced.
+        // Mirrors the rebase loop's skip logic (worker/rebase.ts): the worker
+        // rebases every branch except 'submitted'/'approved' (under an active PR)
+        // and 'archived' (already merged). An exclusion list, not `status ===
+        // 'editing'`, so a status added later still shows its rebase failures by
+        // default instead of silently hiding them.
         const showRebaseFailure = !['submitted', 'approved', 'archived'].includes(b.status) && !!b.rebaseFailure;
         const canMarkMerged = (b.status === 'submitted' || b.status === 'approved') && !!b.pullRequestNumber;
         return (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsxs(Group, { gap: 4, wrap: "nowrap", children: [_jsx(Text, { size: "sm", children: entry.dirName }), entry.isBaseBranch && (_jsx(Badge, { size: "xs", color: "gray", variant: "outline", children: "base" }))] }) }), _jsx(Table.Td, { children: _jsx(Badge, { color: branchStatusColorMap[b.status] ?? 'neutral', variant: "light", children: b.status }) }), _jsx(Table.Td, { children: b.pullRequestNumber ? (_jsxs(Text, { size: "xs", c: "blue", component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", style: { textDecoration: 'underline' }, children: ["PR #", b.pullRequestNumber, b.pullRequestState ? ` (${b.pullRequestState})` : ''] })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: b.syncStatus === 'sync-failed' ? (_jsx(Tooltip, { label: b.syncFailureReason

package/dist/editor/admin/useSystemHealth.d.ts

@@ -14,9 +14,8 @@ export interface UseSystemHealthReturn {
     statusLoading: boolean;
     /**
      * True when workerStatus.lastFatalError exists and is < 30 min old, as of
-     * the last fetch. Computed at fetch time (not in the component's render)
-     * so the panel never calls Date.now() during render -- see the
-     * react-hooks/purity rule this sidesteps.
+     * the last fetch. Computed at fetch time, not in the component's render, so
+     * the panel never calls Date.now() during render (react-hooks/purity).
      */
     isRecentFatalError: boolean;
     tasks: AdminTasksData | null;

package/dist/editor/admin/useSystemHealth.js

@@ -1,12 +1,11 @@
 'use client';
 /**
- * useSystemHealth - Data + actions for the admin System Health panel (PR-U1).
+ * useSystemHealth - Data + actions for the admin System Health panel.
  *
- * Mirrors useGroupManager's shape: loads on open, exposes typed action
- * helpers that each notify then refresh(). Unlike useGroupManager, this also
- * polls every 30s while the panel stays open (cleared on close/unmount) --
- * queue depth and worker liveness go stale quickly, and the panel has no
- * other way to catch a worker coming back up or a task finishing.
+ * Mirrors useGroupManager's shape (load on open, typed actions that notify
+ * then refresh()), but also polls every 30s while open (cleared on
+ * close/unmount) since queue depth and worker liveness go stale quickly and
+ * the panel has no other way to catch a worker recovering or a task finishing.
  */
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { notifications } from '@mantine/notifications';
@@ -14,9 +13,9 @@ import { useApiClient } from '../context/index.js';
 const POLL_INTERVAL_MS = 30_000;
 /**
  * Crash-loop rider window: a worker that fatally exits and restarts
- * repeatedly can flap between 'absent' and 'alive' liveness and never sit
- * still long enough to read 'stale' -- surfacing a recent lastFatalError
- * regardless of liveness state is the only way the panel catches that.
+ * repeatedly can flap between 'absent' and 'alive' and never sit still long
+ * enough to read 'stale' — surfacing a recent lastFatalError regardless of
+ * liveness state is the only way the panel catches that.
  */
 const CRASH_LOOP_WINDOW_MS = 30 * 60_000;
 export function useSystemHealth(options) {
@@ -31,9 +30,8 @@ export function useSystemHealth(options) {
     const [branchHealthLoading, setBranchHealthLoading] = useState(false);
     const [error, setError] = useState(null);
     // refresh() has no status argument, so it needs the CURRENT taskStatus
-    // without taking a dependency on it (that would tear down/rebuild the
-    // polling interval below every time the Tasks tab's segmented control
-    // changes). A ref sidesteps the stale-closure problem cleanly.
+    // without depending on it (that would tear down/rebuild the poll interval
+    // below on every Tasks-tab status change) — a ref sidesteps the stale closure.
     const taskStatusRef = useRef(taskStatus);
     taskStatusRef.current = taskStatus;
     const fetchStatus = useCallback(async () => {

package/dist/editor/client-reference-resolver.d.ts

@@ -11,17 +11,14 @@ import type { ApiClient } from './context/index.js';
  * can't be sourced here via `useApiClient()`/`useOptionalApiClient()` directly; instead every
  * entry point takes an optional `apiClient`, which the caller (a hook, which CAN call
  * `useOptionalApiClient()` during render) resolves and passes down. Falls back to a
- * default-configured `createApiClient()` when no client is supplied, so direct callers/tests
- * that predate this DI path keep working unchanged.
+ * default-configured `createApiClient()` when no client is supplied.
  */
 /**
- * Find which fields changed between two form values.
  * Only returns top-level field configs for fields that changed.
+ * @internal Exported for tests.
  */
 export declare function findChangedFields(prevValue: FormValue, currentValue: FormValue, schema: EntrySchema): FieldConfig[];
 /**
- * Resolve changed references incrementally.
- * Only resolves reference fields that have changed.
  * Uses cache to avoid duplicate API calls.
  */
 export declare function resolveChangedReferences(prevValue: FormValue, currentValue: FormValue, schema: EntrySchema, branch: string, cache: Map<string, unknown>, apiClient?: ApiClient): Promise<Partial<FormValue>>;

package/dist/editor/client-reference-resolver.js

@@ -10,19 +10,17 @@ import { flattenGroupFields } from '../utils/flatten-group-fields.js';
  * can't be sourced here via `useApiClient()`/`useOptionalApiClient()` directly; instead every
  * entry point takes an optional `apiClient`, which the caller (a hook, which CAN call
  * `useOptionalApiClient()` during render) resolves and passes down. Falls back to a
- * default-configured `createApiClient()` when no client is supplied, so direct callers/tests
- * that predate this DI path keep working unchanged.
+ * default-configured `createApiClient()` when no client is supplied.
  */
 /**
- * Find which fields changed between two form values.
  * Only returns top-level field configs for fields that changed.
+ * @internal Exported for tests.
  */
 export function findChangedFields(prevValue, currentValue, schema) {
     const changed = [];
     for (const field of flattenGroupFields(schema)) {
         const prevFieldValue = prevValue[field.name];
         const currentFieldValue = currentValue[field.name];
-        // Deep equality check for objects and arrays
         if (JSON.stringify(prevFieldValue) !== JSON.stringify(currentFieldValue)) {
             changed.push(field);
         }
@@ -30,8 +28,6 @@ export function findChangedFields(prevValue, currentValue, schema) {
     return changed;
 }
 /**
- * Resolve changed references incrementally.
- * Only resolves reference fields that have changed.
  * Uses cache to avoid duplicate API calls.
  */
 export async function resolveChangedReferences(prevValue, currentValue, schema, branch, cache, apiClient) {
@@ -41,14 +37,11 @@ export async function resolveChangedReferences(prevValue, currentValue, schema,
         if (field.type === 'reference') {
             const refField = field;
             const fieldValue = currentValue[field.name];
-            // Resolve this field's value
             if (refField.list && Array.isArray(fieldValue)) {
-                // List of references
                 const resolved = await Promise.all(fieldValue.map((id) => resolveReferenceId(id, branch, cache, apiClient)));
                 updates[field.name] = resolved;
             }
             else if (fieldValue) {
-                // Single reference
                 const resolved = await resolveReferenceId(fieldValue, branch, cache, apiClient);
                 updates[field.name] = resolved;
             }
@@ -56,13 +49,7 @@ export async function resolveChangedReferences(prevValue, currentValue, schema,
     }
     return updates;
 }
-/**
- * Resolve a single reference ID to full object.
- * Checks cache first, then makes API call if needed.
- * Returns original ID if resolution fails.
- */
 async function resolveReferenceId(id, branch, cache, apiClient) {
-    // Only resolve string IDs
     if (typeof id !== 'string') {
         return id;
     }
@@ -71,7 +58,6 @@ async function resolveReferenceId(id, branch, cache, apiClient) {
         return id;
     }
     const cacheKey = `${branch}:${id}`;
-    // Check cache first
     if (cache.has(cacheKey)) {
         return cache.get(cacheKey);
     }
@@ -82,17 +68,14 @@ async function resolveReferenceId(id, branch, cache, apiClient) {
         const client = apiClient ?? createApiClient();
         const result = await client.content.resolveReferences({ branch }, { ids: [id] });
         if (result.ok && result.data && result.data.resolved[id]) {
-            // Cache and return resolved object
             const resolved = result.data.resolved[id];
             cache.set(cacheKey, resolved);
             return resolved;
         }
-        // Resolution failed - return original ID string
         return id;
     }
     catch (error) {
         console.error(`Failed to resolve reference ID ${id}:`, error);
-        // Return original ID on error
         return id;
     }
 }

package/dist/editor/comments/BranchComments.js

@@ -9,15 +9,11 @@ import { ThreadCarousel } from './ThreadCarousel.js';
  */
 export const BranchComments = ({ comments, currentUserId, canResolve, onAddComment, onResolveThread, autoFocus, highlightThreadId, onGetUserMetadata, }) => {
     const [showCarousel, setShowCarousel] = useState(false);
-    // Filter for branch-level threads
     const branchThreads = useMemo(() => comments.filter((t) => t.type === 'branch'), [comments]);
-    // Show carousel if threads exist or if auto-focused
     const shouldShowCarousel = branchThreads.length > 0 || showCarousel || autoFocus;
-    // Wrapper to add branch context to comment handler
     const handleAddComment = async (text, threadId) => {
         await onAddComment(text, 'branch', undefined, undefined, threadId);
     };
-    // Show "New branch comment" button when no threads
     if (!shouldShowCarousel) {
         return (_jsx(Box, { children: _jsx(Button, { size: "xs", variant: "subtle", color: "gray", onClick: () => setShowCarousel(true), style: { fontSize: '0.75rem', height: '1.5rem' }, children: "New branch comment" }) }));
     }

package/dist/editor/comments/EntryComments.js

@@ -9,15 +9,11 @@ import { ThreadCarousel } from './ThreadCarousel.js';
  */
 export const EntryComments = ({ comments, entryPath, currentUserId, canResolve, onAddComment, onResolveThread, autoFocus, highlightThreadId, }) => {
     const [showCarousel, setShowCarousel] = useState(false);
-    // Filter for entry-level threads
     const entryThreads = useMemo(() => comments.filter((t) => t.type === 'entry' && t.entryPath === entryPath), [comments, entryPath]);
-    // Show carousel if threads exist or if auto-focused
     const shouldShowCarousel = entryThreads.length > 0 || showCarousel || autoFocus;
-    // Wrapper to add entry context to comment handler
     const handleAddComment = async (text, threadId) => {
         await onAddComment(text, 'entry', entryPath, undefined, threadId);
     };
-    // Show "New file comment" button when no threads
     if (!shouldShowCarousel) {
         return (_jsx(Box, { children: _jsx(Button, { size: "xs", variant: "subtle", color: "gray", onClick: () => setShowCarousel(true), style: { fontSize: '0.75rem', height: '1.5rem' }, children: "New file comment" }) }));
     }

package/dist/editor/comments/FieldWrapper.js

@@ -10,9 +10,7 @@ import { ThreadCarousel } from './ThreadCarousel.js';
 export const FieldWrapper = ({ children, canopyPath, entryPath, threads, autoFocus, currentUserId, canResolve, onAddComment, onResolveThread, highlightThreadId, }) => {
     const wrapperRef = useRef(null);
     const [showCarousel, setShowCarousel] = useState(false);
-    // Show carousel if threads exist or user explicitly requested it
     const shouldShowCarousel = threads.length > 0 || showCarousel;
-    // Scroll to field when focused from preview
     useEffect(() => {
         if (autoFocus) {
             wrapperRef.current?.scrollIntoView({
@@ -21,12 +19,10 @@ export const FieldWrapper = ({ children, canopyPath, entryPath, threads, autoFoc
             });
         }
     }, [autoFocus]);
-    // Wrapper to add field context to comment handler
     const handleAddComment = async (text, threadId) => {
         await onAddComment(text, 'field', entryPath, canopyPath, threadId);
     };
     return (_jsxs(Box, { ref: wrapperRef, "data-canopy-field": canopyPath, pos: "relative", style: { width: '100%' }, children: [_jsx(Box, { style: {
-                    // Add subtle highlight when auto-focused
                     outline: autoFocus ? '2px solid var(--mantine-color-blue-5)' : undefined,
                     outlineOffset: autoFocus ? 2 : undefined,
                     borderRadius: 4,

package/dist/editor/comments/InlineCommentThread.js

@@ -45,10 +45,8 @@ export const InlineCommentThread = ({ thread, onAddReply, onResolve, currentUser
     const canUserResolve = () => {
         if (!canResolve)
             return false;
-        // Thread author or user with resolver permission
         return thread.authorId === currentUserId || canResolve;
     };
-    // Always show full thread view with per-thread scrolling
     return (_jsx(Paper, { withBorder: true, p: "md", bg: "white", "data-testid": "inline-comment-thread", style: {
             width: '100%',
             overflowY: 'auto',

package/dist/editor/comments/ThreadCarousel.d.ts

@@ -2,64 +2,11 @@ import React from 'react';
 import type { CommentThread } from '../../comment-store.js';
 import type { UserSearchResult } from '../../auth/types.js';
 /**
- * ThreadCarousel - Horizontal comment thread navigation component
- *
  * ## Purpose
  * Provides a horizontal carousel UI for navigating between multiple comment threads
  * on fields, entries, or branches. Supports both keyboard navigation (arrow buttons)
  * and displays a visual "peekaboo" preview of adjacent threads.
  *
- * ## Key Behaviors
- *
- * ### Layout & Sizing
- * - **Active thread width**: `calc(100% - 72px)` - fills container minus peekaboo space
- * - **Single thread width**: `calc(100% - 72px)` - same as active (for consistency)
- * - **Inactive thread width**: `400px` - fixed width when not in view
- * - **Peekaboo size**: `60px` - sliver of next thread shown on right edge
- * - **Gap between threads**: `12px`
- *
- * ### Peekaboo Preview
- * - Shows 60px of the next thread on the right edge (when not viewing last thread)
- * - Gradient fade overlay applied to peekaboo area for visual polish
- * - **Last thread behavior**: Invisible 60px spacer ensures last thread stays left-aligned
- *   without showing previous threads on the left
- * - Peekaboo helps users discover there are more threads to navigate
- *
- * ### Thread Sorting
- * - **Unresolved threads first** (primary sort)
- * - **Newest first within same resolved state** (secondary sort by createdAt)
- * - This ensures urgent unresolved feedback appears first
- *
- * ### Navigation
- * - **Arrow buttons**: `← 2/5 →` counter with disabled states at boundaries
- * - **Smooth scrolling**: CSS `scroll-behavior: smooth` with programmatic scroll
- * - **Auto-scroll**: When `autoFocus` is true, automatically scrolls to first unresolved thread
- * - **Mouse scrolling disabled**: `overflowX: 'hidden'` - only button navigation allowed
- * - **Scroll calculation**: Accounts for active thread width + gaps when navigating
- *
- * ### Always-Visible Design
- * - Component renders even with 0 threads (shows "No comments yet" message)
- * - "New" button always accessible in header
- * - Header shows thread count when threads exist: "Comments (3)"
- * - Navigation arrows only appear when multiple threads exist
- *
- * ### Vertical Resizing
- * - **Default height**: 400px
- * - **Resize range**: 200px (min) to 600px (max)
- * - **Resize handle**: Bottom edge with visual feedback on hover/drag
- * - User can drag to adjust carousel height for their workflow
- *
- * ### New Thread Creation
- * - "New" button in header toggles inline thread creation box
- * - `autoOpenNewThread` prop auto-opens box (used when clicking "New comment" button)
- * - New thread box appears above carousel, with textarea and Create/Cancel buttons
- *
- * ## Usage Context
- * Used by:
- * - **FieldWrapper**: Inline comments beneath form fields
- * - **EntryComments**: Comments at top of entry form
- * - **BranchComments**: Comments at top of BranchManager
- *
  * ## Design Decisions
  *
  * ### Why calc(100% - 72px)?
@@ -67,11 +14,6 @@ import type { UserSearchResult } from '../../auth/types.js';
  * - Active thread fills remaining space for maximum readability
  * - Consistent sizing between single thread and active thread in multi-thread scenarios
  *
- * ### Why invisible spacer at end?
- * - Without spacer: last thread would align to right edge, showing previous threads on left
- * - With spacer: last thread stays left-aligned with blank space on right (matching peekaboo size)
- * - Creates consistent left-alignment across all thread positions
- *
  * ### Why disable mouse scrolling?
  * - Prevents accidental scroll-wheel navigation that could be jarring
  * - Forces deliberate button-based navigation for better UX

package/dist/editor/comments/ThreadCarousel.js

@@ -16,28 +16,23 @@ export const ThreadCarousel = ({ threads, label = 'Comments', contextType: _, cu
     const scrollContainerRef = useRef(null);
     const resizeStartY = useRef(0);
     const resizeStartHeight = useRef(0);
-    // Sort: unresolved first, then resolved
     const sortedThreads = useMemo(() => [...threads].sort((a, b) => {
         if (a.resolved === b.resolved) {
-            // Same resolved state: sort by createdAt (newest first)
             return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
         }
         return a.resolved ? 1 : -1;
     }), [threads]);
-    // Auto-scroll to first unresolved thread when autoFocus is true
     useEffect(() => {
         if (autoFocus && sortedThreads.length > 0) {
             const firstUnresolved = sortedThreads.find((t) => !t.resolved);
             if (firstUnresolved) {
                 const index = sortedThreads.findIndex((t) => t.id === firstUnresolved.id);
                 setCurrentIndex(index);
-                // Scroll to thread
                 scrollToIndex(index);
             }
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps -- scrollToIndex is stable
     }, [autoFocus, sortedThreads]);
-    // Scroll to and highlight specific thread when highlightThreadId changes
     useEffect(() => {
         if (highlightThreadId && sortedThreads.length > 0) {
             const threadIndex = sortedThreads.findIndex((t) => t.id === highlightThreadId);
@@ -45,7 +40,6 @@ export const ThreadCarousel = ({ threads, label = 'Comments', contextType: _, cu
                 setCurrentIndex(threadIndex);
                 scrollToIndex(threadIndex);
                 setHighlightedThreadId(highlightThreadId);
-                // Clear highlight after 2 seconds
                 const timer = window.setTimeout(() => {
                     setHighlightedThreadId(undefined);
                 }, 2000);
@@ -54,13 +48,11 @@ export const ThreadCarousel = ({ threads, label = 'Comments', contextType: _, cu
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps -- scrollToIndex is stable
     }, [highlightThreadId, sortedThreads]);
-    // Auto-open new thread box when autoOpenNewThread is true
     useEffect(() => {
         if (autoOpenNewThread) {
             setShowNewThreadBox(true);
         }
     }, [autoOpenNewThread]);
-    // Handle resize dragging
     useEffect(() => {
         const handleMouseMove = (e) => {
             if (!isResizing)
@@ -90,8 +82,6 @@ export const ThreadCarousel = ({ threads, label = 'Comments', contextType: _, cu
     const scrollToIndex = (index) => {
         if (scrollContainerRef.current) {
             const container = scrollContainerRef.current;
-            // Calculate scroll position based on container width
-            // Active thread takes most space, others are 400px + gap
             let scrollLeft = 0;
             for (let i = 0; i < index; i++) {
                 if (sortedThreads.length > 1) {
@@ -175,12 +165,10 @@ export const ThreadCarousel = ({ threads, label = 'Comments', contextType: _, cu
                                     return (_jsx("div", { style: {
                                             scrollSnapAlign: 'start',
                                             flexShrink: 0,
-                                            // Active thread or single thread stretches to fill space minus peekaboo
                                             width: isActive || sortedThreads.length === 1
                                                 ? 'calc(100% - 72px)' // Active or single: leave room for peekaboo/spacing
                                                 : 400, // Non-active: fixed width
                                             maxWidth: isActive || sortedThreads.length === 1 ? 'calc(100% - 72px)' : 400,
-                                            // Add highlight animation
                                             outline: isHighlighted ? '3px solid var(--mantine-color-blue-5)' : undefined,
                                             outlineOffset: isHighlighted ? 2 : undefined,
                                             borderRadius: isHighlighted ? 8 : undefined,

package/dist/editor/components/EditorFooter.d.ts

@@ -1,6 +1,3 @@
-/**
- * Props for the EditorFooter component.
- */
 export interface EditorFooterProps {
     /**
      * Optional custom footer content.
@@ -10,10 +7,5 @@ export interface EditorFooterProps {
 /**
  * Footer component for the Editor.
  * Displays static links (Terms, Privacy) and copyright notice.
- *
- * @example
- * ```tsx
- * <EditorFooter />
- * ```
  */
 export declare function EditorFooter({ children }: EditorFooterProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/components/EditorFooter.js

@@ -3,11 +3,6 @@ import { Group, Paper, Text } from '@mantine/core';
 /**
  * Footer component for the Editor.
  * Displays static links (Terms, Privacy) and copyright notice.
- *
- * @example
- * ```tsx
- * <EditorFooter />
- * ```
  */
 export function EditorFooter({ children }) {
     return (_jsx(Paper, { withBorder: true, radius: 0, shadow: "sm", px: "md", py: "xs", style: { position: 'fixed', left: 0, right: 0, bottom: 0, zIndex: 40 }, children: children ?? (_jsxs(Group, { gap: "md", justify: "center", children: [_jsx(Text, { size: "xs", c: "dimmed", children: "Terms" }), _jsx(Text, { size: "xs", c: "dimmed", children: "Privacy" }), _jsx(Text, { size: "xs", c: "dimmed", children: "\u00A9 CanopyCMS" })] })) }));