@jini-ai/admin 0.4.2 → 0.4.4

package/dist/core/react/bind-react.js

@@ -0,0 +1,28 @@
+import { createContext, createElement, lazy, useContext } from 'react';
+import { AdminConfigError } from '../module/create-admin.js';
+/** Every page and tab is lazy. The only port context is private to this binding;
+ * a sibling module can never read another module's dependencies through a global locator. */
+export function bindReact({ module, views }, { context } = {}) {
+    const Context = context ?? createContext(null);
+    const pages = Object.fromEntries(Object.entries(views).map(([id, raw]) => {
+        const view = raw;
+        return [
+            id,
+            {
+                Page: lazy(view.page),
+                tabs: Object.fromEntries(Object.entries(view.tabs).map(([tab, load]) => [tab, lazy(load)])),
+            },
+        ];
+    }));
+    function usePorts(_required = {}, _optional = {}) {
+        const ports = useContext(Context);
+        if (!ports)
+            throw new AdminConfigError({ issues: [`React scope unavailable: ${module.id}`] });
+        return ports;
+    }
+    function Provider({ admin, children }, _optional = {}) {
+        return createElement(Context.Provider, { value: admin.scope({ module }) }, children);
+    }
+    return { module, pages, Provider, usePorts };
+}
+//# sourceMappingURL=bind-react.js.map

package/dist/core/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bind-react.js';
+export * from './use-controller.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/react/index.js

@@ -0,0 +1,3 @@
+export * from './bind-react.js';
+export * from './use-controller.js';
+//# sourceMappingURL=index.js.map

package/dist/core/react/use-controller.d.ts

@@ -0,0 +1,16 @@
+import type { DependencyList } from 'react';
+import type { ControllerStore } from '../module/controller-store.js';
+/** Factory runs after commit, never during render. Each effect attachment owns a fresh
+ * controller, so StrictMode's cleanup/replay cannot revive a disposed controller. */
+export declare function useController<C extends ControllerStore<unknown>>({ create, dependencies }: {
+    create: () => C;
+    dependencies: DependencyList;
+}, { start, }?: {
+    start?: (required: {
+        controller: C;
+    }, optional?: Record<string, never>) => void;
+}): {
+    controller: C | null;
+    snapshot: ReturnType<C["getSnapshot"]> | null;
+};
+//# sourceMappingURL=use-controller.d.ts.map

package/dist/core/react/use-controller.js

