canopycms 0.0.68-int.98 → 0.1.0

package/dist/editor/components/UserBadge.js

@@ -1,9 +1,14 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Avatar, Badge, Tooltip, Group, Text, Skeleton, ActionIcon } from '@mantine/core';
-import { IconUserOff, IconX } from '@tabler/icons-react';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Avatar, Badge, Tooltip, Group, Text, Skeleton, ActionIcon, VisuallyHidden, } from '@mantine/core';
+import { IconRobot, IconUserOff, IconX } from '@tabler/icons-react';
 import { useUserMetadata } from '../hooks/useUserMetadata.js';
-export const UserBadge = ({ userId, getUserMetadata, variant = 'avatar-name', showEmailTooltip = true, onRemove, color, size = 'sm', badgeVariant = 'filled', showBadge = false, loading: loadingOverride, cachedUser, }) => {
+import { isSystemUserId } from '../../system-users.js';
+import { personName } from '../../auth/person-name.js';
+export const UserBadge = ({ userId, getUserMetadata, variant = 'avatar-name', showEmailTooltip = true, onRemove, color, size = 'sm', badgeVariant = 'filled', showBadge = false, loading: loadingOverride, cachedUser, revealIdOnFallback = false, }) => {
     const { userMetadata, isLoading, error } = useUserMetadata(userId, getUserMetadata, cachedUser);
+    // The badge's tooltip stays shut while the pointer or focus is on the X and its own tooltip.
+    const [onRemoveButton, setOnRemoveButton] = useState(false);
     const loading = loadingOverride ?? isLoading;
     const avatarSize = {
         xs: 16,
@@ -20,9 +25,35 @@ export const UserBadge = ({ userId, getUserMetadata, variant = 'avatar-name', sh
     if (loading) {
         return (_jsxs(Group, { gap: 4, children: [_jsx(Skeleton, { circle: true, height: avatarSize, width: avatarSize }), variant !== 'avatar-only' && _jsx(Skeleton, { height: 12, width: 60 })] }));
     }
-    if (error || !userMetadata) {
-        const content = (_jsxs(Group, { gap: 4, children: [_jsx(Avatar, { size: avatarSize, color: "gray" }), variant !== 'avatar-only' && (_jsx(Text, { size: textSize, c: "dimmed", children: userId }))] }));
-        return showEmailTooltip ? (_jsx(Tooltip, { label: error ? 'Error loading user' : 'User not found', children: content })) : (content);
+    const inBadge = !!onRemove || showBadge;
+    // A light or outline badge tints its label with the badge colour, too faint for a name.
+    const nameColor = inBadge && badgeVariant !== 'filled' ? 'var(--mantine-color-text)' : undefined;
+    const wrap = (content, tooltip, personLabel) => {
+        const wrapped = inBadge ? (_jsx(Badge, { variant: badgeVariant, color: color, pr: onRemove ? 3 : 8, pl: 4, rightSection: onRemove ? (_jsx(Tooltip, { label: `Remove ${personLabel}`, position: "bottom", children: _jsx(ActionIcon, { size: "xs", radius: "xl", variant: "transparent", onClick: () => onRemove(userId), onMouseEnter: () => setOnRemoveButton(true), onMouseLeave: () => setOnRemoveButton(false), onFocus: () => setOnRemoveButton(true), onBlur: () => setOnRemoveButton(false), "aria-label": `Remove ${personLabel}`, style: { color: nameColor ?? 'var(--mantine-color-white)' }, children: _jsx(IconX, { size: 12, stroke: 2.5 }) }) })) : undefined, styles: {
+                label: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: '4px',
+                },
+            }, children: content })) : (content);
+        return showEmailTooltip ? (_jsx(Tooltip, { label: tooltip, disabled: !tooltip || onRemoveButton, children: wrapped })) : (wrapped);
+    };
+    const record = error ? null : userMetadata;
+    const displayName = record ? personName(userId, record.name) : undefined;
+    if (!record || displayName === undefined) {
+        // The id shows only where `revealIdOnFallback` is set (admin surfaces); the People rule treats
+        // an id as an internal name. A record with no usable name still offers its avatar and email.
+        const unavailable = error ? "Couldn't load this name" : 'Name unavailable';
+        const described = revealIdOnFallback ? `${unavailable} · ${userId}` : unavailable;
+        const emailDetail = showEmailTooltip && variant !== 'full' ? (record?.email ?? '') : '';
+        const describedWithEmail = emailDetail ? `${described}, ${emailDetail}` : described;
+        // A filled badge keeps its white text; dimmed would not contrast with its fill.
+        const fallbackColor = inBadge && badgeVariant === 'filled' ? undefined : 'dimmed';
+        const unavailableText = (_jsx(Text, { size: textSize, c: fallbackColor, fs: "italic", children: unavailable }));
+        const hiddenDetail = `${revealIdOnFallback ? ` · ${userId}` : ''}${emailDetail ? `, ${emailDetail}` : ''}`;
+        return wrap(_jsxs(Group, { gap: 4, children: [_jsx(Avatar, { src: record?.avatarUrl, alt: "", size: avatarSize, color: "gray", "aria-hidden": true }), variant === 'avatar-only' ? (_jsx(VisuallyHidden, { component: "span", children: describedWithEmail })) : (_jsxs(_Fragment, { children: [variant === 'full' && record?.email ? (_jsxs("div", { children: [unavailableText, _jsx(Text, { size: "xs", c: "dimmed", children: record.email })] })) : (unavailableText), hiddenDetail && _jsx(VisuallyHidden, { component: "span", children: hiddenDetail })] }))] }), variant === 'avatar-only'
+            ? describedWithEmail
+            : [revealIdOnFallback ? described : '', emailDetail].filter(Boolean).join(', '), described);
     }
     const getInitials = (name) => {
         const parts = name.trim().split(/\s+/);
@@ -32,51 +63,49 @@ export const UserBadge = ({ userId, getUserMetadata, variant = 'avatar-name', sh
     };
     const renderAvatar = () => {
         if (userId === 'anonymous') {
-            return (_jsx(Avatar, { size: avatarSize, color: "orange", children: _jsx(IconUserOff, { size: avatarSize * 0.6 }) }));
+            return (_jsx(Avatar, { size: avatarSize, color: "orange", "aria-hidden": true, children: _jsx(IconUserOff, { size: avatarSize * 0.6 }) }));
+        }
+        if (isSystemUserId(userId)) {
+            return (_jsx(Avatar, { size: avatarSize, color: "gray", "aria-hidden": true, children: _jsx(IconRobot, { size: avatarSize * 0.6 }) }));
         }
-        // When inside Badge wrapper with filled/light variant, use white background for visibility
-        // For outline badges or no badge, use the passed color
         let avatarColor = color || 'blue';
         let avatarStyles = {};
-        if (onRemove || showBadge) {
+        if (inBadge) {
             if (badgeVariant === 'filled') {
-                // Filled badges: white background with dark text for maximum contrast
                 avatarStyles = {
-                    backgroundColor: 'white',
-                    color: 'var(--mantine-color-dark-6)',
+                    backgroundColor: 'var(--mantine-color-body)',
+                    color: 'var(--mantine-color-text)',
                 };
             }
             else if (badgeVariant === 'light') {
-                // Light badges: use dark avatar for contrast
                 avatarColor = 'dark';
             }
-            // outline badges: keep the passed color
         }
-        return (_jsx(Avatar, { src: userMetadata.avatarUrl, size: avatarSize, color: avatarColor, style: avatarStyles, children: !userMetadata.avatarUrl && getInitials(userMetadata.name) }));
+        return (_jsx(Avatar, { src: record.avatarUrl, 
+            // The name is text beside it (hidden when alone), so initials stay out of the tree.
+            alt: "", "aria-hidden": true, size: avatarSize, color: avatarColor, style: avatarStyles, children: !record.avatarUrl && getInitials(displayName) }));
     };
+    // The tooltip's email, read after the name by a screen reader, with no tab stop.
+    const detail = showEmailTooltip && variant !== 'full' && userId !== 'anonymous' ? record.email : '';
+    const detailText = detail ? (_jsx(VisuallyHidden, { component: "span", children: `, ${detail}` })) : null;
+    const personLabel = userId === 'anonymous' ? 'Anonymous (Public)' : displayName;
     const renderContent = () => {
         const avatar = renderAvatar();
         switch (variant) {
             case 'avatar-only':
-                return avatar;
+                return (_jsxs(Group, { gap: 0, children: [avatar, _jsx(VisuallyHidden, { component: "span", children: personLabel }), detailText] }));
             case 'full':
-                return (_jsxs(Group, { gap: 4, children: [avatar, _jsxs("div", { children: [_jsx(Text, { size: textSize, fw: 500, children: userMetadata.name }), _jsx(Text, { size: "xs", c: "dimmed", children: userMetadata.email })] })] }));
+                return (_jsxs(Group, { gap: 4, children: [avatar, _jsxs("div", { children: [_jsx(Text, { size: textSize, fw: 500, children: displayName }), _jsx(Text, { size: "xs", c: "dimmed", children: record.email })] })] }));
             case 'avatar-name':
             default:
-                return (_jsxs(Group, { gap: 4, children: [avatar, _jsx(Text, { size: textSize, fw: 500, children: userId === 'anonymous' ? 'Anonymous (Public)' : userMetadata.name })] }));
+                return (_jsxs(Group, { gap: 4, children: [avatar, _jsx(Text, { size: textSize, fw: 500, c: nameColor, children: personLabel }), detailText] }));
         }
     };
-    const content = renderContent();
-    if (onRemove || showBadge) {
-        const badgeContent = (_jsx(Badge, { variant: badgeVariant, color: color, pr: onRemove ? 3 : 8, pl: 4, rightSection: onRemove ? (_jsx(ActionIcon, { size: "xs", radius: "xl", variant: "transparent", onClick: () => onRemove(userId), "aria-label": "Remove user", style: { color: 'white' }, children: _jsx(IconX, { size: 12, stroke: 2.5 }) })) : undefined, styles: {
-                label: {
-                    textTransform: 'none',
-                    display: 'flex',
-                    alignItems: 'center',
-                    gap: '4px',
-                },
-            }, children: content }));
-        return showEmailTooltip && variant !== 'full' ? (_jsx(Tooltip, { label: userMetadata.email, children: badgeContent })) : (badgeContent);
-    }
-    return showEmailTooltip && variant !== 'full' ? (_jsx(Tooltip, { label: userMetadata.email, children: content })) : (content);
+    // Alone, the avatar shows no name, so its tooltip gives it before the email.
+    const tooltip = variant === 'full'
+        ? ''
+        : variant === 'avatar-only'
+            ? [personLabel, detail].filter(Boolean).join(', ')
+            : record.email;
+    return wrap(renderContent(), tooltip, personLabel);
 };

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { FieldConfig } from '../../config/index.js';
+export interface ValidationSummaryProps {
+    fields: readonly FieldConfig[];
+    /** The form's value, which names list items and blocks in the breadcrumbs. */
+    value: unknown;
+    /** Messages keyed by canonical canopy path. */
+    errors: Record<string, string>;
+}
+/**
+ * The form's errors as labelled breadcrumbs ("Page sections › Hero › Heading"), each a button
+ * that scrolls to its field in the enclosing form and focuses it.
+ */
+export declare const ValidationSummary: React.FC<ValidationSummaryProps>;

package/dist/editor/components/ValidationSummary.js

@@ -0,0 +1,24 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Anchor, List, Text } from '@mantine/core';
+import { IconAlertCircle } from '@tabler/icons-react';
+import { fieldBreadcrumb } from '../field-breadcrumb.js';
+import { findFieldTarget, focusFieldTarget } from '../field-target.js';
+/**
+ * The form's errors as labelled breadcrumbs ("Page sections › Hero › Heading"), each a button
+ * that scrolls to its field in the enclosing form and focuses it.
+ */
+export const ValidationSummary = ({ fields, value, errors }) => {
+    const entries = Object.entries(errors);
+    if (entries.length === 0)
+        return null;
+    return (_jsx(Alert, { icon: _jsx(IconAlertCircle, { size: 16 }), color: "red", variant: "light", title: "Fix these issues before saving", "data-testid": "validation-alert", children: _jsx(List, { size: "sm", spacing: 2, children: entries.map(([path, message]) => {
+                const crumb = fieldBreadcrumb(fields, value, path).join(' › ');
+                return (_jsxs(List.Item, { children: [_jsx(Anchor, { component: "button", type: "button", size: "sm", c: "inherit", underline: "always", ta: "left", "data-testid": `validation-item-${path}`, onClick: (event) => {
+                                const form = event.currentTarget.closest('[data-form-renderer]') ?? document;
+                                const target = findFieldTarget(path, form);
+                                if (target)
+                                    focusFieldTarget(target.element);
+                            }, children: crumb }), _jsxs(Text, { span: true, size: "sm", children: [": ", message] })] }, path));
+            }) }) }));
+};

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

@@ -1,3 +1,3 @@
-export * from './EditorFooter.js';
+export * from './BranchLockBanner.js';
 export * from './EditorHeader.js';
-export * from './EditorSidebar.js';
+export * from './EditorRail.js';

package/dist/editor/components/index.js

@@ -1,3 +1,3 @@
-export * from './EditorFooter.js';
+export * from './BranchLockBanner.js';
 export * from './EditorHeader.js';
-export * from './EditorSidebar.js';
+export * from './EditorRail.js';

package/dist/editor/context/ApiClientContext.d.ts

@@ -5,6 +5,7 @@
  */
 import React from 'react';
 import { createApiClient } from '../../api/index.js';
+import type { OperatingMode } from '../../operating-mode/types.js';
 export type ApiClient = ReturnType<typeof createApiClient>;
 export interface ApiClientProviderProps {
     children: React.ReactNode;
@@ -17,17 +18,22 @@ export interface ApiClientProviderProps {
      * when `client` is supplied directly. Unset/empty is a no-op (same as today).
      */
     basePath?: string;
+    /** The mode this bundle was built for (`CanopyClientConfig.mode`); see `ApiClientOptions.editorMode`. */
+    editorMode?: OperatingMode;
 }
 /**
  * Provider that creates and provides the API client.
  * Use the client prop to inject a mock client for testing.
  */
-export declare function ApiClientProvider({ children, client, basePath }: ApiClientProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ApiClientProvider({ children, client, basePath, editorMode, }: ApiClientProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
- * Subscribe to every 401 the provider's client receives, from any request. `listener` should be
+ * Subscribe to every unauthenticated response (`ApiClientOptions.onUnauthorized`) the provider's
+ * client receives, from any request. `listener` should be
  * stable (e.g. from `useCallback`): a new function re-subscribes. No-op outside a provider.
  */
 export declare function useOnUnauthorized(listener: () => void): void;
+/** As {@link useOnUnauthorized}, for responses refusing the editor's mode (`EDITOR_MODE_MISMATCH`). */
+export declare function useOnEditorModeMismatch(listener: () => void): void;
 /**
  * Hook to access the API client.
  * Must be used within an ApiClientProvider.

package/dist/editor/context/ApiClientContext.js

@@ -9,7 +9,7 @@ import { createContext, useContext, useEffect, useMemo, useState } from 'react';
 import { createApiClient } from '../../api/index.js';
 import { joinUrlPrefix } from '../../utils/url-prefix.js';
 const ApiClientContext = createContext(null);
-function createUnauthorizedSignal() {
+function createClientSignal() {
     const listeners = new Set();
     return {
         emit: () => {
@@ -25,36 +25,47 @@ function createUnauthorizedSignal() {
     };
 }
 const UnauthorizedSignalContext = createContext(null);
+const EditorModeMismatchSignalContext = createContext(null);
 /**
  * Provider that creates and provides the API client.
  * Use the client prop to inject a mock client for testing.
  */
-export function ApiClientProvider({ children, client, basePath }) {
-    const [unauthorized] = useState(createUnauthorizedSignal);
+export function ApiClientProvider({ children, client, basePath, editorMode, }) {
+    const [unauthorized] = useState(createClientSignal);
+    const [modeMismatch] = useState(createClientSignal);
     // Memoized on identity, not just for cost: several consumers now list the client in their
     // effect deps (useUserContext, useReferenceResolution, ReferenceField), so a fresh client each
     // render would turn those one-shot fetches into a loop. A caller injecting an inline
     // `client={createApiClient()}` would reintroduce exactly that.
     //
-    // Only a client built HERE reports 401s to `useOnUnauthorized`; an injected `client` is used
-    // as-is, so its 401s reach the auth gate only through the gate's own whoami result.
+    // Only a client built HERE reports to `useOnUnauthorized` and `useOnEditorModeMismatch`; an
+    // injected `client` is used as-is, so its 401s and mode mismatches reach the auth gate only
+    // through the gate's own whoami result.
     const apiClient = useMemo(() => {
         return (client ??
             createApiClient({
                 baseUrl: joinUrlPrefix(basePath, '/api/canopycms'),
                 onUnauthorized: unauthorized.emit,
+                editorMode,
+                onEditorModeMismatch: modeMismatch.emit,
             }));
-    }, [client, basePath, unauthorized]);
-    return (_jsx(UnauthorizedSignalContext.Provider, { value: unauthorized, children: _jsx(ApiClientContext.Provider, { value: apiClient, children: children }) }));
+    }, [client, basePath, editorMode, unauthorized, modeMismatch]);
+    return (_jsx(UnauthorizedSignalContext.Provider, { value: unauthorized, children: _jsx(EditorModeMismatchSignalContext.Provider, { value: modeMismatch, children: _jsx(ApiClientContext.Provider, { value: apiClient, children: children }) }) }));
 }
 /**
- * Subscribe to every 401 the provider's client receives, from any request. `listener` should be
+ * Subscribe to every unauthenticated response (`ApiClientOptions.onUnauthorized`) the provider's
+ * client receives, from any request. `listener` should be
  * stable (e.g. from `useCallback`): a new function re-subscribes. No-op outside a provider.
  */
 export function useOnUnauthorized(listener) {
     const signal = useContext(UnauthorizedSignalContext);
     useEffect(() => signal?.subscribe(listener), [signal, listener]);
 }
+/** As {@link useOnUnauthorized}, for responses refusing the editor's mode (`EDITOR_MODE_MISMATCH`). */
+export function useOnEditorModeMismatch(listener) {
+    const signal = useContext(EditorModeMismatchSignalContext);
+    useEffect(() => signal?.subscribe(listener), [signal, listener]);
+}
 /**
  * Hook to access the API client.
  * Must be used within an ApiClientProvider.

package/dist/editor/context/AssetContext.d.ts

@@ -1,44 +1,22 @@
 /**
- * Carries `media.publicBaseUrl` (see CanopyClientConfig.assetBaseUrl) down to
- * every asset-URL-building component - MediaLibrary, ImageField, and the MDX
- * image dialog. A context (rather than a prop) because the MDX dialog is
- * rendered deep inside MDXEditor's lazy-loaded internals via `imagePlugin`'s
- * `ImageDialog` param, with no prop channel of its own (the same reason
- * `EntryLinkContext` exists for the entry-link toolbar button). Unlike
- * `ApiClientContext`, reading this without a provider is safe and intentional:
- * no provider means root-relative URLs, which is the correct default for the
- * common case (editor and site share an origin).
+ * Carries the prefix every editor-built asset URL is put behind - MediaLibrary thumbnails,
+ * ImageField's preview and crop source, and the MDX editor's image previews. A context (rather
+ * than a prop) because the MDX dialog is rendered deep inside MDXEditor's lazy-loaded internals
+ * via `imagePlugin`'s `ImageDialog` param, with no prop channel of its own (the same reason
+ * `EntryLinkContext` exists for the entry-link toolbar button).
  */
 import React from 'react';
+import { authenticatedAssetBase } from '../raw-asset-base.js';
+export { authenticatedAssetBase };
 export interface AssetContextValue {
-    /** Prefixed onto every asset URL the editor builds. `undefined` (no provider, or no `media.publicBaseUrl` configured) means root-relative - same-origin dev/prod-today behavior. */
-    baseUrl?: string;
+    /** The `baseUrl` to pass to `assetUrl` for every asset URL the editor renders. */
+    baseUrl: string;
 }
-export interface AssetContextProviderProps extends AssetContextValue {
+export interface AssetContextProviderProps {
     children: React.ReactNode;
-    /**
-     * `CanopyClientConfig.basePath` - the deployment prefix the host app is served under. Used only
-     * when `baseUrl` is unset.
-     */
+    /** `CanopyClientConfig.basePath` - the deployment prefix the host app is served under. */
     basePath?: string;
 }
-/**
- * `baseUrl` (`media.publicBaseUrl`) wins; `basePath` is the fallback.
- *
- * They are ALTERNATIVES, never composed: whichever is used names where `/assets` is mounted, in
- * full, and a deployment `basePath` cannot apply on top of it. Where the two differ is topology,
- * not precedence - see the asset-mount table in the README.
- *
- * The fallback is kept only so that existing basePath deployments do not break on upgrade,
- * which makes removing it a deliberate decision rather than a cleanup - it is option 1 of
- * `.claude/future-tasks/editor-asset-mount-topology.md`, still open.
- *
- * KNOWN LIMITATION: on a CloudFront/CDK deployment, a basePath does NOT move the asset
- * space (behaviors are anchored at the distribution root), so this fallback prefixes
- * wrongly — requests still resolve, via `withCanopy`'s auto-prefixed `/assets/:path*`
- * rewrite, but bypass the CDN cache and the dedicated transform Lambda. Workaround: set
- * `media.publicBaseUrl` to the distribution origin instead, which takes precedence here.
- */
-export declare function AssetContextProvider({ baseUrl, basePath, children }: AssetContextProviderProps): import("react/jsx-runtime").JSX.Element;
-/** Safe to call outside a provider - returns `{ baseUrl: undefined }` (root-relative URLs). */
+export declare function AssetContextProvider({ basePath, children }: AssetContextProviderProps): import("react/jsx-runtime").JSX.Element;
+/** Safe to call outside a provider - see the context's default. */
 export declare function useAssetContext(): AssetContextValue;

package/dist/editor/context/AssetContext.js

@@ -1,41 +1,22 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 /**
- * Carries `media.publicBaseUrl` (see CanopyClientConfig.assetBaseUrl) down to
- * every asset-URL-building component - MediaLibrary, ImageField, and the MDX
- * image dialog. A context (rather than a prop) because the MDX dialog is
- * rendered deep inside MDXEditor's lazy-loaded internals via `imagePlugin`'s
- * `ImageDialog` param, with no prop channel of its own (the same reason
- * `EntryLinkContext` exists for the entry-link toolbar button). Unlike
- * `ApiClientContext`, reading this without a provider is safe and intentional:
- * no provider means root-relative URLs, which is the correct default for the
- * common case (editor and site share an origin).
+ * Carries the prefix every editor-built asset URL is put behind - MediaLibrary thumbnails,
+ * ImageField's preview and crop source, and the MDX editor's image previews. A context (rather
+ * than a prop) because the MDX dialog is rendered deep inside MDXEditor's lazy-loaded internals
+ * via `imagePlugin`'s `ImageDialog` param, with no prop channel of its own (the same reason
+ * `EntryLinkContext` exists for the entry-link toolbar button).
  */
 import { createContext, useContext, useMemo } from 'react';
-const AssetContext = createContext({});
-/**
- * `baseUrl` (`media.publicBaseUrl`) wins; `basePath` is the fallback.
- *
- * They are ALTERNATIVES, never composed: whichever is used names where `/assets` is mounted, in
- * full, and a deployment `basePath` cannot apply on top of it. Where the two differ is topology,
- * not precedence - see the asset-mount table in the README.
- *
- * The fallback is kept only so that existing basePath deployments do not break on upgrade,
- * which makes removing it a deliberate decision rather than a cleanup - it is option 1 of
- * `.claude/future-tasks/editor-asset-mount-topology.md`, still open.
- *
- * KNOWN LIMITATION: on a CloudFront/CDK deployment, a basePath does NOT move the asset
- * space (behaviors are anchored at the distribution root), so this fallback prefixes
- * wrongly — requests still resolve, via `withCanopy`'s auto-prefixed `/assets/:path*`
- * rewrite, but bypass the CDN cache and the dedicated transform Lambda. Workaround: set
- * `media.publicBaseUrl` to the distribution origin instead, which takes precedence here.
- */
-export function AssetContextProvider({ baseUrl, basePath, children }) {
-    const resolved = baseUrl ?? basePath;
-    const value = useMemo(() => ({ baseUrl: resolved }), [resolved]);
+import { authenticatedAssetBase } from '../raw-asset-base.js';
+export { authenticatedAssetBase };
+/** No provider means no `basePath`: the API is mounted at the origin root. */
+const AssetContext = createContext({ baseUrl: authenticatedAssetBase() });
+export function AssetContextProvider({ basePath, children }) {
+    const value = useMemo(() => ({ baseUrl: authenticatedAssetBase(basePath) }), [basePath]);
     return _jsx(AssetContext.Provider, { value: value, children: children });
 }
-/** Safe to call outside a provider - returns `{ baseUrl: undefined }` (root-relative URLs). */
+/** Safe to call outside a provider - see the context's default. */
 export function useAssetContext() {
     return useContext(AssetContext);
 }

package/dist/editor/context/EditorStateContext.d.ts

@@ -21,11 +21,11 @@ interface EditorStateProviderProps {
     /** Initial modal states (useful for deep linking) */
     initialModals?: Partial<ModalState>;
 }
-/** @internal No importer; deletion candidate in editor-state-context-migration.md. */
+/** @internal No importer; deletion candidate in safeinsights/canopycms#678. */
 export declare function EditorStateProvider({ children, initialModals }: EditorStateProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Convenience hook for loading states only.
- * @internal No importer; deletion candidate in editor-state-context-migration.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#678.
  */
 export declare function useEditorLoading(): {
     busy: boolean;
@@ -36,7 +36,7 @@ export declare function useEditorLoading(): {
 };
 /**
  * Convenience hook for modal states only.
- * @internal No importer; deletion candidate in editor-state-context-migration.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#678.
  */
 export declare function useEditorModals(): {
     openModal: (key: keyof ModalState) => void;
@@ -50,7 +50,7 @@ export declare function useEditorModals(): {
 };
 /**
  * Convenience hook for preview state only.
- * @internal No importer; deletion candidate in editor-state-context-migration.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#678.
  */
 export declare function useEditorPreview(): {
     data: FormValue;

package/dist/editor/context/EditorStateContext.js

@@ -6,7 +6,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
  */
 import { createContext, useContext, useCallback, useState, useMemo } from 'react';
 const EditorStateContext = createContext(null);
-/** @internal No importer; deletion candidate in editor-state-context-migration.md. */
+/** @internal No importer; deletion candidate in safeinsights/canopycms#678. */
 export function EditorStateProvider({ children, initialModals }) {
     const [loading, setLoadingState] = useState({
         branches: false,
@@ -88,7 +88,7 @@ function useEditorState() {
 }
 /**
  * Convenience hook for loading states only.
- * @internal No importer; deletion candidate in editor-state-context-migration.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#678.
  */
 export function useEditorLoading() {
     const { state, actions } = useEditorState();
@@ -100,7 +100,7 @@ export function useEditorLoading() {
 }
 /**
  * Convenience hook for modal states only.
- * @internal No importer; deletion candidate in editor-state-context-migration.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#678.
  */
 export function useEditorModals() {
     const { state, actions } = useEditorState();
@@ -113,7 +113,7 @@ export function useEditorModals() {
 }
 /**
  * Convenience hook for preview state only.
- * @internal No importer; deletion candidate in editor-state-context-migration.md.
+ * @internal No importer; deletion candidate in safeinsights/canopycms#678.
  */
 export function useEditorPreview() {
     const { state, actions } = useEditorState();

package/dist/editor/context/SWRProvider.d.ts

@@ -7,9 +7,9 @@
  *   to snap back to fresh data whenever the tab regains focus; a few
  *   seconds of staleness is harmless, and refetching on every alt-tab is
  *   just extra load against the branch clone.
- * - shouldRetryOnError: false -- matches the hooks' pre-SWR behavior, which
- *   surfaced a single failure (notification + console.error) rather than
- *   silently retrying in the background.
+ * - shouldRetryOnError: false -- a failure, an ApiTimeoutError included,
+ *   stays an error until something revalidates the key (a Retry, a branch
+ *   switch, a re-sign-in), so a stalled API never drives a retry loop.
  * - provider: () => new Map() -- gives the editor its own cache instead of
  *   SWR's module-global one, so editor keys ("canopy:entries:main", ...) can
  *   never collide with an SWR cache the host app is running for its own data.

package/dist/editor/context/SiteMdxAllowContext.d.ts

@@ -0,0 +1,4 @@
+import type { MdxAllowlist } from '../../config/index.js';
+/** The config's `mdxAllow`, which each field checked as MDX narrows by its own. */
+export declare const SiteMdxAllowContext: import("react").Context<MdxAllowlist | undefined>;
+export declare function useSiteMdxAllow(): MdxAllowlist | undefined;

package/dist/editor/context/SiteMdxAllowContext.js

@@ -0,0 +1,7 @@
+'use client';
+import { createContext, useContext } from 'react';
+/** The config's `mdxAllow`, which each field checked as MDX narrows by its own. */
+export const SiteMdxAllowContext = createContext(undefined);
+export function useSiteMdxAllow() {
+    return useContext(SiteMdxAllowContext);
+}

package/dist/editor/context/index.d.ts

@@ -1,4 +1,5 @@
 export { ApiClientProvider, useApiClient, useOptionalApiClient, type ApiClient, type ApiClientProviderProps, } from './ApiClientContext.js';
-export { AssetContextProvider, useAssetContext, type AssetContextValue, type AssetContextProviderProps, } from './AssetContext.js';
+export { AssetContextProvider, authenticatedAssetBase, useAssetContext, type AssetContextValue, type AssetContextProviderProps, } from './AssetContext.js';
 export { SWRProvider, type SWRProviderProps } from './SWRProvider.js';
 export { useEditorLoading, useEditorModals, useEditorPreview } from './EditorStateContext.js';
+export { SiteMdxAllowContext, useSiteMdxAllow } from './SiteMdxAllowContext.js';

package/dist/editor/context/index.js

@@ -1,4 +1,5 @@
 export { ApiClientProvider, useApiClient, useOptionalApiClient, } from './ApiClientContext.js';
-export { AssetContextProvider, useAssetContext, } from './AssetContext.js';
+export { AssetContextProvider, authenticatedAssetBase, useAssetContext, } from './AssetContext.js';
 export { SWRProvider } from './SWRProvider.js';
 export { useEditorLoading, useEditorModals, useEditorPreview } from './EditorStateContext.js';
+export { SiteMdxAllowContext, useSiteMdxAllow } from './SiteMdxAllowContext.js';

package/dist/editor/contrast.d.ts

@@ -0,0 +1,19 @@
+/** Whether Mantine's `toRgba` parses `colour`; it misreads anything else, `oklch()` as black. */
+export declare const isMeasurable: (colour: string) => boolean;
+/** The WCAG 2 contrast ratio of two opaque colours. */
+export declare const contrastRatio: (a: string, b: string) => number;
+/** `color` at `opacity` over the opaque `background`, as one opaque colour. */
+export declare const composite: (color: string, opacity: number, background: string) => string;
+/**
+ * The first step from `from` toward the scale's dark or light end reaching `minimum` on
+ * `background`, else the end shade darkened or lightened until it does (`shade` unset).
+ */
+export declare const readableOnScale: (scale: readonly string[], options: {
+    from: number;
+    toward: "darker" | "lighter";
+    background: string;
+    minimum?: number;
+}) => {
+    shade?: number;
+    value: string;
+};

package/dist/editor/contrast.js

@@ -0,0 +1,41 @@
+import { darken, lighten, luminance, toRgba } from '@mantine/core';
+const MEASURABLE = [
+    /^#([0-9a-f]{3}){1,2}([0-9a-f]{2})?$/i,
+    /^rgba?\(\s*[\d.]+\s*,\s*[\d.]+\s*,\s*[\d.]+\s*(,\s*[\d.]+\s*)?\)$/i,
+    /^hsla?\(\s*\d+\s*,\s*\d+%\s*,\s*\d+%\s*(,\s*[\d.]+\s*)?\)$/i,
+];
+/** Whether Mantine's `toRgba` parses `colour`; it misreads anything else, `oklch()` as black. */
+export const isMeasurable = (colour) => MEASURABLE.some((pattern) => pattern.test(colour.trim()));
+/** WCAG 2's minimum for body text. */
+const TEXT_CONTRAST = 4.5;
+/** The WCAG 2 contrast ratio of two opaque colours. */
+export const contrastRatio = (a, b) => {
+    const [light, dark] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+    return (light + 0.05) / (dark + 0.05);
+};
+/** `color` at `opacity` over the opaque `background`, as one opaque colour. */
+export const composite = (color, opacity, background) => {
+    const fg = toRgba(color);
+    const bg = toRgba(background);
+    const mix = (f, b) => Math.round(f * opacity + b * (1 - opacity));
+    return `rgb(${mix(fg.r, bg.r)}, ${mix(fg.g, bg.g)}, ${mix(fg.b, bg.b)})`;
+};
+/**
+ * The first step from `from` toward the scale's dark or light end reaching `minimum` on
+ * `background`, else the end shade darkened or lightened until it does (`shade` unset).
+ */
+export const readableOnScale = (scale, options) => {
+    const { from, toward, background, minimum = TEXT_CONTRAST } = options;
+    const step = toward === 'darker' ? 1 : -1;
+    const end = toward === 'darker' ? scale.length - 1 : 0;
+    for (let shade = from; step > 0 ? shade <= end : shade >= end; shade += step) {
+        if (contrastRatio(scale[shade], background) >= minimum)
+            return { shade, value: scale[shade] };
+    }
+    for (let amount = 0.05; amount < 1; amount += 0.05) {
+        const value = toward === 'darker' ? darken(scale[end], amount) : lighten(scale[end], amount);
+        if (contrastRatio(value, background) >= minimum)
+            return { value };
+    }
+    return { value: toward === 'darker' ? '#000000' : '#ffffff' };
+};

package/dist/editor/copy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The editor's fixed action verbs, sentence case and verb first. "…" is appended only where
+ * the command asks for more before it acts ("Switch branch…"); see docs/ux-guidelines.md.
+ * New UI uses these instead of writing the strings inline.
+ */
+export declare const EDITOR_ACTIONS: {
+    readonly save: "Save";
+    readonly saveAll: "Save all";
+    readonly refreshFromServer: "Refresh from server";
+    readonly submitForReview: "Submit for review";
+    readonly withdrawFromReview: "Withdraw from review";
+    readonly requestChanges: "Request changes";
+    readonly switchBranch: "Switch branch";
+    readonly newBranch: "New branch";
+    readonly remove: "Remove";
+    readonly clear: "Clear";
+    readonly openEntry: "Open entry";
+};

package/dist/editor/copy.js

@@ -0,0 +1,18 @@
+/**
+ * The editor's fixed action verbs, sentence case and verb first. "…" is appended only where
+ * the command asks for more before it acts ("Switch branch…"); see docs/ux-guidelines.md.
+ * New UI uses these instead of writing the strings inline.
+ */
+export const EDITOR_ACTIONS = {
+    save: 'Save',
+    saveAll: 'Save all',
+    refreshFromServer: 'Refresh from server',
+    submitForReview: 'Submit for review',
+    withdrawFromReview: 'Withdraw from review',
+    requestChanges: 'Request changes',
+    switchBranch: 'Switch branch',
+    newBranch: 'New branch',
+    remove: 'Remove',
+    clear: 'Clear',
+    openEntry: 'Open entry',
+};