@heyo-sh/heyo-cms 0.0.0-stage → 0.2.0

package/dist/engine/relations.d.ts

@@ -0,0 +1,60 @@
+import type { Actor } from "../types/actor";
+import type { RbacConfig, ResolvedCollection } from "../types/config";
+import type { DatabaseAdapter } from "../types/database";
+import type { FieldDefinition } from "../types/fields";
+import type { JsonObject } from "../types/json";
+import type { Tx } from "../types/query";
+import type { LocaleContext } from "./locales";
+export interface RelationLoaderOptions {
+    adapter: DatabaseAdapter;
+    tx: Tx;
+    locale: LocaleContext;
+    /** Every declared collection and global, keyed by name. */
+    collections: Record<string, ResolvedCollection>;
+    includeTrashed?: boolean;
+    /**
+     * Whose read this is.
+     *
+     * A related document is filtered by the rules of the collection it belongs
+     * to, not by the one that pointed at it: `depth` must not be a way to read
+     * a field through a relation that cannot be read directly.
+     */
+    actor?: Actor | null;
+    rbac?: RbacConfig | undefined;
+}
+/**
+ * `depth`, resolved by batching instead of by joining.
+ *
+ * Collect the ids at this level, run one query per target collection, then
+ * recurse. The query count depends on the shape of the schema, never on the
+ * number of documents — which is the N+1 problem Payload users hit with
+ * `depth`, and the reason section 12 rules joins out: one batching strategy
+ * works identically on Postgres, SQLite and MongoDB.
+ */
+export declare class RelationLoader {
+    private readonly options;
+    /** Shared across levels, so a document fetched once is never fetched again. */
+    private readonly cache;
+    /** Counted so a test can assert the absence of N+1 rather than infer it. */
+    private queries;
+    constructor(options: RelationLoaderOptions);
+    get queryCount(): number;
+    expand(documents: JsonObject[], collection: ResolvedCollection, depth: number): Promise<void>;
+    private load;
+    /**
+     * Replaces ids with documents, remembering what was replaced so the next
+     * level can be batched. A reference that no longer resolves stays an id
+     * rather than becoming `null`: losing the value would hide the dangling
+     * reference instead of reporting it.
+     */
+    private substitute;
+}
+/**
+ * What a field points at.
+ *
+ * `media` is a relation that does not spell it out: the value is an id in the
+ * `media` table, which is what makes the usage counting in section 6
+ * possible. Treating it as one here means `depth` resolves a cover image.
+ */
+export declare function relationTarget(field: FieldDefinition): string | undefined;
+//# sourceMappingURL=relations.d.ts.map

package/dist/engine/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/engine/relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAIzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,eAAe,CAAC;IACzB,EAAE,EAAE,EAAE,CAAC;IACP,MAAM,EAAE,aAAa,CAAC;IACtB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAChD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,qBAAa,cAAc;IAMb,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwC;IAC9D,4EAA4E;IAC5E,OAAO,CAAC,OAAO,CAAK;IAEpB,YAA6B,OAAO,EAAE,qBAAqB,EAAI;IAE/D,IAAI,UAAU,IAAI,MAAM,CAEvB;IAEK,MAAM,CACV,SAAS,EAAE,UAAU,EAAE,EACvB,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA8Cf;YAEa,IAAI;IAiElB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;CA4BnB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAGzE"}

package/dist/engine/scoped-db.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseAdapter } from "../types/database";
+import type { ScopedDb } from "../types/hooks";
+import type { Tx } from "../types/query";
+/**
+ * `ctx.db`: the handle that bypasses access control, by name.
+ *
+ * Everything it does happens inside the caller's transaction, so a hook that
+ * writes an audit row and then throws leaves nothing behind. The alternative
+ * — a pooled connection of its own — would commit independently of the
+ * operation that triggered it.
+ */
+export declare function scopedDb(adapter: DatabaseAdapter, tx: Tx): ScopedDb;
+//# sourceMappingURL=scoped-db.d.ts.map

package/dist/engine/scoped-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-db.d.ts","sourceRoot":"","sources":["../../src/engine/scoped-db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAwB,EAAE,EAAS,MAAM,gBAAgB,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE,GAAG,QAAQ,CA6CnE"}

package/dist/engine/slugs.d.ts

