canopycms 0.0.68-int.98 → 0.1.0

package/dist/config/schemas/media.d.ts

@@ -4,22 +4,18 @@
 import { z } from 'zod';
 export declare const mediaSchema: z.ZodDiscriminatedUnion<"adapter", [z.ZodObject<{
     adapter: z.ZodLiteral<"local">;
-    publicBaseUrl: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     /** Root directory for local asset storage. Defaults to the caller's dev-assets dir. */
     directory: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>>;
 }, "strict", z.ZodTypeAny, {
     adapter: "local";
-    publicBaseUrl?: string | undefined;
     directory?: string | undefined;
 }, {
     adapter: "local";
-    publicBaseUrl?: string | undefined;
     directory?: string | undefined;
 }>, z.ZodObject<{
     adapter: z.ZodLiteral<"s3">;
     bucket: z.ZodString;
     region: z.ZodString;
-    publicBaseUrl: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     /**
      * Where the browser POSTs a presigned direct upload. Absolute http(s) URL or a
      * site-relative path; defaults to the S3 REST endpoint the AWS SDK returns.
@@ -29,10 +25,10 @@ export declare const mediaSchema: z.ZodDiscriminatedUnion<"adapter", [z.ZodObjec
      * signature is unaffected — a presigned POST's string-to-sign is the base64 policy
      * alone, so the host never enters it (pinned by store-s3.test.ts).
      *
-     * NOT a prefix. Unlike `publicBaseUrl`, nothing is joined onto this value; it replaces
-     * the POST target outright and is passed through byte-for-byte. Do not route it through
-     * `joinUrlPrefix` "for consistency" — that would strip the trailing slash and silently
-     * stop a CDN path pattern like `/asset-upload/*` from matching.
+     * NOT a prefix: nothing is joined onto this value; it replaces the POST target outright
+     * and is passed through byte-for-byte. Do not route it through `joinUrlPrefix` "for
+     * consistency" — that would strip the trailing slash and silently stop a CDN path
+     * pattern like `/asset-upload/*` from matching.
      */
     uploadUrl: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     /** Max upload size in bytes for presigned direct uploads. Defaults to 50 MiB. */
@@ -41,23 +37,18 @@ export declare const mediaSchema: z.ZodDiscriminatedUnion<"adapter", [z.ZodObjec
     adapter: "s3";
     bucket: string;
     region: string;
-    publicBaseUrl?: string | undefined;
     uploadUrl?: string | undefined;
     maxUploadBytes?: number | undefined;
 }, {
     adapter: "s3";
     bucket: string;
     region: string;
-    publicBaseUrl?: string | undefined;
     uploadUrl?: string | undefined;
     maxUploadBytes?: number | undefined;
 }>, z.ZodObject<{
     adapter: z.ZodLiteral<"lfs">;
-    publicBaseUrl: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strict", z.ZodTypeAny, {
     adapter: "lfs";
-    publicBaseUrl?: string | undefined;
 }, {
     adapter: "lfs";
-    publicBaseUrl?: string | undefined;
 }>]>;

package/dist/config/schemas/media.js

@@ -3,7 +3,7 @@
  */
 import { z } from 'zod';
 import { relativePathSchema } from './collection.js';
-import { assetMountUrlSchema, uploadTargetUrlSchema } from './url.js';
+import { uploadTargetUrlSchema } from './url.js';
 // Media adapter configuration schema.
 // Keyed as a discriminated union on `adapter` so each adapter's required fields are
 // enforced at parse time. With a plain z.union, a malformed s3 config (e.g. missing
@@ -26,7 +26,6 @@ export const mediaSchema = z.discriminatedUnion('adapter', [
     z
         .object({
         adapter: z.literal('local'),
-        publicBaseUrl: assetMountUrlSchema.optional(),
         /** Root directory for local asset storage. Defaults to the caller's dev-assets dir. */
         directory: relativePathSchema.optional(),
     })
@@ -36,7 +35,6 @@ export const mediaSchema = z.discriminatedUnion('adapter', [
         adapter: z.literal('s3'),
         bucket: z.string().min(1),
         region: z.string().min(1),
-        publicBaseUrl: assetMountUrlSchema.optional(),
         /**
          * Where the browser POSTs a presigned direct upload. Absolute http(s) URL or a
          * site-relative path; defaults to the S3 REST endpoint the AWS SDK returns.
@@ -46,10 +44,10 @@ export const mediaSchema = z.discriminatedUnion('adapter', [
          * signature is unaffected — a presigned POST's string-to-sign is the base64 policy
          * alone, so the host never enters it (pinned by store-s3.test.ts).
          *
-         * NOT a prefix. Unlike `publicBaseUrl`, nothing is joined onto this value; it replaces
-         * the POST target outright and is passed through byte-for-byte. Do not route it through
-         * `joinUrlPrefix` "for consistency" — that would strip the trailing slash and silently
-         * stop a CDN path pattern like `/asset-upload/*` from matching.
+         * NOT a prefix: nothing is joined onto this value; it replaces the POST target outright
+         * and is passed through byte-for-byte. Do not route it through `joinUrlPrefix` "for
+         * consistency" — that would strip the trailing slash and silently stop a CDN path
+         * pattern like `/asset-upload/*` from matching.
          */
         uploadUrl: uploadTargetUrlSchema.optional(),
         /** Max upload size in bytes for presigned direct uploads. Defaults to 50 MiB. */
@@ -59,7 +57,6 @@ export const mediaSchema = z.discriminatedUnion('adapter', [
     z
         .object({
         adapter: z.literal('lfs'),
-        publicBaseUrl: assetMountUrlSchema.optional(),
     })
         .strict(),
 ]);

package/dist/config/schemas/url.d.ts

@@ -13,27 +13,9 @@ import { z } from 'zod';
 /**
  * Where the browser POSTs a presigned direct upload (`media.uploadUrl`).
  *
- * Stricter than `assetMountUrlSchema` by exactly one case — no protocol-relative `//host` —
- * because that spelling is ambiguous rather than insecure: it resolves to http or https
- * depending on the editor page issuing the upload, so the config would not determine where a
- * live credential is sent. `isHttpUrlOrSameOriginPath`'s doc carries the full reasoning,
- * including why bare `http://` is nonetheless accepted.
- *
- * "Exactly one case" is measured, not asserted: a census over every 4-character string
- * drawn from an 11-symbol alphabet (slash, backslash, dot, colon, %2e, ?, #, tab, and three
- * letters), plus hand-written shapes, found 39 values the two schemas treat differently — and
- * every one is a literal `//host` (three only after `.trim()` strips a leading tab).
+ * `isHttpUrlOrSameOriginPath`'s doc carries the reasoning, including why a protocol-relative
+ * `//host` is refused while bare `http://` is accepted.
  */
 export declare const uploadTargetUrlSchema: z.ZodEffects<z.ZodString, string, string>;
-/**
- * Where `/assets/…` is mounted for the editor's own previews (`media.publicBaseUrl`).
- *
- * Accepts an absolute http(s) URL, a protocol-relative `//host` URL, or a site-relative path
- * (see `.claude/future-tasks/editor-asset-mount-topology.md` option 1 — the `basePath` fallback
- * in `editor/context/AssetContext.tsx` exists for sites that need one and can't set an absolute
- * value). Rejects non-http(s) schemes: a plain `z.string().url()` check would accept
- * `publicBaseUrl: 'mailto:a@b.c'` and produce `/mailto:a@b.c/assets/…` at render time.
- */
-export declare const assetMountUrlSchema: z.ZodEffects<z.ZodString, string, string>;
 /** `editor.previewPrefix`, by `uploadTargetUrlSchema`'s rule: `//host` leaves the scheme open. */
 export declare const previewPrefixSchema: z.ZodEffects<z.ZodString, string, string>;

package/dist/config/schemas/url.js

@@ -14,16 +14,8 @@ import { isHttpUrlOrSameOriginPath } from '../../utils/sanitize-href.js';
 /**
  * Where the browser POSTs a presigned direct upload (`media.uploadUrl`).
  *
- * Stricter than `assetMountUrlSchema` by exactly one case — no protocol-relative `//host` —
- * because that spelling is ambiguous rather than insecure: it resolves to http or https
- * depending on the editor page issuing the upload, so the config would not determine where a
- * live credential is sent. `isHttpUrlOrSameOriginPath`'s doc carries the full reasoning,
- * including why bare `http://` is nonetheless accepted.
- *
- * "Exactly one case" is measured, not asserted: a census over every 4-character string
- * drawn from an 11-symbol alphabet (slash, backslash, dot, colon, %2e, ?, #, tab, and three
- * letters), plus hand-written shapes, found 39 values the two schemas treat differently — and
- * every one is a literal `//host` (three only after `.trim()` strips a leading tab).
+ * `isHttpUrlOrSameOriginPath`'s doc carries the reasoning, including why a protocol-relative
+ * `//host` is refused while bare `http://` is accepted.
  */
 export const uploadTargetUrlSchema = z
     .string()
@@ -31,21 +23,6 @@ export const uploadTargetUrlSchema = z
     .refine((value) => isHttpUrlOrSameOriginPath(value), {
     message: 'must be an absolute http(s) URL or a site-relative path beginning with a single "/", with no query or fragment',
 });
-/**
- * Where `/assets/…` is mounted for the editor's own previews (`media.publicBaseUrl`).
- *
- * Accepts an absolute http(s) URL, a protocol-relative `//host` URL, or a site-relative path
- * (see `.claude/future-tasks/editor-asset-mount-topology.md` option 1 — the `basePath` fallback
- * in `editor/context/AssetContext.tsx` exists for sites that need one and can't set an absolute
- * value). Rejects non-http(s) schemes: a plain `z.string().url()` check would accept
- * `publicBaseUrl: 'mailto:a@b.c'` and produce `/mailto:a@b.c/assets/…` at render time.
- */
-export const assetMountUrlSchema = z
-    .string()
-    .trim()
-    .refine((value) => isHttpUrlOrSameOriginPath(value, { allowProtocolRelative: true }), {
-    message: 'must be an absolute http(s) URL, a protocol-relative "//host" URL, or a site-relative path beginning with a single "/", with no query or fragment',
-});
 /** `editor.previewPrefix`, by `uploadTargetUrlSchema`'s rule: `//host` leaves the scheme open. */
 export const previewPrefixSchema = z
     .string()

package/dist/config/types.d.ts

@@ -9,8 +9,10 @@ import type { LogicalPath, ContentId } from '../paths/types.js';
 import type { PermissionPath } from '../authorization/types.js';
 import type { EntryLinkUrlResolver } from '../entry-link-resolver.js';
 import type { CropRect } from '../assets/transform-directives.js';
-export declare const primitiveFieldTypes: readonly ["string", "number", "boolean", "datetime", "markdown", "mdx", "code"];
-export declare const fieldTypes: readonly ["string", "number", "boolean", "datetime", "markdown", "mdx", "code", "image", "select", "reference", "object", "block", "group"];
+declare const scalarFieldTypes: readonly ["string", "number", "boolean", "datetime", "code"];
+export declare const markdownFieldTypes: readonly ["markdown", "mdx"];
+export declare const primitiveFieldTypes: readonly ["string", "number", "boolean", "datetime", "code", "markdown", "mdx"];
+export declare const fieldTypes: readonly ["string", "number", "boolean", "datetime", "code", "markdown", "mdx", "image", "select", "reference", "object", "block", "group"];
 export type PrimitiveFieldType = (typeof primitiveFieldTypes)[number];
 export type FieldType = (typeof fieldTypes)[number];
 export type ContentFormat = 'md' | 'mdx' | 'json' | 'yaml';
@@ -51,7 +53,52 @@ interface BaseFieldConfig {
     isBody?: boolean;
 }
 interface PrimitiveFieldConfig extends BaseFieldConfig {
-    type: PrimitiveFieldType;
+    type: (typeof scalarFieldTypes)[number];
+    /**
+     * On a top-level, optional, single `datetime` field: Canopy's first submit of an entry new to
+     * the base branch sets the field, while it is empty, to the submit's time
+     * (`stamp-on-publish.ts`). `ensureStampOnPublishPlacement` (`validation.ts`) refuses it
+     * anywhere else.
+     */
+    stampOnPublish?: boolean;
+}
+/** Content that would run code as it renders is refused at save; see `validation/markdown-safety.ts`. */
+export interface MarkdownFieldConfig extends BaseFieldConfig {
+    type: (typeof markdownFieldTypes)[number];
+    /** Accept code, making every editor of this field a code author for whoever renders it. */
+    executable?: boolean;
+    /** On a `markdown` field the site compiles as MDX: check it as MDX. */
+    renderAs?: 'mdx';
+    /** Narrow what this field accepts as MDX, key by key over the site's `mdxAllow`. */
+    mdxAllow?: MdxAllowlist;
+}
+/**
+ * A prop's allowed values. `true`: any value the base policy accepts, a bare attribute (`<X open>`,
+ * the value `true`) and `{…}` values included. `'string'`: only a quoted string, `title="…"`; a
+ * bare attribute and every `{…}` refused. The object form adds `maxLength`, in characters (code
+ * points). A list: those values only; `[true, false]` is a boolean (bare, `{true}`, `{false}`).
+ */
+export type MdxPropAllow = true | 'string' | {
+    type: 'string';
+    maxLength?: number;
+} | Array<string | number | boolean>;
+export interface MdxComponentAllow {
+    /** Allowed props by name. Omitted: any prop. `{}`: none. */
+    props?: Record<string, MdxPropAllow>;
+}
+/**
+ * What an MDX body may hold, narrowing the base policy (`validation/mdx-allowlist.ts`). An omitted
+ * key keeps the base policy's choice.
+ */
+export interface MdxAllowlist {
+    /** Allowed components by name. Omitted: any plainly named component. `{}`: none. */
+    components?: Record<string, MdxComponentAllow>;
+    /** Allowed HTML tags, from the base policy's safe set. Omitted: that whole set. `[]`: none. */
+    htmlTags?: string[];
+    /** `false` refuses every `{…}`, comments and plain values included. Default `true`. */
+    expressions?: boolean;
+    /** `false` refuses `<>…</>`. Default `true`. */
+    fragments?: boolean;
 }
 export interface SelectFieldConfig extends BaseFieldConfig {
     type: 'select';
@@ -134,9 +181,16 @@ export interface ObjectFieldConfig extends BaseFieldConfig {
     fields: FieldConfig[];
     /**
      * On a `list: true` object, a direct `string` or `number` child whose value titles each
-     * item's card; a blank or non-finite value falls back to "<label> #N".
+     * item's card; a blank or non-finite value falls back to the item's first non-blank `string`
+     * field, then "Item N".
      */
     itemTitleField?: string;
+    /**
+     * On a `list: true` object, what one item is called, as it reads mid-sentence ("team member"):
+     * the add button reads "Add team member" and an untitled item "Team member 3". Without it,
+     * "Add item" and "Item 3". `ensureItemTitleFieldsExist` (`validation.ts`) checks it.
+     */
+    itemLabel?: string;
 }
 /**
  * Inline group field config: visually groups fields in the editor without creating
@@ -159,22 +213,19 @@ export interface InlineGroupFieldConfig {
 export type CustomFieldConfig = BaseFieldConfig & {
     type: Exclude<string, FieldType>;
 };
-export type FieldConfig = PrimitiveFieldConfig | SelectFieldConfig | ReferenceFieldConfig | ImageFieldConfig | BlockFieldConfig | ObjectFieldConfig | InlineGroupFieldConfig | CustomFieldConfig;
+export type FieldConfig = PrimitiveFieldConfig | MarkdownFieldConfig | SelectFieldConfig | ReferenceFieldConfig | ImageFieldConfig | BlockFieldConfig | ObjectFieldConfig | InlineGroupFieldConfig | CustomFieldConfig;
 export type MediaConfig = {
     adapter: 'local';
-    publicBaseUrl?: string;
     directory?: string;
 } | {
     adapter: 's3';
     bucket: string;
     region: string;
-    publicBaseUrl?: string;
     /** POST target for presigned direct uploads; see mediaSchema's s3 branch. */
     uploadUrl?: string;
     maxUploadBytes?: number;
 } | {
     adapter: 'lfs';
-    publicBaseUrl?: string;
 };
 /**
  * Field definitions for one entry type — the array of FieldConfig that
@@ -201,6 +252,23 @@ export type EntryTypeConfig = {
     readonly description?: string;
     readonly default?: boolean;
     readonly maxItems?: number;
+    /**
+     * Set when this entry type could not be resolved, and `schema` is then empty. Only a
+     * branch workspace's schema carries it (see `BranchSchemaCache`); reading, writing,
+     * creating, renaming or deleting an entry of this type is refused.
+     */
+    readonly unavailable?: EntryTypeUnavailable;
+};
+/**
+ * Why an entry type has no schema: its `.collection.json` names an entry schema the running
+ * code's registry does not define, as when content synced ahead of the image that adds it.
+ */
+export type EntryTypeUnavailable = {
+    readonly reason: 'unknown-schema';
+    /** The registry key the meta file names. */
+    readonly schemaRef: string;
+    /** The meta file naming it, relative to the content root. */
+    readonly metaFile: string;
 };
 /**
  * Collection: contains nested collections and typed entries.
@@ -224,7 +292,7 @@ export type CollectionConfig = {
  * Contains top-level collections and entries (typed content at the root level).
  */
 export type RootCollectionConfig = {
-    /** Optional label for the root collection (e.g., "All Files", "Content") */
+    /** Optional label for the root collection (e.g., "All content", "Content") */
     readonly label?: string;
     /** Entry types at the root level */
     readonly entries?: readonly EntryTypeConfig[];
@@ -254,7 +322,6 @@ export interface EditorSignInProps {
 }
 export interface CanopyEditorConfig {
     title?: string;
-    subtitle?: string;
     theme?: unknown;
     /**
      * Preview-pane routes for sites whose routes don't mirror their content tree; otherwise an entry
@@ -331,12 +398,15 @@ export interface EntryValidationIssue {
     /** Path of the offending field (e.g. 'body'), when known. */
     fieldPath?: string;
 }
-/** Input passed to the `validateEntry` hook on every editor save. */
+/** Input passed to the `validateEntry` hook on every content save, from the editor or not. */
 export interface ValidateEntryInput {
     /** Logical entry path including the content root (e.g. 'content/posts/hello-world'). */
     entryPath: string;
     branch: string;
-    /** Entry type name when the editor specifies one (collections with multiple entry types). */
+    /**
+     * The entry type the save is validated and written as: an existing entry's on-disk type, else
+     * the requested one, else the collection's default. Absent only when the collection has none.
+     */
     entryType?: string;
     format: 'md' | 'mdx' | 'json' | 'yaml';
     data: Record<string, unknown>;
@@ -377,12 +447,18 @@ export interface CanopyConfig {
     sourceRoot?: SourceRoot;
     /** Deployment prefix the host app is served under — see {@link CanopyConfigInput.basePath}. */
     basePath?: string;
+    /** HTTP status of an unauthenticated API response — see {@link CanopyConfigInput.unauthenticatedStatus}. */
+    unauthenticatedStatus?: 401 | 419;
+    /** What a production build does on a dangling reference — see {@link CanopyConfigInput.danglingReferences}. */
+    danglingReferences?: 'error' | 'warn';
     editor?: CanopyEditorConfig;
     authPlugin?: AuthPlugin;
     /** Custom URL resolver for entry links — see {@link CanopyConfigInput.entryLinkUrl}. */
     entryLinkUrl?: EntryLinkUrlResolver;
     /** Save-time validation hook — see {@link CanopyConfigInput.validateEntry}. */
     validateEntry?: ValidateEntryHook;
+    /** Site default for every field checked as MDX — see {@link CanopyConfigInput.mdxAllow}. */
+    mdxAllow?: MdxAllowlist;
     /** Dev-mode-only behavior — see {@link CanopyConfigInput.dev}. */
     dev?: DevConfig;
 }
@@ -400,7 +476,10 @@ export interface CanopyConfigInput {
     defaultRemoteUrl?: string;
     gitBotAuthorName: string;
     gitBotAuthorEmail: string;
-    /** Add `Edited-by: Name (user id)` for the submitter to submit commits. Default true. */
+    /**
+     * Add `Edited-by: Name (user id)` to submit commits, for the submitter and each user who saved
+     * since the last submit commit, and to settings commits for the user making the change. Default true.
+     */
     gitEditedByTrailers?: boolean;
     /** Also add `Co-authored-by: Name <email>`. Default false: emails in public history are public. */
     gitCoAuthoredByTrailers?: boolean;
@@ -442,12 +521,33 @@ export interface CanopyConfigInput {
      * silently filter out every entry (zero static params, a build that goes green with no pages).
      */
     basePath?: string;
+    /**
+     * HTTP status of an API response to a request with no accepted session. Default 401.
+     *
+     * Set 419 when the site's own pages sit behind HTTP Basic auth on the same origin as the
+     * editor. Chrome, holding a Basic credential entered at the site root, sends it with the
+     * editor's API requests and drops it when one answers 401; the next gated request, such as a
+     * preview image, then waits on a Basic prompt. 419 rather than 403
+     * because a CloudFront custom error response cannot match 419, and one mapping 403 to an error
+     * page would replace the body below.
+     *
+     * The body says `status: 401` either way, and that is what the editor detects sign-out from.
+     */
+    unauthenticatedStatus?: 401 | 419;
+    /**
+     * What a production build does when a reference names no entry. Default `'error'`: the build
+     * fails, listing each entry, field path and missing id, since the page would otherwise ship
+     * without what the reference supplied. `'warn'` prints the list, capped at 20, and lets the build pass.
+     */
+    danglingReferences?: 'error' | 'warn';
     editor?: CanopyEditorConfig;
     authPlugin?: AuthPlugin;
     /** Custom URL resolver for entry links. Overrides the default URL computation. */
     entryLinkUrl?: EntryLinkUrlResolver;
     /** Save-time validation hook. 'error' issues reject the save; 'warning' issues are returned with it. */
     validateEntry?: ValidateEntryHook;
+    /** What every field checked as MDX accepts; a field's own `mdxAllow` replaces it key by key. */
+    mdxAllow?: MdxAllowlist;
     /** Dev-mode-only behavior (content-sync divergence detection). Ignored when mode !== 'dev'. */
     dev?: DevConfig;
 }
@@ -487,22 +587,16 @@ export type FlatSchemaItem = {
     schemaRef?: string;
     default?: boolean;
     maxItems?: number;
+    /** See {@link EntryTypeConfig.unavailable}. */
+    unavailable?: EntryTypeUnavailable;
 };
 /**
  * Client config - subset safe for browser (DRY - derived from CanopyConfig)
  * Use flatSchema for O(1) cached access to the flattened schema structure.
  * Schema is loaded from .collection.json files on the server and provided as flatSchema.
  */
-export type CanopyClientConfig = Pick<CanopyConfig, 'defaultBaseBranch' | 'defaultActiveBranch' | 'contentRoot' | 'editor' | 'mode' | 'entryLinkUrl' | 'basePath'> & {
+export type CanopyClientConfig = Pick<CanopyConfig, 'defaultBaseBranch' | 'defaultActiveBranch' | 'contentRoot' | 'editor' | 'mode' | 'entryLinkUrl' | 'basePath' | 'mdxAllow'> & {
     flatSchema: FlatSchemaItem[];
-    /**
-     * `media.publicBaseUrl`, when configured - the only part of `media` safe/
-     * useful to expose client-side (the editor may be served from a different
-     * origin than the site; the rest of `MediaConfig` - bucket, region, etc -
-     * has no business in a browser bundle). Threaded through to `Editor`'s
-     * `assetBaseUrl` prop. Undefined means root-relative asset URLs.
-     */
-    assetBaseUrl?: string;
 };
 export interface ClientOnlyFields {
     editor?: {

package/dist/config/types.js

@@ -2,15 +2,9 @@
  * Type definitions for CanopyCMS configuration.
  * These are pure TypeScript types - Zod schemas are in ./schemas/
  */
-export const primitiveFieldTypes = [
-    'string',
-    'number',
-    'boolean',
-    'datetime',
-    'markdown',
-    'mdx',
-    'code',
-];
+const scalarFieldTypes = ['string', 'number', 'boolean', 'datetime', 'code'];
+export const markdownFieldTypes = ['markdown', 'mdx'];
+export const primitiveFieldTypes = [...scalarFieldTypes, ...markdownFieldTypes];
 // 'image' is not a primitive: it has a structured value (ImageFieldValue) and
 // its own per-type config (ImageFieldConfig, below), so it gets a dedicated
 // entry rather than sharing PrimitiveFieldConfig's flat shape.

package/dist/config/validation.d.ts

@@ -5,12 +5,19 @@
  * from `createEntrySchemaRegistry` so the canonical schema-authoring path runs
  * the same checks. Exported so the test suite can exercise them directly.
  */
-import type { CanopyConfig } from './types.js';
+import type { CanopyConfig, FieldConfig } from './types.js';
 /**
  * Recursively check that all select fields have options defined.
  * Throws an error if a select field is missing options.
  */
 export declare const ensureSelectFieldsHaveOptions: (fields: unknown) => void;
+/**
+ * Check that every data field's name can be spelled as a field path segment (`isPathFieldName`):
+ * the form, the preview's marks, validation errors and comment threads all name a field by its
+ * path. An inline group's own name is not part of any path, so only its children are checked.
+ * `ITEM_KEY` is reserved too, since every list item and block carries it.
+ */
+export declare const ensureFieldNamesSpellInPaths: (fields: unknown) => void;
 /**
  * Recursively check that all reference fields have at least one of `collections` or `entryTypes`.
  * Throws an error if a reference field has neither.
@@ -26,9 +33,11 @@ export declare const ensureReferenceFieldsHaveScope: (fields: unknown) => void;
  */
 export declare const forEachReferenceField: (fields: unknown, visit: (field: Record<string, unknown>) => void) => void;
 /**
- * Check that every `itemTitleField` sits on a `list: true` object and names a direct child
- * of type `string` or `number`, the only values the card heading shows as typed (a reference
- * would show its raw id, a select its stored value). Throws an error when it does not.
+ * Check that every `itemLabel` is non-blank text and, like every `itemTitleField`, sits on a
+ * `list: true` object, and that every `itemTitleField` names a direct child of type `string` or
+ * `number`, the only values the card heading shows as typed (a reference would show its raw id, a
+ * select its stored value). Throws an error when it does not. Entry schemas reach the editor
+ * through these checks, not the zod field schema.
  */
 export declare const ensureItemTitleFieldsExist: (fields: unknown) => void;
 /**
@@ -46,6 +55,18 @@ export declare const ensureNoFlattenedFieldNameCollisions: (fields: unknown, sco
  * correct TypeScript types but broken editor rendering.
  */
 export declare const ensureNoGroupsInsideComplexFields: (fields: unknown) => void;
+/**
+ * Check that `stampOnPublish` sits only on an entry's own top-level `datetime` field (an inline
+ * group's members count, since groups carry no data) that is neither `list: true` nor
+ * `required: true`. The submit that stamps sets one top-level value, and a required field can
+ * never be saved empty, so it would never be stamped. Throws on the first problem.
+ */
+export declare const ensureStampOnPublishPlacement: (fields: unknown, scopeLabel?: string) => void;
+/**
+ * Check every markdown and mdx field's `mdxAllow` against its schema and its `renderAs`,
+ * `mdxAllow` and `executable` against each other. Throws on the first problem.
+ */
+export declare const ensureMarkdownFieldOptions: (fields: readonly FieldConfig[]) => void;
 /**
  * Validate and normalize a CanopyConfig object.
  * Performs Zod validation and normalizes paths. Field-shape validation for