@happyvertical/smrt-ui 0.51.39 → 0.53.0

package/dist/components/forms/form-retry/__tests__/submission-key.test.js

@@ -0,0 +1,236 @@
+/**
+ * The submission key and its slot (#3291): one key per filled-in form,
+ * rotated at most once, never rotated by a late result, and never lost to a
+ * storage error.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { beginSubmit, clearSubmissionKey, isSubmissionKeyPersistent, mintSubmissionKey, readSubmissionKey, resetFormRetryMemory, rotateSubmissionKey, settleSubmit, submitDisposition, } from '../submission-key.js';
+import { fullStorage, memoryStorage, refusingStorage, stickyStorage, } from './storage.js';
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+beforeEach(() => {
+    resetFormRetryMemory();
+});
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+describe('submitDisposition', () => {
+    const LIVE = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+    const STALE = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
+    it('rotates on a confirmed write', () => {
+        expect(submitDisposition(LIVE, LIVE, 'success')).toBe('rotate-and-apply');
+    });
+    it('keeps the key on a validation failure, which wrote nothing', () => {
+        expect(submitDisposition(LIVE, LIVE, 'failure')).toBe('apply');
+    });
+    it('keeps the key AND the form on a transport error', () => {
+        expect(submitDisposition(LIVE, LIVE, 'error')).toBe('transport-error');
+    });
+    it('ignores every result whose key is no longer the live one', () => {
+        for (const outcome of [
+            'success',
+            'failure',
+            'redirect',
+            'error',
+        ]) {
+            expect(submitDisposition(STALE, LIVE, outcome)).toBe('ignore');
+            expect(submitDisposition(LIVE, null, outcome)).toBe('ignore');
+        }
+    });
+    it('treats a redirect as unconfirmed unless the caller says otherwise', () => {
+        expect(submitDisposition(LIVE, LIVE, 'redirect')).toBe('apply');
+        expect(submitDisposition(LIVE, LIVE, 'redirect', {
+            redirectConfirmsWrite: true,
+        })).toBe('rotate-and-apply');
+    });
+});
+describe('the submission slot', () => {
+    const A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+    const B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
+    const C = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
+    const idle = (token = A) => ({ token, inFlight: null });
+    it('refuses a SECOND submit while one is unresolved', () => {
+        const first = beginSubmit(idle());
+        expect(first).toMatchObject({ start: true, sent: A });
+        const second = beginSubmit(first.state);
+        expect(second.start).toBe(false);
+        expect(second.state).toEqual(first.state);
+    });
+    it('accepts the next submit once the first has settled', () => {
+        const first = beginSubmit(idle());
+        const settled = settleSubmit(first.state, first.sent, 'success', {
+            formCleared: true,
+            mint: () => B,
+        });
+        expect(settled).toEqual({
+            state: { token: B, inFlight: null },
+            disposition: 'rotate-and-apply',
+        });
+        expect(beginSubmit(settled.state)).toMatchObject({ start: true, sent: B });
+    });
+    it('keeps the key when the submit wrote nothing', () => {
+        for (const outcome of ['failure', 'error']) {
+            const first = beginSubmit(idle());
+            const settled = settleSubmit(first.state, first.sent, outcome, {
+                formCleared: true,
+                mint: () => B,
+            });
+            expect(settled.state, outcome).toEqual({ token: A, inFlight: null });
+        }
+    });
+    it('ignores a duplicate answer to a submit already settled', () => {
+        const first = beginSubmit(idle());
+        const settled = settleSubmit(first.state, first.sent, 'success', {
+            formCleared: true,
+            mint: () => B,
+        });
+        const late = settleSubmit(settled.state, first.sent, 'success', {
+            formCleared: true,
+            mint: () => C,
+        });
+        expect(late).toEqual({ state: settled.state, disposition: 'ignore' });
+    });
+    it('rotates at most once however many answers arrive', () => {
+        const begun = beginSubmit(idle());
+        let state = begun.state;
+        const mint = vi.fn(() => B);
+        for (let i = 0; i < 3; i += 1) {
+            state = settleSubmit(state, begun.sent, 'success', {
+                formCleared: true,
+                mint,
+            }).state;
+        }
+        expect(mint).toHaveBeenCalledTimes(1);
+    });
+    it('KEEPS the key when a confirmed write left content on the form', () => {
+        const first = beginSubmit(idle());
+        const settled = settleSubmit(first.state, first.sent, 'success', {
+            formCleared: false,
+            mint: () => B,
+        });
+        expect(settled).toEqual({
+            state: { token: A, inFlight: null },
+            disposition: 'rotate-and-apply',
+        });
+    });
+});
+describe('the key store', () => {
+    it('returns one stable UUID per form until it is rotated', () => {
+        const storage = memoryStorage();
+        const first = readSubmissionKey({ form: 'po-line', storage });
+        expect(first).toMatch(UUID_V4);
+        expect(readSubmissionKey({ form: 'po-line', storage })).toBe(first);
+        const rotated = rotateSubmissionKey({ form: 'po-line', storage });
+        expect(rotated).not.toBe(first);
+        expect(readSubmissionKey({ form: 'po-line', storage })).toBe(rotated);
+    });
+    it('keeps forms and scopes apart, under derived names', () => {
+        const storage = memoryStorage();
+        const a = readSubmissionKey({ form: 'receipt', scope: 'po/a', storage });
+        const b = readSubmissionKey({ form: 'receipt', scope: 'po-b', storage });
+        const other = readSubmissionKey({ form: 'request', storage });
+        expect(new Set([a, b, other]).size).toBe(3);
+        expect([...storage.store.keys()].sort()).toEqual([
+            'smrt:form-retry:receipt:po%2Fa:key',
+            'smrt:form-retry:receipt:po-b:key',
+            'smrt:form-retry:request:key',
+        ]);
+        clearSubmissionKey({ form: 'receipt', scope: 'po-b', storage });
+        expect(readSubmissionKey({ form: 'receipt', scope: 'po/a', storage })).toBe(a);
+    });
+    it('honours an explicit storage name, for migrating existing keys', () => {
+        const storage = memoryStorage();
+        storage.store.set('legacy:flha:submission-key', 'carried');
+        expect(readSubmissionKey({
+            form: 'flha',
+            storage,
+            storageKey: 'legacy:flha:submission-key',
+        })).toBe('carried');
+    });
+    it('uses this tab sessionStorage by default, never localStorage', () => {
+        const session = memoryStorage();
+        const local = memoryStorage();
+        vi.stubGlobal('sessionStorage', session);
+        vi.stubGlobal('localStorage', local);
+        const key = readSubmissionKey({ form: 'po' });
+        expect(session.store.get('smrt:form-retry:po:key')).toBe(key);
+        expect(local.store.size).toBe(0);
+        expect(isSubmissionKeyPersistent({ form: 'po' })).toBe(true);
+    });
+    it('private window: falls back to memory, and the key still survives a remount', () => {
+        const storage = refusingStorage();
+        const first = readSubmissionKey({ form: 'po', storage });
+        // One page, two mounts: the second read must find the same key or a retry
+        // after `enhance`'s error path would carry a key the server never saw.
+        expect(readSubmissionKey({ form: 'po', storage })).toBe(first);
+        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(false);
+        expect(() => clearSubmissionKey({ form: 'po', storage })).not.toThrow();
+        expect(readSubmissionKey({ form: 'po', storage })).not.toBe(first);
+    });
+    it('private window: survives the sessionStorage property itself throwing', () => {
+        const original = Object.getOwnPropertyDescriptor(globalThis, 'sessionStorage');
+        Object.defineProperty(globalThis, 'sessionStorage', {
+            configurable: true,
+            get() {
+                throw new DOMException('The operation is insecure.', 'SecurityError');
+            },
+        });
+        try {
+            const first = readSubmissionKey({ form: 'po' });
+            expect(first).toMatch(UUID_V4);
+            expect(readSubmissionKey({ form: 'po' })).toBe(first);
+        }
+        finally {
+            if (original)
+                Object.defineProperty(globalThis, 'sessionStorage', original);
+        }
+    });
+    it('a refused write (full quota) still reads back the same key', () => {
+        const storage = fullStorage();
+        const first = readSubmissionKey({ form: 'po', storage });
+        expect(readSubmissionKey({ form: 'po', storage })).toBe(first);
+    });
+    it('rotates even when the store refuses to remove the old key', () => {
+        const storage = stickyStorage();
+        const first = readSubmissionKey({ form: 'po', storage });
+        const rotated = rotateSubmissionKey({ form: 'po', storage });
+        expect(rotated).not.toBe(first);
+        expect(readSubmissionKey({ form: 'po', storage })).toBe(rotated);
+        expect(storage.store.get('smrt:form-retry:po:key')).toBe(rotated);
+        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(true);
+    });
+    it('rotates when removal AND the replacement write are refused over an existing key', () => {
+        const storage = stickyStorage(true);
+        storage.store.set('smrt:form-retry:po:key', 'stale-key');
+        expect(readSubmissionKey({ form: 'po', storage })).toBe('stale-key');
+        const rotated = rotateSubmissionKey({ form: 'po', storage });
+        expect(rotated).not.toBe('stale-key');
+        // The fresh key lives in memory and takes precedence over stale storage.
+        expect(readSubmissionKey({ form: 'po', storage })).toBe(rotated);
+        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(false);
+    });
+    it.each([
+        ['writes still work', false],
+        ['writes are refused too', true],
+    ])('clearing a key the store will not remove mints a fresh one (%s)', (_label, refuseWrites) => {
+        const storage = stickyStorage();
+        const first = readSubmissionKey({ form: 'po', storage });
+        storage.refuseWrites = refuseWrites;
+        clearSubmissionKey({ form: 'po', storage });
+        const next = readSubmissionKey({ form: 'po', storage });
+        expect(next).not.toBe(first);
+        expect(next).toMatch(UUID_V4);
+        expect(readSubmissionKey({ form: 'po', storage })).toBe(next);
+        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(!refuseWrites);
+    });
+    it('`storage: null` keeps everything in memory', () => {
+        const first = readSubmissionKey({ form: 'po', storage: null });
+        expect(readSubmissionKey({ form: 'po', storage: null })).toBe(first);
+        expect(isSubmissionKeyPersistent({ form: 'po', storage: null })).toBe(false);
+    });
+    it('mints distinct v4 UUIDs', () => {
+        const keys = new Set(Array.from({ length: 50 }, mintSubmissionKey));
+        expect(keys.size).toBe(50);
+        for (const key of keys)
+            expect(key).toMatch(UUID_V4);
+    });
+});

package/dist/components/forms/form-retry/__tests__/submitted-draft.test.js

@@ -0,0 +1,334 @@
+/**
+ * The restore-after-reload draft (#3291): restored only under the key it was
+ * submitted with, only for the owner who submitted it, only while fresh, only
+ * when well-formed — and never at the cost of a thrown storage error.
+ */
+import { describe, expect, it } from 'vitest';
+import { applyDraftToForm, clearSubmittedDraft, describeFormData, readSubmittedDraft, saveSubmittedDraft, } from '../submitted-draft.js';
+import { memoryStorage, refusingStorage, stickyStorage } from './storage.js';
+const TOKEN = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const OWNER = 'tenant-1:person-1';
+const NAME = 'smrt:form-retry:report:draft';
+const ALWAYS = () => true;
+const SAVED_AT = new Date('2026-10-01T12:00:00Z');
+function save(storage, owner = OWNER) {
+    saveSubmittedDraft(storage, NAME, {
+        token: TOKEN,
+        owner,
+        savedAt: SAVED_AT,
+        fields: [
+            ['title', 'Trip over a hose'],
+            ['qty', '1'],
+            ['qty', '2'],
+        ],
+        files: [{ field: 'photo', name: 'a.jpg', type: 'image/jpeg', size: 3 }],
+        values: { captureKey: 'k-1' },
+    });
+}
+describe('saveSubmittedDraft / readSubmittedDraft', () => {
+    it('restores exactly what was submitted, under the same key and owner', () => {
+        const storage = memoryStorage();
+        save(storage);
+        expect(readSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            fresh: ALWAYS,
+        })).toEqual({
+            token: TOKEN,
+            savedAt: SAVED_AT,
+            fields: [
+                ['title', 'Trip over a hose'],
+                ['qty', '1'],
+                ['qty', '2'],
+            ],
+            files: [{ field: 'photo', name: 'a.jpg', type: 'image/jpeg', size: 3 }],
+            values: { captureKey: 'k-1' },
+        });
+    });
+    it('does not restore under a new key, and drops the stale draft', () => {
+        const storage = memoryStorage();
+        save(storage);
+        expect(readSubmittedDraft(storage, NAME, {
+            token: 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+            owner: OWNER,
+            fresh: ALWAYS,
+        })).toBeNull();
+        expect(storage.store.size).toBe(0);
+    });
+    it('never restores one person’s draft for another on shared hardware', () => {
+        const storage = memoryStorage();
+        save(storage);
+        expect(readSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: 'tenant-1:person-2',
+            fresh: ALWAYS,
+        })).toBeNull();
+        expect(storage.store.size).toBe(0);
+    });
+    it('never restores for an empty owner', () => {
+        const storage = memoryStorage();
+        save(storage, '');
+        expect(readSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: '',
+            fresh: ALWAYS,
+        })).toBeNull();
+    });
+    it('drops an expired draft', () => {
+        const storage = memoryStorage();
+        save(storage);
+        const seen = [];
+        expect(readSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            fresh: (savedAt) => {
+                seen.push(savedAt);
+                return false;
+            },
+        })).toBeNull();
+        expect(seen).toEqual([SAVED_AT]);
+        expect(storage.store.size).toBe(0);
+    });
+    it('drops a draft that is malformed or not JSON', () => {
+        const storage = memoryStorage();
+        const bad = [
+            '{not json',
+            JSON.stringify({
+                v: 2,
+                token: TOKEN,
+                owner: OWNER,
+                savedAt: 1,
+                fields: [],
+                files: [],
+            }),
+            JSON.stringify({
+                v: 1,
+                token: TOKEN,
+                owner: OWNER,
+                fields: [],
+                files: [],
+            }),
+            JSON.stringify({
+                v: 1,
+                token: TOKEN,
+                owner: OWNER,
+                savedAt: 1,
+                fields: [['a', 1]],
+                files: [],
+            }),
+            JSON.stringify({
+                v: 1,
+                token: TOKEN,
+                owner: OWNER,
+                savedAt: 1,
+                fields: [],
+                files: [{ field: 'p' }],
+            }),
+        ];
+        for (const raw of bad) {
+            storage.store.set(NAME, raw);
+            expect(readSubmittedDraft(storage, NAME, {
+                token: TOKEN,
+                owner: OWNER,
+                fresh: ALWAYS,
+            }), raw).toBeNull();
+            expect(storage.store.size, raw).toBe(0);
+        }
+    });
+    it('clears', () => {
+        const storage = memoryStorage();
+        save(storage);
+        clearSubmittedDraft(storage, NAME);
+        expect(storage.store.size).toBe(0);
+    });
+    it('survives a browser that refuses storage (private window)', () => {
+        const storage = refusingStorage();
+        expect(() => saveSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            savedAt: SAVED_AT,
+            fields: [],
+            files: [],
+        })).not.toThrow();
+        expect(() => clearSubmittedDraft(storage, NAME)).not.toThrow();
+    });
+    it('skips a values capture that cannot be serialized', () => {
+        const storage = memoryStorage();
+        const cyclic = {};
+        cyclic.self = cyclic;
+        saveSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            savedAt: SAVED_AT,
+            fields: [],
+            files: [],
+            values: cyclic,
+        });
+        expect(storage.store.size).toBe(0);
+    });
+});
+describe('a later attempt whose values cannot be serialized', () => {
+    it('clears the earlier attempt’s draft instead of leaving it to be restored', () => {
+        const storage = memoryStorage();
+        save(storage);
+        expect(storage.store.has(NAME)).toBe(true);
+        const cyclic = {};
+        cyclic.self = cyclic;
+        saveSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            savedAt: SAVED_AT,
+            fields: [['title', 'A different submission']],
+            files: [],
+            values: cyclic,
+        });
+        expect(readSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            fresh: ALWAYS,
+        })).toBeNull();
+        expect(storage.store.has(NAME)).toBe(false);
+    });
+});
+describe('a store that refuses to remove the draft', () => {
+    const read = (storage) => readSubmittedDraft(storage, NAME, {
+        token: TOKEN,
+        owner: OWNER,
+        fresh: ALWAYS,
+    });
+    it.each([
+        ['writes still work', false],
+        ['writes are refused too', true],
+    ])('clearing leaves nothing to restore (%s)', (_label, refuseWrites) => {
+        const storage = stickyStorage();
+        save(storage);
+        expect(read(storage)).not.toBeNull();
+        storage.refuseWrites = refuseWrites;
+        clearSubmittedDraft(storage, NAME);
+        expect(read(storage)).toBeNull();
+    });
+    it.each([
+        ['writes still work', false],
+        ['writes are refused too', true],
+    ])('an unserializable later attempt leaves nothing to restore (%s)', (_label, refuseWrites) => {
+        const storage = stickyStorage();
+        save(storage);
+        storage.refuseWrites = refuseWrites;
+        const cyclic = {};
+        cyclic.self = cyclic;
+        saveSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: OWNER,
+            savedAt: SAVED_AT,
+            fields: [['title', 'A different submission']],
+            files: [],
+            values: cyclic,
+        });
+        expect(read(storage)).toBeNull();
+    });
+    it('a draft rejected at read time (another owner) is not restored later', () => {
+        const storage = stickyStorage();
+        save(storage);
+        expect(readSubmittedDraft(storage, NAME, {
+            token: TOKEN,
+            owner: 'tenant-1:person-2',
+            fresh: ALWAYS,
+        })).toBeNull();
+        expect(read(storage)).toBeNull();
+    });
+    it('a later save replaces the invalidation', () => {
+        const storage = stickyStorage();
+        save(storage);
+        clearSubmittedDraft(storage, NAME);
+        save(storage);
+        expect(read(storage)?.fields[0]).toEqual(['title', 'Trip over a hose']);
+    });
+});
+describe('describeFormData', () => {
+    it('keeps text entries in order, describes chosen files, skips excluded names', () => {
+        const data = new FormData();
+        data.append('submissionKey', TOKEN);
+        data.append('title', 'x');
+        data.append('photo', new File(['abc'], 'a.jpg', { type: 'image/jpeg' }));
+        data.append('photo', new File([], '', { type: 'application/octet-stream' }));
+        data.append('title', 'y');
+        expect(describeFormData(data, new Set(['submissionKey']))).toEqual({
+            fields: [
+                ['title', 'x'],
+                ['title', 'y'],
+            ],
+            files: [{ field: 'photo', name: 'a.jpg', type: 'image/jpeg', size: 3 }],
+        });
+    });
+});
+describe('applyDraftToForm', () => {
+    function formOf(html) {
+        document.body.innerHTML = `<form>${html}</form>`;
+        const form = document.body.querySelector('form');
+        if (!form)
+            throw new Error('no form');
+        return form;
+    }
+    it('puts values back by name and order, and notifies bindings', () => {
+        const form = formOf(`
+      <input type="hidden" name="jobId" value="server" />
+      <input name="title" />
+      <input name="qty" /><input name="qty" />
+      <textarea name="notes"></textarea>
+      <select name="unit"><option value="pcs">pcs</option><option value="ft">ft</option></select>
+      <select name="tags" multiple><option value="a" selected>a</option><option value="b">b</option></select>
+      <input type="checkbox" name="urgent" value="yes" />
+      <input type="checkbox" name="checked" value="on" checked />
+      <input type="radio" name="sev" value="minor" checked /><input type="radio" name="sev" value="major" />
+      <input type="password" name="pin" />
+      <input type="file" name="photo" />
+      <input name="secret" />
+    `);
+        const events = [];
+        form.addEventListener('input', (event) => {
+            events.push(event.target.name);
+        });
+        applyDraftToForm(form, {
+            fields: [
+                ['jobId', 'restored'],
+                ['title', 'Trip'],
+                ['qty', '1'],
+                ['qty', '2'],
+                ['notes', 'by the hose'],
+                ['unit', 'ft'],
+                ['tags', 'b'],
+                ['urgent', 'yes'],
+                ['sev', 'major'],
+                ['pin', '1234'],
+                ['secret', 'leaked'],
+            ],
+        }, new Set(['secret']));
+        const value = (selector) => form.querySelector(selector).value;
+        const checked = (selector) => form.querySelector(selector).checked;
+        expect(value('[name=jobId]')).toBe('server');
+        expect(value('[name=title]')).toBe('Trip');
+        expect(Array.from(form.querySelectorAll('[name=qty]'), (q) => q.value)).toEqual(['1', '2']);
+        expect(value('[name=notes]')).toBe('by the hose');
+        expect(value('[name=unit]')).toBe('ft');
+        expect(Array.from(form.querySelector('[name=tags]')
+            .selectedOptions, (o) => o.value)).toEqual(['b']);
+        expect(checked('[name=urgent]')).toBe(true);
+        // Submitted unchecked (absent from the draft): unchecked again.
+        expect(checked('[name=checked]')).toBe(false);
+        expect(checked('[value=major]')).toBe(true);
+        expect(value('[name=pin]')).toBe('');
+        expect(value('[name=secret]')).toBe('');
+        expect(events).toEqual(expect.arrayContaining([
+            'title',
+            'qty',
+            'notes',
+            'unit',
+            'tags',
+            'urgent',
+            'checked',
+            'sev',
+        ]));
+        expect(events).not.toContain('jobId');
+        expect(events).not.toContain('pin');
+    });
+});

