@karibsen/eponyme 0.6.0 → 0.8.0

package/dist/runtime/server/utils/eponyme-reindex.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rebuilds the filterable index of every entry, unconditionally.
+ *
+ * Rarely needed: startup already rebuilds whatever a configuration change invalidated, so
+ * adding a `field.tags()` to a collection that already holds entries is handled on its own.
+ * This is the repair for what a fingerprint cannot see — editing a custom `validate` so that
+ * it now rejects values already stored, or an index suspected of having drifted.
+ *
+ * Auto-imported, so a host can expose it on a route or call it from a script.
+ */
+export declare function reindexEponymeEntries(): Promise<{
+    entries: number;
+}>;

package/dist/runtime/server/utils/eponyme-reindex.js

@@ -0,0 +1,4 @@
+import { useEponymeService } from "../services/eponyme-service.js";
+export async function reindexEponymeEntries() {
+  return useEponymeService().reindexAll();
+}

package/dist/runtime/types/eponyme-config.d.ts

@@ -16,10 +16,3 @@ declare module '#eponyme/variables' {
   const variables: EponymeVariables
   export default variables
 }
-
-declare module '#eponyme/captcha' {
-  import type { EponymeCaptchaVerifier } from './captcha'
-
-  const verifier: EponymeCaptchaVerifier
-  export default verifier
-}

