sveltekit-admin 0.6.0 → 0.9.0

package/dist/server/router.js

@@ -1,27 +1,50 @@
-export function parseRoute(pathname, basePath) {
+export const BUILTIN_ROUTES = [
+    { pattern: [], view: 'dashboard' },
+    { pattern: ['_search'], view: 'search' },
+    { pattern: ['_logout'], view: 'logout' },
+    { pattern: [':model', 'new'], view: 'create' },
+    { pattern: [':model', ':id'], view: 'edit' },
+    { pattern: [':model'], view: 'list' }
+];
+function relativeSegments(pathname, basePath) {
     // Le `replace` n'est PAS redondant avec le `filter(Boolean)` plus bas : il est ce
     // qui fait que `/admin/` et `/admin///` donnent un `path` vide, donc le dashboard.
     // Sans lui, `path` vaudrait '/' — truthy — et le chemin tomberait sur `notFound`.
     const path = pathname.slice(basePath.length).replace(/^\/+|\/+$/g, '');
-    if (!path) {
-        return { view: 'dashboard' };
-    }
-    const segments = path.split('/').filter(Boolean);
-    if (segments.length === 1) {
-        if (segments[0] === '_search') {
-            return { view: 'search' };
-        }
-        if (segments[0] === '_logout') {
-            return { view: 'logout' };
-        }
-        return { view: 'list', model: segments[0] };
-    }
-    if (segments.length === 2) {
-        if (segments[1] === 'new') {
-            return { view: 'create', model: segments[0] };
+    if (!path)
+        return [];
+    return path.split('/').filter(Boolean);
+}
+export function matchRoute(pathname, basePath, routes) {
+    const segments = relativeSegments(pathname, basePath);
+    for (const route of routes) {
+        if (route.pattern.length !== segments.length)
+            continue;
+        const captured = {};
+        let ok = true;
+        for (let i = 0; i < route.pattern.length; i++) {
+            const token = route.pattern[i];
+            const seg = segments[i];
+            if (token === ':model') {
+                captured.model = seg;
+            }
+            else if (token === ':id') {
+                captured.id = seg;
+            }
+            else if (token !== seg) {
+                ok = false;
+                break;
+            }
         }
-        return { view: 'edit', model: segments[0], id: segments[1] };
+        if (ok)
+            return { view: route.view, ...captured };
     }
-    // 3 segments ou plus : aucune vue ne correspond.
     return { view: 'notFound' };
 }
+// Builtins-only helper — NOT the handler's dispatch path. `handler.ts` calls
+// `matchRoute` directly with `[...pluginRoutes, ...BUILTIN_ROUTES]` so plugin
+// patterns are considered first; this function stays around for tests and
+// any caller that only cares about the builtin route table.
+export function parseRoute(pathname, basePath) {
+    return matchRoute(pathname, basePath, BUILTIN_ROUTES);
+}

package/dist/server/runtime.d.ts

@@ -0,0 +1,51 @@
+import type { Schema, Model } from './types/schema.js';
+import type { ActiveSort } from './query/sortQuery.js';
+import { type RelationGraph } from './introspection/relations.js';
+import type { ViewModel } from './views/types.js';
+import type { DataAdapter, SchemaIntrospector, Filter } from './adapters/types.js';
+import type { AdminHandlerConfig } from './handler.js';
+export declare function scopeFrom(relConfig: {
+    where?: (ctx: any) => any;
+} | undefined, ctx: {
+    locals?: any;
+}): any;
+export declare function listScopeFrom(runtime: AdminRuntime, model: Model, ctx: {
+    locals?: any;
+}): Record<string, unknown> | undefined;
+export declare function modelScopeFrom(runtime: AdminRuntime, model: Model, ctx: {
+    locals?: any;
+}): Filter | undefined;
+/** Extract equality predicates so create can force tenant-owned columns. */
+export declare function modelScopeValues(runtime: AdminRuntime, model: Model, ctx: {
+    locals?: any;
+}): Record<string, unknown>;
+export interface AdminRuntime {
+    adapter: {
+        introspector: SchemaIntrospector;
+        data: DataAdapter;
+    };
+    schema: Schema | null;
+    relationGraph: RelationGraph | null;
+    models: Model[];
+    modelList: Array<{
+        name: string;
+        label: string;
+    }>;
+    config: AdminHandlerConfig;
+    basePath: string;
+    perPage: number;
+    /** Tailles sélectionnables, vide quand le mécanisme est désactivé. */
+    pageSizes: number[];
+    /** `models[].defaultSort` validé au démarrage, par nom de modèle. */
+    defaultSortOf(model: Model): ActiveSort | undefined;
+    selectThreshold: number;
+    filterLinkThreshold: number;
+    labelFieldCandidates: string[];
+    findModel(name?: string): Model | undefined;
+    labelOf(model: Model): string;
+    hiddenFieldsOf(model: Model): Set<string>;
+    viewModel(model: Model): ViewModel;
+    resolveLabel(target: Model, row: Record<string, unknown>, labelTemplate?: string): string;
+    resolveFilterableFields(model: Model): Set<string>;
+}
+export declare function createAdminRuntime(config: AdminHandlerConfig): AdminRuntime;

package/dist/server/runtime.js

@@ -0,0 +1,263 @@
+import { isSensitiveFieldName } from './introspection/parser.js';
+import { resolveListColumns } from './query/listColumns.js';
+import { resolvePageSizes } from './query/pageSize.js';
+import { buildRelationGraph } from './introspection/relations.js';
+import { primaryKeyOf } from './data.js';
+import { validateListFilterConfig } from './query/filterDetection.js';
+import { isCompositeFilter, isLeafFilter, normalizeScope } from './adapters/filter.js';
+import { toLabel } from './views/html.js';
+import { AdminConfigError } from './errors.js';
+export function scopeFrom(relConfig, ctx) {
+    return relConfig?.where ? normalizeScope(relConfig.where(ctx)) : undefined;
+}
+export function listScopeFrom(runtime, model, ctx) {
+    const listScope = runtime.config.models?.[model.name]?.listWhere?.(ctx);
+    // A scope function returning `{}` (falsy-looking but truthy as
+    // an object) would otherwise silently fail OPEN — `{}` composed
+    // into an AND matches every row, exactly the opposite of what a
+    // caller configuring listWhere expects (real gap found in
+    // review: `locals.userId` undefined after a session expires is
+    // a realistic way to hit this). Fail loud instead: a scope
+    // function is either omitted entirely, or must return at least
+    // one condition every time it runs.
+    if (listScope && Object.keys(listScope).length === 0) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.listWhere returned an empty object ({}), ` +
+            `which would silently disable list scoping (fail-open). Return undefined/omit the ` +
+            `scope entirely if there is genuinely nothing to scope by for this request, or a ` +
+            `condition that actually restricts rows otherwise.`);
+    }
+    return listScope;
+}
+export function modelScopeFrom(runtime, model, ctx) {
+    const scope = runtime.config.models?.[model.name]?.scope;
+    if (!scope)
+        return undefined;
+    const raw = scope(ctx);
+    if (!raw || (typeof raw === 'object' && !Array.isArray(raw) && Object.keys(raw).length === 0)) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.scope must return a non-empty condition; ` +
+            'refusing to fail open.');
+    }
+    const normalized = normalizeScope(raw);
+    const valid = (node) => {
+        if (isLeafFilter(node))
+            return node.value !== undefined;
+        return isCompositeFilter(node) && node.clauses.length > 0 && node.clauses.every(valid);
+    };
+    if (!valid(normalized)) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.scope returned an invalid condition; refusing to fail open.`);
+    }
+    return normalized;
+}
+/** Extract equality predicates so create can force tenant-owned columns. */
+export function modelScopeValues(runtime, model, ctx) {
+    const normalized = modelScopeFrom(runtime, model, ctx);
+    if (!normalized)
+        return {};
+    const values = {};
+    const visit = (node) => {
+        if (isLeafFilter(node)) {
+            if (node.op !== 'eq')
+                return false;
+            if (node.field in values && values[node.field] !== node.value)
+                return false;
+            values[node.field] = node.value;
+            return true;
+        }
+        if (!isCompositeFilter(node) || node.op === 'or')
+            return false;
+        return node.clauses.every(visit);
+    };
+    if (!visit(normalized) || Object.keys(values).length === 0) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.scope must contain only equality conditions for creation`);
+    }
+    return values;
+}
+export function createAdminRuntime(config) {
+    const { basePath = '/admin', exclude = [], hidePivotTables = true, models: modelsConfig = {} } = config;
+    const adapter = config.adapter;
+    const introspector = adapter.introspector;
+    // Introspect the schema once at startup — same failure handling as before:
+    // a broken/missing schema source degrades to "no models known" rather than
+    // throwing out of `createAdminHandler` itself.
+    let schema = null;
+    let relationGraph = null;
+    try {
+        const introspected = introspector.introspect();
+        if (introspected instanceof Promise) {
+            throw new Error('[sveltekit-admin] SchemaIntrospector.introspect() returned a Promise — ' +
+                'createAdminHandler only supports synchronous introspection today.');
+        }
+        schema = introspected;
+        relationGraph = buildRelationGraph(schema);
+        for (const d of relationGraph.diagnostics) {
+            console.warn(`[sveltekit-admin] ${d}`);
+        }
+    }
+    catch (e) {
+        console.warn('[sveltekit-admin] Could not introspect schema:', e);
+    }
+    /**
+     * Résolu une fois ici plutôt que dans `viewModel` : un `schema?.enums ?? …`
+     * par appel serait une branche que rien ne peut exercer (un schéma nul donne
+     * `models` vide, donc aucune vue à construire), alors qu'à ce niveau les deux
+     * cas sont ceux du démarrage — schéma lu, ou introspection en échec.
+     */
+    const schemaEnums = schema?.enums ?? new Map();
+    const models = schema?.models.filter((m) => {
+        // Exclude explicitly excluded models
+        if (exclude.includes(m.name))
+            return false;
+        // Exclude pivot tables if option is enabled
+        if (hidePivotTables && m.isPivotTable)
+            return false;
+        return true;
+    }) || [];
+    // Valider `listFilter` au démarrage : une config invalide (champ
+    // inexistant, sensible, relation, type non supporté) doit échouer fort
+    // ici plutôt que produire silencieusement un filtre mort à chaque rendu
+    // de liste (docs/design §8, même politique que le groupe ambigu de
+    // relations.ts).
+    const hiddenFieldsOf = (m) => new Set(modelsConfig[m.name]?.hidden ?? []);
+    for (const m of models) {
+        const entries = modelsConfig[m.name]?.listFilter;
+        // Non-null par construction : `models` n'existe que si le schéma
+        // a été parsé, et le graphe est construit dans la même branche de boot.
+        if (entries)
+            validateListFilterConfig(m.name, entries, m, relationGraph, hiddenFieldsOf(m));
+    }
+    /**
+     * `defaultSort` validé ici pour la même raison que `listFilter` : une colonne
+     * inexistante, ou que la liste n'affiche pas, produirait un tri mort à chaque
+     * rendu sans qu'aucun en-tête ne l'annonce — et l'utilisateur n'aurait aucun
+     * moyen d'en sortir, puisque seule une colonne affichée porte un lien. La
+     * liste des colonnes autorisées est la même que celle du tri par URL.
+     */
+    const defaultSortOf = (m) => {
+        const configured = modelsConfig[m.name]?.defaultSort;
+        if (!configured)
+            return undefined;
+        const sortable = resolveListColumns(m.fields, {
+            hidden: modelsConfig[m.name]?.hidden,
+            listFields: modelsConfig[m.name]?.listFields
+        }).map((f) => f.name);
+        if (!sortable.includes(configured.field)) {
+            throw new AdminConfigError(`[sveltekit-admin] models.${m.name}.defaultSort targets "${configured.field}", ` +
+                `which the list view does not display. Displayed columns: [${sortable.join(', ')}].`);
+        }
+        if (configured.dir !== undefined && configured.dir !== 'asc' && configured.dir !== 'desc') {
+            throw new AdminConfigError(`[sveltekit-admin] models.${m.name}.defaultSort.dir must be "asc" or "desc".`);
+        }
+        return { field: configured.field, dir: configured.dir ?? 'asc' };
+    };
+    const defaultSorts = new Map(models.map((m) => [m.name, defaultSortOf(m)]));
+    const labelOf = (m) => {
+        const configured = modelsConfig[m.name]?.label;
+        if (configured)
+            return configured;
+        const label = toLabel(m.name);
+        return label.charAt(0).toUpperCase() + label.slice(1);
+    };
+    const modelList = models.map((m) => ({ name: m.name, label: labelOf(m) }));
+    const findModel = (name) => models.find((m) => m.name.toLowerCase() === name?.toLowerCase());
+    const viewModel = (m) => ({
+        name: m.name,
+        label: labelOf(m),
+        fields: m.fields,
+        primaryKey: primaryKeyOf(m),
+        enums: schemaEnums,
+        // Non-null par construction : `m` vient toujours de `models`,
+        // dérivé du schéma qu'on vient de parser avec succès.
+        relationGraph: relationGraph
+    });
+    /**
+     * Plafond dur. Au-delà ce n'est plus une page mais un export, et sur une
+     * table volumineuse une requête qui tient la connexion. Vaut pour la valeur
+     * configurée comme pour chaque option proposée.
+     */
+    const MAX_PAGE_SIZE = 200;
+    const validPageSize = (n) => typeof n === 'number' && Number.isSafeInteger(n) && n >= 1 && n <= MAX_PAGE_SIZE;
+    if (config.perPage !== undefined && !validPageSize(config.perPage)) {
+        throw new AdminConfigError(`[sveltekit-admin] perPage must be an integer between 1 and ${MAX_PAGE_SIZE}.`);
+    }
+    const perPage = config.perPage ?? 20;
+    const configuredSizes = config.pageSizeOptions ?? [10, 20, 50, 100];
+    if (!Array.isArray(configuredSizes) || !configuredSizes.every(validPageSize)) {
+        throw new AdminConfigError(`[sveltekit-admin] pageSizeOptions must be integers between 1 and ${MAX_PAGE_SIZE}.`);
+    }
+    const pageSizes = resolvePageSizes(perPage, configuredSizes);
+    const selectThreshold = config.relationDefaults?.selectThreshold ?? 200;
+    const filterLinkThreshold = config.listFilterDefaults?.linkThreshold ?? 20;
+    const labelFieldCandidates = config.relationDefaults?.labelFields ?? [
+        'name', 'title', 'label', 'email', 'username', 'slug'
+    ];
+    /**
+     * Champs qu'un `?f.<field>=` est autorisé à cibler pour ce modèle : tout
+     * champ scalaire non-liste, non-relation, de type filtrable
+     * (String/Int/Float/Decimal/BigInt/Boolean/DateTime/enum — donc pas
+     * Json/Bytes), non sensible, et non listé dans `hidden` pour ce modèle.
+     * Sans ce dernier point, `hidden: ['internalNotes']` ne fait que masquer
+     * l'affichage : le champ reste un oracle de confirmation de valeur via
+     * `?f.internalNotes=...contains...`, exactement la faille §0.a fermée
+     * ailleurs pour les champs sensibles par nom — `hidden` et le prédicat
+     * de sensibilité sont deux sources distinctes, toutes deux doivent
+     * fermer l'oracle (docs/design §10, "deux sources, un seul prédicat
+     * partagé, sinon divergence garantie"). Défense en profondeur :
+     * `listQuery.ts` revérifie lui-même la sensibilité par nom, ce set est
+     * la première passe et la seule à connaître la config `hidden`.
+     */
+    const resolveFilterableFields = (model) => {
+        const hidden = hiddenFieldsOf(model);
+        const out = new Set();
+        for (const f of model.fields) {
+            if (f.relation || f.isList)
+                continue;
+            if (['Json', 'Bytes'].includes(f.type))
+                continue;
+            if (isSensitiveFieldName(f.name))
+                continue;
+            if (hidden.has(f.name))
+                continue;
+            out.add(f.name);
+        }
+        return out;
+    };
+    /**
+     * Résout le label BRUT (non échappé) d'une ligne : premier champ String
+     * candidat présent, sinon template `{a} {b}` si configuré, sinon la PK.
+     * Déterministe. Svelte échappe automatiquement à l'interpolation dans les
+     * composants — pas besoin d'échapper ici.
+     */
+    const resolveLabel = (targetModel, row, labelTemplate) => {
+        if (labelTemplate) {
+            return labelTemplate.replace(/\{(\w+)\}/g, (_, k) => String(row[k] ?? ''));
+        }
+        for (const candidate of labelFieldCandidates) {
+            const field = targetModel.fields.find((f) => f.name === candidate);
+            if (field && field.type === 'String' && row[candidate] != null) {
+                return String(row[candidate]);
+            }
+        }
+        return String(row[primaryKeyOf(targetModel)]);
+    };
+    return {
+        adapter,
+        schema,
+        relationGraph,
+        models,
+        modelList,
+        config,
+        basePath,
+        perPage,
+        pageSizes,
+        defaultSortOf: (m) => defaultSorts.get(m.name),
+        selectThreshold,
+        filterLinkThreshold,
+        labelFieldCandidates,
+        findModel,
+        labelOf,
+        hiddenFieldsOf,
+        viewModel,
+        resolveLabel,
+        resolveFilterableFields
+    };
+}