package/dist/components/forms/form-retry/content-digest.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The `runOnce()` content digest, computed in the browser (#3291).
+ *
+ * `runOnce()` (`@happyvertical/smrt-core`, `src/run-once.ts`) digests the
+ * submitted content itself on the server, so pairing a form with it does NOT
+ * need this function: send the submission key, pass the action's `FormData`
+ * as `content`, and the server derives the claim. This exists for the cases
+ * where the browser needs the SAME digest the server will compute — to tell a
+ * person whether the retry they are about to send is byte-identical to the
+ * submit that may already be recorded, to key a client-side record of an
+ * attempt, or to log a correlatable identity without logging the content.
+ *
+ * It is a byte-for-byte port of core's `digestRunOnceContent()`, using Web
+ * Crypto (`crypto.subtle`) instead of `node:crypto`; shared test vectors in
+ * both packages hold the two together. The algorithm:
+ *
+ * - Content is normalized once, following JSON serialization exactly:
+ *   `toJSON(key)` is called with the property name or array index (a `Date`
+ *   digests as its ISO string), and `undefined`, function and symbol values
+ *   are omitted from objects and written as `null` in arrays.
+ * - A `FormData` digests as its ORDERED entry list — repeated fields and their
+ *   order are significant — because JSON would reduce every form to `{}` and
+ *   collapse distinct submissions (#3136). A `File`/`Blob` entry digests by
+ *   `{ name, size, type }`, never its bytes: re-choosing the same file after a
+ *   reload reproduces the digest, and a different file of the same name, size
+ *   and type does too.
+ * - Content containing a `FormData` is hashed in a separate domain (the input
+ *   is prefixed with a byte sorted-key JSON never starts with, and user keys
+ *   starting with NUL are escaped), so no plain object can forge it.
+ * - `Map`, `Set`, `RegExp`, any other non-plain object without `toJSON()`, and
+ *   `bigint` are rejected with a `TypeError` rather than hashed as `{}`.
+ * - The digest is the lowercase hex sha256 of the sorted-key JSON encoding.
+ *
+ * `crypto.subtle` exists only in secure contexts (HTTPS, `localhost`); the
+ * function rejects with a clear error elsewhere.
+ *
+ * @module
+ */
+/**
+ * The exact string `runOnce()` hashes for `content`.
+ * @throws {TypeError} when `content` contains a value with no faithful JSON form.
+ * @internal
+ */
+export declare function submissionDigestInput(content: unknown): string;
+/**
+ * The content digest `runOnce()` will compute on the server for `content`:
+ * lowercase hex sha256. See the module doc for what is and is not digested
+ * (a `File` by name, size and type — never its bytes).
+ *
+ * @throws {TypeError} (as a rejection) when `content` has no faithful JSON
+ *   form, or when Web Crypto is unavailable (not a secure context).
+ */
+export declare function digestSubmissionContent(content: unknown): Promise<string>;
+//# sourceMappingURL=content-digest.d.ts.map

package/dist/components/forms/form-retry/content-digest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-digest.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/form-retry/content-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAoHH;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAO9D;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,CAajB"}