@@ -0,0 +1,124 @@
+import type { ResolvedCollection } from "../types/config";
+import type { FieldDefinition } from "../types/fields";
+import type { ScopedDb } from "../types/hooks";
+import type { JsonObject } from "../types/json";
+/**
+ * The `slug` field's behaviour: made from another field when empty, cleaned
+ * when typed, unique where it has to be, and remembered when it changes.
+ *
+ * Here rather than in a hook because every one of those has to happen on
+ * every write path — the panel, the REST API, an import, a scheduled change,
+ * a script — and a hook is something a project can forget to register.
+ *
+ * The history lives in its own table, `slug_history`, one row per previous
+ * address: a real column with a unique index answers "who owned this URL"
+ * in one lookup on every engine, where a list inside the document body would
+ * be a `LIKE` over every row of the collection.
+ */
+export declare const slugHistoryTable = "slug_history";
+export interface SlugFieldOptions {
+    from?: string;
+    history?: boolean;
+    unique?: boolean;
+    maxLength?: number;
+    slugify?: (text: string) => string;
+}
+/** The field's own `slugify`, or the built-in one at its `maxLength`. */
+export declare function slugCleaner(field: FieldDefinition): (text: string) => string;
+export declare function slugFields(collection: ResolvedCollection): [string, FieldDefinition][];
+export declare function slugOptions(field: FieldDefinition): SlugFieldOptions;
+/** One slug that stopped being a document's address in a write. */
+export interface SlugMove {
+    field: string;
+    /** Empty for a field that is not localized, like `media_usages`. */
+    locale: string;
+    from: string;
+    to: string;
+}
+export interface PrepareSlugsOptions {
+    db: ScopedDb;
+    collection: ResolvedCollection;
+    /** What the write asks for, after the `before` hooks. */
+    input: JsonObject;
+    /** The stored body before this write; null for a create. */
+    stored: JsonObject | null;
+    locale: string;
+    /** Null for a create whose id is not known to the caller yet. */
+    documentId: string | null;
+}
+/**
+ * Fills in, cleans and checks every slug field a write touches.
+ *
+ * Returns the input with the slugs settled and the moves the write implies,
+ * which `recordSlugMoves` writes once the document row exists.
+ */
+export declare function prepareSlugs(options: PrepareSlugsOptions): Promise<{
+    input: JsonObject;
+    moves: SlugMove[];
+}>;
+/**
+ * Writes what `prepareSlugs` decided, inside the same transaction.
+ *
+ * The old slug becomes a previous address of the document; a slug the
+ * document moves back to stops being one, so an address is never both.
+ */
+export declare function recordSlugMoves(db: ScopedDb, collection: ResolvedCollection, documentId: string, moves: SlugMove[], now: Date): Promise<void>;
+export declare function removePreviousSlugRow(db: ScopedDb, collection: ResolvedCollection, documentId: string, field: string, locale: string, slug: string): Promise<void>;
+/** Every previous address of one document goes when the document does. */
+export declare function releaseSlugs(db: ScopedDb, collection: ResolvedCollection, documentId: string): Promise<void>;
+interface SlugScope {
+    db: ScopedDb;
+    collection: ResolvedCollection;
+    documentId: string | null;
+    field: string;
+    /** Empty for a field that is not localized. */
+    locale: string;
+}
+/**
+ * Refuses a slug another document uses, as its address or as a previous one.
+ *
+ * Trashed documents count: restoring a page must never bring back a URL
+ * somebody else has taken since. A previous address is not taken over
+ * silently either — it is a redirect somebody relies on — so the message
+ * says where it leads and how to free it.
+ */
+export declare function assertFree(scope: SlugScope & {
+    slug: string;
+}): Promise<void>;
+export interface SlugCandidate {
+    id: string;
+    /** The locale the slug matched in; null for a field that is not localized. */
+    locale: string | null;
+    current: boolean;
+}
+/**
+ * Every document a slug points at, best match first: a current address in
+ * the requested locale, then in another locale, then a previous address in
+ * the requested locale, then in another.
+ *
+ * Trashed documents are left out — a trashed page has no address — and so
+ * is anything that is not a slug at all, before a query is spent on it.
+ */
+export declare function slugCandidates(options: {
+    db: ScopedDb;
+    collection: ResolvedCollection;
+    field: string;
+    slug: string;
+    locale: string | null;
+    locales: string[];
+}): Promise<SlugCandidate[]>;
+export interface PreviousSlugRow {
+    slug: string;
+    field: string;
+    locale: string | null;
+    createdAt: string | null;
+}
+export declare function previousSlugRows(options: {
+    db: ScopedDb;
+    collection: ResolvedCollection;
+    documentId: string;
+    field?: string;
+    locale?: string | null;
+}): Promise<PreviousSlugRow[]>;
+export {};
+//# sourceMappingURL=slugs.d.ts.map

