@aphexcms/cms-core 9.6.0 → 9.8.0

package/dist/field-validation/utils.js

@@ -81,6 +81,180 @@ export function validateValueShape(field, value) {
             return null;
     }
 }
+/**
+ * Find which `of` entry an array item belongs to. Mirrors ArrayField.svelte's own
+ * resolution (`ref.name === item._type || ref.type === item._type`). An item
+ * carrying an explicit `_type` must match one of the declared entries — an
+ * unrecognized `_type` is an error, never silently coerced to some other entry,
+ * even when only one type is declared. The single-entry fallback only applies
+ * when the item has no `_type` tag at all (untagged items in a single-type array).
+ */
+function resolveArrayItemTypeRef(of, item) {
+    if (isPlainObject(item) && typeof item._type === 'string') {
+        return of.find((ref) => ref.name === item._type || ref.type === item._type);
+    }
+    if (of.length === 1)
+        return of[0];
+    return undefined;
+}
+/**
+ * A leaf field error message is always formatted as `Field "<path>" <reason>`
+ * (see the bottom of `validateField`). When that message becomes an input to a
+ * shallower level of array-item recursion, re-wrapping it verbatim would nest
+ * "Field ..." text once per level. Instead, pull the deeper path back out so the
+ * caller can extend it into one clean breadcrumb and keep only the reason.
+ */
+function splitFieldMessage(message) {
+    const match = message.match(/^Field "([^"]+)"\s*(.*)$/s);
+    return match
+        ? { path: match[1] ?? null, reason: match[2] ?? message }
+        : { path: null, reason: message };
+}
+/**
+ * Shape-check a single Portable Text text block (`_type: 'block'`) — `_key`, `children`
+ * (spans and/or inline objects), and `markDefs` all need to be the shape
+ * portable-text-serializer.ts produces, since nothing else in this write path checks it.
+ * A source that isn't the TipTap editor (an agent's `content_patch_fields` call, an
+ * imported document) has no other gate before this reaches storage.
+ */
+function validatePortableTextBlock(item, itemPath) {
+    if (!isPlainObject(item)) {
+        return [
+            {
+                field: itemPath,
+                errors: [`expected a Portable Text block object, got ${describeValue(item)}`]
+            }
+        ];
+    }
+    const errors = [];
+    if (typeof item._key !== 'string' || item._key.length === 0) {
+        errors.push('is missing a non-empty "_key"');
+    }
+    if (item.style !== undefined && typeof item.style !== 'string') {
+        errors.push(`"style" must be a string, got ${describeValue(item.style)}`);
+    }
+    if (item.listItem !== undefined && typeof item.listItem !== 'string') {
+        errors.push(`"listItem" must be a string, got ${describeValue(item.listItem)}`);
+    }
+    if (item.level !== undefined && typeof item.level !== 'number') {
+        errors.push(`"level" must be a number, got ${describeValue(item.level)}`);
+    }
+    if (!Array.isArray(item.children)) {
+        errors.push(`"children" must be an array, got ${describeValue(item.children)}`);
+    }
+    else {
+        item.children.forEach((child, childIndex) => {
+            const childLabel = `child[${childIndex}]`;
+            if (!isPlainObject(child)) {
+                errors.push(`${childLabel} expected an object, got ${describeValue(child)}`);
+                return;
+            }
+            if (typeof child._type !== 'string' || child._type.length === 0) {
+                errors.push(`${childLabel} is missing a "_type"`);
+            }
+            if (typeof child._key !== 'string' || child._key.length === 0) {
+                errors.push(`${childLabel} is missing a non-empty "_key"`);
+            }
+            if (child._type === 'span') {
+                if (typeof child.text !== 'string') {
+                    errors.push(`${childLabel} (span) "text" must be a string, got ${describeValue(child.text)}`);
+                }
+                if (child.marks !== undefined && !Array.isArray(child.marks)) {
+                    errors.push(`${childLabel} (span) "marks" must be an array, got ${describeValue(child.marks)}`);
+                }
+            }
+        });
+    }
+    if (item.markDefs !== undefined) {
+        if (!Array.isArray(item.markDefs)) {
+            errors.push(`"markDefs" must be an array, got ${describeValue(item.markDefs)}`);
+        }
+        else {
+            item.markDefs.forEach((def, defIndex) => {
+                if (!isPlainObject(def)) {
+                    errors.push(`markDefs[${defIndex}] expected an object, got ${describeValue(def)}`);
+                    return;
+                }
+                if (typeof def._type !== 'string' || def._type.length === 0) {
+                    errors.push(`markDefs[${defIndex}] is missing a "_type"`);
+                }
+                if (typeof def._key !== 'string' || def._key.length === 0) {
+                    errors.push(`markDefs[${defIndex}] is missing a non-empty "_key"`);
+                }
+            });
+        }
+    }
+    return errors.length > 0 ? [{ field: itemPath, errors }] : [];
+}
+/**
+ * Recursively validate each array item against the type it resolves to in `of`.
+ * This is the check that was previously entirely missing: `validateValueShape`
+ * only confirmed the field's value IS an array, never that its items match `of` —
+ * so a mistyped or malformed array item (wrong `_type`, missing required nested
+ * fields) passed validation silently regardless of whether `of` was well-formed.
+ *
+ * Named types in `of` that aren't inline objects (`fields` absent) — i.e. a
+ * reference to another registered schema by name — aren't resolvable here: this
+ * module has no schema registry. Those items are left unvalidated, same as
+ * before this fix, rather than guessed at.
+ */
+async function validateArrayItems(field, items, context) {
+    const of = field.of ?? [];
+    const results = [];
+    for (let index = 0; index < items.length; index++) {
+        const item = items[index];
+        const itemPath = `${field.name}[${index}]`;
+        const typeRef = resolveArrayItemTypeRef(of, item);
+        if (!typeRef) {
+            const gotType = isPlainObject(item) && typeof item._type === 'string' ? item._type : describeValue(item);
+            const declared = of.map((t) => t.name ?? t.type).join(', ') || '(none declared)';
+            results.push({
+                field: itemPath,
+                errors: [
+                    `has type "${gotType}", which is not one of the declared array item types: ${declared}`
+                ]
+            });
+            continue;
+        }
+        // Portable Text text blocks (`_type: 'block'`) — the shape the TipTap editor always
+        // produces (portable-text-serializer.ts), but nothing an agent-authored patch is bound
+        // to. Custom block types (any other `_type` in `of`) fall through to the `typeRef.fields`
+        // branch below and get full field validation already; this is the one shape the rest of
+        // this function never checked.
+        if (typeRef.type === 'block') {
+            results.push(...validatePortableTextBlock(item, itemPath));
+            continue;
+        }
+        if (typeRef.type === 'reference') {
+            if (!isPlainObject(item) || typeof item._ref !== 'string') {
+                results.push({
+                    field: itemPath,
+                    errors: [
+                        `expected a reference object { _type: 'reference', _ref: '<documentId>' }, got ${describeValue(item)}`
+                    ]
+                });
+            }
+            continue;
+        }
+        if (typeRef.fields) {
+            if (!isPlainObject(item)) {
+                results.push({
+                    field: itemPath,
+                    errors: [`expected an object, got ${describeValue(item)}`]
+                });
+                continue;
+            }
+            const nested = await validateFieldSet(typeRef.fields, item, context);
+            for (const err of nested) {
+                for (const rawMessage of err.errors) {
+                    const { path, reason } = splitFieldMessage(rawMessage);
+                    results.push({ field: `${itemPath}.${path ?? err.field}`, errors: [reason] });
+                }
+            }
+        }
+    }
+    return results;
+}
 /**
  * Validate a field value against its validation rules
  */