package/dist/runtime/types/eponyme.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayFieldDefinition, ArrayItemValue, BooleanFieldDefinition, CheckboxGroupFieldDefinition, EmailFieldDefinition, FieldDefinition, NumberFieldDefinition, RadioFieldDefinition, SectionFieldDefinition, SectionValue, SelectFieldDefinition, SlugFieldDefinition, StringFieldDefinition, TabFieldDefinition, TabsValue, TextareaFieldDefinition, UrlFieldDefinition, UrlValue } from './field.js';
+import type { ArrayFieldDefinition, ArrayItemValue, BooleanFieldDefinition, CheckboxGroupFieldDefinition, EmailFieldDefinition, FieldDefinition, NumberFieldDefinition, PhoneFieldDefinition, RadioFieldDefinition, SectionFieldDefinition, SectionValue, SelectFieldDefinition, SlugFieldDefinition, StringFieldDefinition, TabFieldDefinition, TagsFieldDefinition, TagsValueOf, TabsValue, TextareaFieldDefinition, UrlFieldDefinition, UrlValue } from './field.js';
 export type EponymeSchema = Record<string, FieldDefinition>;
 export interface EponymeCollectionDefinitionBase {
     __eponymeCollection: true;
@@ -26,7 +26,7 @@ export interface EponymeCollectionDefinition<T extends EponymeSchema = EponymeSc
  * `slug`, `richText`, `image`, `date`, `color`, `array`, `section` and `tabs` are
  * authoring concerns and are rejected by `form()`.
  */
-export type EponymeFormFieldDefinition = StringFieldDefinition | TextareaFieldDefinition | EmailFieldDefinition | UrlFieldDefinition | NumberFieldDefinition | BooleanFieldDefinition | SelectFieldDefinition | RadioFieldDefinition | CheckboxGroupFieldDefinition;
+export type EponymeFormFieldDefinition = StringFieldDefinition | TextareaFieldDefinition | EmailFieldDefinition | PhoneFieldDefinition | UrlFieldDefinition | NumberFieldDefinition | BooleanFieldDefinition | SelectFieldDefinition | RadioFieldDefinition | CheckboxGroupFieldDefinition;
 export type EponymeFormSchema = Record<string, EponymeFormFieldDefinition>;
 /** `custom` leaves delivery to the host application; `managed` stores the submission. */
 export type EponymeFormMode = 'custom' | 'managed';
@@ -42,8 +42,6 @@ export interface EponymeFormOptions<T extends EponymeFormSchema = EponymeFormSch
     honeypot?: string | false;
     /** In bytes. */
     maxBodyBytes?: number;
-    /** Requires a valid captcha token. Needs an adapter such as `@karibsen/eponyme-captcha`. */
-    captcha?: boolean;
 }
 export interface EponymeFormDefinitionBase {
     __eponymeForm: true;
@@ -53,7 +51,6 @@ export interface EponymeFormDefinitionBase {
     submission: Required<EponymeFormSubmissionOptions>;
     honeypot: string | false;
     maxBodyBytes: number;
-    captcha: boolean;
 }
 export interface EponymeFormDefinition<T extends EponymeFormSchema = EponymeFormSchema> extends EponymeFormDefinitionBase {
     fields: T;
@@ -68,7 +65,7 @@ export type FieldValue<T extends FieldDefinition> = T extends {
     type: 'number';
 } ? number : T extends {
     type: 'boolean';
-} ? boolean : T extends UrlFieldDefinition ? UrlValue : T extends ArrayFieldDefinition<infer Item> ? Array<ArrayItemValue<Item>> : T extends CheckboxGroupFieldDefinition<infer Value> ? Value[] : T extends SectionFieldDefinition<infer Section> ? SectionValue<Section> : T extends TabFieldDefinition<infer Tabs> ? TabsValue<Tabs> : string;
+} ? boolean : T extends UrlFieldDefinition ? UrlValue : T extends ArrayFieldDefinition<infer Item> ? Array<ArrayItemValue<Item>> : T extends CheckboxGroupFieldDefinition<infer Value> ? Value[] : T extends TagsFieldDefinition<infer Options> ? Array<TagsValueOf<Options>> : T extends SectionFieldDefinition<infer Section> ? SectionValue<Section> : T extends TabFieldDefinition<infer Tabs> ? TabsValue<Tabs> : string;
 export type EponymeData<T extends EponymeSchema> = {
     [K in keyof T]: T[K] extends FieldDefinition ? FieldValue<T[K]> : never;
 };
@@ -77,6 +74,57 @@ export type EponymeCollectionName<T extends EponymeConfig> = {
     [K in keyof T & string]: T[K] extends EponymeCollectionDefinitionBase ? K : T[K] extends EponymeFormDefinitionBase ? never : T[K] extends EponymeSchema ? never : T[K] extends EponymeConfig ? `${K}/${EponymeCollectionName<T[K]>}` : never;
 }[keyof T & string];
 export type EponymeCollectionDataByName<T extends EponymeConfig, Name extends EponymeCollectionName<T>> = EponymeCollectionAtPath<T, Name> extends EponymeCollectionDefinition<infer Schema> ? EponymeData<Schema> : never;
+/**
+ * Field types a `where` can filter on, mirroring the write path's `INDEXABLE_TYPES`.
+ *
+ * The two lists are separate because one runs on values and the other on types, but they
+ * describe the same rule: a filterable field is one whose stored form compares correctly as
+ * text. That is why `date` is here — validation pins it to `YYYY-MM-DD` — and `number` is
+ * not, since `'10'` sorts before `'9'`.
+ */
+type FilterableFieldType = 'tags' | 'checkboxGroup' | 'select' | 'radio' | 'boolean' | 'date';
+/** A multi-valued field is filtered by one of its items, not by the whole list. */
+type FilterOperand<T extends FieldDefinition> = FieldValue<T> extends readonly (infer Item)[] ? Item : FieldValue<T>;
+/**
+ * Bounds, offered only where alphabetical order is the value's natural order — which is
+ * `field.date()`, pinned by validation to `YYYY-MM-DD`. On a tag or a select, comparing
+ * with `gte` would sort labels, which answers no question anyone asks.
+ */
+export interface EponymeFilterBounds {
+    gte?: string;
+    lte?: string;
+    gt?: string;
+    lt?: string;
+}
+type FilterOperators<T extends FieldDefinition> = {
+    /** Any of these, the same as passing the list directly. */
+    in?: readonly FilterOperand<T>[];
+    /** None of these. Combines with the positive operators to narrow then subtract. */
+    not?: FilterOperand<T> | readonly FilterOperand<T>[];
+    /**
+     * Substring of the stored value, case-insensitive.
+     *
+     * The only operator that cannot use the index's ordering — a leading wildcard scans it.
+     * That still reads a narrow table instead of every entry's content, but it does not
+     * scale the way the others do.
+     */
+    contains?: string;
+} & (T extends {
+    type: 'date';
+} ? EponymeFilterBounds : unknown);
+/** The values of one key are ORed; the keys of a `where` are ANDed. */
+export type EponymeFieldFilter<T extends FieldDefinition> = FilterOperand<T> | readonly FilterOperand<T>[] | FilterOperators<T>;
+/**
+ * The filter a schema accepts, keyed by field name. Nested fields are left out: a field
+ * inside a section, a tab or an array has no single key to name it by, which is the same
+ * reason `orderBy` cannot reach one.
+ */
+export type EponymeFilterInput<T extends EponymeSchema> = {
+    [K in keyof T as T[K] extends {
+        type: FilterableFieldType;
+    } ? K : never]?: T[K] extends FieldDefinition ? EponymeFieldFilter<T[K]> : never;
+};
+export type EponymeCollectionFilter<T extends EponymeConfig, Name extends EponymeCollectionName<T>> = EponymeCollectionAtPath<T, Name> extends EponymeCollectionDefinition<infer Schema> ? EponymeFilterInput<Schema> : never;
 export type EponymeName<T extends EponymeConfig> = {
     [K in keyof T & string]: T[K] extends EponymeCollectionDefinitionBase ? never : T[K] extends EponymeFormDefinitionBase ? never : T[K] extends EponymeSchema ? K : T[K] extends EponymeConfig ? `${K}/${EponymeName<T[K]>}` : never;
 }[keyof T & string];

package/dist/runtime/types/field.d.ts

@@ -1,4 +1,5 @@
-export type EponymeFieldType = 'string' | 'slug' | 'email' | 'url' | 'textarea' | 'richText' | 'number' | 'boolean' | 'image' | 'select' | 'radio' | 'checkboxGroup' | 'date' | 'color' | 'array' | 'section' | 'tabs';
+import type { CountryCode } from 'libphonenumber-js/min';
+export type EponymeFieldType = 'string' | 'slug' | 'email' | 'phone' | 'url' | 'textarea' | 'richText' | 'number' | 'boolean' | 'image' | 'select' | 'radio' | 'checkboxGroup' | 'tags' | 'date' | 'color' | 'array' | 'section' | 'tabs';
 export type FieldVisibilityCondition = {
     field: string;
     equals: unknown;
@@ -27,8 +28,6 @@ export interface TextFieldOptions extends DefaultFieldOptions<string> {
     placeholder?: string;
     trim?: boolean;
     regex?: RegExp;
-    email?: boolean;
-    url?: boolean;
 }
 export type StringFieldOptions = TextFieldOptions;
 export type TextareaFieldOptions = TextFieldOptions;
@@ -65,6 +64,37 @@ export interface EmailFieldDefinition {
     type: 'email';
     options: EmailFieldOptions;
 }
+/**
+ * Countries a phone field accepts, as ISO 3166-1 alpha-2 codes. Re-exported so declaring a
+ * field autocompletes them without importing from `libphonenumber-js` in application code.
+ */
+export type PhoneCountry = CountryCode;
+export interface PhoneFieldOptions extends DefaultFieldOptions<string> {
+    placeholder?: string;
+    /**
+     * Countries whose numbers are accepted. A number resolving to any other country is refused.
+     * Omitted, every country is accepted.
+     */
+    countries?: PhoneCountry[];
+    /**
+     * Country a number typed without an international prefix belongs to. Without it, only
+     * `+…` numbers can be understood.
+     */
+    defaultCountry?: PhoneCountry;
+    /**
+     * Whether a number may be written in national form and resolved against `defaultCountry`.
+     * `false` requires the international `+…` form, so the country is never guessed.
+     *
+     * @default true
+     */
+    detectCountry?: boolean;
+    /** Value of the input's `autocomplete` attribute. */
+    autocomplete?: 'tel' | 'tel-national' | 'tel-country-code';
+}
+export interface PhoneFieldDefinition {
+    type: 'phone';
+    options: PhoneFieldOptions;
+}
 export type UrlType = 'internal' | 'external';
 export interface UrlValue {
     href: string;
@@ -72,8 +102,23 @@ export interface UrlValue {
     openInNewTab: boolean;
     download?: boolean;
 }
+/**
+ * Scheme of an external link, without the trailing colon. The common ones are suggested, and
+ * any other scheme is still accepted — `bitcoin`, `matrix` or an application scheme are valid
+ * choices this list has no business refusing.
+ */
+export type UrlProtocol = 'http' | 'https' | 'mailto' | 'tel' | 'sms' | 'ftp' | (string & {});
 export interface UrlFieldOptions extends DefaultFieldOptions<UrlValue> {
     placeholder?: string;
+    /**
+     * Schemes an external link may use. `['https']` refuses plain `http`, and adding `mailto`
+     * or `tel` is what makes a contact link possible.
+     *
+     * Internal links are unaffected: they still have to start with `/` or `#`.
+     *
+     * @default ['http', 'https']
+     */
+    protocols?: UrlProtocol[];
 }
 export interface UrlFieldDefinition {
     type: 'url';
@@ -131,6 +176,39 @@ export interface CheckboxGroupFieldDefinition<T extends string = string> {
     type: 'checkboxGroup';
     options: CheckboxGroupFieldOptions<T>;
 }
+export interface TagsFieldOptions<T extends string = string> extends DefaultFieldOptions<T[]> {
+    /** Offered while typing. With `allowCustom` off, they are also the only accepted values. */
+    suggestions?: readonly T[];
+    /**
+     * Whether a tag outside `suggestions` may be entered.
+     *
+     * @default false
+     */
+    allowCustom?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    placeholder?: string;
+}
+/**
+ * Values a tags field may hold, read from the options as they were written: the suggestions
+ * themselves while the list is closed, any string once `allowCustom` opens it. A tag list is
+ * therefore never a mix of types.
+ *
+ * Read from the object rather than from a type parameter on purpose. A parameter carrying
+ * `allowCustom` is re-inferred as `boolean` when the config is checked against `EponymeConfig`,
+ * and a conditional on `boolean` distributes over `true | false`, collapsing the union of
+ * suggestions to plain `string`. The shape of the object survives that check — which is also
+ * how `field.select()` and `field.checkboxGroup()` keep their literals.
+ */
+export type TagsValueOf<O> = O extends {
+    allowCustom: true;
+} ? string : O extends {
+    suggestions: readonly (infer S extends string)[];
+} ? S : string;
+export interface TagsFieldDefinition<O extends TagsFieldOptions = TagsFieldOptions> {
+    type: 'tags';
+    options: O;
+}
 export interface TodayDateDefault {
     readonly __eponymeDefault: 'today';
 }
@@ -155,7 +233,7 @@ export interface ColorFieldDefinition {
     type: 'color';
     options: ColorFieldOptions;
 }
-export type ArrayItemFieldDefinition = StringFieldDefinition | SlugFieldDefinition | EmailFieldDefinition | UrlFieldDefinition | TextareaFieldDefinition | RichTextFieldDefinition | NumberFieldDefinition | BooleanFieldDefinition | ImageFieldDefinition | SelectFieldDefinition | RadioFieldDefinition | CheckboxGroupFieldDefinition | DateFieldDefinition | ColorFieldDefinition;
+export type ArrayItemFieldDefinition = StringFieldDefinition | SlugFieldDefinition | EmailFieldDefinition | PhoneFieldDefinition | UrlFieldDefinition | TextareaFieldDefinition | RichTextFieldDefinition | NumberFieldDefinition | BooleanFieldDefinition | ImageFieldDefinition | SelectFieldDefinition | RadioFieldDefinition | CheckboxGroupFieldDefinition | TagsFieldDefinition | DateFieldDefinition | ColorFieldDefinition;
 export type ArrayItemSchema = Record<string, ArrayItemFieldDefinition>;
 export type ArrayItemDefinition = ArrayItemFieldDefinition | ArrayItemSchema;
 export type ArrayItemValue<T extends ArrayItemDefinition> = T extends NumberFieldDefinition ? number : T extends BooleanFieldDefinition ? boolean : T extends UrlFieldDefinition ? UrlValue : T extends CheckboxGroupFieldDefinition<infer Value> ? Value[] : T extends ArrayItemFieldDefinition ? string : T extends ArrayItemSchema ? {

package/dist/runtime/types/index.d.ts

@@ -1,5 +1,4 @@
 export * from './auth.js';
 export * from './eponyme.js';
 export * from './field.js';
-export * from './captcha.js';
 export * from './variables.js';

package/dist/runtime/types/index.js

@@ -1,5 +1,4 @@
 export * from "./auth.js";
 export * from "./eponyme.js";
 export * from "./field.js";
-export * from "./captcha.js";
 export * from "./variables.js";

package/dist/runtime/utils/eponyme-entry-index.d.ts

@@ -0,0 +1,39 @@
+import type { EponymeSchema } from '../types/eponyme.js';
+export interface EponymeIndexRow {
+    entryName: string;
+    version: 'draft' | 'published';
+    key: string;
+    value: string;
+}
+/** Rejecting a query on an unknown key beats silently returning the whole collection. */
+export declare function eponymeIndexKeys(schema: EponymeSchema): string[];
+export declare function isEponymeIndexKey(schema: EponymeSchema, key: string): boolean;
+/**
+ * Deliberately not `schemaFingerprint`, which covers names and types only. That one is the
+ * import compatibility contract — widening it would start refusing imports over harmless
+ * edits. Here the opposite bias applies: `field.select()` losing an option, or
+ * `field.tags({ allowCustom })` being turned off, makes `reconcile` drop stored values, and
+ * `defaultValue` decides what an entry missing the field gets indexed with. All of that has
+ * to invalidate the index, and none of it changes a name or a type.
+ *
+ * `validate` and `visibleWhen` are functions, kept as their mere presence: a body cannot be
+ * hashed honestly, since a minifier would change it without changing behaviour. Editing a
+ * custom validator so that it rejects previously stored values therefore needs a manual
+ * `reindexEponymeEntries()`.
+ */
+export declare function describeEponymeIndexSchema(schema: EponymeSchema): string;
+/**
+ * Only top-level fields are covered, which is the same reach as `orderBy`: a field nested
+ * in a section, a tab or an array is not addressable by a single key, so neither sorting
+ * nor filtering can name one.
+ *
+ * Draft and published are indexed separately. The dashboard lists drafts and a public page
+ * lists published entries, and the two disagree on purpose — one index for both would make
+ * an unpublished tag leak into a public listing.
+ */
+export declare function buildEponymeIndexRows(entryName: string, schema: EponymeSchema, versions: {
+    draft: Record<string, unknown>;
+    published: Record<string, unknown>;
+}): EponymeIndexRow[];
+/** The form both the write path and a query reduce a value to, so they always agree. */
+export declare function foldEponymeIndexValue(value: string): string;

package/dist/runtime/utils/eponyme-entry-index.js

@@ -0,0 +1,51 @@
+const INDEXABLE_TYPES = /* @__PURE__ */ new Set(["tags", "checkboxGroup", "select", "radio", "boolean", "date"]);
+const INDEX_ALGORITHM = 1;
+const COSMETIC_OPTION_KEYS = /* @__PURE__ */ new Set(["label", "description", "placeholder"]);
+export function eponymeIndexKeys(schema) {
+  return Object.keys(schema).filter((name) => isIndexable(schema[name]));
+}
+export function isEponymeIndexKey(schema, key) {
+  return isIndexable(schema[key]);
+}
+function isIndexable(definition) {
+  return Boolean(definition && INDEXABLE_TYPES.has(definition.type));
+}
+export function describeEponymeIndexSchema(schema) {
+  const fields = Object.keys(schema).filter((name) => isIndexable(schema[name])).sort().map((name) => `${name}:${schema[name].type}:${stableDescribe(schema[name].options)}`);
+  return `v${INDEX_ALGORITHM}|${fields.join(",")}`;
+}
+function stableDescribe(value) {
+  if (typeof value === "function") return "fn";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return `[${value.map(stableDescribe).join(",")}]`;
+  const entries = Object.keys(value).filter((key) => !COSMETIC_OPTION_KEYS.has(key)).sort().map((key) => `${key}:${stableDescribe(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+export function buildEponymeIndexRows(entryName, schema, versions) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const version of ["draft", "published"]) {
+    const data = versions[version];
+    for (const [key, definition] of Object.entries(schema)) {
+      if (!isIndexable(definition)) continue;
+      for (const value of indexValues(data[key])) {
+        rows.set(`${version}\0${key}\0${value}`, { entryName, version, key, value });
+      }
+    }
+  }
+  return [...rows.values()];
+}
+function indexValues(value) {
+  if (value === void 0 || value === null || value === "") return [];
+  if (typeof value === "boolean") return [String(value)];
+  if (typeof value === "string") return [fold(value)];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => typeof item === "string" && item.trim() ? [fold(item)] : []);
+  }
+  return [];
+}
+export function foldEponymeIndexValue(value) {
+  return fold(value);
+}
+function fold(value) {
+  return value.trim().toLocaleLowerCase();
+}

package/dist/runtime/utils/get-field-default-value.js

@@ -17,6 +17,8 @@ export function getFieldDefaultValue(definition) {
       return [];
     case "checkboxGroup":
       return [];
+    case "tags":
+      return [];
     case "section":
       return Object.fromEntries(
         Object.entries(definition.options.fields).map(([name, field]) => [name, getFieldDefaultValue(field)])

package/dist/runtime/utils/middle-ellipsis.d.ts

@@ -0,0 +1 @@
+export declare function middleEllipsis(value: string, maxLength?: number): string;

package/dist/runtime/utils/middle-ellipsis.js

@@ -0,0 +1,8 @@
+export function middleEllipsis(value, maxLength = 28) {
+  const characters = [...value];
+  if (characters.length <= maxLength) return value;
+  const available = maxLength - 1;
+  const startLength = Math.ceil(available / 2);
+  const endLength = Math.floor(available / 2);
+  return `${characters.slice(0, startLength).join("")}\u2026${characters.slice(-endLength).join("")}`;
+}

package/dist/runtime/utils/normalize-eponyme-values.d.ts

@@ -0,0 +1,13 @@
+import type { EponymeSchema } from '../types/index.js';
+/**
+ * Rewrites every value that has a canonical form — a phone in E.164, a tag list deduplicated —
+ * wherever it sits in the schema.
+ *
+ * Applied on the server before a write, which is what makes a stored format a guarantee rather
+ * than a convention: the API accepts any JSON, so a client normalising on its own could always
+ * be bypassed. A value that cannot be understood is left as sent, for validation to reject.
+ *
+ * One walk for every field type that needs one. A second walker would mean a second place to
+ * forget a container when a field type is added.
+ */
+export declare function normalizeEponymeValues(schema: EponymeSchema, data: Record<string, unknown>): Record<string, unknown>;

package/dist/runtime/utils/normalize-eponyme-values.js

@@ -0,0 +1,40 @@
+import { isArrayItemFieldDefinition } from "./get-field-default-value.js";
+import { toEponymePhoneValue } from "./normalize-phone.js";
+import { normalizeEponymeTags } from "./normalize-tags.js";
+export function normalizeEponymeValues(schema, data) {
+  const result = { ...data };
+  for (const [name, definition] of Object.entries(schema)) {
+    if (!(name in result)) continue;
+    result[name] = normalizeField(definition, result[name]);
+  }
+  return result;
+}
+function normalizeField(definition, value) {
+  if (definition.type === "phone") return toEponymePhoneValue(value, definition.options);
+  if (definition.type === "tags") return Array.isArray(value) ? normalizeEponymeTags(value, definition.options) : value;
+  if (definition.type === "section")
+    return normalizeNested(definition.options.fields, value);
+  if (definition.type === "tabs") {
+    if (!isRecord(value)) return value;
+    const tabs = { ...value };
+    for (const [tabName, tab] of Object.entries(definition.options.tabs))
+      if (tabName in tabs) tabs[tabName] = normalizeNested(tab.fields, tabs[tabName]);
+    return tabs;
+  }
+  if (definition.type === "array") {
+    if (!Array.isArray(value)) return value;
+    return value.map((item) => normalizeArrayItem(definition.options.of, item));
+  }
+  return value;
+}
+function normalizeArrayItem(of, item) {
+  if (isArrayItemFieldDefinition(of)) return normalizeField(of, item);
+  return normalizeNested(of, item);
+}
+function normalizeNested(schema, value) {
+  if (!isRecord(value)) return value;
+  return normalizeEponymeValues(schema, value);
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/runtime/utils/normalize-phone.d.ts

@@ -0,0 +1,26 @@
+import type { PhoneFieldOptions } from '../types/field.js';
+export interface NormalizedPhone {
+    /** The number in E.164, present only when it parsed and validated. */
+    e164?: string;
+    /** Country the number resolved to, present as soon as it parsed. */
+    country?: string;
+    valid: boolean;
+    /** Set when the number is valid but its country is not in `countries`. */
+    countryNotAllowed?: boolean;
+}
+/**
+ * Single source of truth for what a phone field accepts, shared by the validation the server
+ * enforces, the editor field, and the write path that stores the value.
+ *
+ * The `min` metadata bundle is deliberate: it is a fraction of the size of the full one and
+ * parses and formats every country. The trade is precision — it accepts a few numbers the full
+ * metadata would reject as impossible for their region.
+ *
+ * @see https://gitlab.com/catamphetamine/libphonenumber-js#min-vs-max-vs-mobile-vs-core
+ */
+export declare function normalizeEponymePhone(value: unknown, options?: PhoneFieldOptions): NormalizedPhone;
+/**
+ * The value to store: E.164 whenever the number is understood, and the input untouched when it
+ * is not, so validation can report it and the editor can still see what was typed.
+ */
+export declare function toEponymePhoneValue(value: unknown, options?: PhoneFieldOptions): unknown;

package/dist/runtime/utils/normalize-phone.js

@@ -0,0 +1,17 @@
+import { parsePhoneNumberFromString } from "libphonenumber-js/min";
+export function normalizeEponymePhone(value, options = {}) {
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!raw) return { valid: true };
+  const international = raw.startsWith("+");
+  if (options.detectCountry === false && !international) return { valid: false };
+  const parsed = parsePhoneNumberFromString(raw, international ? void 0 : options.defaultCountry);
+  if (!parsed || !parsed.isValid()) return { valid: false, country: parsed?.country };
+  const allowed = options.countries?.length ? options.countries : void 0;
+  if (allowed && (!parsed.country || !allowed.includes(parsed.country)))
+    return { valid: false, country: parsed.country, countryNotAllowed: true };
+  return { valid: true, e164: parsed.number, country: parsed.country };
+}
+export function toEponymePhoneValue(value, options = {}) {
+  if (typeof value !== "string") return value;
+  return normalizeEponymePhone(value, options).e164 ?? value;
+}

package/dist/runtime/utils/normalize-tags.d.ts

@@ -0,0 +1,10 @@
+import type { TagsFieldOptions } from '../types/field.js';
+/**
+ * The canonical form of a tag list, shared by the validation the server enforces, the editor
+ * field, and the write path that stores the value.
+ *
+ * A tag list is a taxonomy, so `Nuxt` and ` nuxt ` are the same tag and must not both exist.
+ * The first spelling wins, and a suggestion counts as a first spelling: typing `nuxt` next to a
+ * declared `Nuxt` yields `Nuxt`, which keeps a listing from splitting in two.
+ */
+export declare function normalizeEponymeTags(value: unknown, options?: TagsFieldOptions): string[];

package/dist/runtime/utils/normalize-tags.js

@@ -0,0 +1,17 @@
+export function normalizeEponymeTags(value, options = {}) {
+  if (!Array.isArray(value)) return [];
+  const suggestions = new Map((options.suggestions ?? []).map((tag) => [fold(tag), tag]));
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const tag = item.trim();
+    if (!tag) continue;
+    const key = fold(tag);
+    if (seen.has(key)) continue;
+    seen.set(key, suggestions.get(key) ?? tag);
+  }
+  return [...seen.values()];
+}
+function fold(tag) {
+  return tag.trim().toLocaleLowerCase();
+}

package/dist/runtime/utils/validate-eponyme-data.js

@@ -1,5 +1,7 @@
 import { isArrayItemFieldDefinition } from "./get-field-default-value.js";
 import { isFieldVisible } from "./is-field-visible.js";
+import { normalizeEponymePhone } from "./normalize-phone.js";
+import { normalizeEponymeTags } from "./normalize-tags.js";
 const urlPattern = /^https?:\/\//i;
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
 const colorPattern = /^#(?:[\da-f]{3}|[\da-f]{6}|[\da-f]{8})$/i;
@@ -70,6 +72,21 @@ function validateFieldRules(name, definition, value, errors, mode, _context) {
     }
     return;
   }
+  if (definition.type === "tags") {
+    if (!Array.isArray(value)) {
+      addError(errors, name, "Must be an array.");
+      return;
+    }
+    const tags = normalizeEponymeTags(value, definition.options);
+    if (mode === "publish" && options.required && tags.length === 0) addError(errors, name, "This field is required.");
+    if (mode === "publish" && definition.options.minItems !== void 0 && tags.length < definition.options.minItems) addError(errors, name, `Must contain at least ${definition.options.minItems} items.`);
+    if (definition.options.maxItems !== void 0 && tags.length > definition.options.maxItems) addError(errors, name, `Must contain at most ${definition.options.maxItems} items.`);
+    if (value.some((item) => typeof item !== "string" || !item.trim())) addError(errors, name, "Must contain only non-empty tags.");
+    const suggestions = definition.options.suggestions;
+    if (!definition.options.allowCustom && suggestions?.length && tags.some((tag) => !suggestions.includes(tag)))
+      addError(errors, name, "Must contain only available options.");
+    return;
+  }
   if (definition.type === "checkboxGroup") {
     if (!Array.isArray(value)) {
       addError(errors, name, "Must be an array.");
@@ -134,7 +151,10 @@ function validateFieldRules(name, definition, value, errors, mode, _context) {
     const href = link.href.trim();
     if (mode === "publish" && options.required && !href) addError(errors, name, "This field is required.");
     if (!href) return;
-    if (link.type === "external" && !urlPattern.test(href)) addError(errors, name, "External links must be HTTP(S) URLs.");
+    if (link.type === "external" && !isAllowedProtocol(href, definition.options.protocols)) {
+      const allowed = normalizeProtocols(definition.options.protocols);
+      addError(errors, name, isDefaultProtocols(definition.options.protocols) ? "External links must be HTTP(S) URLs." : `External links must start with ${allowed.map((protocol) => `${protocol}:`).join(" or ")}.`);
+    }
     if (link.type === "internal" && !href.startsWith("/") && !href.startsWith("#")) addError(errors, name, "Internal links must start with / or #.");
     return;
   }
@@ -160,6 +180,16 @@ function validateFieldRules(name, definition, value, errors, mode, _context) {
     if (definition.options.max && normalized > definition.options.max) addError(errors, name, `Must be on or before ${definition.options.max}.`);
     return;
   }
+  if (definition.type === "phone") {
+    const phone = normalizeEponymePhone(normalized, definition.options);
+    if (normalized && phone.countryNotAllowed) {
+      const accepted = definition.options.countries?.join(", ");
+      addError(errors, name, phone.country ? `Numbers from ${phone.country} are not accepted. Use a number from: ${accepted}.` : `Must be a number from: ${accepted}.`);
+    } else if (normalized && !phone.valid) {
+      addError(errors, name, definition.options.detectCountry === false ? "Must be a valid phone number in international format, starting with the country code." : "Must be a valid phone number.");
+    }
+    return;
+  }
   if (definition.type === "color") {
     if (normalized && !colorPattern.test(normalized)) addError(errors, name, "Must be a valid hex color.");
     return;
@@ -179,8 +209,20 @@ function validateFieldRules(name, definition, value, errors, mode, _context) {
   if (definition.options.maxLength !== void 0 && value.length > definition.options.maxLength) addError(errors, name, `Must contain at most ${definition.options.maxLength} characters.`);
   if (definition.options.regex && !definition.options.regex.test(value)) addError(errors, name, "Has an invalid format.");
   const [localPart, domain, ...extraParts] = normalized.split("@");
-  if ((definition.type === "email" || definition.options.email) && normalized && (!localPart || !domain?.includes(".") || extraParts.length)) addError(errors, name, "Must be a valid email address.");
-  if (definition.options.url && normalized && !urlPattern.test(normalized)) addError(errors, name, "Must be an HTTP(S) URL.");
+  if (definition.type === "email" && normalized && (!localPart || !domain?.includes(".") || extraParts.length)) addError(errors, name, "Must be a valid email address.");
+}
+const DEFAULT_URL_PROTOCOLS = ["http", "https"];
+const schemePattern = /^([a-z][a-z0-9+.-]*):/i;
+function normalizeProtocols(protocols) {
+  const declared = protocols?.length ? protocols : DEFAULT_URL_PROTOCOLS;
+  return declared.map((protocol) => protocol.trim().toLowerCase().replace(/:.*$/, ""));
+}
+function isDefaultProtocols(protocols) {
+  return !protocols?.length;
+}
+function isAllowedProtocol(href, protocols) {
+  const scheme = schemePattern.exec(href)?.[1]?.toLowerCase();
+  return Boolean(scheme) && normalizeProtocols(protocols).includes(scheme);
 }
 function getRichTextContent(value) {
   return value.replace(/<br\s*\/?>/gi, " ").replace(/<\/p>|<\/h[1-6]>|<\/li>|<\/blockquote>/gi, " ").replace(/<[^>]+>/g, "").replace(/&nbsp;|&#160;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/\s+/g, " ").trim();

package/dist/runtime/utils/variables.d.ts

@@ -1,4 +1,8 @@
 import type { EponymeVariableDefinition, EponymeVariables } from '../types/variables.js';
+export declare function findEponymeVariableRanges(text: string): Array<{
+    from: number;
+    to: number;
+}>;
 /** Always available, whatever the host application configures. */
 export declare function builtinEponymeVariables(now?: Date): Record<string, EponymeVariableDefinition>;
 /** Host variables win, so an application can override a built-in for its own wording. */

package/dist/runtime/utils/variables.js

@@ -1,4 +1,11 @@
-const VARIABLE_PATTERN = /\{\{\s*([A-Z_]\w*)\s*\}\}/gi;
+const VARIABLE_PATTERN_SOURCE = String.raw`\{\{\s*([A-Z_]\w*)\s*\}\}`;
+const VARIABLE_PATTERN = new RegExp(VARIABLE_PATTERN_SOURCE, "gi");
+export function findEponymeVariableRanges(text) {
+  return [...text.matchAll(new RegExp(VARIABLE_PATTERN_SOURCE, "gi"))].map((match) => ({
+    from: match.index,
+    to: match.index + match[0].length
+  }));
+}
 export function builtinEponymeVariables(now = /* @__PURE__ */ new Date()) {
   return {
     currentYear: { label: "Current year", description: "The year at the time the page is served.", value: () => now.getFullYear() },