package/dist/engine/slugs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugs.d.ts","sourceRoot":"","sources":["../../src/engine/slugs.ts"],"names":[],"mappings":"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"}

package/dist/engine/trash.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedCmsConfig, ResolvedCollection } from "../types/config";
+import type { DatabaseAdapter } from "../types/database";
+import type { TrashListArgs, TrashPage } from "../types/trash";
+export interface ListTrashedOptions {
+    adapter: DatabaseAdapter;
+    config: ResolvedCmsConfig;
+    /** Collections and globals, by name. */
+    collections: Record<string, ResolvedCollection>;
+    args: TrashListArgs;
+}
+/**
+ * The trash across collections.
+ *
+ * One query, not one per collection: the panel shows a single list ordered by
+ * when things were deleted, and assembling that from per-collection pages
+ * would page wrongly the moment two collections have entries.
+ *
+ * Access control is folded into the filter rather than applied afterwards —
+ * the same rule as everywhere else (stage 4). Each collection contributes one
+ * branch of an `OR`, carrying its own `read` filter; a collection the actor
+ * may not read contributes nothing and is therefore invisible rather than
+ * forbidden.
+ */
+export declare function listTrashed(options: ListTrashedOptions): Promise<TrashPage>;
+//# sourceMappingURL=trash.d.ts.map

package/dist/engine/trash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trash.d.ts","sourceRoot":"","sources":["../../src/engine/trash.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAa/D,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,wCAAwC;IACxC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAChD,IAAI,EAAE,aAAa,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,SAAS,CAAC,CAuFpB"}

package/dist/errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * One error type for everything a caller can provoke.
+ *
+ * A hook that throws, an access rule that refuses and a field that fails
+ * validation all end up in the same HTTP response builder, so they all carry
+ * the status and a machine-readable code instead of leaving the transport
+ * layer to guess from the message.
+ */
+export declare class CmsError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        details?: unknown;
+        /**
+         * The error this one replaces, for the operator's log.
+         *
+         * `details` is part of the response and `cause` never is: when a
+         * provider or a driver fails, the caller gets a sentence and a code
+         * while the original stack stays where somebody debugging can reach it.
+         */
+        cause?: unknown;
+    });
+    static notFound(message?: string): CmsError;
+    static forbidden(message?: string): CmsError;
+    static unauthorized(message?: string): CmsError;
+    static conflict(message: string): CmsError;
+    static validation(message: string, details?: unknown): CmsError;
+}
+/**
+ * A mistake in the configuration, not in a request.
+ *
+ * These are thrown while `heyoCms()` is still building, so they must read like
+ * a compiler diagnostic: what is wrong, where, and what to write instead.
+ */
+export declare class CmsConfigError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAE3B,YACE,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QACP,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB;;;;;;WAMG;QACH,KAAK,CAAC,EAAE,OAAO,CAAC;KACZ,EAOP;IAED,MAAM,CAAC,QAAQ,CAAC,OAAO,SAAc,GAAG,QAAQ,CAE/C;IAED,MAAM,CAAC,SAAS,CAAC,OAAO,SAAc,GAAG,QAAQ,CAEhD;IAED,MAAM,CAAC,YAAY,CAAC,OAAO,SAAiB,GAAG,QAAQ,CAEtD;IAED,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAEzC;IAED,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,CAM9D;CACF;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAIxC;CACF"}

package/dist/fields/builtin.d.ts

