canopycms 0.0.68-int.98 → 0.1.0

package/dist/validation/deletion-checker.js

@@ -1,122 +1,46 @@
-import { resolveBlockItem } from './field-traversal.js';
-/**
- * DeletionChecker finds all references to an entry before deletion.
- */
-export class DeletionChecker {
-    constructor(store, idIndex, collections) {
-        this.store = store;
-        this.idIndex = idIndex;
-        this.collections = collections;
+import { extractEntryLinkIds } from '../entry-link-resolver.js';
+import { collectReferenceIds } from './field-traversal.js';
+/** Entries but the target whose schema's reference fields or `entry:` links hold `targetId`. */
+export function findReferencingEntries(entries, targetId) {
+    const found = [];
+    for (const entry of entries) {
+        if (entry.entryId === targetId)
+            continue;
+        const fields = entry.schemaUnavailable
+            ? findIdPaths(entry.data, '', targetId)
+            : entry.schema
+                ? collectReferenceIds(entry.schema, entry.data)
+                    .filter((occurrence) => occurrence.id === targetId)
+                    .map((occurrence) => occurrence.path)
+                : [];
+        const links = findLinkingPaths(entry.data, '', targetId);
+        if (fields.length > 0 || links.length > 0)
+            found.push({ entry, fields, links });
     }
-    async canDelete(id) {
-        const referencedBy = await this.findReferences(id);
-        return {
-            canDelete: referencedBy.length === 0,
-            referencedBy,
-        };
-    }
-    async findReferences(targetId) {
-        const references = [];
-        for (const [collectionPath, collectionDef] of this.collections.entries()) {
-            const refs = await this.scanCollection(collectionPath, collectionDef.fields, targetId);
-            references.push(...refs);
-        }
-        return references;
-    }
-    async scanCollection(collectionPath, fields, targetId) {
-        const references = [];
-        const entries = this.listEntriesInCollection(collectionPath);
-        for (const entry of entries) {
-            try {
-                const doc = await this.store.read(entry.collection, entry.slug);
-                const refs = this.findIdInData(doc.data, targetId, fields);
-                if (refs.length > 0) {
-                    const id = this.idIndex.findByPath(entry.relativePath);
-                    references.push({
-                        entryPath: id || '',
-                        entryTitle: doc.data.title,
-                        collection: entry.collection,
-                        slug: entry.slug,
-                        fields: refs,
-                    });
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        return references;
+    return found;
+}
+/** Paths of every string in `value` equal to `targetId`; `seen` stops at a YAML alias cycle. */
+function findIdPaths(value, path, targetId, seen = new WeakSet()) {
+    if (typeof value === 'string')
+        return value === targetId ? [path] : [];
+    if (value === null || typeof value !== 'object' || seen.has(value))
+        return [];
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => findIdPaths(item, `${path}[${index}]`, targetId, seen));
     }
-    findIdInData(data, targetId, schema, pathPrefix = '') {
-        const found = [];
-        for (const field of schema) {
-            // Inline groups are transparent (walkFields, ./field-traversal) — recurse at the same level.
-            if (field.type === 'group') {
-                found.push(...this.findIdInData(data, targetId, field.fields, pathPrefix));
-                continue;
-            }
-            const fieldPath = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
-            const value = data[field.name];
-            if (value === undefined || value === null)
-                continue;
-            if (field.type === 'reference') {
-                if (Array.isArray(value)) {
-                    if (value.includes(targetId)) {
-                        found.push(fieldPath);
-                    }
-                }
-                else if (value === targetId) {
-                    found.push(fieldPath);
-                }
-            }
-            else if (field.type === 'object') {
-                // Recurse into object fields — handles both single objects and list:true (array of objects)
-                const objectField = field;
-                if (objectField.fields) {
-                    if (Array.isArray(value)) {
-                        // list: true — value is an array of objects
-                        value.forEach((item, index) => {
-                            if (typeof item === 'object' && item !== null) {
-                                found.push(...this.findIdInData(item, targetId, objectField.fields, `${fieldPath}[${index}]`));
-                            }
-                        });
-                    }
-                    else if (typeof value === 'object' && value !== null) {
-                        found.push(...this.findIdInData(value, targetId, objectField.fields, fieldPath));
-                    }
-                }
-            }
-            else if (field.type === 'block') {
-                const blockField = field;
-                if (Array.isArray(value)) {
-                    value.forEach((item, index) => {
-                        if (typeof item === 'object' && item !== null) {
-                            const resolved = resolveBlockItem(blockField, item);
-                            if (resolved) {
-                                found.push(...this.findIdInData(resolved.data, targetId, resolved.fields, `${fieldPath}[${index}]`));
-                            }
-                        }
-                    });
-                }
-            }
-        }
-        return found;
+    return Object.entries(value).flatMap(([key, item]) => findIdPaths(item, path ? `${path}.${key}` : key, targetId, seen));
+}
+/** Mirrors `resolveEntryLinksInData` (any string); `seen` stops at a YAML alias cycle. */
+function findLinkingPaths(value, path, targetId, seen = new WeakSet()) {
+    if (typeof value === 'string') {
+        return extractEntryLinkIds(value).some((link) => link.id === targetId) ? [path] : [];
     }
-    listEntriesInCollection(collectionPath) {
-        const entries = [];
-        const allLocations = this.idIndex.getAllLocations();
-        for (const location of allLocations) {
-            if (location.type === 'entry') {
-                if (location.collection === collectionPath ||
-                    location.collection?.startsWith(collectionPath + '/')) {
-                    entries.push({
-                        relativePath: location.relativePath,
-                        collection: location.collection,
-                        slug: location.slug,
-                    });
-                }
-            }
-        }
-        return entries;
+    if (value === null || typeof value !== 'object' || seen.has(value))
+        return [];
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => findLinkingPaths(item, `${path}[${index}]`, targetId, seen));
     }
+    return Object.entries(value).flatMap(([key, item]) => findLinkingPaths(item, path ? `${path}.${key}` : key, targetId, seen));
 }

package/dist/validation/entry-validator.d.ts

@@ -21,26 +21,22 @@ export interface EntryFieldError {
     fieldPath: string;
     message: string;
 }
-/**
- * Extract the id from a reference value. The editor holds references either
- * as an id string or as a resolved object `{ id, slug, collection, ... }`
- * (content reads resolve references by default). Returns undefined for any
- * other shape.
- * @internal Exported for tests.
- */
-export declare function referenceValueId(value: unknown): string | undefined;
 /**
  * Merge an md/mdx body string into the data record under the schema's body
  * field name (`isBody: true`, defaulting to `'body'`), so required/type checks
  * apply to the body like any other field.
  */
 export declare function mergeBodyIntoData(fields: EntrySchema, data: Record<string, unknown>, body: string | undefined): Record<string, unknown>;
+export interface ValidateEntryOptions {
+    /** False skips the required-field checks and keeps every type and format check. Default true. */
+    required?: boolean;
+}
 /**
  * Validate entry data against an entry schema. Pure — safe to run in the
  * browser. Returns one error per offending field path; an empty array means
  * the data is structurally valid.
  */
-export declare function validateEntryData(fields: EntrySchema, data: Record<string, unknown>, pathPrefix?: string): EntryFieldError[];
+export declare function validateEntryData(fields: EntrySchema, data: Record<string, unknown>, pathPrefix?: string, options?: ValidateEntryOptions): EntryFieldError[];
 /**
  * Validate an editor FormValue (client-side entry point). For md/mdx formats
  * the editor keeps the body under the literal `body` key; remap it to the
@@ -59,7 +55,7 @@ export declare function validateEntryFormValue(fields: EntrySchema, format: Cont
  * a save, and the write path now preserves it and its comments), so this feeds the
  * non-blocking `validationWarnings` channel, not the 422 path.
  *
- * Deliberately not reported: a container with no fields at all (`api/content.ts`
+ * Deliberately not reported: a list item's `ITEM_KEY`, a container with no fields at all (`api/content.ts`
  * falls back to `[]` for a collection with no configured entry type — "no schema"
  * isn't "every key is unknown"), and anything inside a `reference` value (a resolved
  * reference's value is `{ ...target data, id, slug, collection, urlPath }`; the

package/dist/validation/entry-validator.js

@@ -12,9 +12,10 @@
  * `ReferenceValidator` at the write boundary.
  */
 import { fieldTypes } from '../config/index.js';
-import { isValidCropRect } from '../assets/transform-directives.js';
+import { isValidCropRect, roundCropRect } from '../assets/transform-directives.js';
 import { BLOCK_STRUCTURAL_KEYS } from './block-structural-keys.js';
-import { resolveBlockItem, traverseFields } from './field-traversal.js';
+import { ITEM_KEY } from '../item-keys.js';
+import { referenceValueId, resolveBlockItem, traverseFields } from './field-traversal.js';
 import { findBodyFieldName } from '../utils/body-field.js';
 import { flattenGroupFields } from '../utils/flatten-group-fields.js';
 import { isDataOnlyFormat } from '../utils/format.js';
@@ -27,7 +28,10 @@ function isPlainRecord(value) {
 function isPositiveInt(value) {
     return typeof value === 'number' && Number.isInteger(value) && value > 0;
 }
-/** True when `value` is a well-formed `{ x, y, w, h }` normalized crop rect. */
+/**
+ * True when `value` is a well-formed `{ x, y, w, h }` normalized crop rect that is still valid
+ * after `roundCropRect`, the rounding its transform URL applies.
+ */
 function isValidImageCropValue(value) {
     if (!isPlainRecord(value))
         return false;
@@ -38,7 +42,10 @@ function isValidImageCropValue(value) {
         typeof h !== 'number') {
         return false;
     }
-    return isValidCropRect(x, y, w, h);
+    if (!isValidCropRect(x, y, w, h))
+        return false;
+    const rounded = roundCropRect({ x, y, w, h });
+    return isValidCropRect(rounded.x, rounded.y, rounded.w, rounded.h);
 }
 /**
  * Validate a structured `image` field value: `{ src, alt, width?, height?, crop? }`
@@ -73,20 +80,6 @@ function validateImageValue(field, value, path) {
     }
     return errors;
 }
-/**
- * Extract the id from a reference value. The editor holds references either
- * as an id string or as a resolved object `{ id, slug, collection, ... }`
- * (content reads resolve references by default). Returns undefined for any
- * other shape.
- * @internal Exported for tests.
- */
-export function referenceValueId(value) {
-    if (typeof value === 'string')
-        return value;
-    if (isPlainRecord(value) && typeof value.id === 'string')
-        return value.id;
-    return undefined;
-}
 const selectOptionValues = (field) => (field.options ?? []).map((opt) => (typeof opt === 'string' ? opt : opt.value));
 /**
  * Merge an md/mdx body string into the data record under the schema's body
@@ -160,17 +153,17 @@ function isEmptyForRequired(field, value) {
  * browser. Returns one error per offending field path; an empty array means
  * the data is structurally valid.
  */
-export function validateEntryData(fields, data, pathPrefix = '') {
+export function validateEntryData(fields, data, pathPrefix = '', options = {}) {
     const errors = [];
     for (const field of fields) {
         // Inline groups are transparent (walkFields, ./field-traversal) — children live at this level.
         if (field.type === 'group') {
-            errors.push(...validateEntryData(field.fields, data, pathPrefix));
+            errors.push(...validateEntryData(field.fields, data, pathPrefix, options));
             continue;
         }
         const path = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
         const value = data[field.name];
-        const isRequired = 'required' in field && field.required === true;
+        const isRequired = options.required !== false && 'required' in field && field.required === true;
         if (isRequired && isEmptyForRequired(field, value)) {
             const message = Array.isArray(value)
                 ? 'At least one item is required'
@@ -201,7 +194,7 @@ export function validateEntryData(fields, data, pathPrefix = '') {
                     });
                     return;
                 }
-                errors.push(...validateEntryData(resolved.fields, resolved.data, itemPath));
+                errors.push(...validateEntryData(resolved.fields, resolved.data, itemPath, options));
             });
             continue;
         }
@@ -219,7 +212,7 @@ export function validateEntryData(fields, data, pathPrefix = '') {
                         return;
                     }
                     if (objectField.fields) {
-                        errors.push(...validateEntryData(objectField.fields, item, itemPath));
+                        errors.push(...validateEntryData(objectField.fields, item, itemPath, options));
                     }
                 });
             }
@@ -227,7 +220,7 @@ export function validateEntryData(fields, data, pathPrefix = '') {
                 errors.push({ fieldPath: path, message: 'Expected an object' });
             }
             else if (objectField.fields) {
-                errors.push(...validateEntryData(objectField.fields, value, path));
+                errors.push(...validateEntryData(objectField.fields, value, path, options));
             }
             continue;
         }