@@ -0,0 +1,18 @@
+import { useEffect, useState, useSyncExternalStore, useCallback } from 'react';
+/** Factory runs after commit, never during render. Each effect attachment owns a fresh
+ * controller, so StrictMode's cleanup/replay cannot revive a disposed controller. */
+export function useController({ create, dependencies }, { start, } = {}) {
+    const [controller, setController] = useState(null);
+    useEffect(() => {
+        const current = create();
+        setController(current);
+        start?.({ controller: current });
+        return () => current.dispose();
+        // Dependencies are explicitly supplied by the owning hook, like useMemo's contract.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, dependencies);
+    const subscribe = useCallback((listener) => controller?.subscribe({ listener }) ?? (() => { }), [controller]);
+    const snapshot = useSyncExternalStore(subscribe, () => (controller?.getSnapshot() ?? null), () => null);
+    return { controller, snapshot };
+}
+//# sourceMappingURL=use-controller.js.map

package/dist/forms/adapters/http.d.ts

@@ -0,0 +1,26 @@
+import type { AdminFormsPort } from '../../core/ports/forms.js';
+import type { FormsTrashPort } from '../ports.js';
+/** The host owns auth, workspace addressing, retries, error decoding and telemetry. */
+export interface FormsTransportPort {
+    request<T>(required: {
+        path: string;
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+        body?: unknown;
+    }, optional?: {
+        signal?: AbortSignal;
+    }): Promise<T>;
+    url(required: {
+        path: string;
+    }, optional?: Record<string, never>): string;
+}
+/** Preserve the existing forms wire, including its data envelopes and explicit authoring route. */
+export declare function createHttpFormsApi({ transport, basePath }: {
+    transport: FormsTransportPort;
+    basePath: string;
+}, _optional?: Record<string, never>): AdminFormsPort;
+/** The same generic POST used by both host screens; no form lifecycle is reimplemented here. */
+export declare function createHttpFormsTrash({ transport, basePath }: {
+    transport: FormsTransportPort;
+    basePath: string;
+}, _optional?: Record<string, never>): FormsTrashPort;
+//# sourceMappingURL=http.d.ts.map

package/dist/forms/adapters/http.js

@@ -0,0 +1,43 @@
+/** Preserve the existing forms wire, including its data envelopes and explicit authoring route. */
+export function createHttpFormsApi({ transport, basePath }, _optional = {}) {
+    const base = basePath.replace(/\/$/, '');
+    const formPath = (id) => `${base}/${encodeURIComponent(id)}`;
+    const submissionPath = (formId, submissionId) => `${formPath(formId)}/submissions${submissionId === undefined ? '' : `/${encodeURIComponent(submissionId)}`}`;
+    return {
+        async listFormDefinitions(_required, _optional = {}) {
+            return (await transport.request({ path: base, method: 'GET' })).data;
+        },
+        async getFormDefinition({ id }, _optional = {}) {
+            return (await transport.request({ path: formPath(id), method: 'GET' })).data;
+        },
+        async createFormDefinition(input, optional = {}) {
+            return (await transport.request({ path: base, method: 'POST', body: { ...input, ...optional } })).data;
+        },
+        async updateFormDefinition({ id }, patch = {}) {
+            const authoring = patch.mode !== undefined || patch.html !== undefined;
+            return (await transport.request({ path: `${formPath(id)}${authoring ? '/authoring' : ''}`, method: 'PUT', body: patch })).data;
+        },
+        async listFormSubmissions({ formId }, options = {}) {
+            const params = new URLSearchParams();
+            if (options.cursor)
+                params.set('cursor', options.cursor);
+            if (options.limit)
+                params.set('limit', String(options.limit));
+            const qs = params.toString();
+            const response = await transport.request({ path: `${submissionPath(formId)}${qs ? `?${qs}` : ''}`, method: 'GET' });
+            return { items: response.data, nextCursor: response.nextCursor };
+        },
+        async getFormSubmission({ formId, submissionId }, _optional = {}) {
+            return (await transport.request({ path: submissionPath(formId, submissionId), method: 'GET' })).data;
+        },
+        async deleteFormSubmission({ formId, submissionId }, _optional = {}) {
+            // The server delegates DELETE to Trash; permanent deletion belongs to the Trash screen.
+            await transport.request({ path: submissionPath(formId, submissionId), method: 'DELETE' });
+        },
+    };
+}
+/** The same generic POST used by both host screens; no form lifecycle is reimplemented here. */
+export function createHttpFormsTrash({ transport, basePath }, _optional = {}) {
+    return { trash: (body, _options = {}) => transport.request({ path: basePath, method: 'POST', body }) };
+}
+//# sourceMappingURL=http.js.map

package/dist/forms/adapters/memory.d.ts

@@ -0,0 +1,14 @@
+import type { AdminFormsPort, AdminFormDefinition, AdminFormSubmission } from '../../core/ports/forms.js';
+import type { FormsTrashPort } from '../ports.js';
+/** A scoped, deterministic in-memory API with the core contract's add/edit-only invariant. */
+export declare function createMemoryFormsApi(_required?: Record<string, never>, { forms, submissions, now, nextId }?: {
+    forms?: readonly AdminFormDefinition[];
+    submissions?: readonly AdminFormSubmission[];
+    now?: () => string;
+    nextId?: () => string;
+}): AdminFormsPort & {
+    readonly forms: AdminFormDefinition[];
+    readonly submissions: AdminFormSubmission[];
+    readonly trash: FormsTrashPort;
+};
+//# sourceMappingURL=memory.d.ts.map

package/dist/forms/adapters/memory.js

@@ -0,0 +1,77 @@
+import { AdminApiError } from '../../core/transport/errors.js';
+/** A scoped, deterministic in-memory API with the core contract's add/edit-only invariant. */
+export function createMemoryFormsApi(_required = {}, { forms = [], submissions = [], now = () => new Date(0).toISOString(), nextId } = {}) {
+    const definitions = structuredClone([...forms]);
+    const answers = structuredClone([...submissions]);
+    let sequence = definitions.length;
+    const missing = (id) => { throw new AdminApiError({ message: `form definition '${id}' was not found`, status: 404 }); };
+    const find = (id) => definitions.find(form => form.slug === id) ?? definitions.find(form => form.id === id) ?? missing(id);
+    const definitionId = (id) => definitions.find(form => form.slug === id)?.id ?? id;
+    const findSubmission = (formId, id) => {
+        const resolvedId = definitionId(formId);
+        return answers.find(item => item.id === id && item.formDefinitionId === resolvedId && item.status !== 'trash') ?? missing(id);
+    };
+    const remove = (type, id) => {
+        const rows = type === 'form' ? definitions : answers;
+        const index = rows.findIndex(row => row.id === id);
+        if (index < 0)
+            missing(id);
+        // The fixture retains submission payloads just as the generic Trash owner does. Definitions
+        // keep their existing separate fixture projection; the core has no definition-delete method.
+        if (type === 'form_submission')
+            answers[index] = { ...answers[index], status: 'trash' };
+        else
+            rows.splice(index, 1);
+    };
+    return {
+        forms: definitions, submissions: answers,
+        async listFormDefinitions(_required, _optional = {}) { return structuredClone(definitions); },
+        async getFormDefinition({ id }, _optional = {}) { return structuredClone(find(id)); },
+        async createFormDefinition(input, options = {}) {
+            if (definitions.some(form => form.slug === input.slug))
+                throw new AdminApiError({ message: 'form slug already exists', status: 409 });
+            let id = nextId?.() ?? `fake-${++sequence}`;
+            if (!nextId)
+                while (definitions.some(form => form.id === id))
+                    id = `fake-${++sequence}`;
+            if (definitions.some(form => form.id === id))
+                throw new AdminApiError({ message: 'form id already exists', status: 409 });
+            const created = { ...structuredClone(input), id, notify: structuredClone(options.notify ?? { enabled: false, recipients: [] }), status: 'active', createdAt: now(), updatedAt: now() };
+            definitions.push(created);
+            return structuredClone(created);
+        },
+        async updateFormDefinition({ id }, patch = {}) {
+            const current = definitions.find(form => form.id === id) ?? missing(id);
+            const incomingIds = patch.fields ? new Set(patch.fields.map(field => field.id)) : null;
+            if (incomingIds && current.fields.some(field => !incomingIds.has(field.id))) {
+                throw new AdminApiError({ message: 'existing form fields cannot be removed', status: 400 }, { code: 'FORMS_FIELD_VALIDATION_ERROR' });
+            }
+            // The contract excludes slug; runtime callers cannot smuggle it through a cast either.
+            const { name, fields, notify, status, mode, html } = patch;
+            const applied = { ...(name !== undefined ? { name } : {}), ...(fields !== undefined ? { fields } : {}), ...(notify !== undefined ? { notify } : {}), ...(status !== undefined ? { status } : {}), ...(mode !== undefined ? { mode } : {}), ...(html !== undefined ? { html } : {}) };
+            const updated = { ...current, ...structuredClone(applied), updatedAt: now() };
+            definitions[definitions.indexOf(current)] = updated;
+            return structuredClone(updated);
+        },
+        // O(n log n) time/O(n) space over the fixture submissions; one filtered cursor page,
+        // no per-row I/O. This adapter is a disposable contract fixture, not a production store.
+        async listFormSubmissions({ formId }, { cursor, limit = 50 } = {}) {
+            const resolvedId = definitionId(formId);
+            const sorted = answers.filter(item => item.formDefinitionId === resolvedId && item.status !== 'trash').sort((a, b) => b.submittedAt.localeCompare(a.submittedAt) || b.id.localeCompare(a.id));
+            const start = cursor ? sorted.findIndex(item => item.id === cursor) + 1 : 0;
+            if (cursor && start === 0)
+                throw new AdminApiError({ message: 'invalid submissions cursor', status: 400 });
+            if (!Number.isInteger(limit) || limit < 1)
+                throw new AdminApiError({ message: 'invalid submissions limit', status: 400 });
+            const items = sorted.slice(start, start + limit);
+            return { items: structuredClone(items), nextCursor: start + limit < sorted.length ? items.at(-1).id : null };
+        },
+        async getFormSubmission({ formId, submissionId }, _optional = {}) { return structuredClone(findSubmission(formId, submissionId)); },
+        async deleteFormSubmission({ formId, submissionId }, _optional = {}) {
+            const found = findSubmission(formId, submissionId);
+            remove('form_submission', found.id);
+        },
+        trash: { async trash({ type, id }, _optional = {}) { remove(type, id); return { ok: true, version: null }; } },
+    };
+}
+//# sourceMappingURL=memory.js.map

package/dist/forms/conformance/forms-api.conformance.d.ts

@@ -0,0 +1,17 @@
+import type { AdminFormsPort } from '../../core/ports/forms.js';
+export interface FormsConformanceResult {
+    readonly passed: number;
+    readonly failures: readonly string[];
+}
+/** Run on an isolated API: creates definitions and trashes seeded submissions.
+ * The host provides a disposable seed so conformance never touches an operator's live data. */
+export declare function runFormsApiConformance({ api }: {
+    api: AdminFormsPort;
+}, { slug, submission }?: {
+    slug?: string;
+    submission?: {
+        formId: string;
+        submissionId: string;
+    };
+}): Promise<FormsConformanceResult>;
+//# sourceMappingURL=forms-api.conformance.d.ts.map

package/dist/forms/conformance/forms-api.conformance.js

@@ -0,0 +1,71 @@
+/** Run on an isolated API: creates definitions and trashes seeded submissions.
+ * The host provides a disposable seed so conformance never touches an operator's live data. */
+export async function runFormsApiConformance({ api }, { slug = 'forms-conformance', submission } = {}) {
+    const failures = [];
+    let passed = 0;
+    const check = (name, accepted) => { if (accepted)
+        passed++;
+    else
+        failures.push(name); };
+    const field = { id: 'email', label: 'Email', type: 'email', required: true, className: 'wide', attributes: { 'aria-label': 'Email' } };
+    const created = await api.createFormDefinition({ name: 'Contact', slug, fields: [field] }, { notify: { enabled: true, recipients: ['owner@example.com'] } });
+    check('create returns requested definition', created.name === 'Contact' && created.slug === slug && created.status === 'active');
+    check('field attributes survive create', created.fields[0]?.className === 'wide' && created.fields[0]?.attributes?.['aria-label'] === 'Email');
+    check('list includes created definition', (await api.listFormDefinitions({})).some(form => form.id === created.id));
+    check('get returns created id', (await api.getFormDefinition({ id: created.id })).id === created.id);
+    const snapshot = await api.getFormDefinition({ id: created.id });
+    Object.assign(snapshot.fields[0], { label: 'Changed only in the read snapshot' });
+    check('read snapshots cannot mutate stored fields', (await api.getFormDefinition({ id: created.id })).fields[0]?.label === 'Email');
+    const updated = await api.updateFormDefinition({ id: created.id }, { name: 'Renamed', fields: [...created.fields, { id: 'message', label: 'Message', type: 'textarea', required: false }] });
+    check('name patch and added field persist', updated.name === 'Renamed' && updated.fields.length === 2);
+    check('untouched notify survives update', updated.notify.enabled && updated.notify.recipients[0] === 'owner@example.com');
+    let refused = false;
+    try {
+        await api.updateFormDefinition({ id: created.id }, { fields: [] });
+    }
+    catch {
+        refused = true;
+    }
+    check('existing fields cannot be removed', refused);
+    check('rejected removal leaves fields intact', (await api.getFormDefinition({ id: created.id })).fields.length === 2);
+    const disabled = await api.updateFormDefinition({ id: created.id }, { status: 'disabled' });
+    check('definition disable is reversible', disabled.status === 'disabled' && (await api.updateFormDefinition({ id: created.id }, { status: 'active' })).status === 'active');
+    const html = await api.updateFormDefinition({ id: created.id }, { mode: 'html', html: '<input name="email">' });
+    check('HTML authoring survives update', html.mode === 'html' && html.html === '<input name="email">');
+    check('builder switch is explicit', (await api.updateFormDefinition({ id: created.id }, { mode: 'builder' })).mode === 'builder');
+    check('empty submission page has null cursor', (await api.listFormSubmissions({ formId: created.id })).nextCursor === null);
+    check('definition has no delete operation', !('deleteFormDefinition' in api));
+    if (submission) {
+        const page = await api.listFormSubmissions({ formId: submission.formId }, { limit: 1 });
+        check('submission page is form scoped', page.items.every(item => item.formDefinitionId === submission.formId));
+        check('submission detail is scoped', (await api.getFormSubmission(submission)).formDefinitionId === submission.formId);
+        let wrongFormRejected = false;
+        try {
+            await api.getFormSubmission({ formId: created.id, submissionId: submission.submissionId });
+        }
+        catch {
+            wrongFormRejected = true;
+        }
+        check('a submission of another form is unavailable', wrongFormRejected);
+        let wrongFormDeleteRejected = false;
+        try {
+            await api.deleteFormSubmission({ formId: created.id, submissionId: submission.submissionId });
+        }
+        catch {
+            wrongFormDeleteRejected = true;
+        }
+        check('cross-form trash is rejected without removing the submission', wrongFormDeleteRejected && (await api.getFormSubmission(submission)).id === submission.submissionId);
+        await api.deleteFormSubmission(submission);
+        let missing = false;
+        try {
+            await api.getFormSubmission(submission);
+        }
+        catch {
+            missing = true;
+        }
+        check('trashed submission detail is unavailable', missing);
+        check('trashed submission is absent from active pages', !(await api.listFormSubmissions({ formId: submission.formId })).items.some(item => item.id === submission.submissionId));
+    }
+    return { passed, failures };
+}
+//# sourceMappingURL=forms-api.conformance.js.map

package/dist/forms/controllers/draft-store.d.ts

@@ -0,0 +1,18 @@
+/** Section controllers share only the typed draft-update mechanism, not domain decisions. */
+export declare function createFormsDraftStore<S extends object>({ initial }: {
+    initial: S;
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<S>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends keyof S>({ key, value }: {
+        key: K;
+        value: S[K] | ((current: S[K]) => S[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<S>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=draft-store.d.ts.map

package/dist/forms/controllers/draft-store.js

@@ -0,0 +1,17 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+/** Section controllers share only the typed draft-update mechanism, not domain decisions. */
+export function createFormsDraftStore({ initial }, _optional = {}) {
+    const store = createControllerStore({ initial });
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        update({ key, value }, _options = {}) {
+            const current = store.getSnapshot()[key];
+            const next = typeof value === 'function' ? value(current) : value;
+            const patch = {};
+            patch[key] = next;
+            store.set({ patch });
+        },
+        patch({ patch }, _options = {}) { store.set({ patch }); },
+    };
+}
+//# sourceMappingURL=draft-store.js.map

package/dist/forms/controllers/field-attributes-dialog.controller.d.ts

@@ -0,0 +1,37 @@
+import type { AdminFormField } from "../models.js";
+import { type AttrRow } from "../rules.js";
+export interface FieldAttributesDialogState {
+    className: string;
+    rows: AttrRow[];
+    error: string | null;
+}
+export declare function initialFieldAttributesDialogState({ field }: {
+    field: AdminFormField;
+}, _optional?: {}): FieldAttributesDialogState;
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export declare function createFieldAttributesDialogController({ field }: {
+    field: AdminFormField;
+}, _optional?: {}): {
+    updateRow({ rowId, patch }: {
+        rowId: number;
+        patch: Partial<AttrRow>;
+    }, _options?: {}): void;
+    removeRow({ rowId }: {
+        rowId: number;
+    }, _options?: {}): void;
+    addRow(_required: Record<string, never>, _options?: {}): void;
+    submit(_required: Record<string, never>, _options?: {}): import("../rules.js").FieldAttributesSubmitResult;
+    getSnapshot: () => Readonly<FieldAttributesDialogState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends keyof FieldAttributesDialogState>({ key, value }: {
+        key: K;
+        value: FieldAttributesDialogState[K] | ((current: FieldAttributesDialogState[K]) => FieldAttributesDialogState[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<FieldAttributesDialogState>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=field-attributes-dialog.controller.d.ts.map

package/dist/forms/controllers/field-attributes-dialog.controller.js

@@ -0,0 +1,27 @@
+import { createFormsDraftStore } from "./draft-store.js";
+import { attrRowsFromField, updateAttrRow, removeAttrRow, addAttrRow, buildFieldAttributesPatch } from "../rules.js";
+export function initialFieldAttributesDialogState({ field }, _optional = {}) {
+    return { className: field.className ?? "", rows: attrRowsFromField({ field }), error: null };
+}
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export function createFieldAttributesDialogController({ field }, _optional = {}) {
+    const store = createFormsDraftStore({ initial: initialFieldAttributesDialogState({ field }) });
+    return {
+        ...store,
+        updateRow({ rowId, patch }, _options = {}) {
+            store.update({ key: 'rows', value: rows => updateAttrRow({ rows, rowId, patch }) });
+        },
+        removeRow({ rowId }, _options = {}) {
+            store.update({ key: 'rows', value: rows => removeAttrRow({ rows, rowId }) });
+        },
+        addRow(_required, _options = {}) {
+            store.update({ key: 'rows', value: rows => addAttrRow({ rows }) });
+        },
+        submit(_required, _options = {}) {
+            const result = buildFieldAttributesPatch(store.getSnapshot());
+            store.update({ key: 'error', value: result.ok ? null : result.error });
+            return result;
+        },
+    };
+}
+//# sourceMappingURL=field-attributes-dialog.controller.js.map

package/dist/forms/controllers/form-editor.controller.d.ts

@@ -0,0 +1,36 @@
+import type { AdminFormDefinition, AdminFormField, AdminFormNotify } from "../models.js";
+export interface FormEditorState {
+    form: AdminFormDefinition | null;
+    mode: "builder" | "html";
+    html: string;
+    copyFeedback: string | null;
+    name: string;
+    slug: string;
+    fields: AdminFormField[];
+    notify: AdminFormNotify;
+}
+export declare function initialFormEditorState(_required: Record<string, never>, _optional?: {}): FormEditorState;
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export declare function createFormEditorController(_required: Record<string, never>, _optional?: {}): {
+    seed({ form }: {
+        form: AdminFormDefinition;
+    }, _options?: {}): void;
+    changeMode({ mode }: {
+        mode: "builder" | "html";
+    }, { submitLabel }?: {
+        submitLabel?: string;
+    }): void;
+    getSnapshot: () => Readonly<FormEditorState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends keyof FormEditorState>({ key, value }: {
+        key: K;
+        value: FormEditorState[K] | ((current: FormEditorState[K]) => FormEditorState[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<FormEditorState>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=form-editor.controller.d.ts.map

package/dist/forms/controllers/form-editor.controller.js

@@ -0,0 +1,22 @@
+import { createFormsDraftStore } from "./draft-store.js";
+import { blankField } from "../rules.js";
+import { formHtmlStarter } from "../html-rules.js";
+export function initialFormEditorState(_required, _optional = {}) {
+    return { form: null, mode: "builder", html: "", copyFeedback: null, name: "", slug: "", fields: [blankField()], notify: { enabled: false, recipients: [] } };
+}
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export function createFormEditorController(_required, _optional = {}) {
+    const store = createFormsDraftStore({ initial: initialFormEditorState({}) });
+    return {
+        ...store,
+        seed({ form }, _options = {}) {
+            store.patch({ patch: { form, name: form.name, slug: form.slug, fields: form.fields, mode: form.mode ?? 'builder', html: form.html ?? '', notify: form.notify } });
+        },
+        changeMode({ mode }, { submitLabel = 'Send' } = {}) {
+            const state = store.getSnapshot();
+            const html = mode === 'html' && !state.html ? formHtmlStarter({ fields: state.fields }, { submitLabel }) : state.html;
+            store.patch({ patch: { mode, html } });
+        },
+    };
+}
+//# sourceMappingURL=form-editor.controller.js.map

package/dist/forms/controllers/form-fields-editor.controller.d.ts

@@ -0,0 +1,20 @@
+export interface FormFieldsEditorState {
+    editingAttrsIndex: number | null;
+}
+export declare function initialFormFieldsEditorState(_required: Record<string, never>, _optional?: {}): FormFieldsEditorState;
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export declare function createFormFieldsEditorController(_required: Record<string, never>, _optional?: {}): {
+    getSnapshot: () => Readonly<FormFieldsEditorState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends "editingAttrsIndex">({ key, value }: {
+        key: K;
+        value: FormFieldsEditorState[K] | ((current: FormFieldsEditorState[K]) => FormFieldsEditorState[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<FormFieldsEditorState>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=form-fields-editor.controller.d.ts.map

package/dist/forms/controllers/form-fields-editor.controller.js

@@ -0,0 +1,10 @@
+import { createFormsDraftStore } from "./draft-store.js";
+export function initialFormFieldsEditorState(_required, _optional = {}) {
+    return { editingAttrsIndex: null };
+}
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export function createFormFieldsEditorController(_required, _optional = {}) {
+    const store = createFormsDraftStore({ initial: initialFormFieldsEditorState({}) });
+    return store;
+}
+//# sourceMappingURL=form-fields-editor.controller.js.map

package/dist/forms/controllers/form-submission-detail.controller.d.ts

@@ -0,0 +1,20 @@
+export interface FormSubmissionDetailState {
+    confirmOpen: boolean;
+}
+export declare function initialFormSubmissionDetailState(_required: Record<string, never>, _optional?: {}): FormSubmissionDetailState;
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export declare function createFormSubmissionDetailController(_required: Record<string, never>, _optional?: {}): {
+    getSnapshot: () => Readonly<FormSubmissionDetailState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends "confirmOpen">({ key, value }: {
+        key: K;
+        value: FormSubmissionDetailState[K] | ((current: FormSubmissionDetailState[K]) => FormSubmissionDetailState[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<FormSubmissionDetailState>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=form-submission-detail.controller.d.ts.map

package/dist/forms/controllers/form-submission-detail.controller.js

@@ -0,0 +1,10 @@
+import { createFormsDraftStore } from "./draft-store.js";
+export function initialFormSubmissionDetailState(_required, _optional = {}) {
+    return { confirmOpen: false };
+}
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export function createFormSubmissionDetailController(_required, _optional = {}) {
+    const store = createFormsDraftStore({ initial: initialFormSubmissionDetailState({}) });
+    return store;
+}
+//# sourceMappingURL=form-submission-detail.controller.js.map

package/dist/forms/controllers/form-submissions.controller.d.ts

@@ -0,0 +1,25 @@
+import type { AdminFormSubmission } from "../models.js";
+export interface FormSubmissionsState {
+    morePages: AdminFormSubmission[];
+    moreCursor: string | null;
+    moreError: string | null;
+    selectedId: string | null;
+    loadingMore: boolean;
+}
+export declare function initialFormSubmissionsState(_required: Record<string, never>, _optional?: {}): FormSubmissionsState;
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export declare function createFormSubmissionsController(_required: Record<string, never>, _optional?: {}): {
+    getSnapshot: () => Readonly<FormSubmissionsState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends keyof FormSubmissionsState>({ key, value }: {
+        key: K;
+        value: FormSubmissionsState[K] | ((current: FormSubmissionsState[K]) => FormSubmissionsState[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<FormSubmissionsState>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=form-submissions.controller.d.ts.map

package/dist/forms/controllers/form-submissions.controller.js

@@ -0,0 +1,10 @@
+import { createFormsDraftStore } from "./draft-store.js";
+export function initialFormSubmissionsState(_required, _optional = {}) {
+    return { morePages: [], moreCursor: null, moreError: null, selectedId: null, loadingMore: false };
+}
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export function createFormSubmissionsController(_required, _optional = {}) {
+    const store = createFormsDraftStore({ initial: initialFormSubmissionsState({}) });
+    return store;
+}
+//# sourceMappingURL=form-submissions.controller.js.map

package/dist/forms/controllers/forms-list.controller.d.ts

@@ -0,0 +1,22 @@
+import type { AdminFormDefinition } from "../models.js";
+export interface FormsListState {
+    rowSavingId: string | null;
+    pendingDelete: AdminFormDefinition | null;
+}
+export declare function initialFormsListState(_required: Record<string, never>, _optional?: {}): FormsListState;
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export declare function createFormsListController(_required: Record<string, never>, _optional?: {}): {
+    getSnapshot: () => Readonly<FormsListState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    update<K extends keyof FormsListState>({ key, value }: {
+        key: K;
+        value: FormsListState[K] | ((current: FormsListState[K]) => FormsListState[K]);
+    }, _options?: {}): void;
+    patch({ patch }: {
+        patch: Partial<FormsListState>;
+    }, _options?: {}): void;
+};
+//# sourceMappingURL=forms-list.controller.d.ts.map

package/dist/forms/controllers/forms-list.controller.js

@@ -0,0 +1,10 @@
+import { createFormsDraftStore } from "./draft-store.js";
+export function initialFormsListState(_required, _optional = {}) {
+    return { rowSavingId: null, pendingDelete: null };
+}
+/** A headless section store. React owns subscriptions/effects, never this state. */
+export function createFormsListController(_required, _optional = {}) {
+    const store = createFormsDraftStore({ initial: initialFormsListState({}) });
+    return store;
+}
+//# sourceMappingURL=forms-list.controller.js.map