@@ -0,0 +1,169 @@
+import type { FieldDefinition, FieldOptions } from "../types/fields";
+import type { JsonObject, JsonValue } from "../types/json";
+import { type FieldValue } from "./registry";
+export interface TextOptions extends FieldOptions {
+    default?: string;
+    minLength?: number;
+    maxLength?: number;
+    /** Source string for the pattern; kept serialisable for the snapshot. */
+    pattern?: string;
+}
+export declare const text: import("./registry").FieldBuilder<string, TextOptions>;
+export interface TextareaOptions extends TextOptions {
+    rows?: number;
+}
+export declare const textarea: import("./registry").FieldBuilder<string, TextareaOptions>;
+/** A ProseMirror document. TipTap writes it, the serialisers read it. */
+export type RichTextValue = JsonObject;
+export interface RichTextOptions extends FieldOptions {
+    /** Editor nodes allowed in this field; the panel hides the rest. */
+    nodes?: string[];
+    default?: RichTextValue;
+}
+export declare const richText: import("./registry").FieldBuilder<JsonObject, RichTextOptions>;
+export interface NumberOptions extends FieldOptions {
+    default?: number;
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}
+export declare const number: import("./registry").FieldBuilder<number, NumberOptions>;
+export interface BooleanOptions extends FieldOptions {
+    default?: boolean;
+}
+export declare const boolean: import("./registry").FieldBuilder<boolean, BooleanOptions>;
+export interface DateOptions extends FieldOptions {
+    default?: string;
+    /** `date` hides the clock in the panel; storage is identical. */
+    mode?: "date" | "datetime";
+}
+/**
+ * Dates are ISO strings, not `Date` objects.
+ *
+ * The value travels through JSON on every path the engine has — storage, REST,
+ * webhook payloads — and a string survives all of them unchanged. Converting
+ * at the edges would mean three places that can disagree about time zones.
+ */
+export declare const date: import("./registry").FieldBuilder<string, DateOptions>;
+export type SelectChoice = string | {
+    label: string;
+    value: string;
+};
+export interface SelectOptions extends FieldOptions {
+    options: readonly SelectChoice[];
+    default?: string;
+}
+/** Literal choices become a union in the document type. */
+export type SelectValue<TOptions extends {
+    options: readonly SelectChoice[];
+}> = TOptions["options"][number] extends infer TChoice ? TChoice extends string ? TChoice : TChoice extends {
+    value: infer TValue;
+} ? TValue : never : never;
+/**
+ * A plain choice field.
+ *
+ * `status` is one of its uses and nothing more: the engine attaches no meaning
+ * to it, which is what removed the whole publish/unpublish lifecycle from the
+ * core (sections 3 and 11).
+ */
+export declare function select<const TOptions extends SelectOptions>(options: TOptions): FieldDefinition<FieldValue<SelectValue<TOptions>, TOptions>>;
+export interface MultiselectOptions extends FieldOptions {
+    options: readonly SelectChoice[];
+    default?: string[];
+    minItems?: number;
+    maxItems?: number;
+}
+export declare function multiselect<const TOptions extends MultiselectOptions>(options: TOptions): FieldDefinition<FieldValue<SelectValue<TOptions>[], TOptions>>;
+export interface JsonFieldOptions extends FieldOptions {
+    default?: JsonValue;
+}
+export declare const json: import("./registry").FieldBuilder<JsonValue, JsonFieldOptions>;
+export interface MediaOptions extends FieldOptions {
+    /** MIME whitelist for the picker, e.g. `image/*`. */
+    accept?: string;
+}
+/**
+ * A reference to a row in `media`.
+ *
+ * Storing the id rather than a URL is what makes the media lifecycle work:
+ * `media_usages` can count references, and a file that loses its last one is
+ * orphaned rather than deleted (section 6).
+ */
+export declare const media: import("./registry").FieldBuilder<string, MediaOptions>;
+export interface RelationOptions extends FieldOptions {
+    relationTo?: string;
+    /** Many-to-many: the value is an array of ids. */
+    many?: boolean;
+}
+/**
+ * A reference to another collection.
+ *
+ * Resolved by a batch loader rather than a join: one query per collection per
+ * depth level works the same on all three engines and removes the N+1 problem
+ * that Payload users hit with `depth` (section 12).
+ */
+export declare function relation<const TOptions extends RelationOptions>(to: string, options?: TOptions): FieldDefinition<FieldValue<string, TOptions>>;
+export interface SlugOptions extends FieldOptions {
+    /**
+     * The field a slug is made from while it is empty: `"title"`.
+     *
+     * Made once, on the write that first has a value for it, and then left
+     * alone: retitling a page must not move its URL. Clearing the slug makes
+     * it again. The same function is the panel's "Generate" button.
+     */
+    from?: string;
+    /**
+     * Keep every slug a document stops using as a previous address of it.
+     *
+     * `cms.api.<collection>.resolveSlug()` finds a document by a previous
+     * address too, which is what a 301 from an old URL is built on; a new
+     * document cannot take an address an old one still redirects from. Needs
+     * the `slug_history` table, which `heyo-cms generate` adds.
+     */
+    history?: boolean;
+    /** The longest slug produced; longer input is cut at a hyphen. 96 by default. */
+    maxLength?: number;
+    /**
+     * Your own transliteration, when the built-in one is not the house style:
+     * `&` as `and`, a language's own rules. Used everywhere a slug is made or
+     * cleaned — writes, the Generate button, previous slugs. Its output must
+     * still match `slugPattern`; `maxLength` is then yours to apply.
+     */
+    slugify?: (text: string) => string;
+    default?: string;
+}
+/**
+ * A URL slug: `"lodz-in-autumn"`.
+ *
+ * What makes it more than `text` with a pattern is the engine, on every
+ * write path — the panel, the REST API, an import, a scheduled change:
+ *
+ * - a typed slug is cleaned (`"Łódź in Autumn!"` becomes `lodz-in-autumn`);
+ * - an empty one is made `from` another field, with `-2`, `-3`… until free;
+ * - it is unique within the collection — per language when localized, which
+ *   a database index cannot express, so the engine checks it, trashed
+ *   documents included;
+ * - with `history`, a changed slug stays a previous address of the document,
+ *   which `resolveSlug()` finds and nobody else may take.
+ *
+ * ```ts
+ * slug: slug({ from: "title", localized: true, history: true })
+ * ```
+ */
+export declare function slug<const TOptions extends SlugOptions>(options?: TOptions): FieldDefinition<FieldValue<string, TOptions>>;
+export declare const email: import("./registry").FieldBuilder<string, TextOptions>;
+export declare const url: import("./registry").FieldBuilder<string, TextOptions>;
+/**
+ * SEO as fields, not as a plugin.
+ *
+ * A plugin would own the fields, the prompts and the panel section; a preset
+ * spreads into `fields` and stays editable (`...seoFields()`), which is the
+ * decision recorded in section 11.
+ */
+export declare function seoFields(): {
+    seoTitle: FieldDefinition<string | null>;
+    seoDescription: FieldDefinition<string | null>;
+    ogImage: FieldDefinition<string | null>;
+    canonical: FieldDefinition<string | null>;
+};
+//# sourceMappingURL=builtin.d.ts.map