@@ -273,7 +266,7 @@ export function validateEntryFormValue(fields, format, value) {
  * a save, and the write path now preserves it and its comments), so this feeds the
  * non-blocking `validationWarnings` channel, not the 422 path.
  *
- * Deliberately not reported: a container with no fields at all (`api/content.ts`
+ * Deliberately not reported: a list item's `ITEM_KEY`, a container with no fields at all (`api/content.ts`
  * falls back to `[]` for a collection with no configured entry type — "no schema"
  * isn't "every key is unknown"), and anything inside a `reference` value (a resolved
  * reference's value is `{ ...target data, id, slug, collection, urlPath }`; the
@@ -285,7 +278,7 @@ export function findUnknownKeys(fields, data) {
             return [];
         const known = new Set(flattenGroupFields(containerFields).map((field) => field.name));
         return Object.keys(record)
-            .filter((key) => !known.has(key) && !BLOCK_STRUCTURAL_KEYS.has(key))
+            .filter((key) => !known.has(key) && !BLOCK_STRUCTURAL_KEYS.has(key) && key !== ITEM_KEY)
             .map((key) => (path ? `${path}.${key}` : key));
     });
 }

package/dist/validation/field-traversal.d.ts

@@ -36,6 +36,12 @@ interface ContainerContext {
     data: Record<string, unknown>;
     /** Path to the record itself ('' at the top level, e.g. `blocks[0]` inside a block). */
     path: string;
+    /**
+     * The keys that lead from the traversed root to this record (`[]` at the top level). Unlike
+     * `path`, it addresses the data rather than the schema: a block item's fields live under its
+     * `value`, so the third block's record is `['blocks', 2, 'value']` where `path` reads `blocks[2]`.
+     */
+    dataPath: readonly (string | number)[];
 }
 /**
  * Visitor called once per container, before its fields are walked.
@@ -52,6 +58,8 @@ export interface ResolvedBlockItem {
     /** The record containing the block's nested field values */
     data: Record<string, unknown>;
 }