@@ -102,6 +276,14 @@ export async function validateField(field, value, context = {}) {
             errors: [{ level: 'error', message: `Field "${field.name}" ${shapeError}` }]
         };
     }
+    // Array items are never validated by the shape check above (it only confirms
+    // the value IS an array) — recurse into each item against `field.of` here.
+    if (field.type === 'array' && Array.isArray(value)) {
+        const itemErrors = await validateArrayItems(field, value, context);
+        for (const err of itemErrors) {
+            allErrors.push({ level: 'error', message: `Field "${err.field}" ${err.errors.join('; ')}` });
+        }
+    }
     // Add automatic validation for date/datetime/url fields based on type
     if (field.type === 'date') {
         const dateField = field;
@@ -207,6 +389,34 @@ export function getValidationClasses(hasErrors) {
     // No green styling for success - only show red for errors
     return '';
 }
+/**
+ * Validate a flat set of fields against their values in `data`. Shared by
+ * top-level document validation and, recursively, by array-item/nested-object
+ * validation — `context.document` carries the full top-level document through
+ * either way, since it's set once by the top-level caller and left untouched on
+ * recursive calls (so cross-field `Rule.custom((v, { document }) => ...)`
+ * validators still see the whole document, not just the nested item).
+ */
+async function validateFieldSet(fields, data, context) {
+    const validationErrors = [];
+    for (const field of fields) {
+        const value = data[field.name];
+        const result = await validateField(field, value, {
+            ...context,
+            document: context.document !== undefined ? context.document : data
+        });
+        if (!result.isValid) {
+            const errorMessages = result.errors.filter((e) => e.level === 'error').map((e) => e.message);
+            if (errorMessages.length > 0) {
+                validationErrors.push({
+                    field: field.name,
+                    errors: errorMessages
+                });
+            }
+        }
+    }
+    return validationErrors;
+}
 /**
  * Validate an entire document's data against a schema
  * This function:
@@ -225,41 +435,13 @@ export async function validateDocumentData(schema, data, context = {}) {
         schemaName: schema.name,
         data
     });
-    const validationErrors = [];
     // Normalize date fields: convert to ISO for storage, user format for validation
     const { normalizedData, dataForValidation } = normalizeDateFields(data, schema);
     cmsLogger.debug('[validateDocumentData]', 'After normalization', {
         normalizedData,
         dataForValidation
     });
-    // Validate each field using the user-formatted data
-    for (const field of schema.fields) {
-        const value = dataForValidation[field.name];
-        cmsLogger.debug('[validateDocumentData]', `Validating field "${field.name}"`, {
-            type: field.type,
-            value
-        });
-        // Build the document context here from the data we're already validating —
-        // no need for callers to pass it. Cross-field validators read it via
-        // `Rule.custom((v, { document }) => ...)`, matching ValidationContext.
-        const result = await validateField(field, value, {
-            ...context,
-            document: dataForValidation
-        });
-        cmsLogger.debug('[validateDocumentData]', `Field "${field.name}" validation result`, {
-            isValid: result.isValid,
-            errors: result.errors
-        });
-        if (!result.isValid) {
-            const errorMessages = result.errors.filter((e) => e.level === 'error').map((e) => e.message);
-            if (errorMessages.length > 0) {
-                validationErrors.push({
-                    field: field.name,
-                    errors: errorMessages
-                });
-            }
-        }
-    }
+    const validationErrors = await validateFieldSet(schema.fields, dataForValidation, context);
     cmsLogger.debug('[validateDocumentData]', 'Final result', {
         isValid: validationErrors.length === 0,
         errors: validationErrors

package/dist/forms/define-form.d.ts

@@ -0,0 +1,25 @@
+import type { Field } from '../types/schemas.js';
+import type { FormDefinition } from './types.js';
+/**
+ * Define a form whose submission type is inferred from its own fields.
+ *
+ * @example
+ * ```ts
+ * export const contactForm = defineForm({
+ *   id: 'contact',
+ *   title: 'Contact us',
+ *   fields: [
+ *     { name: 'name', type: 'string', title: 'Name', validation: (R) => R.required() },
+ *     { name: 'email', type: 'string', title: 'Email', validation: (R) => R.required().email() },
+ *     { name: 'message', type: 'text', title: 'Message', validation: (R) => R.required() }
+ *   ]
+ * });
+ *
+ * type ContactSubmission = InferForm<typeof contactForm>;
+ * // { name?: string; email?: string; message?: string }
+ * ```
+ */
+export declare function defineForm<const F extends readonly Field[]>(form: Omit<FormDefinition, 'fields'> & {
+    fields: F;
+}): FormDefinition<F>;
+//# sourceMappingURL=define-form.d.ts.map

package/dist/forms/define-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-form.d.ts","sourceRoot":"","sources":["../../src/lib/forms/define-form.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,KAAK,EAAE,EAC1D,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,CAAC,CAAA;CAAE,GAClD,cAAc,CAAC,CAAC,CAAC,CAEnB"}

package/dist/forms/define-form.js

@@ -0,0 +1,22 @@
+/**
+ * Define a form whose submission type is inferred from its own fields.
+ *
+ * @example
+ * ```ts
+ * export const contactForm = defineForm({
+ *   id: 'contact',
+ *   title: 'Contact us',
+ *   fields: [
+ *     { name: 'name', type: 'string', title: 'Name', validation: (R) => R.required() },
+ *     { name: 'email', type: 'string', title: 'Email', validation: (R) => R.required().email() },
+ *     { name: 'message', type: 'text', title: 'Message', validation: (R) => R.required() }
+ *   ]
+ * });
+ *
+ * type ContactSubmission = InferForm<typeof contactForm>;
+ * // { name?: string; email?: string; message?: string }
+ * ```
+ */
+export function defineForm(form) {
+    return form;
+}

package/dist/forms/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './define-form.js';
+export * from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/forms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/forms/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/forms/index.js

@@ -0,0 +1,5 @@
+// Forms primitives — developer-owned form definitions with compile-time inference and
+// runtime validation reuse. Plain TS (no Svelte), safe in the root barrel.
+export * from './types.js';
+export * from './define-form.js';
+export * from './validate.js';

package/dist/forms/types.d.ts

@@ -0,0 +1,49 @@
+import type { Field, InferFields } from '../types/schemas.js';
+/**
+ * A developer-authored form. `id` is the stable public key (submission endpoint + event
+ * payload); `fields` is an ordinary CMS field array, so a text field, an email (a `string`
+ * with an email `Rule`), a number, a boolean, etc. all just work.
+ *
+ * The type parameter preserves the exact field literals when built via `defineForm`, which is
+ * what lets `InferForm<typeof form>` recover the submission shape with no generated types.
+ */
+export interface FormDefinition<F extends readonly Field[] = readonly Field[]> {
+    /** Stable public id — the submission key and the `form.submitted` payload's `formId`. */
+    id: string;
+    title: string;
+    /** The form's fields, reusing the CMS field DSL. */
+    fields: F;
+    /** Optional message a client can show after a successful submit. */
+    successMessage?: string;
+    /**
+     * Optional input transform, run on the raw submission BEFORE validation — the one thing
+     * validation can't do (it judges, never mutates): `trim()` strings, lowercase an email, coerce
+     * shapes. Return the transformed data. This is the forms-native equivalent of a schema's
+     * `beforeValidate` hook — a form isn't a document, so it owns its own input shaping here rather
+     * than borrowing the document-hook machinery. Rejection (required, format) still belongs in a
+     * field's `validation` Rule; side effects (notify) belong in a `form.submitted` consumer.
+     */
+    transform?: (data: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Where a "new submission" notification is sent. One address or several. Kept next to the form
+     * definition so the routing decision lives with the form, not in a global env var — different
+     * forms notify different inboxes. Omit to store-only (no notification); a notification consumer
+     * skips forms without it. The email itself is sent out of band by a `form.submitted` consumer,
+     * never in the submit path.
+     */
+    notifyEmail?: string | string[];
+    /**
+     * Persist submissions to `cms_plugin_storage` (under `plugin:'forms', collection:id`). Default
+     * `true`. Set `false` for a
+     * "just email me" form — the `form.submitted` event still fires (so notification consumers
+     * run), but nothing is stored. Matches the real split where some forms only notify.
+     */
+    store?: boolean;
+}
+/**
+ * The typed shape of a form's submission data, inferred from its fields. Values are
+ * `T | undefined` (a submission may omit optional fields); required-ness is enforced at
+ * runtime by validation, exactly as in the rest of the CMS.
+ */
+export type InferForm<D> = D extends FormDefinition<infer F> ? InferFields<F> : never;
+//# sourceMappingURL=types.d.ts.map

package/dist/forms/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/forms/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,SAAS,KAAK,EAAE,GAAG,SAAS,KAAK,EAAE;IAC5E,yFAAyF;IACzF,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,MAAM,EAAE,CAAC,CAAC;IACV,oEAAoE;IACpE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvE;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAChC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC"}

package/dist/forms/types.js

@@ -0,0 +1 @@
+export {};

package/dist/forms/validate.d.ts

@@ -0,0 +1,9 @@
+import type { FormDefinition } from './types.js';
+import { type DocumentValidationResult } from '../field-validation/utils.js';
+/**
+ * Validate raw submission data against a form's fields. Returns the standard
+ * `DocumentValidationResult` (`isValid`, field-keyed `errors`, `normalizedData`) — the core
+ * submit path rejects on `!isValid` and stores/emits from `normalizedData`.
+ */
+export declare function validateFormData(form: FormDefinition, data: Record<string, unknown>): Promise<DocumentValidationResult>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/forms/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/lib/forms/validate.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAwB,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAYhG;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,OAAO,CAAC,wBAAwB,CAAC,CAEnC"}

package/dist/forms/validate.js

@@ -0,0 +1,18 @@
+import { validateDocumentData } from '../field-validation/utils.js';
+/** Adapt a form to a schema-like object so the field validator can run against it. */
+function formToSchema(form) {
+    return {
+        type: 'object',
+        name: form.id,
+        title: form.title,
+        fields: [...form.fields]
+    };
+}
+/**
+ * Validate raw submission data against a form's fields. Returns the standard
+ * `DocumentValidationResult` (`isValid`, field-keyed `errors`, `normalizedData`) — the core
+ * submit path rejects on `!isValid` and stores/emits from `normalizedData`.
+ */
+export function validateFormData(form, data) {
+    return validateDocumentData(formToSchema(form), data);
+}

package/dist/hooks.d.ts

@@ -5,6 +5,7 @@ import type { DatabaseAdapter } from './db/index.js';
 import type { AssetService } from './services/asset-service.js';
 import type { StorageAdapter } from './storage/interfaces/storage.js';
 import type { EmailAdapter } from './email/index.js';
+import type { AIProviderAdapter } from './ai/index.js';
 import type { AuthProvider } from './auth/provider.js';
 import type { GraphQLSettings } from './graphql/index.js';
 import type { Logger } from './utils/logger.js';
@@ -20,6 +21,7 @@ export interface CMSInstances {
     storageAdapter: StorageAdapter;
     databaseAdapter: DatabaseAdapter;
     emailAdapter?: EmailAdapter | null;
+    aiProvider?: AIProviderAdapter | null;
     cmsEngine: CMSEngine;
     localAPI: LocalAPI;
     rolesService: RolesService;

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAO7C,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAa,SAAS,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAIN,KAAK,QAAQ,EACb,MAAM,oBAAoB,CAAC;AAG5B,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,uEAAuE;IACvE,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IACzC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACvB,sFAAsF;IACtF,YAAY,EAAE,YAAY,CAAC;CAC3B;AAmCD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAGrE;AAgBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAmMvD"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAO7C,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAa,SAAS,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE3E,OAAO,EAIN,KAAK,QAAQ,EACb,MAAM,oBAAoB,CAAC;AAG5B,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,UAAU,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACtC,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,uEAAuE;IACvE,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IACzC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACvB,sFAAsF;IACtF,YAAY,EAAE,YAAY,CAAC;CAC3B;AAsCD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAGrE;AAgBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAiNvD"}

package/dist/hooks.js

@@ -9,6 +9,7 @@ import { PluginSettingsService } from './services/plugin-settings-service.js';
 import { createCMS } from './engine.js';
 import { createLocalAPI } from './local-api/index.js';
 import { createPartResolver } from './plugins/resolver.js';
+import { startEmbeddedJobRunner } from './jobs/embedded-runner.js';
 import { createAphexApi, mountAphexBuiltins, toHonoHandler } from './server/api/index.js';
 /**
  * Wrap a plugin route handler so it enforces `requiredCapabilities` before running.
@@ -35,6 +36,9 @@ let schemaError = null;
 let initPromise = null;
 let activeConfig = null;
 let configDirty = false;
+// Started once per process (not per request, and not restarted on schema-HMR re-init): the loop
+// resolves the live `cmsInstances` at each tick, so a rebuilt instance is picked up automatically.
+let embeddedRunner = null;
 /**
  * Called by the Vite HMR plugin (`@aphexcms/cms-core/vite`) when schema
  * files or `aphex.config.ts` change. Replaces the captured config with the
@@ -105,6 +109,7 @@ export function createCMSHook(config) {
             // Use the storage adapter from config, or create the default local one.
             const storageAdapter = currentConfig.storage ?? createDefaultStorageAdapter();
             const emailAdapter = currentConfig.email ?? null;
+            const aiProvider = currentConfig.aiProvider ?? null;
             const assetService = new AssetServiceClass(storageAdapter, databaseAdapter);
             const cmsEngine = createCMS(currentConfig, databaseAdapter);
             const rolesService = new RolesService(databaseAdapter, currentConfig.cache ?? null);
@@ -190,6 +195,7 @@ export function createCMSHook(config) {
                 assetService: assetService,
                 storageAdapter: storageAdapter,
                 emailAdapter: emailAdapter,
+                aiProvider: aiProvider,
                 cmsEngine: cmsEngine,
                 localAPI: localAPI,
                 rolesService,
@@ -200,6 +206,17 @@ export function createCMSHook(config) {
                 apiApp,
                 partResolver
             };
+            // Start the embedded in-process job loop once, if opted in. It drives the queue
+            // directly (no HTTP, no worker secret) so scheduled publishes and event consumers
+            // run with zero setup — ideal for dev and single-instance self-hosting. It reads
+            // the live `cmsInstances` at each tick, so it survives schema-HMR re-init.
+            if (currentConfig.jobs?.embedded && !embeddedRunner) {
+                embeddedRunner = startEmbeddedJobRunner({
+                    intervalMs: currentConfig.jobs.embeddedIntervalMs,
+                    logger: cmsLogger,
+                    getServices: () => cmsInstances
+                });
+            }
             resolveInit();
         }
         // Attach schema error to instances so it can be accessed in load functions

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export * from './field-validation/rule.js';
 export * from './field-validation/utils.js';
 export { createContentHash, hasUnpublishedChanges } from './utils/content-hash.js';
 export * from './schema-utils/index.js';
+export * from './events/index.js';
+export * from './forms/index.js';
 export * from './theme/index.js';
 export * from './plugins/index.js';
 export * from './utils/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAkBA,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGjG,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGhF,cAAc,sBAAsB,CAAC;AAGrC,cAAc,eAAe,CAAC;AAI9B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,eAAe,CAAC;AAG9B,cAAc,aAAa,CAAC;AAC5B,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAkBA,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGjG,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGhF,cAAc,sBAAsB,CAAC;AAIrC,cAAc,gBAAgB,CAAC;AAI/B,cAAc,eAAe,CAAC;AAG9B,cAAc,eAAe,CAAC;AAI9B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,eAAe,CAAC;AAG9B,cAAc,aAAa,CAAC;AAC5B,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -23,6 +23,12 @@ export * from './field-validation/utils.js';
 export { createContentHash, hasUnpublishedChanges } from './utils/content-hash.js';
 // Schema utilities
 export * from './schema-utils/index.js';
+// Event catalog — defineEvent() + built-in event definitions (document.published, …).
+// Plain TS (zod only), safe for the universal barrel.
+export * from './events/index.js';
+// Forms primitives — defineForm(), InferForm, validateFormData. Plain TS, reuses the field
+// model + validation engine, safe for the universal barrel.
+export * from './forms/index.js';
 // Theme design-system tokens — plain TS (Svelte-free), safe for the universal barrel.
 export * from './theme/index.js';
 // Plugin API — definePlugin(), part types, part resolver. Runtime is plain JS

package/dist/jobs/document-jobs.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { LocalAPI } from '../local-api/index.js';
+import type { JobHandlerMap } from './types.js';
+/** Reserved built-in job types. Scheduling uses these; the worker maps them to the handlers below. */
+export declare const DOCUMENT_PUBLISH_JOB = "document.publish";
+export declare const DOCUMENT_UNPUBLISH_JOB = "document.unpublish";
+/** Payload for document.publish / document.unpublish jobs — identifiers only, never content. */
+export declare const documentJobPayload: z.ZodObject<{
+    documentId: z.ZodString;
+    documentType: z.ZodString;
+}, z.core.$strip>;
+export type DocumentJobPayload = z.infer<typeof documentJobPayload>;
+export interface DocumentJobDeps {
+    localAPI: LocalAPI;
+}
+/**
+ * Built-in handlers for scheduled publish/unpublish.
+ *
+ * Runs as the system (override access) — the permission check already happened when the
+ * job was scheduled. Publish routes through `CollectionAPI.publish`, so it re-runs
+ * validation + reference guards + cache invalidation and emits `document.published`
+ * inside the publish transaction, exactly like a manual publish. A handler throw is a
+ * job failure: the runner retries with backoff or dead-letters it (e.g. a doc whose
+ * references became unpublished before the scheduled time fails validation and retries).
+ */
+export declare function createDocumentJobHandlers(deps: DocumentJobDeps): JobHandlerMap;
+//# sourceMappingURL=document-jobs.d.ts.map

package/dist/jobs/document-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-jobs.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/document-jobs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,sGAAsG;AACtG,eAAO,MAAM,oBAAoB,qBAAqB,CAAC;AACvD,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAE3D,gGAAgG;AAChG,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,MAAM,WAAW,eAAe;IAC/B,QAAQ,EAAE,QAAQ,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,eAAe,GAAG,aAAa,CAgB9E"}

package/dist/jobs/document-jobs.js

@@ -0,0 +1,42 @@
+// Built-in job types for the scheduled document workflow: publish / unpublish at a
+// future `runAt`. The handlers are provided by core but DI'd with the request-scoped
+// LocalAPI at the worker endpoint (the runner itself only knows the database adapter).
+import { z } from 'zod';
+import { systemContext } from '../local-api/auth-helpers.js';
+/** Reserved built-in job types. Scheduling uses these; the worker maps them to the handlers below. */
+export const DOCUMENT_PUBLISH_JOB = 'document.publish';
+export const DOCUMENT_UNPUBLISH_JOB = 'document.unpublish';
+/** Payload for document.publish / document.unpublish jobs — identifiers only, never content. */
+export const documentJobPayload = z.object({
+    documentId: z.string(),
+    documentType: z.string()
+});
+/**
+ * Built-in handlers for scheduled publish/unpublish.
+ *
+ * Runs as the system (override access) — the permission check already happened when the
+ * job was scheduled. Publish routes through `CollectionAPI.publish`, so it re-runs
+ * validation + reference guards + cache invalidation and emits `document.published`
+ * inside the publish transaction, exactly like a manual publish. A handler throw is a
+ * job failure: the runner retries with backoff or dead-letters it (e.g. a doc whose
+ * references became unpublished before the scheduled time fails validation and retries).
+ */
+export function createDocumentJobHandlers(deps) {
+    const { localAPI } = deps;
+    return {
+        [DOCUMENT_PUBLISH_JOB]: async ({ job }) => {
+            const { documentId, documentType } = documentJobPayload.parse(job.payload);
+            const collection = localAPI.getCollection(documentType);
+            if (!collection)
+                throw new Error(`Unknown collection "${documentType}" for job ${job.id}`);
+            await collection.publish(systemContext(job.organizationId), documentId);
+        },
+        [DOCUMENT_UNPUBLISH_JOB]: async ({ job }) => {
+            const { documentId, documentType } = documentJobPayload.parse(job.payload);
+            const collection = localAPI.getCollection(documentType);
+            if (!collection)
+                throw new Error(`Unknown collection "${documentType}" for job ${job.id}`);
+            await collection.unpublish(systemContext(job.organizationId), documentId);
+        }
+    };
+}

package/dist/jobs/embedded-runner.d.ts

@@ -0,0 +1,25 @@
+import type { JobRunnerServices } from './run-batch.js';
+import type { Logger } from '../utils/logger.js';
+/** Handle for a running embedded loop. Call `stop()` to clear the interval. */
+export interface EmbeddedJobRunner {
+    stop(): void;
+}
+export interface EmbeddedJobRunnerOptions {
+    /** Milliseconds between ticks. Default 3000. */
+    intervalMs?: number;
+    logger: Logger;
+    /**
+     * Resolve the live services at tick time (rather than capturing them once), so a schema-HMR
+     * re-init that rebuilds the CMS instances is picked up automatically. Return `null` to skip a
+     * tick (e.g. the app hasn't finished initializing yet).
+     */
+    getServices: () => JobRunnerServices | null;
+}
+/**
+ * Start the loop. Ticks NEVER overlap: while a tick is in flight the next interval fire is
+ * skipped, so a slow batch can't stack runs on top of each other. A thrown error in a tick is
+ * logged and swallowed — the loop must survive a transient DB blip and keep going. The interval
+ * is `unref`'d where supported so it never keeps the process alive on its own.
+ */
+export declare function startEmbeddedJobRunner(options: EmbeddedJobRunnerOptions): EmbeddedJobRunner;
+//# sourceMappingURL=embedded-runner.d.ts.map

package/dist/jobs/embedded-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-runner.d.ts","sourceRoot":"","sources":["../../src/lib/jobs/embedded-runner.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,aAAa,CAAC;AAEzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C,+EAA+E;AAC/E,MAAM,WAAW,iBAAiB;IACjC,IAAI,IAAI,IAAI,CAAC;CACb;AAED,MAAM,WAAW,wBAAwB;IACxC,gDAAgD;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,WAAW,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAC;CAC5C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CAyC3F"}