@voltro/cms 0.1.0

package/dist/index.js

@@ -0,0 +1,376 @@
+import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as ee, u as te } from "./ContentForm-D0YGVkRu.js";
+import { and as f, boolean as p, date as m, eq as h, gt as ne, gte as re, id as g, integer as _, json as ie, lt as ae, lte as v, neq as y, table as oe, text as b, timestamp as x } from "@voltro/database";
+import { tenant as se } from "@voltro/plugin-multitenancy/mixin";
+import { createHmac as S, timingSafeEqual as ce } from "node:crypto";
+import { Effect as C } from "effect";
+//#region src/contentType.ts
+var w = [
+	"draft",
+	"published",
+	"archived"
+], T = [
+	"id",
+	"status",
+	"publishAt",
+	"tenantId",
+	"createdAt",
+	"updatedAt",
+	"createdBy",
+	"updatedBy"
+], le = (e) => {
+	let t = {}, n = [], r = [];
+	for (let [i, a] of Object.entries(e.fields)) {
+		if (T.includes(i)) throw Error(`defineContentType('${e.name}'): field '${i}' collides with a reserved lifecycle column (${T.join(", ")}). Rename it.`);
+		let o = a;
+		if (o.unique && o.kind !== "string") throw Error(`defineContentType('${e.name}'): field '${i}' is marked unique() but is a '${o.kind}' field — per-tenant uniqueness is only supported on string fields (a slug). Remove unique() or make it a Schema.String.`);
+		t[i] = o, o.derived && n.push(i), o.unique && r.push(i);
+	}
+	if (e.list) {
+		let n = /* @__PURE__ */ new Set([...Object.keys(t), ...T]);
+		for (let t of e.list.columns) if (!n.has(t)) throw Error(`defineContentType('${e.name}'): list.columns entry '${t}' is not a declared field (or lifecycle column) of this content type.`);
+		let r = e.list.defaultSort?.field;
+		if (r !== void 0 && !n.has(r)) throw Error(`defineContentType('${e.name}'): list.defaultSort.field '${r}' is not a declared field (or lifecycle column) of this content type.`);
+	}
+	return {
+		name: e.name,
+		displayName: e.displayName,
+		pluralName: e.pluralName,
+		fields: t,
+		...e.list ? { list: e.list } : {},
+		...e.idPrefix ? { idPrefix: e.idPrefix } : {},
+		derivedFields: n,
+		uniqueFields: r
+	};
+}, E = (e) => {
+	switch (e.kind) {
+		case "string": return e.isOptional ? b().nullable() : b();
+		case "number": return e.isOptional ? _().nullable() : _();
+		case "boolean": return e.isOptional ? p().nullable() : p();
+		case "date": return e.isOptional ? m().nullable() : m();
+		case "datetime": return e.isOptional ? x().nullable() : x();
+		case "literal": {
+			let t = e.literals ?? [], n = t.length > 0 ? b().oneOf(t) : b();
+			return e.isOptional ? n.nullable() : n;
+		}
+		case "richText":
+		case "array":
+		case "struct": {
+			let t = ie();
+			return e.isOptional ? t.nullable() : t;
+		}
+		case "media":
+		case "reference": return e.isOptional ? b().nullable() : b();
+	}
+}, ue = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e.fields)) t[n] = E(r);
+	return t;
+}, de = (e) => e.idPrefix, D = (e, t) => {
+	let n = de(e), r = n ? g({ prefix: n }) : g(), i = oe(`${e.name}_${t}`, {
+		id: r,
+		status: b().oneOf(w),
+		...t === "drafts" ? { publishAt: x().nullable() } : {},
+		...ue(e)
+	}).with(se()).reactive();
+	return e.uniqueFields.reduce((e, t) => e.unique(`uq_${t}`, ["tenantId", t]), i);
+}, fe = (e) => ({
+	draft: D(e, "drafts"),
+	published: D(e, "published")
+}), pe = 3600, O = (e) => (Buffer.isBuffer(e) ? e : Buffer.from(e, "utf8")).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""), k = (e) => Buffer.from(e.replace(/-/g, "+").replace(/_/g, "/"), "base64"), A = (e) => e ?? process.env.VOLTRO_SESSION_SECRET ?? null, me = (e, t, n = {}) => {
+	let r = A(n.secret);
+	if (r === null) throw Error("cms previewToken requires a signing secret — set VOLTRO_SESSION_SECRET or pass { secret }. Refusing to sign with a hardcoded default (it would ship in the bundle and be forgeable).");
+	let i = {
+		t: e,
+		i: t,
+		exp: Math.floor(Date.now() / 1e3) + (n.ttlSeconds ?? pe)
+	}, a = O(JSON.stringify(i));
+	return `${a}.${O(S("sha256", r).update(a).digest())}`;
+}, j = (e, t = {}) => {
+	if (!e) return null;
+	let n = A(t.secret);
+	if (n === null) return null;
+	let r = e.indexOf(".");
+	if (r <= 0 || r === e.length - 1) return null;
+	let i = e.slice(0, r), a = e.slice(r + 1), o = S("sha256", n).update(i).digest(), s = k(a);
+	if (s.length !== o.length || !ce(s, o)) return null;
+	try {
+		let e = JSON.parse(k(i).toString("utf8"));
+		return typeof e.t != "string" || typeof e.i != "string" || typeof e.exp != "number" || e.exp < Math.floor(Date.now() / 1e3) ? null : {
+			type: e.t,
+			id: e.i
+		};
+	} catch {
+		return null;
+	}
+}, he = (e, t, n) => {
+	switch (t) {
+		case "=": return h(e, n);
+		case "!=": return y(e, n);
+		case "<": return ae(e, n);
+		case "<=": return v(e, n);
+		case ">": return ne(e, n);
+		case ">=": return re(e, n);
+	}
+}, M = (e) => {
+	let t = e.excludeArchived ? [...e.predicates, y("status", "archived")] : e.predicates, n = t.length === 0 ? void 0 : t.length === 1 ? t[0] : f(...t);
+	return {
+		table: e.table,
+		predicate: n,
+		order: e.order,
+		take: e.take,
+		skip: e.skip,
+		projection: void 0
+	};
+}, N = (e, t) => ({
+	where(n, r, i) {
+		return N(e, {
+			...t,
+			predicates: [...t.predicates, he(n, r, i)]
+		});
+	},
+	orderBy(n, r = "asc") {
+		return N(e, {
+			...t,
+			order: [...t.order, {
+				column: n,
+				direction: r
+			}]
+		});
+	},
+	limit(n) {
+		return N(e, {
+			...t,
+			take: n
+		});
+	},
+	offset(n) {
+		return N(e, {
+			...t,
+			skip: n
+		});
+	},
+	async all() {
+		return e.query(M(t));
+	},
+	async one() {
+		return (await e.query(M({
+			...t,
+			take: 1
+		})))[0] ?? null;
+	}
+}), P = (e, t, n) => {
+	let r = new Map(t.map((e) => [e.name, e])), i = (e) => {
+		let t = r.get(e);
+		if (!t) throw Error(`cms.contentType('${e}'): unknown content type. Register it via defineContentType and pass it to cmsContext / createCmsClient.`);
+		return t;
+	};
+	return {
+		contentType(t) {
+			return i(t), N(e, {
+				table: `${t}_published`,
+				predicates: [],
+				order: [],
+				take: void 0,
+				skip: void 0,
+				excludeArchived: !0
+			});
+		},
+		async preview(t, r, a) {
+			i(t);
+			let o = a ? j(a, n ? { secret: n } : {}) : null, s = o !== null && o.type === t && o.id === r ? `${t}_drafts` : `${t}_published`;
+			return (await e.query({
+				table: s,
+				predicate: h("id", r),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0] ?? null;
+		}
+	};
+}, ge = (e, t, n = {}) => P(e, t, n.secret), F = (e) => P(e.store, e.types, e.secret), I = (e) => {
+	if (e.cms === void 0) throw Error("useCms: `ctx.cms` is not set. Build it with cmsContext(store, types) and attach it to your AppContext (or use createCmsClient at build time).");
+	return e.cms;
+}, L = (e) => `${e.name}_drafts`, R = (e) => `${e.name}_published`, z = (e, t, n) => ({
+	table: e,
+	predicate: h("id", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0,
+	...n === !0 ? { crossTenant: !0 } : {}
+}), B = async (e, t, n) => (await e.query(z(t, n)))[0], V = (e, t) => {
+	let n = {};
+	for (let r of Object.keys(e.fields)) r in t && (n[r] = t[r]);
+	return n;
+}, H = async (t, n, r) => {
+	let i = u(n, r);
+	e(n, i);
+	let a = L(n), o = V(n, i), s = i.id;
+	if (s !== void 0) {
+		let e = await B(t, a, s);
+		if (e !== void 0) return await t.update(a, s, {
+			...o,
+			status: "draft"
+		}) ?? e;
+		if ((await t.query(z(a, s, !0))).length > 0) throw new c({
+			contentType: n.name,
+			id: s
+		});
+		return t.insert(a, {
+			...o,
+			id: s,
+			status: "draft"
+		});
+	}
+	return t.insert(a, {
+		...o,
+		status: "draft"
+	});
+}, U = async (e, t, n) => e.transactional(async (e) => {
+	let r = await B(e, L(t), n);
+	if (r === void 0) throw new d({
+		contentType: t.name,
+		id: n,
+		stage: "draft"
+	});
+	let i = R(t), a = V(t, r), o = await B(e, i, n), s;
+	if (o !== void 0) s = await e.update(i, n, {
+		...a,
+		status: "published"
+	}) ?? o;
+	else {
+		let t = r.tenantId;
+		s = await e.insert(i, {
+			...a,
+			id: n,
+			status: "published",
+			...t == null ? {} : { tenantId: t }
+		});
+	}
+	return await e.update(L(t), n, { status: "published" }), s;
+}), W = async (e, t, n) => e.transactional(async (e) => {
+	if (await B(e, R(t), n) === void 0) throw new d({
+		contentType: t.name,
+		id: n,
+		stage: "published"
+	});
+	await e.delete(R(t), n), await B(e, L(t), n) !== void 0 && await e.update(L(t), n, { status: "draft" });
+}), G = async (e, t, n) => e.transactional(async (e) => {
+	let r = await B(e, L(t), n), i = await B(e, R(t), n);
+	if (r === void 0 && i === void 0) throw new d({
+		contentType: t.name,
+		id: n,
+		stage: "draft"
+	});
+	r !== void 0 && await e.update(L(t), n, { status: "archived" }), i !== void 0 && await e.update(R(t), n, { status: "archived" });
+}), K = (e, t) => C.tryPromise({
+	try: e,
+	catch: (e) => e
+}).pipe(C.catchAll((e) => t(e) ? C.fail(e) : C.die(e))), _e = (e) => e instanceof t || e instanceof c, q = (e) => e instanceof d, ve = (e, t, n) => K(() => H(e, t, n), _e), ye = (e, t, n) => K(() => U(e, t, n), q), be = (e, t, n) => K(() => W(e, t, n), q), xe = (e, t, n) => K(() => G(e, t, n), q), J = (e) => `${e.name}_drafts`, Y = async (e, t, n, r) => {
+	let i = J(t), a = await e.query({
+		table: i,
+		predicate: h("id", n),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a[0] === void 0) throw new d({
+		contentType: t.name,
+		id: n,
+		stage: "draft"
+	});
+	return await e.update(i, n, { publishAt: r }) ?? a[0];
+}, Se = (e, t) => ({
+	table: J(e),
+	predicate: f(v("publishAt", t), h("status", "draft")),
+	order: [],
+	take: void 0,
+	skip: void 0,
+	projection: void 0
+}), X = async (e, t, n = /* @__PURE__ */ new Date()) => {
+	let r = await e.query(Se(t, n)), i = [];
+	for (let n of r) {
+		let r = n.id;
+		typeof r == "string" && (await U(e, t, r), await e.update(J(t), r, { publishAt: null }), i.push(r));
+	}
+	return i;
+}, Ce = (e, t, n, r) => C.tryPromise({
+	try: () => Y(e, t, n, r),
+	catch: (e) => e
+}).pipe(C.catchAll((e) => e instanceof d ? C.fail(e) : C.die(e))), we = (e, t, n = /* @__PURE__ */ new Date()) => C.promise(() => X(e, t, n)), Te = (e) => Object.entries(e.fields).filter(([, e]) => e.kind === "media").map(([e]) => e), Z = async (e, t, n) => {
+	if (t == null) return t;
+	switch (e.kind) {
+		case "media": return typeof t == "string" ? await n(t) ?? t : t;
+		case "array": {
+			let r = e.element;
+			return r === void 0 || !Array.isArray(t) ? t : Promise.all(t.map((e) => Z(r, e, n)));
+		}
+		case "struct": {
+			let r = e.struct;
+			if (r === void 0 || typeof t != "object" || Array.isArray(t)) return t;
+			let i = t, a = { ...i };
+			for (let [e, t] of Object.entries(r)) e in i && (a[e] = await Z(t, i[e], n));
+			return a;
+		}
+		default: return t;
+	}
+}, Q = async (e, t, n) => {
+	let r = { ...t };
+	for (let [i, a] of Object.entries(e.fields)) {
+		let e = a;
+		e.kind !== "media" && e.kind !== "array" && e.kind !== "struct" || i in t && (r[i] = await Z(e, t[i], n));
+	}
+	return r;
+}, $ = async (e, t, n) => Promise.all(t.map((t) => Q(e, t, n))), Ee = (e) => Te(e), De = "/v1/cms/", Oe = (e) => {
+	let t = e.authorization;
+	return t && t.toLowerCase().startsWith("bearer ") ? t.slice(7).trim() : e["x-api-key"];
+}, ke = async (e, t) => {
+	if (e.method.toUpperCase() !== "GET") return {
+		status: 405,
+		body: { error: "method_not_allowed" }
+	};
+	if (!e.path.startsWith(De)) return {
+		status: 404,
+		body: { error: "not_found" }
+	};
+	let n = Oe(e.headers), r = n ? t.apiKeys.find((e) => e.key === n) : void 0;
+	if (!r) return {
+		status: 401,
+		body: { error: "unauthorized" }
+	};
+	let i = e.path.slice(8).split("/").filter((e) => e.length > 0), a = i[0];
+	if (!a || !t.types.some((e) => e.name === a)) return {
+		status: 404,
+		body: { error: "unknown_content_type" }
+	};
+	if (!(r.types === void 0 || r.types.includes("*") || r.types.includes(a))) return {
+		status: 403,
+		body: {
+			error: "forbidden",
+			type: a
+		}
+	};
+	if (i.length >= 2) {
+		let e = i.slice(1).join("/"), n = await t.cms.contentType(a).where("slug", "=", e).one();
+		return n ? {
+			status: 200,
+			body: n
+		} : {
+			status: 404,
+			body: {
+				error: "not_found",
+				type: a,
+				slug: e
+			}
+		};
+	}
+	let o = t.defaultLimit ?? 20, s = t.maxLimit ?? 100, c = Number(e.query?.limit), l = Number.isFinite(c) && c > 0 ? Math.min(c, s) : o;
+	return {
+		status: 200,
+		body: await t.cms.contentType(a).limit(l).all()
+	};
+};
+//#endregion
+export { w as CONTENT_STATUSES, ee as ContentForm, c as ContentIdConflict, d as ContentNotFound, t as ContentValidationFailed, a as Schema, u as applyDerivations, G as archive, xe as archiveEffect, ge as cmsContext, fe as contentTypeToEntities, i as contentViolations, F as createCmsClient, le as defineContentType, te as derivedFrom, ke as handleCmsRest, n as maxLength, Ee as mediaFields, r as pattern, me as previewToken, U as publish, X as publishDue, we as publishDueEffect, ye as publishEffect, Q as resolveMedia, $ as resolveMediaAll, H as saveDraft, ve as saveDraftEffect, Y as schedulePublish, Ce as schedulePublishEffect, l as slugify, o as unique, W as unpublish, be as unpublishEffect, I as useCms, e as validateContent, j as verifyPreviewToken, s as widgetFor };

package/dist/web.d.ts

@@ -0,0 +1,312 @@
+import { ReactNode } from 'react';
+import { Schema as Schema_2 } from 'effect';
+
+/**
+ * Compute every `derivedFrom` field from its source value. Returns a NEW
+ * row — the input is not mutated. A caller-provided value for a derived
+ * field is OVERWRITTEN (derived values are the content type's opinion,
+ * mirroring the column `.computed()` semantics). Derivations run in
+ * declaration order against the progressively-updated row, so a derived
+ * field may source another, earlier-declared derived field.
+ */
+export declare const applyDerivations: (type: Pick<ContentType, "fields" | "derivedFields">, row: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+
+/** Everything the write pipeline can fail with on the typed channel. */
+export declare type CmsWriteError = ContentValidationFailed | ContentNotFound | ContentIdConflict;
+
+/**
+ * Auto-generated content form. Renders one labelled widget per field,
+ * driven entirely by each field's `editorHint`. Stateless — the caller
+ * owns `value` + `onChange`.
+ */
+export declare const ContentForm: (props: ContentFormProps) => ReactNode;
+
+export declare interface ContentFormProps {
+    readonly contentType: ContentFormType;
+    readonly value: ContentValue;
+    readonly onChange: (next: ContentValue) => void;
+    /** Override the widget for one or more editor hints (e.g. a TipTap richText). */
+    readonly widgets?: Partial<Record<EditorHint, Widget>>;
+}
+
+/** The content-type shape ContentForm reads (structural — avoids a value import). */
+export declare interface ContentFormType {
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+}
+
+/**
+ * Raised by `saveDraft` when the caller supplies an explicit `id` that
+ * already exists OUTSIDE the caller's scope (another tenant's row).
+ * Refusing here keeps a caller-pinned id from ever updating — or, on a
+ * store without DB-enforced PKs, overwriting — a foreign row.
+ */
+export declare class ContentIdConflict extends ContentIdConflict_base {
+}
+
+declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflict, "ContentIdConflict", {
+    readonly _tag: Schema_2.tag<"ContentIdConflict">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+}>;
+
+/**
+ * Raised by `publish` / `unpublish` / `archive` when the row id doesn't
+ * exist in the caller's scope. On a tenant-scoped request store this is
+ * ALSO the cross-tenant answer: another tenant's row is indistinguishable
+ * from a missing one (the scoped read never sees it).
+ */
+export declare class ContentNotFound extends ContentNotFound_base {
+}
+
+declare const ContentNotFound_base: Schema_2.TaggedErrorClass<ContentNotFound, "ContentNotFound", {
+    readonly _tag: Schema_2.tag<"ContentNotFound">;
+} & {
+    contentType: typeof Schema_2.String;
+    id: typeof Schema_2.String;
+    /** Which lifecycle table the id was looked up in. */
+    stage: Schema_2.Literal<["draft", "published"]>;
+}>;
+
+/** A registered content type. */
+declare interface ContentType {
+    readonly name: string;
+    readonly displayName: string;
+    readonly pluralName: string;
+    readonly fields: Readonly<Record<string, FieldSchema>>;
+    readonly list?: ListConfig;
+    readonly idPrefix?: string;
+    /** Field names whose value is computed-on-save (derivedFrom). */
+    readonly derivedFields: ReadonlyArray<string>;
+    /** Field names marked unique-per-tenant (composite `(tenantId, field)` UNIQUE). */
+    readonly uniqueFields: ReadonlyArray<string>;
+}
+
+/**
+ * Raised by `validateContent` / `saveDraft` when a row violates the
+ * content type's field rules (pattern / maxLength / typed kinds /
+ * literal sets / rich-text content policy). Carries EVERY violation,
+ * per field, so an editor can annotate the whole form in one pass.
+ */
+export declare class ContentValidationFailed extends ContentValidationFailed_base {
+}
+
+declare const ContentValidationFailed_base: Schema_2.TaggedErrorClass<ContentValidationFailed, "ContentValidationFailed", {
+    readonly _tag: Schema_2.tag<"ContentValidationFailed">;
+} & {
+    contentType: typeof Schema_2.String;
+    violations: Schema_2.Array$<Schema_2.Struct<{
+        field: typeof Schema_2.String;
+        rule: typeof Schema_2.String;
+        message: typeof Schema_2.String;
+    }>>;
+}>;
+
+export declare type ContentValue = Record<string, unknown>;
+
+/**
+ * Collect every save-time rule violation for `row` against `type` —
+ * required presence, per-kind type checks, `maxLength`, `pattern`,
+ * `Literal` value sets, and the rich-text content policy
+ * (`allowImages` / `allowEmbeds: false` reject image/embed nodes or the
+ * `<img>` / `<iframe>` / `<embed>` markers in string values).
+ *
+ * Pure and never throws — usable in a browser form ("annotate every
+ * invalid field") as well as on the server. `id` is allowed (must be a
+ * string); the lifecycle/mixin columns the pipeline owns (`status`,
+ * `tenantId`, audit who/when) are tolerated on input and ignored; any
+ * OTHER undeclared key is an `unknown` violation (usually a typo'd
+ * field name).
+ *
+ * NOTE on ordering: run `applyDerivations` first when validating a row
+ * that is about to be written — a derived field's rules apply to the
+ * derived value, not to a caller value that's about to be overwritten.
+ */
+export declare const contentViolations: (type: Pick<ContentType, "name" | "fields">, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
+
+/**
+ * Mark a field computed-on-save from another field. The transform runs
+ * before the row is written — `saveDraft` applies it (via
+ * `applyDerivations`) ahead of validation, and `publish` copies the
+ * derived value. A caller-provided value is overwritten, mirroring the
+ * column `.computed()` semantics.
+ *
+ * ```ts
+ * slug: Schema.String.pipe(pattern(/^[a-z0-9-]+$/), derivedFrom('title', slugify))
+ * ```
+ */
+export declare const derivedFrom: (source: string, transform: (value: unknown, row: Record<string, unknown>) => unknown) => FieldRefinement;
+
+/** A field marked computed-on-save from another field's value. */
+export declare interface DerivedSpec {
+    readonly source: string;
+    readonly transform: (value: unknown, row: Record<string, unknown>) => unknown;
+}
+
+/** The widget the editor renders for a field — drives ContentForm. */
+export declare type EditorHint = 'text' | 'textarea' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'richText' | 'media' | 'reference' | 'array' | 'struct';
+
+/** Discriminator for how a field compiles to a column + serialises. */
+export declare type FieldKind = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'literal' | 'richText' | 'media' | 'reference' | 'array' | 'struct';
+
+/** A refinement applied through `.pipe(...)`. */
+export declare type FieldRefinement = (field: FieldSchema) => FieldSchema;
+
+/** A fully-resolved field descriptor stored on a content type. */
+export declare interface FieldSchema {
+    readonly kind: FieldKind;
+    readonly editorHint: EditorHint;
+    /** When true the field is nullable in the DB + optional in the editor. */
+    readonly isOptional: boolean;
+    /** Max string length — drives textarea-vs-input + save-time validation. */
+    readonly maxLength?: number;
+    /** Source-form regex (string) for save-time validation. */
+    readonly pattern?: string;
+    /** Closed value set for `literal` fields → `<select>` + CHECK constraint. */
+    readonly literals?: ReadonlyArray<string>;
+    /**
+     * When true, the field is unique PER TENANT — the derived tables carry a
+     * composite `(tenantId, <field>)` DB UNIQUE constraint (see contentType.ts).
+     * Only meaningful on a `string` field (typically a slug).
+     */
+    readonly unique?: boolean;
+    /** RichText options. */
+    readonly richText?: RichTextOptions;
+    /** Referenced content-type name for `reference` fields. */
+    readonly referenceType?: string;
+    /** Element field for `array` fields. */
+    readonly element?: FieldSchema;
+    /** Nested field map for `struct` fields. */
+    readonly struct?: Readonly<Record<string, FieldSchema>>;
+    /** Computed-on-save derivation (set via `derivedFrom`). */
+    readonly derived?: DerivedSpec;
+}
+
+/** One save-time rule violation, addressed to a field path. */
+export declare interface FieldViolation {
+    /** Dotted/indexed field path, e.g. `title`, `meta.ogTitle`, `tags[2]`. */
+    readonly field: string;
+    /** The rule that failed: `required` | `type` | `maxLength` | `pattern` | `literal` | `richText` | `unknown`. */
+    readonly rule: string;
+    readonly message: string;
+}
+
+/**
+ * List-view configuration for the consuming editor/template: which
+ * columns its list page shows and the default sort. Validated by
+ * `defineContentType` — every referenced name must be a declared field
+ * or a lifecycle column, so a typo fails at definition time instead of
+ * rendering an empty column.
+ */
+declare interface ListConfig {
+    readonly columns: ReadonlyArray<string>;
+    readonly defaultSort?: {
+        readonly field: string;
+        readonly dir: 'asc' | 'desc';
+    };
+}
+
+/** Cap a string field's length. Past `value` the editor renders a textarea. */
+export declare const maxLength: (value: number) => FieldRefinement;
+
+/** Constrain a string field to a regex (source form, validated on save). */
+export declare const pattern: (re: RegExp) => FieldRefinement;
+
+export declare interface PipeableField extends FieldSchema {
+    readonly isOptional: boolean;
+    pipe(...refinements: ReadonlyArray<FieldRefinement>): PipeableField;
+    /** Mark the field optional → nullable column + non-required editor input. */
+    optional(): PipeableField;
+}
+
+/**
+ * Options carried by a RichText field, enforced at save time by
+ * `validateContent`: an explicit `false` REJECTS the content class
+ * (image/embed nodes in a structured document, or `<img>` / `<iframe>` /
+ * `<embed>` markers in a string value); `true` or omitted allows it.
+ */
+export declare interface RichTextOptions {
+    readonly allowImages?: boolean;
+    readonly allowEmbeds?: boolean;
+}
+
+/**
+ * The CMS field namespace. Scalars mirror the effect/Schema names the
+ * docs use; the CMS-only constructors (RichText / Media / Reference /
+ * Array / Struct) carry their editor metadata. `optional()` is exposed
+ * as a property accessor on each scalar through the underlying field.
+ */
+export declare const Schema: {
+    /** Single-line text. `.pipe(maxLength(N>120))` switches it to a textarea. */
+    readonly String: PipeableField;
+    /** Numeric input. */
+    readonly Number: PipeableField;
+    /** Toggle. */
+    readonly Boolean: PipeableField;
+    /** Date-only picker. */
+    readonly Date: PipeableField;
+    /** Date + time picker. */
+    readonly DateTime: PipeableField;
+    readonly maxLength: (value: number) => FieldRefinement;
+    readonly pattern: (re: RegExp) => FieldRefinement;
+    readonly unique: () => FieldRefinement;
+    /** Closed value set → `<select>` widget + a CHECK constraint. */
+    readonly Literal: (values_0: string, ...values: string[]) => PipeableField;
+    /**
+     * Rich text, stored as a JSON document (e.g. a TipTap doc). The shipped
+     * default widget is a plain textarea placeholder — swap in a real editor
+     * via the `ContentForm` `widgets` override. `allowImages` /
+     * `allowEmbeds: false` reject that content class at save time.
+     */
+    readonly RichText: (options?: RichTextOptions) => PipeableField;
+    /**
+     * A storage object key (e.g. one issued by `@voltro/plugin-storage`),
+     * stored as text. Resolve the key to a served URL after a read with
+     * `resolveMedia(type, row, resolver)` — the app supplies the resolver
+     * (built from its storage layer's `getUrl`/`mintUrl`), so the core
+     * package stays decoupled from any storage plugin.
+     */
+    readonly Media: () => PipeableField;
+    /** A reference to another content type's published rows. */
+    readonly Reference: (type: string) => PipeableField;
+    /** Repeatable field. Stored as a JSON array. */
+    readonly Array: (element: FieldSchema) => PipeableField;
+    /** Nested object. Stored as a JSON document. */
+    readonly Struct: (fields: Readonly<Record<string, FieldSchema>>) => PipeableField;
+};
+
+/** The canonical slug helper: lowercase, hyphenate, strip non-url chars. */
+export declare const slugify: (value: unknown) => string;
+
+/**
+ * Mark a string field unique PER TENANT. The derived `<type>_drafts` +
+ * `<type>_published` tables get a real composite `(tenantId, <field>)`
+ * DB UNIQUE constraint (the tenant() mixin's `tenantId` is NOT NULL, so
+ * no partial/NULL machinery is needed) — the database rejects a second
+ * row with the same slug in the same tenant, not the application. Pair it
+ * with `derivedFrom('title', slugify)` for a per-tenant-unique slug.
+ */
+export declare const unique: () => FieldRefinement;
+
+/**
+ * Validate a row against a content type's save-time rules. Throws
+ * `ContentValidationFailed` carrying EVERY violation (per-field detail)
+ * when any rule breaks; returns nothing on success. The throwing face of
+ * `contentViolations` — `saveDraft` calls this after derivation.
+ */
+export declare const validateContent: (type: Pick<ContentType, "name" | "fields">, row: Readonly<Record<string, unknown>>) => void;
+
+export declare type Widget = (props: WidgetProps) => ReactNode;
+
+/** Resolve the widget for a field, honouring `widgets` overrides. */
+export declare const widgetFor: (hint: EditorHint, overrides?: Partial<Record<EditorHint, Widget>>) => Widget;
+
+/** Props for a single field widget. */
+export declare interface WidgetProps {
+    readonly name: string;
+    readonly field: FieldSchema;
+    readonly value: unknown;
+    readonly onChange: (value: unknown) => void;
+}
+
+export { }

package/dist/web.js

@@ -0,0 +1,2 @@
+import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p } from "./ContentForm-D0YGVkRu.js";
+export { f as ContentForm, c as ContentIdConflict, d as ContentNotFound, t as ContentValidationFailed, a as Schema, u as applyDerivations, i as contentViolations, p as derivedFrom, n as maxLength, r as pattern, l as slugify, o as unique, e as validateContent, s as widgetFor };