package/dist/fields/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/fields/builtin.ts"],"names":[],"mappings":"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"}

package/dist/fields/index.d.ts

@@ -0,0 +1,3 @@
+export { defineField, getFieldType, registeredFieldTypes, registerFieldType, type FieldBuilder, type FieldValue, } from "./registry";
+export * from "./builtin";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fields/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,GAChB,MAAM,YAAY,CAAC;AACpB,cAAc,WAAW,CAAC"}

package/dist/fields/registry.d.ts

@@ -0,0 +1,35 @@
+import type { FieldDefinition, FieldOptions, FieldType } from "../types/fields";
+import type { JsonValue } from "../types/json";
+/**
+ * Nullability is a property of the options, not of the field type.
+ *
+ * `text()` holds `string | null` and `text({ required: true })` holds
+ * `string`, and both facts are visible in the inferred document type instead
+ * of being discovered at runtime.
+ */
+export type FieldValue<TValue, TOptions> = TOptions extends {
+    required: true;
+} ? TValue : TValue | null;
+export interface FieldBuilderOptions extends FieldOptions {
+    default?: JsonValue;
+}
+/**
+ * A field builder: what `text`, `select` or a third-party `rating` is.
+ *
+ * `const TOptions` captures literal option values, which is what lets
+ * `select({ options: ["draft", "published"] })` infer a union rather than
+ * `string`.
+ */
+export type FieldBuilder<TValue, TOptions extends FieldOptions> = <const TGiven extends TOptions>(options?: TGiven) => FieldDefinition<FieldValue<TValue, TGiven>>;
+export declare function registerFieldType<TValue, TOptions extends FieldOptions>(type: FieldType<TValue, TOptions>): void;
+export declare function getFieldType<TValue = unknown>(name: string): FieldType<TValue, FieldOptions> | undefined;
+export declare function registeredFieldTypes(): string[];
+/**
+ * Declares a field type and returns its builder.
+ *
+ * Every built-in field goes through this function. A shortcut for built-ins
+ * would mean the public extension API is the one nobody uses, which is how
+ * extension points rot (stage 9).
+ */
+export declare function defineField<TValue, TOptions extends FieldOptions>(type: FieldType<TValue, TOptions>): FieldBuilder<TValue, TOptions>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/fields/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/fields/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,eAAe,EACf,YAAY,EACZ,SAAS,EACV,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,QAAQ,IAAI,QAAQ,SAAS;IAAE,QAAQ,EAAE,IAAI,CAAA;CAAE,GAC1E,MAAM,GACN,MAAM,GAAG,IAAI,CAAC;AAElB,MAAM,WAAW,mBAAoB,SAAQ,YAAY;IACvD,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,CAAC,MAAM,EAAE,QAAQ,SAAS,YAAY,IAAI,CAChE,KAAK,CAAC,MAAM,SAAS,QAAQ,EAE7B,OAAO,CAAC,EAAE,MAAM,KACb,eAAe,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAUjD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,QAAQ,SAAS,YAAY,EACrE,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,GAChC,IAAI,CASN;AAED,wBAAgB,YAAY,CAAC,MAAM,GAAG,OAAO,EAC3C,IAAI,EAAE,MAAM,GACX,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,CAE7C;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,SAAS,YAAY,EAC/D,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,GAChC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAkGhC"}