package/dist/server/search.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `_search` JSON endpoint — split out of `handler.ts`, pure orchestration
+ * over `AdminRuntime`.
+ */
+import { type AdminRuntime } from './runtime.js';
+/**
+ * Endpoint de recherche `GET {basePath}/_search?rel=Model.field&q=...&page=N`.
+ * Sert les options d'une relation to-one-owning ou m2m en JSON
+ * paginé — la voie prévue pour un futur widget autocomplete côté client
+ * quand le nombre d'options dépasse `selectThreshold`. Respecte le `where`
+ * de scoping configuré sur la relation, comme le select et la validation
+ * POST : même garantie anti-IDOR sur les trois chemins.
+ */
+export declare function handleSearch(runtime: AdminRuntime, event: any): Promise<Response>;

package/dist/server/search.js

@@ -0,0 +1,78 @@
+/**
+ * `_search` JSON endpoint — split out of `handler.ts`, pure orchestration
+ * over `AdminRuntime`.
+ */
+import { primaryKeyOf, paginate } from './data.js';
+import { scopeFrom, modelScopeFrom } from './runtime.js';
+/**
+ * Endpoint de recherche `GET {basePath}/_search?rel=Model.field&q=...&page=N`.
+ * Sert les options d'une relation to-one-owning ou m2m en JSON
+ * paginé — la voie prévue pour un futur widget autocomplete côté client
+ * quand le nombre d'options dépasse `selectThreshold`. Respecte le `where`
+ * de scoping configuré sur la relation, comme le select et la validation
+ * POST : même garantie anti-IDOR sur les trois chemins.
+ */
+export async function handleSearch(runtime, event) {
+    const modelsConfig = runtime.config.models ?? {};
+    const relParam = event.url.searchParams.get('rel') ?? '';
+    const [modelName, fieldName] = relParam.split('.');
+    const q = event.url.searchParams.get('q') ?? '';
+    const { page } = paginate(event.url.searchParams.get('page'), runtime.perPage);
+    const model = runtime.findModel(modelName);
+    const edge = model && runtime.relationGraph
+        ? runtime.relationGraph.edges.get(`${model.name}.${fieldName}`)
+        : undefined;
+    if (!model || !edge || (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m') || edge.unsupported) {
+        return new Response(JSON.stringify({ error: 'unknown relation' }), {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+    const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+    const configWhere = scopeFrom(relConfig, { locals: event.locals });
+    const modelWhere = modelScopeFrom(runtime, targetModel, { locals: event.locals });
+    // Recherche sur le premier champ String candidat du modèle cible — le
+    // même champ que celui utilisé pour construire le label par défaut.
+    const searchField = runtime.labelFieldCandidates.find((c) => targetModel.fields.some((f) => f.name === c && f.type === 'String'));
+    // `_search` must stay case-sensitive on every adapter/provider. A
+    // `{ op: 'contains' }` leaf would pick up the adapter-wide
+    // `caseInsensitiveSearch` flag (Prisma `mode: 'insensitive'`, Drizzle
+    // `ilike`). `containsExact` compiles to `{ contains }` / `LIKE` with
+    // no case-folding — same observable Prisma behavior as the previous
+    // opaque `{ [field]: { contains: q } }` pass-through.
+    const containsFilter = q && searchField
+        ? { op: 'containsExact', field: searchField, value: q }
+        : undefined;
+    const searchClauses = [modelWhere, configWhere, containsFilter].filter(Boolean);
+    const searchFilter = searchClauses.length > 1
+        ? { op: 'and', clauses: searchClauses }
+        : searchClauses[0];
+    try {
+        // Count + fetch are independent reads — run them in parallel (as this
+        // endpoint always has, pre-refactor) rather than doubling latency with
+        // two sequential awaits.
+        const [total, rows] = await Promise.all([
+            runtime.adapter.data.countRecords(targetModel, searchFilter),
+            runtime.adapter.data.findMany(targetModel, {
+                filter: searchFilter,
+                orderBy: relConfig?.orderBy,
+                skip: (page - 1) * runtime.perPage,
+                take: runtime.perPage
+            })
+        ]);
+        const options = rows.map((row) => ({
+            id: row[primaryKeyOf(targetModel)],
+            label: runtime.resolveLabel(targetModel, row, relConfig?.labelTemplate)
+        }));
+        return new Response(JSON.stringify({ options, total, page }), {
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    catch {
+        return new Response(JSON.stringify({ error: 'search failed' }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+}

package/dist/server/submitted.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Extraction des valeurs réellement soumises par un POST de formulaire admin,
+ * pour les re-rendre après un échec de mutation.
+ *
+ * Ce module ne rend rien : il traduit un `FormData` en la forme minimale dont
+ * les vues ont besoin. Il porte en revanche la décision de sécurité de ce
+ * chemin — ce qui NE doit pas repartir dans le HTML.
+ */
+export interface SubmittedForm {
+    /** Scalaires et scalaires de relation, par nom de champ. */
+    values: Record<string, string>;
+    /**
+     * IDs cochés par arête m2m. Une entrée présente avec un tableau vide dit
+     * « l'utilisateur a tout décoché » ; une arête absente dit « le widget
+     * n'était pas dans le formulaire ». Même distinction, et même raison, que
+     * le sentinelle côté écriture.
+     */
+    m2m: Record<string, string[]>;
+}
+export declare function readSubmittedForm(formData: FormData, hidden: ReadonlySet<string>): SubmittedForm;

package/dist/server/submitted.js

@@ -0,0 +1,54 @@
+/**
+ * Extraction des valeurs réellement soumises par un POST de formulaire admin,
+ * pour les re-rendre après un échec de mutation.
+ *
+ * Ce module ne rend rien : il traduit un `FormData` en la forme minimale dont
+ * les vues ont besoin. Il porte en revanche la décision de sécurité de ce
+ * chemin — ce qui NE doit pas repartir dans le HTML.
+ */
+import { isSensitiveFieldName } from './introspection/parser.js';
+/** Clé de dispatch de `handleMutation`, jamais un champ du modèle. */
+const ACTION_KEY = '_action';
+/** Préfixes posés par `RelationCheckboxes.svelte`, cf. `mutations.ts`. */
+const M2M_VALUE_PREFIX = '__rel__';
+const M2M_SENTINEL_PREFIX = '__rel_present__';
+/**
+ * Un champ jamais rendu par le formulaire (`hidden`) ne doit pas non plus
+ * reparaître par ce chemin, et une valeur sensible ne repart pas du tout :
+ * `isSensitiveFieldName` est le prédicat partagé du dépôt (affichage en liste,
+ * whitelist de recherche/filtres, rédaction d'audit), et un second heuristique
+ * local finirait par diverger du premier. Conséquence assumée, celle de Django
+ * (`PasswordInput(render_value=False)`) : un mot de passe est à retaper après
+ * une erreur.
+ */
+function isEchoable(name, hidden) {
+    return !hidden.has(name) && !isSensitiveFieldName(name);
+}
+export function readSubmittedForm(formData, hidden) {
+    const values = {};
+    const m2m = {};
+    // Deux passes : les valeurs `__rel__` peuvent précéder leur sentinelle dans
+    // le corps (l'ordre est celui du DOM, pas un contrat), donc on ne peut pas
+    // décider de les garder au fil de la première itération.
+    for (const key of formData.keys()) {
+        if (!key.startsWith(M2M_SENTINEL_PREFIX))
+            continue;
+        const field = key.slice(M2M_SENTINEL_PREFIX.length);
+        if (!isEchoable(field, hidden))
+            continue;
+        m2m[field] = formData.getAll(`${M2M_VALUE_PREFIX}${field}`).map(String);
+    }
+    for (const [key, raw] of formData.entries()) {
+        if (key === ACTION_KEY)
+            continue;
+        // Les deux préfixes, testés séparément : `__rel_present__` ne commence pas
+        // par `__rel__` (5e caractère `p` contre `_`), donc un seul test laisserait
+        // le sentinelle passer pour un scalaire.
+        if (key.startsWith(M2M_VALUE_PREFIX) || key.startsWith(M2M_SENTINEL_PREFIX))
+            continue;
+        if (!isEchoable(key, hidden))
+            continue;
+        values[key] = String(raw);
+    }
+    return { values, m2m };
+}