+/** A record of named fields: not null, and not an array, which spreading would index-key. */
+export declare function isPlainRecord(value: unknown): value is Record<string, unknown>;
 /**
  * Resolve a block item to its template fields and nested data record.
  *
@@ -78,4 +86,18 @@ export declare function resolveBlockItem(blockField: BlockFieldConfig, item: Rec
  */
 export declare function traverseFields<T>(fields: readonly FieldConfig[], data: Record<string, unknown>, visitor: FieldVisitor<T>, pathPrefix?: string, onContainer?: ContainerVisitor<T>): T[];
 export declare function findFieldsByType(fields: readonly FieldConfig[], data: Record<string, unknown>, fieldType: string): TraversalContext[];
+/** The id of a reference value held as an id string or a resolved `{ id, ... }` object. */
+export declare function referenceValueId(value: unknown): string | undefined;
+export interface ReferenceIdOccurrence {
+    id: string;
+    path: string;
+}
+/**
+ * Every id held by the schema's `reference` fields, in traversal order, one per stored value
+ * (duplicates kept). `path` is traverseFields' (`a.b`, `items[0].x`, `blocks[2].author`), plus
+ * `[i]` per element of a `list: true` reference (`reviewers[1]`). Raw ids and resolved or
+ * `unavailable` objects both yield their id (`referenceValueId`); `''`, null, and values with
+ * no id are skipped.
+ */
+export declare function collectReferenceIds(fields: readonly FieldConfig[], data: Record<string, unknown>): ReferenceIdOccurrence[];
 export {};