package/dist/fields.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The field registry and every built-in type.
+ *
+ * Built-ins are declared with the same `defineField()` a third-party package
+ * uses, so there is no privileged path into the registry (stage 9).
+ */
+export * from "./fields/index";
+export { isSlug, slugify, slugPattern, type SlugifyOptions } from "./slugify";
+//# sourceMappingURL=fields.d.ts.map

package/dist/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC"}

package/dist/fields.js

@@ -0,0 +1 @@
+import{Mn,sn,ye}from"./index-abfzb1ve.js";import{po,Ko,Yo,O}from"./index-67e458ws.js";import{z as e}from"zod";var i=e.looseObject({label:e.string().optional(),description:e.string().optional(),localized:e.boolean().optional(),required:e.boolean().optional(),unique:e.boolean().optional(),index:e.boolean().optional(),readOnly:e.boolean().optional()}),a=e.lazy(()=>e.union([e.string(),e.number(),e.boolean(),e.null(),e.array(a),e.record(e.string(),a)])),g=O({name:"text",optionsSchema:i.extend({default:e.string().optional(),minLength:e.number().int().nonnegative().optional(),maxLength:e.number().int().positive().optional(),pattern:e.string().optional()}),schema:(n)=>{let t=e.string();if(n.minLength!==void 0)t=t.min(n.minLength);if(n.maxLength!==void 0)t=t.max(n.maxLength);if(n.pattern!==void 0)t=t.regex(new RegExp(n.pattern));return t},column:(n)=>({type:"text",...n.default===void 0?{}:{default:n.default}}),aiActions:["generate","improve","summarize","translate"]}),x=O({name:"textarea",optionsSchema:i.extend({default:e.string().optional(),maxLength:e.number().int().positive().optional(),rows:e.number().int().positive().optional()}),schema:(n)=>n.maxLength===void 0?e.string():e.string().max(n.maxLength),column:()=>({type:"text"}),aiActions:["generate","improve","summarize","translate"]}),w=O({name:"richText",optionsSchema:i.extend({nodes:e.array(e.string()).optional()}),schema:()=>e.looseObject({type:e.string()}),column:()=>({type:"json"}),aiActions:["generate","improve","summarize","translate"]}),k=O({name:"number",optionsSchema:i.extend({default:e.number().optional(),min:e.number().optional(),max:e.number().optional(),integer:e.boolean().optional()}),schema:(n)=>{let t=n.integer===!0?e.number().int():e.number();if(n.min!==void 0)t=t.min(n.min);if(n.max!==void 0)t=t.max(n.max);return t},column:(n)=>({type:n.integer===!0?"integer":"real",...n.default===void 0?{}:{default:n.default}})}),D=O({name:"boolean",optionsSchema:i.extend({default:e.boolean().optional()}),schema:()=>e.boolean(),column:(n)=>({type:"boolean",...n.default===void 0?{}:{default:n.default}})}),L=O({name:"date",optionsSchema:i.extend({default:e.string().optional(),mode:e.enum(["date","datetime"]).optional()}),schema:()=>e.string().refine((n)=>!Number.isNaN(Date.parse(n)),"must be an ISO 8601 date"),column:()=>({type:"timestamp"})}),d=(n)=>n.map((t)=>typeof t==="string"?t:t.value),m=i.extend({options:e.array(e.union([e.string(),e.strictObject({label:e.string(),value:e.string()})])).min(1),default:e.string().optional()}),f=O({name:"select",optionsSchema:m,schema:(n)=>e.enum(d(n.options)),column:(n)=>({type:"text",...n.default===void 0?{}:{default:n.default}})});function v(n){return f(n)}var h=O({name:"multiselect",optionsSchema:m.extend({default:e.array(e.string()).optional(),minItems:e.number().int().nonnegative().optional(),maxItems:e.number().int().positive().optional()}),schema:(n)=>{let t=e.array(e.enum(d(n.options)));if(n.minItems!==void 0)t=t.min(n.minItems);if(n.maxItems!==void 0)t=t.max(n.maxItems);return t},column:()=>({type:"json",array:!0}),aiActions:["tags"]});function Z(n){return h(n)}var j=O({name:"json",optionsSchema:i,schema:()=>a,column:()=>({type:"json"})}),y=O({name:"media",optionsSchema:i.extend({accept:e.string().optional()}),schema:()=>e.string().min(1),column:()=>({type:"text"}),aiActions:["alt"]}),T=O({name:"relation",optionsSchema:i.extend({relationTo:e.string().min(1),many:e.boolean().optional()}),schema:()=>e.string().min(1),column:(n)=>({type:"text",...n.many===!0?{type:"json",array:!0}:{}}),aiActions:["tags"]});function R(n,t){return T({...t??{},relationTo:n})}var b=O({name:"slug",optionsSchema:i.extend({from:e.string().min(1).optional(),history:e.boolean().optional(),maxLength:e.number().int().min(8).max(512).optional(),slugify:e.function().optional(),default:e.string().optional()}),schema:(n)=>e.string().max(n.maxLength??96).regex(new RegExp(Mn),"lowercase letters, digits and single hyphens only"),column:(n)=>({type:"text",...n.default===void 0?{}:{default:n.default}})});function I(n){let t={...n??{}},s=t.localized===!0,{maxLength:l,from:r}=t,c=t.slugify??((o)=>ye(o,l===void 0?{}:{maxLength:l}));return b({...t,unique:s?t.unique===!1?!1:void 0:t.unique??!0,index:s?void 0:t.index??!0,...t.generate===void 0&&r!==void 0?{generate:({fields:o})=>{let p=o[r],u=typeof p==="string"?c(p):"";return u===""?null:u}}:{}})}var C=O({name:"email",optionsSchema:i,schema:()=>e.string().email(),column:()=>({type:"text"})}),F=O({name:"url",optionsSchema:i,schema:()=>e.string().url(),column:()=>({type:"text"})});function J(){return{seoTitle:g({label:"SEO title",localized:!0,maxLength:70,aiGenerate:{label:"Suggest an SEO title",prompt:"Write a search-friendly title under 60 characters."}}),seoDescription:x({label:"SEO description",localized:!0,maxLength:160,aiGenerate:{label:"Suggest an SEO description",prompt:"Summarise the article in one sentence under 155 characters."}}),ogImage:y({label:"Social image",accept:"image/*"}),canonical:F({label:"Canonical URL"})}}export{D as boolean,L as date,O as defineField,C as email,Ko as getFieldType,sn as isSlug,j as json,y as media,Z as multiselect,k as number,po as registerFieldType,Yo as registeredFieldTypes,R as relation,w as richText,v as select,J as seoFields,I as slug,Mn as slugPattern,ye as slugify,g as text,x as textarea,F as url};