package/dist/validation/field-traversal.js

@@ -5,7 +5,8 @@
  * according to a schema, handling objects, blocks, and arrays with their
  * own schemas.
  */
-function isPlainRecord(value) {
+/** A record of named fields: not null, and not an array, which spreading would index-key. */
+export function isPlainRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /**
@@ -49,7 +50,7 @@ export function resolveBlockItem(blockField, item) {
  * @returns Array of all items returned by the visitors
  */
 export function traverseFields(fields, data, visitor, pathPrefix = '', onContainer) {
-    return walkFields(fields, data, visitor, pathPrefix, onContainer, true);
+    return walkFields(fields, data, visitor, pathPrefix, [], onContainer, true);
 }
 /**
  * The traversal itself. `fireContainer` is what keeps an inline group from being mistaken for a
@@ -58,10 +59,10 @@ export function traverseFields(fields, data, visitor, pathPrefix = '', onContain
  * every sibling of the group reads as an unknown key. The hook still propagates INTO the group,
  * so a nested object or block below it is reported normally.
  */
-function walkFields(fields, data, visitor, pathPrefix, onContainer, fireContainer) {
+function walkFields(fields, data, visitor, pathPrefix, dataPath, onContainer, fireContainer) {
     const results = [];
     if (onContainer && fireContainer) {
-        results.push(...onContainer({ fields, data, path: pathPrefix }));
+        results.push(...onContainer({ fields, data, path: pathPrefix, dataPath }));
     }
     for (const field of fields) {
         const fieldPath = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
@@ -69,7 +70,7 @@ function walkFields(fields, data, visitor, pathPrefix, onContainer, fireContaine
         // Inline groups are transparent to the data — their children live at the parent
         // data level, not under field.name, so skip the null/undefined guard for them.
         if (field.type === 'group') {
-            results.push(...walkFields(field.fields, data, visitor, pathPrefix, onContainer, false));
+            results.push(...walkFields(field.fields, data, visitor, pathPrefix, dataPath, onContainer, false));
             continue;
         }
         if (value === undefined || value === null)
@@ -82,12 +83,12 @@ function walkFields(fields, data, visitor, pathPrefix, onContainer, fireContaine
                     // list: true — value is an array of objects
                     value.forEach((item, index) => {
                         if (typeof item === 'object' && item !== null) {
-                            results.push(...walkFields(objectField.fields, item, visitor, `${fieldPath}[${index}]`, onContainer, true));
+                            results.push(...walkFields(objectField.fields, item, visitor, `${fieldPath}[${index}]`, [...dataPath, field.name, index], onContainer, true));
                         }
                     });
                 }
                 else if (typeof value === 'object' && value !== null) {
-                    results.push(...walkFields(objectField.fields, value, visitor, fieldPath, onContainer, true));
+                    results.push(...walkFields(objectField.fields, value, visitor, fieldPath, [...dataPath, field.name], onContainer, true));
                 }
             }
         }
@@ -98,7 +99,9 @@ function walkFields(fields, data, visitor, pathPrefix, onContainer, fireContaine
                     if (typeof item === 'object' && item !== null) {
                         const resolved = resolveBlockItem(blockField, item);
                         if (resolved) {
-                            results.push(...walkFields(resolved.fields, resolved.data, visitor, `${fieldPath}[${index}]`, onContainer, true));
+                            results.push(...walkFields(resolved.fields, resolved.data, visitor, `${fieldPath}[${index}]`, resolved.data === item
+                                ? [...dataPath, field.name, index]
+                                : [...dataPath, field.name, index, 'value'], onContainer, true));
                         }
                     }
                 });
@@ -115,3 +118,31 @@ export function findFieldsByType(fields, data, fieldType) {
         return [];
     });
 }