package/dist/http/guard.d.ts

@@ -0,0 +1,45 @@
+import type { Actor, OperationSource } from "../types/actor";
+import type { ResolvedCmsConfig } from "../types/config";
+/**
+ * Who may call the administrative endpoints.
+ *
+ * Document and media routes need nothing from this file: the engine already
+ * answers "may this actor do this" for them, including the anonymous case —
+ * a collection with `read: () => true` is a public API and that is the point.
+ *
+ * The endpoints that manage the CMS itself are different. `GET /users` has no
+ * collection to carry an `access` rule, so the rule is here, and it has two
+ * parts:
+ *
+ * 1. **Always an authenticated caller.** Without `rbac` a collection defaults
+ *    to open, which is a sensible default for content and a catastrophic one
+ *    for user management.
+ * 2. **With `rbac`, also the permission.** Declaring roles is the statement
+ *    that this deployment distinguishes between editors, so the distinction
+ *    is applied here too.
+ *
+ * The permission names follow the same `resource:action` grammar as
+ * everything else — `users:invite`, `roles:create`, `webhooks:create`,
+ * `activity:read`, `jobs:run` — so an administrator writes them in `rbac`
+ * without learning a second vocabulary.
+ */
+export declare function requireActor(actor: Actor | null): Actor;
+export declare function requirePermission(config: ResolvedCmsConfig, actor: Actor | null, permission: string): Actor;
+/**
+ * A session, specifically.
+ *
+ * Used by the endpoints that mint credentials: an API key that can create
+ * another API key turns a leaked read-only key into a permanent foothold,
+ * and the same argument applies to enrolling a second factor.
+ */
+export declare function requireSession(actor: Actor | null): Actor;
+/**
+ * Where the call came from, for hooks, events and the activity log.
+ *
+ * Everything over HTTP is `rest` unless the panel says otherwise with a
+ * header. Trusting a client header is fine precisely because it grants
+ * nothing: it is a label on a log line, and the panel is the only thing that
+ * sends it.
+ */
+export declare function requestSource(request: Request): OperationSource;
+//# sourceMappingURL=guard.d.ts.map