+/** The id of a reference value held as an id string or a resolved `{ id, ... }` object. */
+export function referenceValueId(value) {
+    if (typeof value === 'string')
+        return value;
+    if (isPlainRecord(value) && typeof value.id === 'string')
+        return value.id;
+    return undefined;
+}
+/**
+ * Every id held by the schema's `reference` fields, in traversal order, one per stored value
+ * (duplicates kept). `path` is traverseFields' (`a.b`, `items[0].x`, `blocks[2].author`), plus
+ * `[i]` per element of a `list: true` reference (`reviewers[1]`). Raw ids and resolved or
+ * `unavailable` objects both yield their id (`referenceValueId`); `''`, null, and values with
+ * no id are skipped.
+ */
+export function collectReferenceIds(fields, data) {
+    return traverseFields(fields, data, ({ field, value, path }) => {
+        if (field.type !== 'reference')
+            return [];
+        const items = Array.isArray(value)
+            ? value.map((item, index) => ({ item, path: `${path}[${index}]` }))
+            : [{ item: value, path }];
+        return items.flatMap(({ item, path: itemPath }) => {
+            const id = referenceValueId(item);
+            return id ? [{ id, path: itemPath }] : [];
+        });
+    });
+}

package/dist/validation/markdown-safety.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The save-time policy that keeps code out of `markdown` and `mdx` content.
+ *
+ * MDX compiles `{expressions}`, `import`/`export` and JSX into JavaScript that runs wherever a
+ * body renders: a preview with the viewer's session, a server render, a CI build. A body this
+ * policy accepts runs only the site's own components. A field or body `markdownPolicyOf` checks as
+ * MDX accepts:
+ *
+ * - no `import`/`export`, and no `{…}` expression except a comment or a static literal
+ *   (`{300}`, `{["a", "b"]}`), in text or as an attribute value; no spread attributes;
+ * - components by plain name (`<Callout>`, the site's own code) and HTML tags from
+ *   `SAFE_HTML_TAGS` only, since a tag is a real element whose attributes need no expression to
+ *   run code (`<script>`, `<iframe srcdoc>`);
+ * - on an HTML tag, attributes from `SAFE_HTML_ATTRIBUTES` and `aria-*` only; no event handler
+ *   (`on…` on a tag, `onX` on a component), `dangerouslySetInnerHTML` or `srcdoc` anywhere;
+ * - URLs, in links, images, definitions and URL attributes, that are relative, use a scheme in
+ *   `SAFE_URL_SCHEMES`, or are raster `data:` images; no `javascript:` or `vbscript:` value in any
+ *   prop. React 18 renders a `javascript:` href as given.
+ *
+ * An `mdxAllow` allowlist (`mdx-allowlist.ts`) narrows this further. Other markdown renders braces
+ * and imports as text and runs no tag without raw HTML, so only its URLs are checked; a field with
+ * `executable: true` is not checked. A body is parsed with and without GFM, so `remark-gfm` cannot
+ * hide a construct; an MDX body that does not parse cannot be checked, so is refused.
+ *
+ * A save keeps code the stored entry already holds (from outside the CMS, or from before this
+ * policy) only in a field saved unchanged: code reads what surrounds it (the props beside it, its
+ * parent, the markup a script reads), so no smaller unit is safe to keep. Other fields stay
+ * editable, and removing the code is always accepted.
+ */
+import type { ContentFormat, EntrySchema, MdxAllowlist } from '../config/index.js';
+import type { EntryFieldError } from './entry-validator.js';
+import type { ResolvedMdxAllowlist } from './mdx-allowlist.js';
+type MarkdownDialect = 'md' | 'mdx';
+interface MarkdownSafetyIssue {
+    message: string;
+    /** 1-based line in the checked source, when known. */
+    line?: number;
+    /** What a stored issue must match to be kept: its dialect, allowlist and whole field. None: never kept. */
+    key?: string;
+}
+/** One field's issues. */
+export interface MarkdownSafetyFinding {
+    fieldPath: string;
+    issues: MarkdownSafetyIssue[];
+}
+/**
+ * Every construct in `source` that runs code, or loads a URL that does, when it renders.
+ * @internal Exported for tests.
+ */
+export declare function findUnsafeMarkdown(source: string, dialect: MarkdownDialect, allow?: ResolvedMdxAllowlist): MarkdownSafetyIssue[];
+/**
+ * The policy's issues in one entry's on-disk-shaped data, the body merged in under the schema's
+ * body field name. The body is checked as `markdownPolicyOf` says for its field and the entry's
+ * format, even when the schema declares no body field; it is exempt only when its field is
+ * `executable`. `siteAllow` is the config's `mdxAllow`, under each field's own.
+ */
+export declare function findMarkdownSafetyIssues(fields: EntrySchema, format: ContentFormat | undefined, data: Record<string, unknown>, siteAllow?: MdxAllowlist): MarkdownSafetyFinding[];
+/**
+ * Splits a save's findings into those it adds, which refuse it, and those of a field saved exactly
+ * as the stored entry held it, which it keeps. Fields are matched by site and key, one stored field
+ * for one saved field, so a second copy of a stored field is refused, as is one moved to a field of
+ * another name or allowlist. A finding with an unkeyed issue is never kept.
+ */
+export declare function splitByStored(found: readonly MarkdownSafetyFinding[], stored: readonly MarkdownSafetyFinding[]): {
+    refused: EntryFieldError[];
+    kept: EntryFieldError[];
+};
+export {};