package/dist/http/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/http/guard.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,CAKvD;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,UAAU,EAAE,MAAM,GACjB,KAAK,CAOP;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,CAQzD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,CAI/D"}

package/dist/http/handler.d.ts

@@ -0,0 +1,31 @@
+import type { CmsHandler, CmsInstance, RouteInspection } from "../types/instance";
+import type { JsonObject } from "../types/json";
+/**
+ * `cms.handler`: the only HTTP contract in the product.
+ *
+ * `basePath` is stripped and the rest is matched, which is the whole of the
+ * Better Auth arrangement the plan asks for (section 10): one catch-all route
+ * in any framework mounts the API, the panel and every plugin route, and a
+ * route added to the core or to a plugin tomorrow needs no change in the
+ * application.
+ *
+ * The order inside a request is fixed and worth knowing:
+ *
+ * 1. the path is resolved against `basePath`,
+ * 2. the caller is resolved from the cookie or the `Authorization` header,
+ * 3. `hooks.before` run, and may answer instead of the route,
+ * 4. the route's own middleware wrap the handler,
+ * 5. `hooks.after` see the response and may add to it.
+ *
+ * Authentication is resolved before the hooks because a rate limiter that
+ * cannot tell an editor from a stranger is a rate limiter on the wrong thing.
+ */
+export interface CmsHttp {
+    handler: CmsHandler;
+    /** What `cms.inspect().routes` prints. */
+    routes(): RouteInspection[];
+    /** The generated document, memoised. */
+    openapi(): JsonObject;
+}
+export declare function createCmsHttp(cms: CmsInstance): CmsHttp;
+//# sourceMappingURL=handler.d.ts.map

package/dist/http/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/http/handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AA0BhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,0CAA0C;IAC1C,MAAM,IAAI,eAAe,EAAE,CAAC;IAC5B,wCAAwC;IACxC,OAAO,IAAI,UAAU,CAAC;CACvB;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAkHvD"}