sygnal 6.6.0 → 7.0.0

package/dist/index.esm.js

@@ -63,6 +63,8 @@ const NOT_SINK = /^(__|(props|children|dispose|commands)\$$|(CHILD|PARENT|EFFECT
  */
 const abortReason = {};
 const abort = (reason) => (abortReason.r = reason, ABORT);
+/** Private semantic binding identity, shared by built-in helpers and the runtime. */
+const BINDING = /*#__PURE__*/ Symbol.for('sygnal.binding');
 
 /**
  * PLAN-4.6 (D162): `defineComponent(opts)` builds a component from an options object, for code
@@ -753,6 +755,8 @@ const DEV_CODE_SEVERITY = {
     SYG634: 'info',
     // PLAN-3 5-5 (fetch.ts)
     SYG635: 'warn',
+    // PLAN-11 U-1 (fetch.ts)
+    SYG636: 'warn',
     // PLAN-4 GS-2 (checks/elementCommands.ts, through the core bridge; renderComponent too)
     SYG640: 'warn',
     SYG641: 'error',
@@ -869,6 +873,12 @@ const DEV_CODE_SEVERITY = {
     // PLAN-9 X-2: static only (sygnal-check); listed so the entry knows their titles
     SYG253: 'warn',
     SYG254: 'info',
+    // PLAN-12: static only; proven after-state output guard contradiction.
+    SYG256: 'warn',
+    // 7.0: the opt-in timing audit (checks/next.ts; configureTimingAudit)
+    SYG257: 'info',
+    // PLAN-12: static only for legacy (6.x) binding contracts. Sygnal 7 remounts known targets.
+    SYG454: 'warn',
 };
 function docsUrlFor(code) {
     return `${DOCS_BASE_URL}/reference/errors#${code.toLowerCase()}`;
@@ -1264,6 +1274,8 @@ function normalize$1(view, src) {
         const list = [];
         for (const sink in e)
             list.push([sink, e[sink]]), sinks.add(sink);
+        // 7.0: STATE first, so the other sinks get the state it committed
+        list.sort((a, b) => +(a[0] != 'STATE') - +(b[0] != 'STATE'));
         handlers.set(key, list);
     }
     const c = normCalc(name, src.calculated, src.initialState);
@@ -1855,7 +1867,7 @@ function handle(inst, type, data, cause, src) {
         return;
     const def = inst.def;
     const pre = inst.cell.get();
-    let props, outs;
+    let props, afterProps, post = pre, outs;
     const next = (t, d, ms = 10, effect) => {
         if (typeof ms !== 'number')
             fail$2('SYG215', inst, `next() delay in '${type}' must be a number`, "Use next('ACTION', data, ms)");
@@ -1870,35 +1882,28 @@ function handle(inst, type, data, cause, src) {
     };
     for (const [sink, h0] of hs) {
         const h = H.wrapHandler ? H.wrapHandler(viewOf(inst), type, sink, h0) || h0 : h0;
-        if (sink == 'EFFECT') {
-            if (typeof h != 'function')
-                continue;
-            const failed = (e) => app.caught(inst, 'SYG214', `EFFECT handler '${type}' threw`, e, 'effect', type);
-            try {
-                const p = { ...(props || (props = inst_props(inst, pre))), signal: (inst.ac || (inst.ac = globalThis.AbortController && new AbortController()))?.signal };
-                const r = h(pre, data, (t, d, ms) => next(t, d, ms, true), p);
-                if (r?.then)
-                    r.then(null, failed);
-                else if (r !== undefined && !isAbort(r))
-                    warn('SYG219', inst, `EFFECT handler '${type}' returned a value, which is ignored`, 'Use a STATE or driver sink');
-            }
-            catch (e) {
-                failed(e);
-            }
-            continue;
-        }
+        const effect = sink == 'EFFECT';
         let v;
         if (typeof h == 'function') {
             try {
-                v = h(pre, data, next, props || (props = inst_props(inst, pre)));
+                const p = sink == 'STATE' ? props || (props = inst_props(inst, pre, pre)) : afterProps || (afterProps = inst_props(inst, post, pre));
+                v = h(p.state, data, effect ? (t, d, ms) => next(t, d, ms, true) : next, effect ? { ...p, signal: (inst.ac || (inst.ac = globalThis.AbortController && new AbortController()))?.signal } : p);
+                if (effect) {
+                    if (v?.then)
+                        v.then(null, (e) => handlerFailed(inst, type, sink, e));
+                    else if (v !== undefined && !isAbort(v))
+                        warn('SYG219', inst, `EFFECT handler '${type}' returned a value, which is ignored`, 'Use a STATE or driver sink');
+                }
             }
             catch (e) {
-                app.caught(inst, 'SYG216', `Reducer for '${type}' threw; ${sink == 'STATE' ? 'state unchanged' : 'nothing sent'}`, e, 'reducer', type);
+                handlerFailed(inst, type, sink, e);
                 continue;
             }
         }
         else
             v = h === undefined || h === true ? data : h;
+        if (effect)
+            continue;
         if (sink == 'STATE' && (isAbort(v) || v === pre)) {
             // D205: the DOM event being dispatched (window.event) is the one this action came from
             if (/^(input|change)$/.test(globalThis.event?.type))
@@ -1911,6 +1916,11 @@ function handle(inst, type, data, cause, src) {
             H.onReducer?.(viewOf(inst), type, pre, v);
             dbg(inst, () => `<${type}> State reducer added`);
             inst.cell.set(v);
+            // a STATE that removed the component's own state (a deleted record it is bound to): the
+            // outputs get its last state, as a Collection item's do
+            post = inst.cell.get();
+            if (post === undefined)
+                post = pre;
             // GS-12: this app's DOM driver patches inside a View Transition (makeViewTransitionDOMDriver
             // reads the flag on its IsolateModule); includes?.: a non-array static lists nothing (G-228).
             // Only for a state that changed structurally: today an equal one renders nothing (its
@@ -1959,9 +1969,14 @@ function handle(inst, type, data, cause, src) {
                 send$1(inst, outs[i], outs[i + 1]);
     }
 }
-/** the handlers' 4th argument: the props, children, slots, context, uid and the pre-action state */
-function inst_props(inst, pre) {
-    return { ...inst.props, children: inst.children, slots: inst.slots, context: inst.context(), uid: inst.uid, state: pre };
+/** Keep the same failure boundary for sync handlers and rejected EFFECT promises. */
+function handlerFailed(inst, type, sink, e) {
+    const effect = sink == 'EFFECT';
+    inst.app.caught(inst, effect ? 'SYG214' : 'SYG216', effect ? `EFFECT handler '${type}' threw` : `Reducer for '${type}' threw; ${sink == 'STATE' ? 'state unchanged' : 'nothing sent'}`, e, effect ? 'effect' : 'reducer', type);
+}
+/** the handlers' 4th argument: the props, children, slots, context, uid, the state and the pre-action state */
+function inst_props(inst, state, previousState) {
+    return { ...inst.props, children: inst.children, slots: inst.slots, context: inst.context(), uid: inst.uid, state, previousState };
 }
 /**
  * A sink value of an instance: stamped with its sender (EVENTS; object values for a reply-capable
@@ -2195,6 +2210,19 @@ const flat = (v) => {
  * - dispose(): DISPOSE, onDispose, dispose$, the EFFECT signal aborted, the subtree, then the
  *   streams (the scoped _remove swap: no xstream stop timers, D165/Q18).
  */
+// v7: a known binding target joins key/id/path in the lifetime identity. Fresh equivalent
+// byId helpers retain identity; opaque lenses need an explicit key for a new target.
+function bindingChanged(a, b) {
+    if (a === b)
+        return false;
+    const x = a?.[BINDING], y = b?.[BINDING];
+    return x && y ? !x.every((v, i) => Object.is(v, y[i]))
+        : !!(x || y || typeof a == 'string' || typeof b == 'string' || a === undefined || b === undefined);
+}
+function bindingState(k) {
+    const c = k.base || k.cell || k.arr;
+    return c && (c.has?.() ?? c.get() !== undefined) ? (k.cell || k.arr).get() : undefined;
+}
 const ERR_FIX$1 = 'See the attached error';
 // 4-I G-557: a fragment root (a Collection's): each of its top-level elements is marked.
 // 4-K G-572: a text root (no element; an attribute would land on a Text node) gets `ready: false`
@@ -2237,8 +2265,8 @@ const idOf$1 = (n, path) => {
     return `${n.sel}::${(s && s.replace(/"/g, '')) || path}`;
 };
 /**
- * a component vnode's props, without `resetState` (D174: read at creation, like `state`, never a
- * prop of the child)
+ * a component vnode's props, without `resetState` (D174: read at creation, never a
+ * prop of the child). Known `state` target changes start a new lifetime in v7.
  */
 function propsOf(p) {
     if (!p)
@@ -2302,10 +2330,14 @@ const EMPTY_CTX = Object.freeze({});
 /** a view read every key (spread, Object.keys): any context change re-renders it */
 const ALL = '\u0000all';
 let IDS = 0;
-/** a child that failed to instantiate: renders the owner's error fallback (SYG408) */
+/**
+ * a child that failed to instantiate: renders the owner's error fallback (SYG408). It keeps its
+ * props, so only a changed binding target makes another attempt (not every owner render)
+ */
 class Failed {
-    constructor(outv) {
+    constructor(outv, props) {
         this.outv = outv;
+        this.props = props;
         this.lr = true;
         this.ready = true;
         this.def = null;
@@ -2313,7 +2345,7 @@ class Failed {
         this.shown = true;
     }
     render() { return this.outv; }
-    setProps() { }
+    setProps(p) { this.props = p; }
     dispose() { }
 }
 class Inst {
@@ -2321,6 +2353,7 @@ class Inst {
         this.app = app;
         this.def = def;
         this.parent = parent;
+        this.base = base;
         this.dom = dom;
         this.scope = scope;
         this.kind = kind;
@@ -2487,10 +2520,32 @@ class Inst {
     }
     /** called after each action and before each render pass: STATE.stream emits a new state */
     notify() {
-        const v = this.cell.raw();
-        if (v !== this.stLast && v !== undefined) {
-            this.stLast = v;
-            this.st$.shamefullySendNext(v);
+        // A completed action can remove and reinsert a target before the next render. Owners
+        // observe each transition, including hidden pages; the current action finishes first.
+        // only the bound children (a string / byId binding), not every child
+        if (this.bound)
+            for (const k of this.bound) {
+                if (k.disposed) {
+                    this.bound.delete(k);
+                    continue;
+                }
+                const previous = k.bs, state = k.bs = bindingState(k);
+                if (previous !== undefined && state === undefined) {
+                    // Cleanup reads its last owned snapshot. A dying path must not recreate the
+                    // deleted target; the fresh lifetime receives a new writable cell at reconciliation.
+                    const cell = k.cell || k.arr;
+                    cell.get = () => previous;
+                    cell.set = () => { };
+                    k.dispose();
+                    this.forced = true;
+                }
+            }
+        if (this.st$) {
+            const v = this.cell.raw();
+            if (v !== this.stLast && v !== undefined) {
+                this.stLast = v;
+                this.st$.shamefullySendNext(v);
+            }
         }
     }
     dispose$() {
@@ -2739,7 +2794,9 @@ class Inst {
                     for (const r of resolvers)
                         view = r(view, this) || view;
                 let k = this.kids.get(id);
-                if (k && view && k.def && k.def.view !== view) {
+                // Collection and VirtualCollection share an array cell; Switchable binds `state`.
+                const binding = host && sel != 'switchable' ? 'from' : 'state';
+                if (k && (k.disposed || (view && k.def && k.def.view !== view) || bindingChanged(k.props?.[binding], props[binding]))) {
                     k.dispose();
                     this.kids.delete(id);
                     k = undefined;
@@ -2747,7 +2804,12 @@ class Inst {
                 if (k)
                     k.setProps(props, children, n, id);
                 else
-                    this.kids.set(id, host ? this.host(host, props, children, id, n) : this.child(view, props, children, id, !!data.props?.resetState));
+                    this.kids.set(id, k = host ? this.host(host, props, children, id, n) : this.child(view, props, children, id, !!data.props?.resetState));
+                if (typeof props[binding] == 'string' || props[binding]?.[BINDING]) {
+                    k.bs = bindingState(k);
+                    (this.bound || (this.bound = new Set())).add(k);
+                    this.app.watchers.add(this);
+                }
                 return;
             }
             if (posts[sel] && !(ps || (ps = [])).includes(sel))
@@ -2772,11 +2834,11 @@ class Inst {
             return make(this, props, children, id, n);
         }
         catch (err) {
-            return this.failed(err);
+            return this.failed(err, props);
         }
     }
     /** the owner's error fallback for a child that failed to instantiate (SYG408) */
-    failed(err) {
+    failed(err, props) {
         const e = err instanceof Error ? err : new Error(String(err));
         let out = errorDiv$1(this.def.name);
         if (this.def.onError) {
@@ -2788,7 +2850,7 @@ class Inst {
             }
         }
         this.app.caught(this, 'SYG408', 'Sub-component threw; rendering the error fallback', e, 'instantiate');
-        return new Failed(out);
+        return new Failed(out, props);
     }
     /** a tag child: state="key" | state={lens} | none (the parent's state) | isolatedState (D174: `resetState`) */
     child(view, props, children, id, reset = false) {
@@ -2807,7 +2869,7 @@ class Inst {
             return new Inst(app, def, this, cell, this.dom && this.dom.isolateSource(this.dom, scope), props, children, scope, this.uid(uidPart(id.replace(/.*::(r\.)?/, ''))), 'child', reset);
         }
         catch (err) {
-            return this.failed(err);
+            return this.failed(err, props);
         }
     }
     inject(n, path) {
@@ -2870,8 +2932,7 @@ class Inst {
             tearDown(() => { for (const s of subs)
                 s.unsubscribe(); }, app.dq, this);
         this.subs = [];
-        if (this.st$)
-            app.watchers.delete(this);
+        app.watchers.delete(this);
         this.hub = null;
     }
 }
@@ -2970,7 +3031,7 @@ function arrayCell(owner, from) {
     if (typeof from == 'string')
         return keyCell(oc, from, owner.def.calcNames?.has(pathOf$1(from)[0]) && name, undefined, 'Collection');
     if (isObj$2(from) && typeof from.get == 'function') {
-        let lp = {}, lv;
+        let lp = {}, lv, raw;
         return {
             get() {
                 const p = oc.get();
@@ -2986,7 +3047,7 @@ function arrayCell(owner, from) {
                         owner.app.appError(owner, e, 'view');
                         return lv;
                     }
-                    lv = g;
+                    raw = lv = g;
                     if (!Array.isArray(lv)) {
                         warn('SYG401', name, "Collection 'from' getter returned a non-array; it renders nothing", 'Return an array from get()', lv);
                         lv = NONE$1;
@@ -2994,6 +3055,7 @@ function arrayCell(owner, from) {
                 }
                 return lv;
             },
+            has() { this.get(); return raw !== undefined; },
             set(v) {
                 if (typeof from.set != 'function')
                     return;
@@ -5355,8 +5417,11 @@ const validateWith = async (schema, value) => {
  * declarations in src/index.d.ts and docs/guide/drivers.md. Summary:
  *
  * - Request (sink value): `{ url, ok?, error?, key?, category?, method?, headers?, query?, json?,
- *   body?, latest?, timeoutMs?, parse?, init? }` or a URL string. `json` is stringified with a JSON
- *   content-type; method defaults to POST with a body/json, else GET. `query` is appended as a
+ *   multipart?, body?, latest?, timeoutMs?, parse?, init? }` or a URL string. `json` is stringified
+ *   with a JSON content-type; PLAN-11 U-5: `multipart` (an object) becomes a FormData body (a
+ *   File / Blob a file part, an array repeats the name, null / undefined skipped, an object JSON,
+ *   anything else a string), the content-type left to the browser (its boundary); method defaults
+ *   to POST with a body/json/multipart, else GET. `query` is appended as a
  *   query string (null/undefined values skipped, arrays repeat the key, before any #fragment).
  *   Other fetch options (credentials, mode, cache, ...) go under `init` (R4-5); other top-level
  *   keys are the app's own: not sent, but returned on `request`.
@@ -5433,6 +5498,15 @@ const validateWith = async (schema, value) => {
  *   the request itself) into requests sent again in parallel and combined, at most 3 deep. One
  *   failure fails the request once (`error.status` / `error.body`). No cache entry sharing, no
  *   per-part retry. The test fake (`_whole`) sends and answers it as one request. decide() uses it.
+ * - PLAN-11 U-1 (D555): `progress: 'ACTION'` replies to the sender with each progress step,
+ *   `progress: true` (or a string with no sender) sends it down `progress(category?)`:
+ *   `{ phase: 'upload' | 'download', loaded, total, fraction, category, request }` (`total` /
+ *   `fraction` null when the length is unknown). Such a request goes over XMLHttpRequest (the
+ *   only transport with upload progress in every engine; S-1), turned back into a Response so
+ *   parsing, status, retry and timeouts are the same. Steps are throttled to one per 50 ms per
+ *   phase, keeping the first and the last. Not for resources or `batch`; never shares a fetch.
+ *   No XMLHttpRequest (Node, a service worker): plain fetch, no steps. The transport is
+ *   `options.XMLHttpRequest`, else the global one, read at request time.
  * - dispose / sink completion aborts everything in flight.
  * - `fetch` is read at request time (options.fetch, else globalThis.fetch), so test stubs work.
  * - PLAN-3 5-1 (H-9): renderComponent's HTTP fake runs this driver over an in-memory fetch;
@@ -5526,6 +5600,81 @@ const mergeHeaders = (...all) => {
     h.forEach((v, k) => { out[k] = v; });
     return out;
 };
+// PLAN-11 U-1: statuses whose Response must have a null body
+const NULL_BODY = [101, 103, 204, 205, 304];
+const abortError$1 = () => typeof DOMException == 'function'
+    ? new DOMException('The operation was aborted.', 'AbortError')
+    : Object.assign(new Error('The operation was aborted.'), { name: 'AbortError' });
+/**
+ * PLAN-11 U-1 (S-1): a fetch-shaped call over XMLHttpRequest that reports progress:
+ * `on(phase, loaded, total)` (total 0 when unknown), at most every 50 ms per phase, always the
+ * first and the final step. Resolves with a real Response (blob body, parsed headers); network
+ * errors and timeouts reject with a TypeError, an abort with an AbortError, like fetch.
+ */
+const xhrFetch = (X, url, init, on) => new Promise((res, rej) => {
+    const x = new X();
+    const last = {};
+    const step = (phase, loaded, total, final) => {
+        const l = last[phase], now = Date.now();
+        if (l && (l.loaded === loaded || (!final && now - l.at < 50 && !(total && loaded >= total))))
+            return;
+        last[phase] = { loaded, at: now };
+        on(phase, loaded, total);
+    };
+    const ev = (phase) => (e) => step(phase, e.loaded, e.lengthComputable ? e.total : 0);
+    x.open(init.method || 'GET', url);
+    x.responseType = 'blob';
+    const h = init.headers || {};
+    Object.keys(h).forEach(k => x.setRequestHeader(k, h[k]));
+    if (init.credentials == 'include')
+        x.withCredentials = true;
+    const sig = init.signal;
+    if (sig) {
+        if (sig.aborted)
+            return rej(abortError$1());
+        sig.addEventListener?.('abort', () => x.abort(), { once: true });
+    }
+    if (init.body != null && x.upload) {
+        x.upload.onprogress = ev('upload');
+        x.upload.onload = (e) => step('upload', e.loaded, e.lengthComputable ? e.total : e.loaded, 1);
+    }
+    x.onprogress = ev('download');
+    x.onload = () => {
+        const size = x.response?.size ?? last.download?.loaded ?? 0;
+        step('download', size, size, 1);
+        const headers = typeof Headers == 'function' ? new Headers() : undefined;
+        String(x.getAllResponseHeaders?.() || '').trim().split(/[\r\n]+/).forEach((line) => {
+            const i = line.indexOf(':');
+            if (i > 0)
+                try {
+                    headers?.append(line.slice(0, i).trim(), line.slice(i + 1).trim());
+                }
+                catch (_) { }
+        });
+        try {
+            res(new Response(NULL_BODY.includes(x.status) ? null : x.response, { status: x.status, statusText: x.statusText, headers }));
+        }
+        catch (e) {
+            rej(e);
+        }
+    };
+    x.onerror = x.ontimeout = () => rej(new TypeError(`Network request failed: ${url}`));
+    x.onabort = () => rej(abortError$1());
+    x.send(init.body ?? null);
+});
+/** PLAN-11 U-5: a request's `multipart` object as FormData (see the header) */
+const toFormData = (parts) => {
+    const fd = new FormData();
+    Object.keys(parts || {}).forEach(k => [].concat(parts[k]).forEach((v) => {
+        if (v == null)
+            return;
+        if (typeof Blob != 'undefined' && v instanceof Blob)
+            fd.append(k, v, v.name ?? 'blob');
+        else
+            fd.append(k, typeof v == 'object' ? JSON.stringify(v) : String(v));
+    }));
+    return fd;
+};
 const IDEMPOTENT$1 = /^(GET|HEAD)$/i;
 // D80: an invalidate value matches a request by tag, URL prefix ('/…') or predicate
 const hit = (x, q) => {
@@ -5550,6 +5699,22 @@ function makeFetchDriver(options = {}) {
         // q (the request), timer, f (the fetch it waits on), ok / ko (its outcomes) }
         const inflight = new Map();
         const subs = new Set();
+        // PLAN-11 U-1: progress(category?) listeners (not held while nobody listens)
+        const psubs = new Set();
+        const emitProgress = (v) => psubs.forEach(s => {
+            let m = false;
+            try {
+                m = matches(s, v);
+            }
+            catch (_) { }
+            if (m)
+                try {
+                    s.l.next(v);
+                }
+                catch (e) {
+                    console.error('[Sygnal] makeFetchDriver: a listener threw', e);
+                }
+        });
         // R4-4: replies held until the first select() listener, failures until the first errors()
         // listener (or the next macrotask, when they're logged if nothing listens)
         const started = [false, false];
@@ -5612,6 +5777,10 @@ function makeFetchDriver(options = {}) {
             return {
                 select: make(false),
                 errors: make(true),
+                progress: (sel) => {
+                    let sub;
+                    return xs$2.create({ start: l => { psubs.add((sub = { l, sel, ns })); }, stop: () => { psubs.delete(sub); } });
+                },
                 isolateSource: (_, scope) => source(ns.concat(scope)),
                 isolateSink: (sink$, scope) => sink$.map((req) => tagRequest(req, scope)),
                 // PLAN-4.6: the same per value (the core scopes a request without a stream per instance)
@@ -5731,7 +5900,7 @@ function makeFetchDriver(options = {}) {
                 req = { url: req };
             if (!req || typeof req != 'object' || disposed || !allowed$1(req, 'makeFetchDriver'))
                 return;
-            const { url, category, method, headers, query, json, body, latest, timeoutMs, parse, abort, init, ok, error, key, resources, refresh, invalidates, updates, retry, validate, prefetch } = req;
+            const { url, category, method, headers, query, json, body, latest, timeoutMs, parse, abort, init, ok, error, key, resources, refresh, invalidates, updates, retry, validate, prefetch, progress } = req;
             if ('invalidate' in req)
                 return inval(req.invalidate);
             if (prefetch)
@@ -5783,7 +5952,9 @@ function makeFetchDriver(options = {}) {
             }
             const scope = scopeKey(req);
             // reply actions: keyed per (sender, key ?? ok ?? error); a resource per (sender, '\0' + name)
-            const rk = rn !== undefined ? '\0' + rn : !pf && sender !== undefined && (ok || error) ? key ?? ok ?? error : undefined;
+            // PLAN-11 U-1: a progress action is a reply action too (abort on dispose, its own lane)
+            const pr = !pf && rn === undefined && !req.batch && progress;
+            const rk = rn !== undefined ? '\0' + rn : !pf && sender !== undefined && (ok || error || typeof pr == 'string') ? key ?? ok ?? error ?? pr : undefined;
             if (sender !== undefined && (typeof abort == 'string' || (abort && key !== undefined)))
                 return cancel(r => r.sender === sender && r.rk === (key ?? abort));
             // per (scope, category): another component's requests are never cancelled
@@ -5793,7 +5964,7 @@ function makeFetchDriver(options = {}) {
                 cancel(rk === undefined ? r => r.rk === undefined && r.scope === scope && r.category === category : r => r.sender === sender && r.rk === rk);
             const base = options.init;
             // a request's URL and fetch() init (the batch's sub-requests inherit the request's fields)
-            const prep = ({ url, method, headers, query, json, body, init: own }) => {
+            const prep = ({ url, method, headers, query, json, multipart, body, init: own }) => {
                 const h = mergeHeaders(options.headers, base?.headers, own?.headers, headers);
                 let b = body ?? own?.body;
                 if (json !== undefined) {
@@ -5801,6 +5972,12 @@ function makeFetchDriver(options = {}) {
                     if (!Object.keys(h).some(k => k.toLowerCase() == 'content-type'))
                         h['content-type'] = 'application/json';
                 }
+                else if (multipart !== undefined) {
+                    b = toFormData(multipart);
+                    // the browser writes multipart/form-data with its boundary; a content-type set here would break it
+                    Object.keys(h).forEach(k => { if (k.toLowerCase() == 'content-type')
+                        delete h[k]; });
+                }
                 return [withQuery((options.baseUrl || '') + (url ?? ''), query), { ...pickInit(base), ...pickInit(own), method: method || own?.method || base?.method || (b !== undefined ? 'POST' : 'GET'), headers: h, body: b }];
             };
             const [href, fetchInit] = prep(req);
@@ -5809,7 +5986,8 @@ function makeFetchDriver(options = {}) {
             // parts, at most 3 deep), their parsed bodies merged by `combine` into one reply. The test
             // fake (_whole) answers such a request as one
             const { batch, split, combine = (x) => x } = options._whole ? {} : req;
-            const k = C?.key(req, rn !== undefined || pf);
+            // PLAN-11 U-1: a progress request never shares a fetch (each sender gets its own steps)
+            const k = pr ? undefined : C?.key(req, rn !== undefined || pf);
             const id = ++seq;
             const r = { category, scope, sender, rk };
             inflight.set(id, r);
@@ -5857,7 +6035,19 @@ function makeFetchDriver(options = {}) {
                 const parser = parserOf(parse || options.parse);
                 // the global fetch is called as a method: a detached window.fetch throws "Illegal invocation"
                 const g = globalThis;
-                const doFetch = options.fetch || (typeof g.fetch == 'function' && ((u, i) => g.fetch(u, i)));
+                let doFetch = options.fetch || (typeof g.fetch == 'function' && ((u, i) => g.fetch(u, i)));
+                // PLAN-11 U-1: a progress request over XMLHttpRequest (renderComponent's fake: `_progress`)
+                const X = options.XMLHttpRequest ?? g.XMLHttpRequest;
+                if (pr && (options._progress || typeof X == 'function')) {
+                    const step = (phase, loaded, total) => {
+                        if (!inflight.has(id) || disposed)
+                            return;
+                        const t = total > 0 ? total : null;
+                        const v = { phase, loaded, total: t, fraction: t ? Math.min(1, loaded / t) : null, category, request: req };
+                        typeof pr == 'string' && sender !== undefined ? reply(sender, pr, v) : emitProgress(v);
+                    };
+                    doFetch = options._progress ? (u, i) => options._progress(u, i, step, req) : (u, i) => xhrFetch(X, u, i, step);
+                }
                 // the outcome, to every request waiting on this fetch (the failure once, after the last attempt)
                 const end = (e, x, status) => {
                     done(F);
@@ -6019,9 +6209,10 @@ function queryCache(o = {}) {
     const key = (q, res) => {
         if (typeof q == 'string')
             q = { url: q };
-        const { method, json, body, parse, query } = q;
-        const m = (method || (json !== undefined || body !== undefined ? 'POST' : 'GET')).toUpperCase();
-        const b = json !== undefined ? JSON.stringify(json) : body ?? '';
+        const { method, json, body, parse, query, multipart } = q;
+        const m = (method || (json !== undefined || body !== undefined || multipart !== undefined ? 'POST' : 'GET')).toUpperCase();
+        // PLAN-11 U-5: a multipart request is never cached (its body isn't a string)
+        const b = json !== undefined ? JSON.stringify(json) : multipart !== undefined ? multipart : body ?? '';
         if (q.cache === false || typeof b != 'string' || typeof parse == 'function' || parse == 'response' ||
             !(q.cache || q.staleTime != null || (res && IDEMPOTENT.test(m))))
             return;
@@ -6090,6 +6281,272 @@ function queryCache(o = {}) {
     return C;
 }
 
+/*
+ * PLAN-6 L-2: what the HTTP transports share (side-effect free; each transport imports only what
+ * it uses).
+ * - post(): the fetch (the `fetch` option, 0-S5), the headers option (an object or a function of
+ *   the request), HTTP errors as Errors with `status` and the provider's message, and SYG670.
+ * - sse(): a fetch Response body as SSE frames ({ event, data }), per the HTML spec's parsing
+ *   rules: CRLF / LF, comments, multi-line data. The reader is cancelled when the consumer stops
+ *   (abort, a thrown error), so the connection closes.
+ * - SYG670: in a browser, a request with an auth header (Authorization, x-api-key, api-key,
+ *   x-goog-api-key) to a host that is neither local (localhost, 127.0.0.1, [::1], *.localhost)
+ *   nor the page's own origin is refused unless the transport has `dangerouslyAllowBrowser: true`:
+ *   the key would ship to every visitor. Same-origin requests are the app's own server (its
+ *   proxy), so a session header there is fine.
+ */
+const g$6 = globalThis;
+const AUTH = /^(authorization|x-api-key|api-key|x-goog-api-key)$/i;
+const LOCAL = /^(localhost|127\.0\.0\.1|\[::1\]|.+\.localhost)$/;
+/** the URL a transport posts to, or a SYG670 Error when it must not (see the header) */
+function guard(url, headers, opts, name) {
+    if (opts.dangerouslyAllowBrowser || typeof g$6.document == 'undefined' || !Object.keys(headers).some(h => AUTH.test(h)))
+        return;
+    const here = g$6.location?.href;
+    let u;
+    try {
+        u = new URL(url, here);
+    }
+    catch (_) {
+        return;
+    }
+    if (LOCAL.test(u.hostname) || (here && u.origin == new URL(here).origin))
+        return;
+    const fix = `Call ${u.origin} from your server and point the transport at that route (an AI SDK route with uiMessageStream('/api/chat'), or your own proxy), so the key stays there. For a key the user typed in themselves, pass ${name}({ ..., dangerouslyAllowBrowser: true })`;
+    const msg = `${name}: refused to send an auth header from the browser to ${u.origin}: anyone who opens the page can read it`;
+    error('SYG670', undefined, msg, fix);
+    fail$2('SYG670', undefined, msg, fix);
+}
+/**
+ * POST JSON; a non-2xx response is an Error with `status`, `body` and the provider's message.
+ * The transport's `body` option and the request's `body` are merged over the built body (so they
+ * can override provider defaults such as `max_tokens`); `fixed` fields are merged last and can't be
+ * overridden (G-654: uiMessageStream's protocol fields, as the AI SDK's DefaultChatTransport)
+ */
+async function post$1(url, body, req, signal, opts, name, fixed) {
+    const h = typeof opts.headers == 'function' ? await opts.headers(req) : opts.headers || {};
+    guard(url, h, opts, name);
+    const f = opts.fetch || ((u, i) => g$6.fetch(u, i));
+    const res = await f(url, { method: 'POST', headers: { 'content-type': 'application/json', ...h }, body: JSON.stringify({ ...body, ...opts.body, ...req.body, ...fixed }), signal });
+    if (!res.ok) {
+        let text = '', message = '';
+        try {
+            text = await res.text();
+            const j = JSON.parse(text);
+            message = j.error?.message ?? j.error ?? j.message ?? '';
+        }
+        catch (_) {
+            message || (message = text.slice(0, 200));
+        }
+        throw Object.assign(new Error(`${name}: HTTP ${res.status}${message ? ': ' + message : ''}`), { status: res.status, body: text });
+    }
+    if (!res.body)
+        throw new Error(`${name}: the response has no body`);
+    return res;
+}
+/**
+ * the SSE frames of a response body: `{ event, data }` (data: the joined data lines). PLAN-11
+ * E-1: `meta` (optional) follows the stream's `id` (the last event id, kept across frames) and
+ * `retry` (ms) fields, as EventSource does, for a reconnect
+ */
+async function* sse(res, meta) {
+    const reader = res.body.getReader(), dec = new TextDecoder();
+    let buf = '', cr = '', done = false;
+    try {
+        for (;;) {
+            const r = await reader.read();
+            // line ends -> \n (a \r at a chunk's end waits: it may be half of a \r\n)
+            let s = cr + (r.done ? '\n\n' : dec.decode(r.value, { stream: true }));
+            cr = !r.done && s.endsWith('\r') ? '\r' : '';
+            if (cr)
+                s = s.slice(0, -1);
+            buf += s.replace(/\r\n?/g, '\n');
+            done = r.done;
+            let i;
+            while ((i = buf.indexOf('\n\n')) >= 0) {
+                const frame = buf.slice(0, i);
+                buf = buf.slice(i + 2);
+                let event = 'message', data = [];
+                for (const line of frame.split('\n')) {
+                    if (!line || line[0] == ':')
+                        continue;
+                    const c = line.indexOf(':'), field = c < 0 ? line : line.slice(0, c);
+                    const v = c < 0 ? '' : line.slice(c + 1).replace(/^ /, '');
+                    if (field == 'event')
+                        event = v;
+                    else if (field == 'data')
+                        data.push(v);
+                    else if (meta && field == 'id' && !v.includes('\0'))
+                        meta.id = v;
+                    else if (meta && field == 'retry' && /^\d+$/.test(v))
+                        meta.retry = +v;
+                }
+                if (data.length)
+                    yield { event, data: data.join('\n') };
+            }
+            if (done)
+                return;
+        }
+    }
+    finally {
+        if (!done)
+            reader.cancel().catch(() => { });
+    }
+}
+/** JSON.parse, or the text itself when it isn't JSON (a model's malformed tool arguments go to validation as is) */
+const json$1 = (s) => {
+    if (typeof s != 'string')
+        return s;
+    try {
+        return JSON.parse(s || '{}');
+    }
+    catch (_) {
+        return s;
+    }
+};
+/** a provider's usage as `{ inputTokens, outputTokens, totalTokens, reasoningTokens? }` (AI SDK names) */
+const usageOf = (u) => u && {
+    inputTokens: u.input_tokens ?? u.prompt_tokens,
+    outputTokens: u.output_tokens ?? u.completion_tokens,
+    totalTokens: u.total_tokens,
+    ...((u.output_tokens_details ?? u.completion_tokens_details)?.reasoning_tokens != null && { reasoningTokens: (u.output_tokens_details ?? u.completion_tokens_details).reasoning_tokens }),
+};
+/** the parts of a message (a `content` string is one text part) */
+const partsOf = (m) => m.parts ?? (typeof m.content == 'string' ? [{ type: 'text', text: m.content }] : []);
+/** the tool name of a `tool-<name>` / `dynamic-tool` part, or '' */
+const toolName = (p) => p.type == 'dynamic-tool' ? p.toolName : p.type.startsWith('tool-') ? p.type.slice(5) : '';
+/** what a tool part sends back to the model, or undefined when it has no result yet */
+const toolOutput = (p) => p.state == 'output-available' ? (typeof p.output == 'string' ? p.output : JSON.stringify(p.output ?? null))
+    : p.state == 'output-error' ? JSON.stringify({ error: p.errorText ?? 'error' })
+        : p.state == 'output-denied' ? JSON.stringify({ error: 'The user denied this tool call' })
+            : undefined;
+// dev-only diagnostics (SYG675): the dev entry formats them (checks/chat.ts)
+const dev$8 = (...a) => g$6.__SYGNAL_DIAGNOSTICS__?.chat?.(...a);
+
+/*
+ * PLAN-11 E-1: an EventSource over fetch, for server-sent events that need request headers
+ * (`Authorization`), which the native EventSource can't send. makeSocketDriver uses it for an
+ * `sse` connection with `headers`. It behaves as EventSource does where the driver relies on it:
+ *
+ * - connects on construction (a microtask later, so handlers can be set first); `readyState`
+ *   CONNECTING (0) → OPEN (1) on a 2xx `text/event-stream` response;
+ * - `onmessage` and `addEventListener(type)` get `{ type, data, lastEventId }`;
+ * - the stream ending or a network error: `error`, readyState CONNECTING, a reconnect after
+ *   `retry` ms (the stream's `retry:` field, default 3000) with `Last-Event-ID`;
+ * - a non-2xx status or another content type: `error` with readyState CLOSED (no retry; the
+ *   driver's reconnect policy decides);
+ * - `close()` aborts the request and stops retrying.
+ */
+const NAMES = ['CONNECTING', 'OPEN', 'CLOSED'];
+class FetchEventSource {
+    constructor(url, init = {}) {
+        this.readyState = 0;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.ls = new Map();
+        this.meta = { id: '', retry: 3000 };
+        this.url = url;
+        this.withCredentials = !!init.withCredentials;
+        this.init = init;
+        queueMicrotask(() => this.connect());
+    }
+    addEventListener(type, f) {
+        let s = this.ls.get(type);
+        if (!s)
+            this.ls.set(type, (s = new Set()));
+        s.add(f);
+    }
+    removeEventListener(type, f) { this.ls.get(type)?.delete(f); }
+    close() {
+        this.readyState = 2;
+        clearTimeout(this.timer);
+        try {
+            this.ctl?.abort();
+        }
+        catch (_) { }
+    }
+    emit(type, ev) {
+        if (type == 'message')
+            this.onmessage?.(ev);
+        else if (type == 'open')
+            this.onopen?.(ev);
+        else if (type == 'error')
+            this.onerror?.(ev);
+        this.ls.get(type)?.forEach(f => { try {
+            f(ev);
+        }
+        catch (e) {
+            console.error(e);
+        } });
+    }
+    async connect() {
+        if (this.readyState == 2)
+            return;
+        const g = globalThis;
+        const f = this.init.fetch || (typeof g.fetch == 'function' && ((u, i) => g.fetch(u, i)));
+        if (typeof f != 'function')
+            return this.fail(new Error('fetch is not available in this environment'));
+        const ctl = this.ctl = typeof AbortController == 'function' ? new AbortController() : {};
+        const headers = { accept: 'text/event-stream', ...this.init.headers };
+        if (this.meta.id)
+            headers['last-event-id'] = this.meta.id;
+        let res;
+        try {
+            res = await f(this.url, { headers, credentials: this.withCredentials ? 'include' : 'same-origin', cache: 'no-store', signal: ctl.signal });
+        }
+        catch (error) {
+            return this.retry(error);
+        }
+        if (this.readyState == 2 || this.ctl !== ctl)
+            return;
+        const type = res.headers?.get?.('content-type') || '';
+        if (!(res.status >= 200 && res.status < 300) || !/^text\/event-stream/i.test(type) || !res.body) {
+            try {
+                res.body?.cancel?.();
+            }
+            catch (_) { }
+            return this.fail(Object.assign(new Error(`SSE ${res.status}${type ? ' ' + type : ''}: ${this.url}`), { status: res.status }));
+        }
+        this.readyState = 1;
+        this.emit('open', { type: 'open' });
+        try {
+            for await (const fr of sse(res, this.meta)) {
+                if (this.readyState == 2 || this.ctl !== ctl)
+                    return;
+                this.emit(fr.event, { type: fr.event, data: fr.data, lastEventId: this.meta.id });
+            }
+        }
+        catch (error) {
+            if (this.readyState == 2 || this.ctl !== ctl)
+                return;
+            return this.retry(error);
+        }
+        if (this.readyState != 2 && this.ctl === ctl)
+            this.retry();
+    }
+    /** a drop: error, CONNECTING, try again after `retry` ms (unless the error handler closed it) */
+    retry(error) {
+        if (this.readyState == 2)
+            return;
+        this.readyState = 0;
+        this.emit('error', { type: 'error', error });
+        if (this.readyState == 2)
+            return;
+        this.timer = setTimeout(() => this.connect(), this.meta.retry);
+    }
+    /** a failed connection: error, CLOSED */
+    fail(error) {
+        this.readyState = 2;
+        this.emit('error', { type: 'error', error });
+    }
+    /** the state's name (debugging) */
+    get state() { return NAMES[this.readyState]; }
+}
+FetchEventSource.CONNECTING = 0;
+FetchEventSource.OPEN = 1;
+FetchEventSource.CLOSED = 2;
+
 /*
  * makeSocketDriver(options?) (PLAN-3 §1.3): WebSocket and server-sent events, declared per
  * component instance and answered with reply actions (./replies.ts). Docs on the declarations
@@ -6098,7 +6555,7 @@ function queryCache(o = {}) {
  * - Sink values:
  *   - `{ connections: { [name]: spec | falsy } }`: the sender's whole set of connections. Diffed
  *     per (sender, name): a new name opens, a removed or falsy one closes, a changed URL /
- *     protocols / withCredentials / share closes and reopens, anything else (action names,
+ *     protocols / withCredentials / headers / share closes and reopens, anything else (action names,
  *     reconnect) only rebinds.
  *   - `{ to: name, json? | text? | binary? }`: send on the sender's connection `name` (json is
  *     stringified). Queued while (re)connecting, bounded (`queueLimit`, oldest dropped). A send
@@ -6123,6 +6580,10 @@ function queryCache(o = {}) {
  * - A disposed sender's connections close (and their retries stop); app dispose closes all.
  * - No WebSocket / EventSource (SSR): nothing opens, nothing is reported.
  * - `WebSocket` / `EventSource` are read at connect time: options.WebSocket ?? globalThis.WebSocket.
+ * - PLAN-11 E-1: an `sse` connection with `headers` (data: a token in it comes from state, and a
+ *   changed header reconnects) is read with FetchEventSource (fetch, `options.fetch` if given),
+ *   since EventSource can't send headers. An `options.EventSource` (a polyfill, the test fake)
+ *   still wins and gets the headers in its init.
  */
 const SCOPE$1 = '__sygnalScope';
 const scopeOf = (v) => v[SCOPE$1] || [];
@@ -6222,12 +6683,13 @@ function makeSocketDriver(options = {}) {
         };
         const connect = (t) => {
             t.timer = 0;
-            const C = t.sse ? options.EventSource ?? g.EventSource : options.WebSocket ?? g.WebSocket;
+            const hdr = t.sse && t.spec.headers && typeof t.spec.headers == 'object' ? t.spec.headers : undefined;
+            const C = t.sse ? options.EventSource ?? (hdr && typeof g.fetch == 'function' ? FetchEventSource : g.EventSource) : options.WebSocket ?? g.WebSocket;
             if (typeof C != 'function')
                 return;
             let s;
             try {
-                s = t.sse ? new C(t.url, { withCredentials: !!t.spec.withCredentials }) : new C(t.url, t.spec.protocols);
+                s = t.sse ? new C(t.url, { withCredentials: !!t.spec.withCredentials, ...(hdr && { headers: hdr, fetch: options.fetch }) }) : new C(t.url, t.spec.protocols);
             }
             catch (error) {
                 // a URL the constructor rejects never opens: no retry
@@ -6331,7 +6793,7 @@ function makeSocketDriver(options = {}) {
                 const sse = typeof spec.sse == 'string';
                 const url = resolve(sse ? spec.sse : spec.socket, sse);
                 // the connection's identity: a change reconnects, anything else only rebinds
-                const key = (spec.share === false ? 'u' : '') + (sse ? 'e' + !!spec.withCredentials : 's' + JSON.stringify(spec.protocols)) + url;
+                const key = (spec.share === false ? 'u' : '') + (sse ? 'e' + !!spec.withCredentials + (spec.headers ? JSON.stringify(spec.headers) : '') : 's' + JSON.stringify(spec.protocols)) + url;
                 if (old && old.key === key) {
                     old.spec = spec;
                     if (old.t)
@@ -6408,7 +6870,7 @@ const dec = (s) => { try {
 catch (_) {
     return s;
 } };
-const g$6 = globalThis;
+const g$5 = globalThis;
 const PARAM$1 = /:(\w+)/g;
 // G-571: synchronous navigations (redirects) before a microtask, after which each waits a task
 const HOPS = 32;
@@ -6416,7 +6878,7 @@ const HOPS = 32;
 const paramsOf$2 = (pat) => (pat.match(PARAM$1) || []).map(p => p.slice(1));
 // the core's coded error() (published on the diagnostics bridge): no import, so the router
 // costs nothing more standalone; prints in production too (like SYG611)
-const bad$1 = (v, msg, fix) => (g$6.__SYGNAL_DIAGNOSTICS__?.error || console.error)('SYG620', v.__emitterName, `router: ${msg}; not navigated`, fix, v);
+const bad$1 = (v, msg, fix) => (g$5.__SYGNAL_DIAGNOSTICS__?.error || console.error)('SYG620', v.__emitterName, `router: ${msg}; not navigated`, fix, v);
 function makeRouter(options = {}) {
     const { mode, prefetch, navigate } = options, routes = options.routes || {};
     const base = (options.base || '').replace(/\/$/, '');
@@ -6425,7 +6887,7 @@ function makeRouter(options = {}) {
     const doScroll = options.scroll ?? !navigate;
     const href = (name, params = {}, query, hash) => {
         // dev entry only (SYG130: unknown name, missing or extra params)
-        g$6.__SYGNAL_DIAGNOSTICS__?.routerHref?.(routes, name, params);
+        g$5.__SYGNAL_DIAGNOSTICS__?.routerHref?.(routes, name, params);
         const pat = routes[name];
         const path = pat == null || pat == '*' ? '/' : pat.replace(PARAM$1, (_, k) => enc(params[k] ?? ''));
         const q = query && new URLSearchParams(Object.entries(query).filter(([, v]) => v != null)) + '';
@@ -6535,7 +6997,7 @@ function makeRouter(options = {}) {
             if (!hops++)
                 queueMicrotask(() => { hops = 0; });
             if (hops > HOPS) {
-                if (g$6.__SYGNAL_DIAGNOSTICS__?.hooks?.on?.() && !warned++)
+                if (g$5.__SYGNAL_DIAGNOSTICS__?.hooks?.on?.() && !warned++)
                     console.warn(`[Sygnal] router: more than ${HOPS} navigations in one flush (a redirect loop?); each next one waits a task (reported once)`, r.path);
                 setTimeout(send);
             }
@@ -8077,7 +8539,7 @@ function makeHeadDriver(options = {}) {
  * - An invalid spec (non-positive `every`, negative `after`, no action) doesn't start; the dev
  *   entry reports SYG422 through the `timerSpec` diagnostics hook.
  */
-const g$5 = globalThis;
+const g$4 = globalThis;
 const now$1 = () => Date.now();
 const valid = (s) => s.frame
     ? typeof s.frame == 'string'
@@ -8087,7 +8549,7 @@ const valid = (s) => s.frame
 // changes) the timer clears the pending one.
 const start$1 = (s, send, e) => {
     let id, n = 0, last;
-    const t0 = now$1(), every = s.every, raf = s.frame && g$5.requestAnimationFrame;
+    const t0 = now$1(), every = s.every, raf = s.frame && g$4.requestAnimationFrame;
     const later = (ms) => id = raf ? requestAnimationFrame(tick) : setTimeout(tick, ms);
     // a frame's `ts` is requestAnimationFrame's timestamp (the fallback passes none: the clock)
     const tick = (ts = now$1()) => {
@@ -8132,7 +8594,7 @@ const timerDriver = (runners) => (sink$) => {
             if (e.ok = valid(s))
                 e.x = start$1(s, (type, data) => reply(id, type, data), e);
             else
-                g$5.__SYGNAL_DIAGNOSTICS__?.timerSpec?.(n, s, c);
+                g$4.__SYGNAL_DIAGNOSTICS__?.timerSpec?.(n, s, c);
         }
         if (!d)
             runners.delete(id);
@@ -8190,10 +8652,10 @@ const makeTimerDriver = () => timerDriver(new Map());
  *   an intersection / resize declaration with nothing to observe (no DOM source bound). A
  *   component declaring `browser` with no driver is SYG643, as timers.
  */
-const g$4 = globalThis;
+const g$3 = globalThis;
 const noop = () => { };
 const KINDS = ['intersection', 'resize', 'media', 'storage', 'visibility', 'online', 'geolocation'];
-const diag = (...a) => g$4.__SYGNAL_DIAGNOSTICS__?.browserSource?.(...a);
+const diag = (...a) => g$3.__SYGNAL_DIAGNOSTICS__?.browserSource?.(...a);
 // the driver names in use (the definition hook looks each up in a declaring instance's sources)
 const names$1 = new Set();
 let hooked;
@@ -8279,16 +8741,16 @@ const track = (c, kind, target, Obs, opts, data) => {
 };
 /** Element visibility: `{ intersection: '.cover' | true, action, threshold?, rootMargin? }`, data `{ visible, ratio, index, dataset }` */
 const intersectionSource = { d: {
-        intersection: (s, c) => track(c, 'i', s.intersection, g$4.IntersectionObserver, { threshold: s.threshold, rootMargin: s.rootMargin }, (e) => ({ visible: e.isIntersecting, ratio: e.intersectionRatio })),
+        intersection: (s, c) => track(c, 'i', s.intersection, g$3.IntersectionObserver, { threshold: s.threshold, rootMargin: s.rootMargin }, (e) => ({ visible: e.isIntersecting, ratio: e.intersectionRatio })),
     } };
 /** Element size: `{ resize: '.chart' | true, action }`, data `{ width, height, index, dataset }` (the content box) */
 const resizeSource = { d: {
-        resize: (s, c) => track(c, 'r', s.resize, g$4.ResizeObserver, undefined, (e) => ({ width: e.contentRect.width, height: e.contentRect.height })),
+        resize: (s, c) => track(c, 'r', s.resize, g$3.ResizeObserver, undefined, (e) => ({ width: e.contentRect.width, height: e.contentRect.height })),
     } };
 /** A media query: `{ media: '(prefers-color-scheme: dark)', action }`, data `{ matches, media }` */
 const mediaSource = { d: {
         media: (s, c) => {
-            const m = g$4.matchMedia?.(s.media);
+            const m = g$3.matchMedia?.(s.media);
             if (!m)
                 return;
             const f = () => c.send({ matches: m.matches, media: s.media });
@@ -8297,7 +8759,7 @@ const mediaSource = { d: {
             return () => m.removeEventListener('change', f);
         },
     } };
-const area = (s) => g$4[s.area == 'session' ? 'sessionStorage' : 'localStorage'];
+const area = (s) => g$3[s.area == 'session' ? 'sessionStorage' : 'localStorage'];
 const failed$1 = (e) => ({ name: e?.name, message: e?.message });
 /**
  * A storage key (read and observed, other tabs' writes included): `{ storage: 'theme', action,
@@ -8326,8 +8788,8 @@ const storageSource = {
             };
             f();
             watching.add(f);
-            g$4.addEventListener?.('storage', f);
-            return () => { watching.delete(f); g$4.removeEventListener?.('storage', f); };
+            g$3.addEventListener?.('storage', f);
+            return () => { watching.delete(f); g$3.removeEventListener?.('storage', f); };
         } },
     c: (() => {
         const write = (v, value, ok, fail) => {
@@ -8354,7 +8816,7 @@ const storageSource = {
 /** The document's visibility: `{ visibility: true, action }`, data `{ visible }` */
 const visibilitySource = { d: {
         visibility: (_, c) => {
-            const d = g$4.document;
+            const d = g$3.document;
             if (!d)
                 return;
             const f = () => c.send({ visible: d.visibilityState != 'hidden' });
@@ -8366,13 +8828,13 @@ const visibilitySource = { d: {
 /** The network: `{ online: true, action }`, data `{ online }` */
 const onlineSource = { d: {
         online: (_, c) => {
-            if (!g$4.navigator || !g$4.addEventListener)
+            if (!g$3.navigator || !g$3.addEventListener)
                 return;
-            const f = () => c.send({ online: g$4.navigator.onLine });
+            const f = () => c.send({ online: g$3.navigator.onLine });
             f();
-            g$4.addEventListener('online', f);
-            g$4.addEventListener('offline', f);
-            return () => { g$4.removeEventListener('online', f); g$4.removeEventListener('offline', f); };
+            g$3.addEventListener('online', f);
+            g$3.addEventListener('offline', f);
+            return () => { g$3.removeEventListener('online', f); g$3.removeEventListener('offline', f); };
         },
     } };
 /**
@@ -8382,7 +8844,7 @@ const onlineSource = { d: {
  */
 const geolocationSource = { d: {
         geolocation: (s, c) => {
-            const geo = g$4.navigator?.geolocation;
+            const geo = g$3.navigator?.geolocation;
             if (!geo)
                 return c.fail({ code: 2, message: 'Geolocation is not available' });
             const id = geo.watchPosition((p) => {
@@ -8398,11 +8860,11 @@ const geolocationSource = { d: {
  */
 const clipboardSource = { c: {
         copy: (v, ok, fail) => {
-            const text = '' + v.copy, cb = g$4.navigator?.clipboard;
+            const text = '' + v.copy, cb = g$3.navigator?.clipboard;
             cb ? cb.writeText(text).then(() => ok({ text }), (e) => fail(failed$1(e))) : fail({ name: 'NotSupportedError', message: 'Clipboard is not available' });
         },
         paste: (_, ok, fail) => {
-            const cb = g$4.navigator?.clipboard;
+            const cb = g$3.navigator?.clipboard;
             cb ? cb.readText().then((text) => ok({ text }), (e) => fail(failed$1(e))) : fail({ name: 'NotSupportedError', message: 'Clipboard is not available' });
         },
     } };
@@ -9107,6 +9569,9 @@ class App {
     }
     /** STATE.stream: the instances whose state changed emit it */
     notify() {
+        if (this.nv === this.ver)
+            return;
+        this.nv = this.ver;
         for (const i of this.watchers)
             i.notify();
     }
@@ -9234,7 +9699,7 @@ class App {
                 this.ran = false;
                 this.last = v;
                 this.hooks.onPatch?.(v);
-                this.vdomL?.next(v);
+                this.vdomL?.next(v ?? null);
             }
             if (this.dq.length)
                 this.stopLater();
@@ -9923,7 +10388,7 @@ const W$1 = '__sw';
 const HOST = /^(id|class(Name)?|style|title|name|placeholder|role|tab[iI]ndex|hidden|lang|dir|attrs)$|^(aria|data)-/;
 /** the dev entry's reporter (checks/widgets.ts); returns the diagnostic when one was reported
  * (r: G-580, a 661 the widget reported through error(e), not a throwing update) */
-const dev$8 = (code, w, o, x, r) => globalThis.__SYGNAL_DIAGNOSTICS__?.widget?.(code, w, o, x, r);
+const dev$7 = (code, w, o, x, r) => globalThis.__SYGNAL_DIAGNOSTICS__?.widget?.(code, w, o, x, r);
 let ids$1 = 0;
 // shallow; G-362: an object host prop (style, attrs, a class map) compares one level deep, so a
 // new object with the same entries is no change (snabbdom patches the host from it anyway)
@@ -9936,16 +10401,16 @@ const same$2 = (a, b, d) => {
 // reported through error(e)
 function fail$1(o, w, k, code, e, r) {
     e = e instanceof Error ? e : Error(e);
-    dev$8(code, w, o, e, r) || console.error(`[Sygnal SYG${code}]`, e);
+    dev$7(code, w, o, e, r) || console.error(`[Sygnal SYG${code}]`, e);
     o.app.appError(o, e, 'widget');
     if (code < 662 && !o.disposed)
         (o.$wf || (o.$wf = new Map())).set(k, [e]), o.refresh();
 }
 function mount(v) {
     const el = v.elm, { ww: w, wp: p, wo: o } = v.data;
-    const d = (n, detail) => { dev$8(140, w, o, n); el.dispatchEvent(new CustomEvent(n, { detail, bubbles: true })); };
+    const d = (n, detail) => { dev$7(140, w, o, n); el.dispatchEvent(new CustomEvent(n, { detail, bubbles: true })); };
     let i;
-    dev$8(144, w, o, el);
+    dev$7(144, w, o, el);
     // G-409: mount's fourth parameter reports a later failure (an adapter's own redraw): SYG661,
     // the owner's onError fallback in this instance's place, as for a throwing update (G-580: the
     // dev text says error(e) reported it)
@@ -10065,7 +10530,7 @@ function defineWidget(def) {
         },
         $ssr: host,
         // D190/D199: a widget tag is not a selector (SYG143 in dev): select its className or a control
-        toString: () => (dev$8(143, w), ':not(*)'),
+        toString: () => (dev$7(143, w), ':not(*)'),
     });
 }
 
@@ -10114,6 +10579,30 @@ function defineWidget(def) {
  *   can still be assigned), which reads the host's current `uses`.
  * - Limitations: a host intent must return an object (not one stream).
  */
+/** A behavior output's slice from before the action (outputs get the updated one): for a transition shared with STATE */
+const was = (s, p, k) => p?.previousState ? p.previousState[k] : s;
+/**
+ * A behavior model whose outputs compute from the state before the action (its slice and
+ * `props.state`), for behaviors whose STATE and outputs share one transition; STATE / HOST as is
+ */
+const fromPrevious = (model) => {
+    const out = {};
+    for (const a in model) {
+        const e = model[a];
+        if (!e || typeof e != 'object') {
+            out[a] = e;
+            continue;
+        }
+        const m = {};
+        for (const s in e) {
+            const f = e[s];
+            m[s] = s == 'STATE' || s == 'HOST' || typeof f != 'function' ? f
+                : (x, d, n, p, o, k) => f(was(x, p, k), d, n, p?.previousState ? { ...p, state: p.previousState } : p, o, k);
+        }
+        out[a] = m;
+    }
+    return out;
+};
 // a model entry as { sink: fn }: a constant is sent as is, `true` sends the action's data, an
 // EFFECT constant does nothing (as the core treats them)
 const sinksOf = (e, S) => {
@@ -10296,6 +10785,8 @@ const pager = /*#__PURE__*/ defineBehavior({
 });
 
 const isRow = (r) => r?.id != null;
+/** PLAN-11 F-2: a File / Blob is a field value (a leaf), not an object of fields */
+const isFile = (v) => typeof Blob != 'undefined' && v instanceof Blob;
 // the key of segment `s` in `v`: an array's row with that id, else the index unless the element
 // there is a row (G-380: a row is named by its id only; -1, no element), an object's key
 const key = (v, s) => {
@@ -10342,7 +10833,7 @@ const setField = (values, name, value) => {
  * array-level error such as "at least one address"); a row's `id` is not a field
  */
 const fieldNames = (v, at = '', row) => {
-    if (!v || typeof v != 'object')
+    if (!v || typeof v != 'object' || isFile(v))
         return at ? [at] : [];
     const a = Array.isArray(v), out = a ? [at] : [];
     for (const k in v) {
@@ -10423,7 +10914,12 @@ const focusInvalid = (names, within) => {
  * field.
  *
  * Options: `values` (the start values; D239: or a function of the host's state, called when the
- * form starts), `submit` (host action), `check` (async per-field checks through a driver: a
+ * form starts), `submit` (host action), `request` (PLAN-11 F-3: the form sends the valid submit
+ * itself on the `http` sink: a request, or `(data, hostState) => request`, completed with the
+ * body (`multipart: data` when a top-level value is a File / Blob or an array of them, else
+ * `json: data`, unless it sets json / multipart / body), `progress: '<key>.PROGRESS'` (unless set)
+ * and its own `ok: '<key>.DONE'`, `error: '<key>.ERRORS'`; with `submit` too, that host action is
+ * still dispatched (for state), and should send no request), `check` (async per-field checks through a driver: a
  * request with a reply action, `latest`), `show` ('blur' default: a schema error shows once its
  * field was blurred; 'input'; 'submit'), `form` (selector), `http` (the driver sink of the
  * checks, 'HTTP'), `resetOnShow` (D239), `tool` (PLAN-6 A-3, experimental: `formTool({ … })` from
@@ -10442,6 +10938,8 @@ const focusInvalid = (names, within) => {
  * before that (a child's first render) the fields come from calling it with a blank state.
  *
  * Slice (state.form): values, initial, errors (all current schema errors by name), touched,
+ * progress (PLAN-11 F-2: the submit's last progress step or null), resets (counts RESET and
+ * resetOnShow starts: key a file input with it, since a file input can't be cleared by state),
  * server (server errors), remote (async check results: '' passed), pending (name -> value being
  * checked), submitting, submitted, submitCount, queued (a submit waits for a check or an async
  * schema), validating (an async schema runs), validated (the schema has answered since the start
@@ -10451,11 +10949,14 @@ const focusInvalid = (names, within) => {
  *
  * Actions: form.CHANGE ({ name, value, item? }: G-376: a checkbox gives `checked`, and `item`, its
  * value, which toggles membership when the field is an array; <select multiple> an array of the
- * selected values; type=file is ignored), form.SET ({ values }: G-647, field name -> value, several
+ * selected values; PLAN-11 F-2: a file input its File, `multiple` an array of them, none null),
+ * form.SET ({ values }: G-647, field name -> value, several
  * fields changed at once as if typed: one validation, `touched` as for CHANGE, unknown names
  * skipped; e.g. an AI fill), form.BLUR (name), form.SUBMIT, form.ADD ({ field,
  * value }), form.REMOVE ({ field, id }), form.ERRORS (an error reply or a map: server errors),
- * form.DONE (saved), form.RESET (values?); internal: form.RESULT (an async schema's result),
+ * form.DONE (saved), form.RESET (values?), form.PROGRESS (PLAN-11 F-2: a progress step of the
+ * submit request, `progress: 'form.PROGRESS'`: kept as `progress` while submitting, cleared by
+ * DONE / ERRORS / RESET); internal: form.RESULT (an async schema's result),
  * form.CHECKED_<name> (a check's reply; a failed check passes: the server checks on submit),
  * form.VALIDATE (the first validation, when the host starts: G-375; `valid` is false until the
  * schema answered; with resetOnShow also each time the form element appears, D239).
@@ -10479,8 +10980,14 @@ const focusInvalid = (names, within) => {
  * fields. The host checks (SYG234 submit, SYG235 check names, SYG236 row ids)
  * run when the host is created.
  */
-const dev$7 = (...a) => globalThis.__SYGNAL_DIAGNOSTICS__?.form?.(...a);
+// PLAN-11 F-3: a submit's data goes as multipart when a top-level value is a file (or files)
+const hasFile = (d) => !!d && typeof d == 'object' && Object.values(d).some(x => isFile(x) || Array.isArray(x) && x.some(isFile));
+const dev$6 = (...a) => globalThis.__SYGNAL_DIAGNOSTICS__?.form?.(...a);
 const keys = (o) => Object.keys(o).filter(k => o[k]);
+// PLAN-11 F-2: values compared as JSON, a File by identity-ish fields (JSON gives every File {})
+const fileIds = new WeakMap();
+let fileSeq = 0;
+const json = (v) => JSON.stringify(v, (_k, x) => isFile(x) ? `\0file:${fileIds.get(x) ?? (fileIds.set(x, ++fileSeq), fileSeq)}` : x);
 const drop = (o, p) => {
     const r = {};
     for (const k in o)
@@ -10489,8 +10996,8 @@ const drop = (o, p) => {
     return r;
 };
 const form = (schema, o = {}) => {
-    isStandardSchema(schema) || dev$7(231, schema);
-    const { values: vo = {}, submit, check: checks = {}, show = 'blur', http = 'HTTP', form: sel = 'form', resetOnShow: again } = o;
+    isStandardSchema(schema) || dev$6(231, schema);
+    const { values: vo = {}, submit, request: rq, check: checks = {}, show = 'blur', http = 'HTTP', form: sel = 'form', resetOnShow: again } = o;
     // D239: `values` can be a function of the host's state, called when the form starts (and each
     // show, resetOnShow). Before that (the host's first render, before its first action) the
     // fields come from calling it with a blank state: every read gives '' in the result
@@ -10522,7 +11029,7 @@ const form = (schema, o = {}) => {
     // from a named button)
     const known = (s, n, quiet) => {
         const k = n && hasField(s.values, n);
-        n && !k && !quiet && dev$7(230, n, s.values);
+        n && !k && !quiet && dev$6(230, n, s.values);
         return k;
     };
     // new values: errors now (sync schema), or after the schema's Promise (RESULT)
@@ -10537,7 +11044,7 @@ const form = (schema, o = {}) => {
     });
     const ask = (s, f, k, queued) => {
         const x = getField(s.values, f), q = checks[f].request(x), ok = `${k}.CHECKED_${f}`;
-        dev$7(235, f, q);
+        dev$6(235, f, q);
         return { s: { ...s, queued, pending: { ...s.pending, [f]: x } }, req: { ...q, ok, error: ok, latest: true } };
     };
     // a submit with s's errors: blocked (focus the first), a check to run or to wait for, or sent
@@ -10548,10 +11055,11 @@ const form = (schema, o = {}) => {
                 : Object.keys(s.pending).length ? { s: { ...s, queued: true } }
                     : { s: req ? { ...s, queued: false, submitting: true } : done({ ...s, queued: false }), send: 1 };
     };
-    const base = (vals) => ({ initial: vals, values: vals, touched: {}, server: {}, remote: {}, pending: {},
-        submitting: false, submitted: false, submitCount: 0, queued: false, errors: {}, validated: false });
-    const fresh = (vals) => edit(base(vals), vals);
-    const done = (s) => ({ ...s, submitting: false, submitted: true, initial: s.values, server: {}, touched: {} });
+    const base = (vals, resets = 0) => ({ initial: vals, values: vals, touched: {}, server: {}, remote: {}, pending: {},
+        submitting: false, submitted: false, submitCount: 0, queued: false, errors: {}, validated: false, progress: null, resets });
+    // a start over (RESET, resetOnShow): `resets` counts them, so a file input keyed by it is made anew
+    const fresh = (vals, s) => edit(base(vals, s ? (s.resets || 0) + 1 : 0), vals);
+    const done = (s) => ({ ...s, submitting: false, submitted: true, initial: s.values, server: {}, touched: {}, progress: null });
     const group = (cur, d) => {
         if (!Array.isArray(cur) || !('item' in d))
             return d.value;
@@ -10560,10 +11068,10 @@ const form = (schema, o = {}) => {
     };
     // fields changed as typed ones ([name, value] pairs; unknown names skipped, SYG230): their
     // server errors, check results and running checks go, `touched` as show 'input' says; one validation
-    const put = (s, d) => {
+    const put = (s, d, quiet) => {
         let vals = s.values, server = drop(s.server, ''), remote = s.remote, pending = s.pending, touched = s.touched;
         for (const [n, y] of d)
-            if (known(s, n)) {
+            if (known(s, n, quiet)) {
                 vals = setField(vals, n, y), server = drop(server, n), remote = drop(remote, n), pending = drop(pending, n);
                 if (show == 'input')
                     touched = { ...touched, [n]: true };
@@ -10573,7 +11081,9 @@ const form = (schema, o = {}) => {
     const steps = {
         // G-376: a checkbox (`item`: its value) on an array field is one of a group: checked adds
         // its value, unchecked removes it
-        CHANGE: (s, d) => put(s, d?.name ? [[d.name, group(getField(s.values, d.name), d)]] : []),
+        // PLAN-11 F-2: a file input whose name isn't in values is left alone, quietly (an app that reads
+        // its files in its own intent, as before 6.7)
+        CHANGE: (s, d) => put(s, d?.name ? [[d.name, group(getField(s.values, d.name), d)]] : [], d?.file),
         BLUR: (s, n, k) => {
             if (!known(s, n, 1))
                 return null;
@@ -10582,7 +11092,7 @@ const form = (schema, o = {}) => {
         },
         SUBMIT: (s, _, k) => {
             if (s.submitting || s.queued)
-                return void dev$7(232, s);
+                return void dev$6(232, s);
             const n = { ...s, submitCount: s.submitCount + 1 }, r = v(s.values);
             // G-371: a submit waiting for an async schema is queued (a second one is dropped)
             return r.then ? { s: { ...n, validating: true, queued: true }, wait: { values: s.values, submit: 1 } } : attempt({ ...n, errors: r.errors }, k);
@@ -10606,16 +11116,20 @@ const form = (schema, o = {}) => {
         SET: (s, d) => put(s, Object.entries(d?.values || {})),
         ERRORS: (s, d) => {
             const e = replyErrors(d, s.values);
-            return { s: { ...s, server: e, submitting: false, queued: false }, focus: focusInvalid(e, sel) };
+            return { s: { ...s, server: e, submitting: false, queued: false, progress: null }, focus: focusInvalid(e, sel) };
         },
         DONE: (s) => ({ s: done(s) }),
-        RESET: (s, d) => fresh(d && typeof d == 'object' ? d : s.initial),
+        // PLAN-11 F-2: a progress step of the submit's request (`progress: 'form.PROGRESS'`), while it is pending
+        PROGRESS: (s, d) => s.submitting && d && typeof d == 'object'
+            ? { s: { ...s, progress: { phase: d.phase, loaded: d.loaded, total: d.total ?? null, fraction: d.fraction ?? null } } } : null,
+        // PLAN-11: only a plain object is new values (a click event from `DOM.click('.reset')` is not)
+        RESET: (s, d) => fresh(d && typeof d == 'object' && [Object.prototype, null].includes(Object.getPrototypeOf(d)) ? d : s.initial, s),
         // G-375: the first validation, when the host starts (form() doesn't validate at module load).
         // G-575: a slice kept in parent state from a host that unmounted mid-submit starts unstuck.
         // D239: with resetOnShow (also each time the form element appears again), or a `values`
         // function not called yet, the slice starts over from the start values (h: the host state)
-        VALIDATE: (s, _, _k, h) => again || fn && s.values === values ? fresh(fn ? vo(h) : vo)
-            : edit({ ...s, submitting: false, queued: false, pending: {} }, s.values),
+        VALIDATE: (s, _, _k, h) => again || fn && s.values === values ? fresh(fn ? vo(h) : vo, again && s)
+            : edit({ ...s, submitting: false, queued: false, pending: {}, progress: null }, s.values),
     };
     // a check's reply (ok and error: an error reply carries an Error and passes)
     for (const f of checked)
@@ -10625,6 +11139,14 @@ const form = (schema, o = {}) => {
             const n = { ...s, pending: drop(s.pending, f), remote: { ...s.remote, [f]: d?.error instanceof Error ? '' : checks[f].error?.(d) || '' } };
             return s.queued ? attempt(n, k) : { s: n };
         };
+    // PLAN-11 F-3: the `request` option's request for a valid submit (data: the schema's output)
+    const send = (vals, h, k) => {
+        const data = v(vals).value, q = typeof rq == 'function' ? rq(data, h) : rq;
+        if (!q || q === ABORT)
+            return ABORT;
+        const own = 'json' in q || 'multipart' in q || 'body' in q;
+        return { ...(!own && (hasFile(data) ? { multipart: data } : { json: data })), progress: `${k}.PROGRESS`, ...q, ok: `${k}.DONE`, error: `${k}.ERRORS` };
+    };
     const model = {};
     for (const a in steps) {
         let last = [];
@@ -10634,19 +11156,28 @@ const form = (schema, o = {}) => {
             // VALIDATE: on the host's state (HOST), for a `values` function; the slice's own steps on it
             ...a == 'VALIDATE' ? { HOST: (h, d, _n, _p, _o, k) => { const x = out(h[k], d, k, h); return x ? { ...h, [k]: x.s } : h; } }
                 : { STATE: (s, d, _n, _p, _o, k) => out(s, d, k)?.s || ABORT },
-            EFFECT: (s, d, next, _p, _o, k) => {
+            // outputs share STATE's transition: computed from the slice before the action
+            EFFECT: (s, d, next, p, _o, k) => {
+                s = was(s, p, k);
                 const x = out(s, d, k), w = x?.wait;
                 if (x?.send) {
                     const r = v(x.s.values).value;
-                    dev$7(233, s.values, r);
+                    dev$6(233, s.values, r);
                     // G-577: a submit named after one of the form's own actions goes to that one
-                    submit in steps && dev$7(234, submit, k, b);
-                    next(submit, r, 0);
+                    submit in steps && dev$6(234, submit, k, b);
+                    // PLAN-11 F-3: with `request`, `submit` is optional (dispatched for state when given)
+                    if (submit !== undefined || !rq)
+                        next(submit, r, 0);
                 }
                 w && Promise.resolve(v(w.values)).then(() => next('RESULT', w, 0));
             },
-            ELEMENT: (s, d, _n, _p, _o, k) => out(s, d, k)?.focus || ABORT,
-            ...(checked.length && { [http]: (s, d, _n, _p, _o, k) => out(s, d, k)?.req || ABORT }),
+            ELEMENT: (s, d, _n, p, _o, k) => out(was(s, p, k), d, k)?.focus || ABORT,
+            // the checks' requests, and (PLAN-11 F-3) the `request` option's for a valid submit; the
+            // step from the slice before the action (7.0: outputs get the updated one), the host state as committed
+            ...((checked.length || rq) && { [http]: (s, d, _n, p, _o, k) => {
+                    const x = out(was(s, p, k), d, k);
+                    return x?.req || (x?.send && rq ? send(x.s.values, p?.state, k) : ABORT);
+                } }),
         };
     }
     const b = defineBehavior({
@@ -10662,9 +11193,11 @@ const form = (schema, o = {}) => {
                 VALIDATE: again ? xs$1.merge(xs$1.of(0), f.elements().filter((e) => { const r = e.length && !on; on = e.length; return r; })) : xs$1.of(0),
                 // G-376: a checkbox (native, or a hyphenated tag with a boolean `checked`: a
                 // form-associated custom checkbox / switch) gives `checked` and its value as `item`; a
-                // <select multiple> the selected values; type=file is left alone; others give `value`
-                CHANGE: f.events('input').filter(({ target: t }) => t.type != 'file').map(({ target: t }) => t.type == 'checkbox' || /-/.test(t.tagName) && typeof t.checked == 'boolean' ? { name: t.name, value: t.checked, item: t.value }
-                    : { name: t.name, value: t.type == 'select-multiple' ? [...t.selectedOptions].map((o) => o.value) : t.value }),
+                // <select multiple> the selected values; PLAN-11 F-2: a file input its File (`multiple`:
+                // an array of them; none: null); others give `value`
+                CHANGE: f.events('input').map(({ target: t }) => t.type == 'file' ? { name: t.name, value: t.multiple || t.getAttribute?.('multiple') != null ? [...(t.files || [])] : t.files?.[0] ?? null, file: true }
+                    : t.type == 'checkbox' || /-/.test(t.tagName) && typeof t.checked == 'boolean' ? { name: t.name, value: t.checked, item: t.value }
+                        : { name: t.name, value: t.type == 'select-multiple' ? [...t.selectedOptions].map((o) => o.value) : t.value }),
                 BLUR: f.events('focusout').map((e) => e.target.name),
                 SUBMIT: f.events('submit', { preventDefault: true }),
             };
@@ -10682,7 +11215,7 @@ const form = (schema, o = {}) => {
             },
             // G-382: an async schema re-validating keeps the last answer's validity (no flicker)
             valid: (s) => s.validated && !keys(s.errors).length && !keys(s.remote).length,
-            dirty: (s) => JSON.stringify(s.values) != JSON.stringify(s.initial),
+            dirty: (s) => json(s.values) != json(s.initial),
             error: (s) => s.server[''] || (s.submitCount && s.errors['']) || '',
         },
     })({ ...o, values }), merge = b.merge;
@@ -10690,7 +11223,7 @@ const form = (schema, o = {}) => {
     o.tool?.$?.(b, v);
     b.merge = (c, k) => {
         const e = c.model?.[submit];
-        req = !!e && typeof e == 'object' && http in e;
+        req = !!rq || !!e && typeof e == 'object' && http in e;
         merge(c, k);
     };
     return b;
@@ -10839,7 +11372,7 @@ const selection = (options = {}) => {
  * interaction, SYG147 a `from` key that isn't an array in the host state, SYG435 (3-H) a list
  * shown in another order than its array's (a Collection's sort / filter).
  */
-const dev$6 = (...a) => globalThis.__SYGNAL_DIAGNOSTICS__?.sortable?.(...a);
+const dev$5 = (...a) => globalThis.__SYGNAL_DIAGNOSTICS__?.sortable?.(...a);
 const LIFT = /^( |Enter|Spacebar)$/;
 const KEYS = /^(Arrow(Up|Down|Left|Right)|Home|End|Escape|Tab)$/;
 const S$1 = String;
@@ -10953,7 +11486,7 @@ const sortable = (options = {}) => {
                         } } } } };
     };
     // dev: SYG435, the list shown in another order than the array's (G-449)
-    const check = (st, seen, k) => seen && dev$6(435, seen, st, lists, idField, k);
+    const check = (st, seen, k) => seen && dev$5(435, seen, st, lists, idField, k);
     // a press or key handler: drag state this instance didn't start (its token `n` isn't the
     // event's: restored, synced) is dropped first (G-452)
     const live = (h) => (st, d, next, _p, _o, k) => {
@@ -10994,7 +11527,7 @@ const sortable = (options = {}) => {
             const gripOf = (e, self) => {
                 const t = e.target, r = e.ownerTarget || e.currentTarget;
                 if (!checked)
-                    checked = dev$6(146, r, item, handle, attr);
+                    checked = dev$5(146, r, item, handle, attr);
                 const g = !claimed.has(e) && t?.closest?.(grip);
                 if (!g || self && g !== t)
                     return null;
@@ -11008,14 +11541,14 @@ const sortable = (options = {}) => {
                     return null;
                 const id = idOf(it);
                 if (id == null)
-                    dev$6(145, it, item, attr);
+                    dev$5(145, it, item, attr);
                 return id;
             };
             const keyed = (keys, kb) => (e) => keys.test(e.key) && (kb || e.key != 'Tab') && gripOf(e, true) != null;
             const lift = keyed(LIFT), step = keyed(KEYS, 1);
             // dev (SYG435): this host's own items' ids in the order they're shown (computed by the
             // diagnostics entry only)
-            const shown = (e) => dev$6(435, () => {
+            const shown = (e) => dev$5(435, () => {
                 const r = e.ownerTarget || e.currentTarget;
                 return [[...r.querySelectorAll(item)].filter((it) => own(it, r)), r];
             }, key, lists, idOf);
@@ -11059,7 +11592,7 @@ const sortable = (options = {}) => {
             // again by HMR, a second host of the slice) is reset, as at END
             INIT: { HOST: (st, _d, _n, _p, _o, k) => {
                     for (const l of lists)
-                        Array.isArray(st?.[l]) || dev$6(147, l, st, k);
+                        Array.isArray(st?.[l]) || dev$5(147, l, st, k);
                     return st[k].press || st[k].dragging ? back(st, k) : ABORT;
                 } },
             // unmounted mid-drag: the drag is cancelled (no DROPPED; a keyboard drag's item goes back
@@ -11471,14 +12004,14 @@ const undo = (options) => {
  *   too), once per kind (restore / save / clear; a save that works again re-arms it); the app
  *   continues on initialState / unsaved, and a failed save is retried at the next change.
  */
-const g$3 = globalThis;
+const g$2 = globalThis;
 const setupPersist = (c, o) => {
     const { key, pick, omit, version = 1, migrate, sync, debounceMs = 100 } = o, plain = o.format == 'plain', src = c.sources, m = src.__m;
     const env = src.__storage, calc = c.calculated || {};
     // hydrating: the option, else the integration's signal (__hydrate: Astro, Vike), else whether
     // run()'s mount point starts with renderToString's markup (its root element is marked; a
     // client-only app's loading placeholder isn't server markup)
-    const hydrate = o.hydrate ?? src.__hydrate ?? !!(typeof m == 'string' ? g$3.document?.querySelector(m) : m)?.firstElementChild?.hasAttribute('data-sygnal-ssr');
+    const hydrate = o.hydrate ?? src.__hydrate ?? !!(typeof m == 'string' ? g$2.document?.querySelector(m) : m)?.firstElementChild?.hasAttribute('data-sygnal-ssr');
     let S, t, last, raw, skip, off;
     // (the docs link the message ends with explains the causes and fixes). Once per kind (restore,
     // save, clear): a storage that throws on every write must not warn on every change; a save that
@@ -11551,7 +12084,7 @@ const setupPersist = (c, o) => {
     }
     c.model = model;
     try {
-        S = typeof o.storage == 'object' ? o.storage : (env || g$3)[(o.storage || 'local') + (env ? '' : 'Storage')];
+        S = typeof o.storage == 'object' ? o.storage : (env || g$2)[(o.storage || 'local') + (env ? '' : 'Storage')];
     }
     catch (_) { }
     if (!S)
@@ -11588,14 +12121,14 @@ const setupPersist = (c, o) => {
         send(read(raw = v)); };
     const onStorage = (e) => (!e.storageArea || e.storageArea == S) && onSync(e.key, e.newValue);
     if (sync)
-        off = S.subscribe ? S.subscribe(onSync) : (g$3.addEventListener?.('storage', onStorage), () => g$3.removeEventListener?.('storage', onStorage));
-    g$3.addEventListener?.('pagehide', flush);
+        off = S.subscribe ? S.subscribe(onSync) : (g$2.addEventListener?.('storage', onStorage), () => g$2.removeEventListener?.('storage', onStorage));
+    g$2.addEventListener?.('pagehide', flush);
     env?.f.add(flush);
     c._dispose$.addListener({ next: () => {
             flush();
             state$.removeListener(L);
             off?.();
-            g$3.removeEventListener?.('pagehide', flush);
+            g$2.removeEventListener?.('pagehide', flush);
             env?.f.delete(flush);
         } });
 };
@@ -12827,7 +13360,7 @@ const snake = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/\W+/g, '_
 const keyOf$1 = (iv) => iv.state?.id;
 const done = new WeakMap();
 /** a dev diagnostic, once per (declaration, what); 'error' mode rethrows outside the caller */
-const dev$5 = (code, decl, what, component, message) => {
+const dev$4 = (code, decl, what, component, message) => {
     let s = done.get(decl);
     if (!s)
         done.set(decl, s = new Set());
@@ -13036,7 +13569,7 @@ function agentTools(target, options = {}) {
             v = d.read(s);
         }
         catch (e) {
-            dev$5('SYG241', d, 'read', iv.name, `agent.read threw: ${e?.message ?? e}`);
+            dev$4('SYG241', d, 'read', iv.name, `agent.read threw: ${e?.message ?? e}`);
         }
         reads.set(iv, { s, v });
         return v;
@@ -13055,7 +13588,7 @@ function agentTools(target, options = {}) {
             v = !!w(s);
         }
         catch (e) {
-            dev$5('SYG241', declOf(iv), 'when' + action, iv.name, `agent.actions.${action}.when threw: ${e?.message ?? e}`);
+            dev$4('SYG241', declOf(iv), 'when' + action, iv.name, `agent.actions.${action}.when threw: ${e?.message ?? e}`);
         }
         m.set(action, { s, v });
         return v;
@@ -13066,7 +13599,7 @@ function agentTools(target, options = {}) {
             return d.label ? String(d.label(iv.state)) : undefined;
         }
         catch (e) {
-            dev$5('SYG241', d, 'label', iv.name, `agent.label threw: ${e?.message ?? e}`);
+            dev$4('SYG241', d, 'label', iv.name, `agent.label threw: ${e?.message ?? e}`);
         }
     };
     function walk(iv, out) {
@@ -13101,7 +13634,7 @@ function agentTools(target, options = {}) {
             else if (e.decl === d && e.item && item)
                 e.ivs.push(iv);
             else
-                dev$5('SYG440', d, name, iv.name, `two agent declarations are named '${name}'; only the first is offered`);
+                dev$4('SYG440', d, name, iv.name, `two agent declarations are named '${name}'; only the first is offered`);
         }
         for (const e of by.values())
             if (e.item) {
@@ -13110,9 +13643,9 @@ function agentTools(target, options = {}) {
                     const k = keyOf$1(iv);
                     // an item without an id is keyed by its index (the core's `_i<index>` uid part): unstable
                     if (k == null || /-_i\d+$/.test(iv.uid))
-                        dev$5('SYG441', e.decl, 'nokey', iv.name, `items of '${e.name}' have no id: agents address them by index`);
+                        dev$4('SYG441', e.decl, 'nokey', iv.name, `items of '${e.name}' have no id: agents address them by index`);
                     else if (ks.has(k + ''))
-                        dev$5('SYG441', e.decl, 'dup', iv.name, `two items of '${e.name}' have the id ${JSON.stringify(k)}; calls reach the first`);
+                        dev$4('SYG441', e.decl, 'dup', iv.name, `two items of '${e.name}' have the id ${JSON.stringify(k)}; calls reach the first`);
                     else
                         ks.add(k + '');
                 }
@@ -13138,11 +13671,11 @@ function agentTools(target, options = {}) {
             for (const [action, a, isQuery] of defs) {
                 const name = e.name + '_' + snake(action), comp = e.ivs[0].name, where = `agent.${isQuery ? 'queries' : 'actions'}.${action}`;
                 if (isQuery && recs.has(name)) {
-                    dev$5('SYG247', d, action, comp, `${where} has the tool name ${name} of an action; the query is not offered (rename it)`);
+                    dev$4('SYG247', d, action, comp, `${where} has the tool name ${name} of an action; the query is not offered (rename it)`);
                     continue;
                 }
                 if (isQuery && typeof a?.run != 'function') {
-                    dev$5('SYG246', d, action, comp, `${where}.run is not a function; the query is not offered`);
+                    dev$4('SYG246', d, action, comp, `${where}.run is not a function; the query is not offered`);
                     continue;
                 }
                 const c = a.input ? toJsonSchema(a.input) : undefined;
@@ -13157,11 +13690,11 @@ function agentTools(target, options = {}) {
                 if (c?.error) {
                     tool.error = `SYG240 ${c.error}`;
                     rec.off = 1;
-                    dev$5('SYG240', d, action, comp, `${where}.input: ${c.error}; the tool is not offered`);
+                    dev$4('SYG240', d, action, comp, `${where}.input: ${c.error}; the tool is not offered`);
                     continue;
                 }
                 if (c?.lossy)
-                    dev$5('SYG243', d, action, comp, `${where}.input: the model doesn't see ${c.lossy}`);
+                    dev$4('SYG243', d, action, comp, `${where}.input: the model doesn't see ${c.lossy}`);
                 const live = e.ivs.filter(iv => whenOk(iv, action, a.when));
                 if (!live.length) {
                     rec.off = 1;
@@ -13333,7 +13866,7 @@ function agentTools(target, options = {}) {
             return;
         const res = iv.def.view.resources;
         if (!res || !(u in res)) {
-            dev$5('SYG248', declOf(iv), 'until' + action, iv.name, `agent.actions.${action}.until names '${u}', which is not one of ${iv.name}'s resources${res ? ` (${Object.keys(res).join(', ')})` : ''}; the call answers at once`);
+            dev$4('SYG248', declOf(iv), 'until' + action, iv.name, `agent.actions.${action}.until names '${u}', which is not one of ${iv.name}'s resources${res ? ` (${Object.keys(res).join(', ')})` : ''}; the call answers at once`);
             return;
         }
         return (s) => { const r = s?.[u]; return !r || (r.status != 'loading' && !r.refreshing); };
@@ -13351,7 +13884,7 @@ function agentTools(target, options = {}) {
                 return !!test(iv.state);
             }
             catch (err) {
-                dev$5('SYG241', declOf(iv), 'until' + action, iv.name, `agent.actions.${action}.until threw: ${err?.message ?? err}`);
+                dev$4('SYG241', declOf(iv), 'until' + action, iv.name, `agent.actions.${action}.until threw: ${err?.message ?? err}`);
                 return true;
             }
         };
@@ -13377,11 +13910,11 @@ function agentTools(target, options = {}) {
         }
         catch (err) {
             const m = err?.message ?? err;
-            dev$5('SYG241', declOf(iv), 'query' + query, iv.name, `agent.queries.${query}.run threw: ${m}`);
+            dev$4('SYG241', declOf(iv), 'query' + query, iv.name, `agent.queries.${query}.run threw: ${m}`);
             return { ok: false, error: `${name} failed: ${m}` };
         }
         if (result && typeof result.then == 'function') {
-            dev$5('SYG246', declOf(iv), 'promise' + query, iv.name, `agent.queries.${query}.run returned a promise: a query is a pure, synchronous function of the state`);
+            dev$4('SYG246', declOf(iv), 'promise' + query, iv.name, `agent.queries.${query}.run returned a promise: a query is a pure, synchronous function of the state`);
             return { ok: false, error: `${name} is not available: it returned a promise` };
         }
         return { ok: true, result };
@@ -13742,28 +14275,28 @@ function withToolResults(message, results) {
 const SCOPE = '__sygnalScope';
 const tag$1 = (v, scope) => v && typeof v == 'object'
     ? Object.defineProperty(keepSender(v, { ...v }), SCOPE, { value: [scope, ...(v[SCOPE] || [])] }) : v;
-const g$2 = globalThis;
-const now = () => g$2.performance?.now?.() ?? Date.now();
+const g$1 = globalThis;
+const now = () => g$1.performance?.now?.() ?? Date.now();
 // internal (D254): the 120 Hz floor and the hidden-tab fallback
 const MIN_GAP = 15, FALLBACK = 100;
 /** rAF raced with a timer (a hidden tab never runs rAF), else a 16 ms timer; `f` gets the frame's time */
 const frame = (f) => {
-    if (typeof g$2.requestAnimationFrame != 'function')
+    if (typeof g$1.requestAnimationFrame != 'function')
         return void setTimeout(() => f(now()), 16);
     let done = 0, a, t;
     const go = (ts) => {
         if (done++)
             return;
-        g$2.cancelAnimationFrame?.(a);
+        g$1.cancelAnimationFrame?.(a);
         clearTimeout(t);
         f(typeof ts == 'number' ? ts : now());
     };
-    a = g$2.requestAnimationFrame(go);
+    a = g$1.requestAnimationFrame(go);
     t = setTimeout(go, FALLBACK);
 };
 // dev-only diagnostics (SYG673, SYG677): the dev entry formats them (checks/chat.ts), so their
 // text costs apps nothing; without it they're silent
-const dev$4 = (...a) => g$2.__SYGNAL_DIAGNOSTICS__?.chat?.(...a);
+const dev$3 = (...a) => g$1.__SYGNAL_DIAGNOSTICS__?.chat?.(...a);
 const FIX = "Send { messages, ok: 'DONE', error: 'FAILED' }";
 /** why a request can't be sent ('' when it can) */
 const problem = (r) => !Array.isArray(r.messages) ? 'no messages array'
@@ -13785,7 +14318,7 @@ function makeChatDriver(options = {}) {
         const { replies, reply } = makeReplies(sender => abortWhere(r => r.sender === sender));
         // SYG673 (dev): `why` is 'type' | 'delta' | 'name' | 'id'; the first five per driver
         const malformed = (req, ev, why) => { if (warned++ < 5)
-            dev$4('SYG673', req, ev, why); };
+            dev$3('SYG673', req, ev, why); };
         const start = async (req, sender) => {
             const key = req.key ?? req.ok ?? req.error ?? 'default';
             if (req.latest !== false)
@@ -13978,7 +14511,7 @@ function makeChatDriver(options = {}) {
                     return;
                 const sender = senderOf(req);
                 if (sender === undefined)
-                    return void dev$4('SYG677', req);
+                    return void dev$3('SYG677', req);
                 const { abort } = req;
                 if (abort !== undefined && abort !== false) {
                     // D469 (PLAN-9 H-2): a list of keys stops each (STOP: the reply and a card being composed)
@@ -15034,6 +15567,17 @@ const validMs = (v) => typeof v == 'number' && Number.isFinite(v) && v >= 0 && v
 // too, so its time is the clock's (Date may be left real by `toFake`), and its waits drive it.
 const fakeClock = () => setTimeout.clock;
 const clockNow = () => { const c = fakeClock(); return c ? c.now : Date.now(); };
+/** PLAN-11 Q-3: ms until the next pending fake timer (0: none, or real timers) */
+const nextFakeTimer = () => {
+    const c = fakeClock();
+    let due = Infinity;
+    try {
+        Object.values(c?.timers || {}).forEach((t) => { if (t && t.callAt > c.now && t.callAt < due)
+            due = t.callAt; });
+    }
+    catch (_) { }
+    return due < Infinity ? due - c.now : 0;
+};
 /**
  * Under fake timers, advance the clock timer by timer (nextAsync flushes promises around each
  * one) until `p` settles. Every pending wait has a timer (its timeout, a quiet-window tick), so
@@ -15224,6 +15768,7 @@ const headFake = () => {
 };
 let savedConfig;
 let savedStrict;
+let savedAudit;
 /*
  * PLAN-4 GS-2, mock DOM: could the element a command targets have this method? The core runs any
  * method of the element; the mock DOM has no elements, so: the documented commands, common
@@ -15334,7 +15879,7 @@ function fakeElementMethods(W) {
         Object.defineProperty(proto, name, own); });
 }
 function renderComponent(componentDef, options = {}) {
-    const { initialState, mockConfig = {}, drivers = {}, diagnostics, strict, dom = 'mock', autoConnect = true, socketSink = 'WS', resourceSink = 'HTTP', llmSink = 'LLM', http: httpOptions, context: ancestors } = options;
+    const { initialState, mockConfig = {}, drivers = {}, diagnostics, strict, timingAudit, dom = 'mock', autoConnect = true, socketSink = 'WS', resourceSink = 'HTTP', llmSink = 'LLM', http: httpOptions, context: ancestors } = options;
     const { intent, model = {} } = componentDef;
     // E4: real DOM mode
     const real = dom == 'real';
@@ -15382,6 +15927,7 @@ function renderComponent(componentDef, options = {}) {
     if (!active++) {
         savedConfig = _getDiagnosticsConfig();
         savedStrict = core.strict;
+        savedAudit = core.timingAudit;
         // G-051: forget the checks' report dedupe (once()), so a finding from an earlier test is
         // reported again. Only that set: resetChecks() would also drop inspect()'s records of
         // other live instances / apps.
@@ -15390,6 +15936,9 @@ function renderComponent(componentDef, options = {}) {
     configureDiagnostics({ mode: diagnostics || (prevMode == 'off' ? 'collect' : prevMode) });
     if (strict !== undefined)
         core.strict = strict;
+    // 7.0 timing audit (SYG257, 'sygnal/diagnostics'): same bridge flag as configureTimingAudit()
+    if (timingAudit !== undefined)
+        core.timingAudit = timingAudit;
     // PLAN-4 GS-2: element commands run on the real DOM (jsdom gets the missing methods), and their
     // SYG640/SYG641 are reported without the dev entry too
     if (real && !domFakes)
@@ -15580,6 +16129,7 @@ function renderComponent(componentDef, options = {}) {
         if (!--active) {
             configureDiagnostics(savedConfig);
             core.strict = savedStrict;
+            core.timingAudit = savedAudit;
             domFakes?.();
             domFakes = undefined;
         }
@@ -15625,14 +16175,22 @@ function renderComponent(componentDef, options = {}) {
                 const lin$ = xs$1.create();
                 llm = { in$: lin$, src: makeChatDriver({ transport: tr, _frame: (f) => { frames.push(f); } })(lin$) };
             }
+            let memFetch;
             const http = makeFetchDriver({
                 ...httpOptions,
+                // PLAN-11 U-2: a progress request is answered like any other (t.respond / t.fail); its
+                // pending entry keeps the driver's progress callback for t.progress
+                _progress: (url, init, step) => {
+                    const r = memFetch(url, init);
+                    pending[pending.length - 1].step = step;
+                    return r;
+                },
                 // 5-3: focus / online come from t.focus() / t.online() only
                 _on: (f) => { signals.add(f); return () => signals.delete(f); },
                 _tap: (req, res, pf) => { tapped = [req, res, pf]; },
                 // D472: a batch / split request (a large decide()) is one fetch here, answered as one
                 _whole: true,
-                fetch: (url, init) => new Promise((resolve, reject) => {
+                fetch: memFetch = (url, init) => new Promise((resolve, reject) => {
                     const [req, res, pf] = tapped || [{ url }];
                     tapped = undefined;
                     // G-171(1): a resource fetch is listed as { url, ...request, resource: name }; 5-5: a
@@ -15666,6 +16224,7 @@ function renderComponent(componentDef, options = {}) {
                 return {
                     select: (sel) => xs$1.merge(hs.select(sel), own(false)(sel), sock.select(sel)),
                     errors: (sel) => xs$1.merge(hs.errors(sel), own(true)(sel)),
+                    progress: (sel) => hs.progress(sel),
                     subs, at, pending, in$, http, ws, llm,
                     // 5-3: the driver's matcher / inspection (the dev checks' SYG632, t.cache)
                     __matches: http.__matches, __inspect: http.__inspect,
@@ -16431,7 +16990,7 @@ function renderComponent(componentDef, options = {}) {
             return { match: cat, desc: catDesc, o };
         if (typeof tg == 'string') {
             // an ok/error action name, key, category, resource name or URL
-            return { match: r => { const v = r.value || {}; return cat(r) && [v.ok, v.error, v.key, v.category, r.res, v.url].includes(tg); }, desc: ` matching '${tg}'${catDesc}`, o };
+            return { match: r => { const v = r.value || {}; return cat(r) && [v.ok, v.error, v.progress, v.key, v.category, r.res, v.url].includes(tg); }, desc: ` matching '${tg}'${catDesc}`, o };
         }
         if (typeof tg == 'function') {
             return { match: r => { try {
@@ -16688,6 +17247,27 @@ function renderComponent(componentDef, options = {}) {
         const err = typeof error == 'number' || resp ? Object.assign(new Error(`HTTP ${status}`), { status }) : x;
         return { error: err, category, request: e?.req, status: status ?? x?.status, body };
     });
+    // PLAN-11 U-2: t.progress. One progress step of a pending request sent with `progress` (its
+    // reply action, or progress() for `progress: true`); the request stays pending. Targets as
+    // t.respond's; the phase defaults to 'upload' for a request with a body, else 'download'
+    const progress = (name, step, opts) => {
+        throwFailure();
+        if (drivers[name])
+            throw new Error(`[Sygnal] t.progress('${name}'): ${name} has a real driver (passed in drivers), so there is nothing to script`);
+        if (!step || typeof step != 'object' || typeof step.loaded != 'number')
+            throw new Error(`[Sygnal] t.progress('${name}', step): step is { loaded, total?, phase? } (got ${brief(step)})`);
+        const tg = targetOf(opts);
+        const what = `t.progress('${name}'${typeof opts == 'string' ? `, …, '${opts}'` : ''})`;
+        const now = isReady && !inputs.length ? pick(name, tg) : undefined;
+        if (now && !now.step)
+            throw new Error(`[Sygnal] ${what}: the request ${brief(now.value)} has no progress: send it with progress: 'UPLOADING' (a reply action) or progress: true`);
+        return scripted(() => pick(name, tg), w => noPending(what, name, tg, w), (e) => {
+            if (!e.step)
+                return new Error(`[Sygnal] ${what}: the request ${brief(e.value)} has no progress: send it with progress: 'UPLOADING' (a reply action) or progress: true`);
+            const r = e.req || {};
+            e.step(step.phase || (r.body !== undefined || r.json !== undefined || r.multipart !== undefined ? 'upload' : 'download'), step.loaded, step.total ?? 0);
+        }, sendDue);
+    };
     // PLAN-6 L-4: t.stream. Targets as t.respond's (an action name or key, a partial request, a
     // predicate, { request, nth }); `end: false` (the last argument, or in the target options)
     // leaves the stream open. Chunks become ChatEvents pushed into the in-memory stream; the fake's
@@ -17192,7 +17772,14 @@ function renderComponent(componentDef, options = {}) {
             let msg = `${name} timed out after ${timeoutMs}ms.`;
             const [why, pending] = explainNext(start);
             msg += why;
-            if (pending)
+            if (inputs.length)
+                msg += ` ${inputs.length} simulated input(s) still pending.`;
+            // PLAN-11 Q-3: on the fake clock a state a timer (TIMER driver, periodic, delay) brings
+            // later than the timeout can't arrive in time: name the next pending timer
+            const later = pending ? 0 : nextFakeTimer();
+            if (later)
+                msg += ` A timer is still pending on the fake clock (it fires ${later}ms after this timeout): if the state comes from it, this wait ended first.`;
+            if (pending || later)
                 msg += ` Wait longer: t.${name}(pred, ms), or the renderComponent timeoutMs option (default for every wait).`;
             // G-065: a state from before the call matched; next() only looks at new ones
             for (let i = from - 1; i >= 0; i--) {
@@ -17392,6 +17979,7 @@ function renderComponent(componentDef, options = {}) {
         requests,
         respond,
         fail,
+        progress,
         stream,
         connections,
         cache,
@@ -17968,7 +18556,7 @@ function jsonSchema(schema, options = {}) {
  * Side-effect free: an app that doesn't import it pays 0 B.
  */
 const NAME = 30, DESC = 500, PARAM = 150, OUT = 1500, SUMMARY = 300;
-const g$1 = globalThis;
+const g = globalThis;
 /** cut to n characters with an ellipsis, never inside a surrogate pair */
 const cut = (s, n) => {
     if (s.length <= n)
@@ -17985,7 +18573,7 @@ const hash = (s) => {
     return (h % 1679616).toString(36).padStart(4, '0');
 };
 function experimentalExposeWebMcp(app, options = {}) {
-    const mc = options.modelContext ?? g$1.document?.modelContext ?? g$1.navigator?.modelContext;
+    const mc = options.modelContext ?? g.document?.modelContext ?? g.navigator?.modelContext;
     const said = new Set();
     const dev = (code, key, message, severity = 'warn') => {
         if (said.has(code + key))
@@ -18188,7 +18776,7 @@ function experimentalExposeWebMcp(app, options = {}) {
 let n$2 = 0;
 /** the default confirmation: a native modal dialog outside the app's tree (Escape and "Deny" decline) */
 function dialog(info, setClose) {
-    const doc = g$1.document;
+    const doc = g.document;
     if (!doc?.createElement)
         return Promise.resolve(false);
     return new Promise(resolve => {
@@ -18444,7 +19032,7 @@ const toolsOf$1 = (e) => e.o.agent === false ? null : e.tools || (e.tools = agen
     }),
 }));
 // dev diagnostics (SYG684, SYG685): no-ops with diagnostics off
-const dev$3 = (code, message, fix) => { try {
+const dev$2 = (code, message, fix) => { try {
     report(code, { component: 'chat', message, fix, severity: 'warn' });
 }
 catch (e) {
@@ -18654,7 +19242,7 @@ function steps(c, o) {
     const openPart = (s, id, what, guard = (_p) => true) => {
         const p = openToolCalls(s).find(x => x.toolCallId === id && isClient(c, x) && guard(x));
         if (!p)
-            dev$3('SYG685', `${what} for the tool call '${id}', which is not waiting for an answer (answered, closed, or not a client tool call of the last message); it is ignored`, 'Answer only the calls in openToolCalls(state); a late answer after STOP, SEND or REGENERATE is dropped on purpose');
+            dev$2('SYG685', `${what} for the tool call '${id}', which is not waiting for an answer (answered, closed, or not a client tool call of the last message); it is ignored`, 'Answer only the calls in openToolCalls(state); a late answer after STOP, SEND or REGENERATE is dropped on purpose');
         return p;
     };
     /** after a call closed or a card changed: the next queued card, then rule 3 */
@@ -18782,7 +19370,7 @@ function request(e, o, k, messages, fresh, c, host) {
         for (const n in c.client) {
             if (n in tools && !shadowed.has(n)) {
                 shadowed.add(n);
-                dev$3('SYG684', `the client tool '${n}' has the name of an agent tool; the client tool is sent and its calls are the app's to answer`, 'Rename the client tool, or the agent declaration or action');
+                dev$2('SYG684', `the client tool '${n}' has the name of an agent tool; the client tool is sent and its calls are the app's to answer`, 'Rename the client tool, or the agent declaration or action');
             }
             const x = c.client[n];
             tools[n] = c.ask && n == 'ask_user' ? c.kit.askTool(c.ask, host) : { description: x.description, inputSchema: schemaOf(x) };
@@ -18899,7 +19487,7 @@ const chat = (options = {}) => {
                 ...(c.ask?.controls && DOM && { CONTROL: DOM.select('[data-compose-control]').events('click').map(controlOf$1).filter((x) => !!x) }),
             };
         },
-        model: {
+        model: fromPrevious({
             PROMPT: (s, p) => typeof p == 'string' && p !== s.prompt ? { ...s, prompt: p } : ABORT,
             SEND: {
                 STATE: (s, d) => sendStep(s, d) || ABORT,
@@ -18997,153 +19585,19 @@ const chat = (options = {}) => {
                 ANSWER: { STATE: stateOf(S.answerCard), ...sinks(S.answerCard) },
                 CONTROL: (s, d) => S.controlStep(s, d) || ABORT,
             }),
-        },
+        }),
     })(options);
     // the `prompt` option is a selector, not the slice's start value (defineBehavior's option override)
     b.state = { ...b.state, prompt: '' };
     return linked(b);
 };
 
-/*
- * PLAN-6 L-2: what the HTTP transports share (side-effect free; each transport imports only what
- * it uses).
- * - post(): the fetch (the `fetch` option, 0-S5), the headers option (an object or a function of
- *   the request), HTTP errors as Errors with `status` and the provider's message, and SYG670.
- * - sse(): a fetch Response body as SSE frames ({ event, data }), per the HTML spec's parsing
- *   rules: CRLF / LF, comments, multi-line data. The reader is cancelled when the consumer stops
- *   (abort, a thrown error), so the connection closes.
- * - SYG670: in a browser, a request with an auth header (Authorization, x-api-key, api-key,
- *   x-goog-api-key) to a host that is neither local (localhost, 127.0.0.1, [::1], *.localhost)
- *   nor the page's own origin is refused unless the transport has `dangerouslyAllowBrowser: true`:
- *   the key would ship to every visitor. Same-origin requests are the app's own server (its
- *   proxy), so a session header there is fine.
- */
-const g = globalThis;
-const AUTH = /^(authorization|x-api-key|api-key|x-goog-api-key)$/i;
-const LOCAL = /^(localhost|127\.0\.0\.1|\[::1\]|.+\.localhost)$/;
-/** the URL a transport posts to, or a SYG670 Error when it must not (see the header) */
-function guard(url, headers, opts, name) {
-    if (opts.dangerouslyAllowBrowser || typeof g.document == 'undefined' || !Object.keys(headers).some(h => AUTH.test(h)))
-        return;
-    const here = g.location?.href;
-    let u;
-    try {
-        u = new URL(url, here);
-    }
-    catch (_) {
-        return;
-    }
-    if (LOCAL.test(u.hostname) || (here && u.origin == new URL(here).origin))
-        return;
-    const fix = `Call ${u.origin} from your server and point the transport at that route (an AI SDK route with uiMessageStream('/api/chat'), or your own proxy), so the key stays there. For a key the user typed in themselves, pass ${name}({ ..., dangerouslyAllowBrowser: true })`;
-    const msg = `${name}: refused to send an auth header from the browser to ${u.origin}: anyone who opens the page can read it`;
-    error('SYG670', undefined, msg, fix);
-    fail$2('SYG670', undefined, msg, fix);
-}
-/**
- * POST JSON; a non-2xx response is an Error with `status`, `body` and the provider's message.
- * The transport's `body` option and the request's `body` are merged over the built body (so they
- * can override provider defaults such as `max_tokens`); `fixed` fields are merged last and can't be
- * overridden (G-654: uiMessageStream's protocol fields, as the AI SDK's DefaultChatTransport)
- */
-async function post$1(url, body, req, signal, opts, name, fixed) {
-    const h = typeof opts.headers == 'function' ? await opts.headers(req) : opts.headers || {};
-    guard(url, h, opts, name);
-    const f = opts.fetch || ((u, i) => g.fetch(u, i));
-    const res = await f(url, { method: 'POST', headers: { 'content-type': 'application/json', ...h }, body: JSON.stringify({ ...body, ...opts.body, ...req.body, ...fixed }), signal });
-    if (!res.ok) {
-        let text = '', message = '';
-        try {
-            text = await res.text();
-            const j = JSON.parse(text);
-            message = j.error?.message ?? j.error ?? j.message ?? '';
-        }
-        catch (_) {
-            message || (message = text.slice(0, 200));
-        }
-        throw Object.assign(new Error(`${name}: HTTP ${res.status}${message ? ': ' + message : ''}`), { status: res.status, body: text });
-    }
-    if (!res.body)
-        throw new Error(`${name}: the response has no body`);
-    return res;
-}
-/** the SSE frames of a response body: `{ event, data }` (data: the joined data lines) */
-async function* sse(res) {
-    const reader = res.body.getReader(), dec = new TextDecoder();
-    let buf = '', cr = '', done = false;
-    try {
-        for (;;) {
-            const r = await reader.read();
-            // line ends -> \n (a \r at a chunk's end waits: it may be half of a \r\n)
-            let s = cr + (r.done ? '\n\n' : dec.decode(r.value, { stream: true }));
-            cr = !r.done && s.endsWith('\r') ? '\r' : '';
-            if (cr)
-                s = s.slice(0, -1);
-            buf += s.replace(/\r\n?/g, '\n');
-            done = r.done;
-            let i;
-            while ((i = buf.indexOf('\n\n')) >= 0) {
-                const frame = buf.slice(0, i);
-                buf = buf.slice(i + 2);
-                let event = 'message', data = [];
-                for (const line of frame.split('\n')) {
-                    if (!line || line[0] == ':')
-                        continue;
-                    const c = line.indexOf(':'), field = c < 0 ? line : line.slice(0, c);
-                    const v = c < 0 ? '' : line.slice(c + 1).replace(/^ /, '');
-                    if (field == 'event')
-                        event = v;
-                    else if (field == 'data')
-                        data.push(v);
-                }
-                if (data.length)
-                    yield { event, data: data.join('\n') };
-            }
-            if (done)
-                return;
-        }
-    }
-    finally {
-        if (!done)
-            reader.cancel().catch(() => { });
-    }
-}
-/** JSON.parse, or the text itself when it isn't JSON (a model's malformed tool arguments go to validation as is) */
-const json = (s) => {
-    if (typeof s != 'string')
-        return s;
-    try {
-        return JSON.parse(s || '{}');
-    }
-    catch (_) {
-        return s;
-    }
-};
-/** a provider's usage as `{ inputTokens, outputTokens, totalTokens, reasoningTokens? }` (AI SDK names) */
-const usageOf = (u) => u && {
-    inputTokens: u.input_tokens ?? u.prompt_tokens,
-    outputTokens: u.output_tokens ?? u.completion_tokens,
-    totalTokens: u.total_tokens,
-    ...((u.output_tokens_details ?? u.completion_tokens_details)?.reasoning_tokens != null && { reasoningTokens: (u.output_tokens_details ?? u.completion_tokens_details).reasoning_tokens }),
-};
-/** the parts of a message (a `content` string is one text part) */
-const partsOf = (m) => m.parts ?? (typeof m.content == 'string' ? [{ type: 'text', text: m.content }] : []);
-/** the tool name of a `tool-<name>` / `dynamic-tool` part, or '' */
-const toolName = (p) => p.type == 'dynamic-tool' ? p.toolName : p.type.startsWith('tool-') ? p.type.slice(5) : '';
-/** what a tool part sends back to the model, or undefined when it has no result yet */
-const toolOutput = (p) => p.state == 'output-available' ? (typeof p.output == 'string' ? p.output : JSON.stringify(p.output ?? null))
-    : p.state == 'output-error' ? JSON.stringify({ error: p.errorText ?? 'error' })
-        : p.state == 'output-denied' ? JSON.stringify({ error: 'The user denied this tool call' })
-            : undefined;
-// dev-only diagnostics (SYG675): the dev entry formats them (checks/chat.ts)
-const dev$2 = (...a) => g.__SYGNAL_DIAGNOSTICS__?.chat?.(...a);
-
 const EMPTY$1 = { type: 'object', properties: {} };
 function prepare(req, strict, seen, transport, dialect = 'openai', limits) {
     const sent = {};
     if (strict && typeof strict != 'function' && !seen.has('')) {
         seen.add('');
-        dev$2('SYG672', req, { transport });
+        dev$8('SYG672', req, { transport });
     }
     const fn = typeof strict == 'function' ? strict : undefined;
     // what the request has left of `limits` (strictSchemas counts it down)
@@ -19156,7 +19610,7 @@ function prepare(req, strict, seen, transport, dialect = 'openai', limits) {
             return { schema: s.schema, strict: true };
         if (!seen.has(what)) {
             seen.add(what);
-            dev$2('SYG675', req, { tool: what, errors: s.errors });
+            dev$8('SYG675', req, { tool: what, errors: s.errors });
         }
         return { schema, strict: false };
     };
@@ -19227,12 +19681,12 @@ function openResponses(options = {}) {
                 c.done = 1;
                 called++;
                 const name = c.name ?? item?.name;
-                return { type: 'tool-call', id: c.call_id ?? item?.call_id ?? id, name, input: p.input(name, json(args ?? item?.arguments ?? c.args)) };
+                return { type: 'tool-call', id: c.call_id ?? item?.call_id ?? id, name, input: p.input(name, json$1(args ?? item?.arguments ?? c.args)) };
             };
             for await (const { data } of sse(res)) {
                 if (data == '[DONE]')
                     break;
-                const e = json(data), t = e?.type;
+                const e = json$1(data), t = e?.type;
                 if (typeof t != 'string')
                     continue;
                 if (t == 'response.output_text.delta' || t == 'response.refusal.delta' || REASONING.test(t)) {
@@ -19324,13 +19778,13 @@ function chatCompletions(options = {}) {
             const done = function* () {
                 for (const c of calls)
                     if (c)
-                        yield { type: 'tool-call', id: c.id, name: c.name, input: p.input(c.name, json(c.args)) };
+                        yield { type: 'tool-call', id: c.id, name: c.name, input: p.input(c.name, json$1(c.args)) };
                 calls = [];
             };
             for await (const { data } of sse(res)) {
                 if (data == '[DONE]')
                     break;
-                const e = json(data);
+                const e = json$1(data);
                 if (!e || typeof e != 'object')
                     continue;
                 if (e.error)
@@ -19418,7 +19872,7 @@ function uiMessageStream(url, options = {}) {
             for await (const { data } of sse(res)) {
                 if (data == '[DONE]')
                     break;
-                const c = json(data), t = c?.type;
+                const c = json$1(data), t = c?.type;
                 if (typeof t != 'string')
                     continue;
                 if (ONE.test(t)) {
@@ -20149,7 +20603,7 @@ const commandBar = (options = {}) => {
                 ...(deny && { DENY: on(DOM, deny) }),
             };
         },
-        model: {
+        model: fromPrevious({
             INPUT: (s, v) => typeof v == 'string' && v !== s.text ? { ...s, text: v } : ABORT,
             RUN: {
                 STATE: (s, d, _n, p, o, k) => runStep(s, d, E(p, k, o))?.s || ABORT,
@@ -20185,7 +20639,7 @@ const commandBar = (options = {}) => {
             // a command ran (or was refused): the result; the input is cleared when it was this command
             DONE: (s, d) => s.status != 'running' ? ABORT
                 : { ...s, status: 'ready', command: null, pending: null, result: d, text: d?.ok && s.text.trim() === d.command ? '' : s.text },
-        },
+        }),
     })(options);
     return linked(b);
 };
@@ -20285,7 +20739,7 @@ function anthropicMessages(options = {}) {
                 return { inputTokens: i, outputTokens: o, totalTokens: i + o, ...(u.output_tokens_details?.thinking_tokens != null && { reasoningTokens: u.output_tokens_details.thinking_tokens }) };
             };
             for await (const { data } of sse(res)) {
-                const e = json(data), t = e?.type;
+                const e = json$1(data), t = e?.type;
                 if (typeof t != 'string')
                     continue;
                 if (t == 'message_start') {
@@ -20321,9 +20775,9 @@ function anthropicMessages(options = {}) {
                     if (b?.type == 'thinking' && b.signature)
                         yield { type: 'reasoning', delta: '', providerMetadata: { anthropic: { signature: b.signature } } };
                     else if (b?.type == 'tool_use')
-                        yield { type: 'tool-call', id: b.id, name: b.name, input: p.input(b.name, b.json ? json(b.json) : b.input ?? {}) };
+                        yield { type: 'tool-call', id: b.id, name: b.name, input: p.input(b.name, b.json ? json$1(b.json) : b.input ?? {}) };
                     else if (b?.type == 'server_tool_use')
-                        yield { type: 'tool-call', id: b.id, name: b.name, input: b.json ? json(b.json) : b.input ?? {}, executed: true, providerExecuted: true };
+                        yield { type: 'tool-call', id: b.id, name: b.name, input: b.json ? json$1(b.json) : b.input ?? {}, executed: true, providerExecuted: true };
                 }
                 else if (t == 'message_delta') {
                     if (e.delta?.stop_reason)
@@ -20463,10 +20917,10 @@ function agui(url, options = {}) {
                 if (!c || c.done)
                     return;
                 c.done = 1;
-                open.push({ type: 'tool-call', id, name: c.name, input: json(c.args || '{}') });
+                open.push({ type: 'tool-call', id, name: c.name, input: json$1(c.args || '{}') });
             };
             for await (const { data } of sse(res)) {
-                const e = json(data), t = e?.type;
+                const e = json$1(data), t = e?.type;
                 if (typeof t != 'string')
                     continue;
                 if (t == 'TEXT_MESSAGE_START') {
@@ -20514,7 +20968,7 @@ function agui(url, options = {}) {
                 else if (t == 'TOOL_CALL_RESULT') {
                     end(e.toolCallId);
                     yield* take(e.toolCallId);
-                    yield { type: 'tool-result', id: e.toolCallId, output: typeof e.content == 'string' ? json(e.content) : e.content };
+                    yield { type: 'tool-result', id: e.toolCallId, output: typeof e.content == 'string' ? json$1(e.content) : e.content };
                 }
                 else if (t == 'STATE_SNAPSHOT' || t == 'STATE_DELTA') {
                     state = t == 'STATE_SNAPSHOT' ? e.snapshot : applyPatch(state, e.delta);
@@ -21715,7 +22169,7 @@ function composeBehavior(catalog, options = {}) {
                         .map(({ key, name, value }) => ({ key, name, value })) }),
             };
         },
-        model: {
+        model: fromPrevious({
             PROMPT: (s, p) => typeof p == 'string' && p !== s.prompt ? { ...s, prompt: p } : ABORT,
             COMPOSE: { HOST: host(start), [S]: sink(start) },
             REPLY: {
@@ -21757,7 +22211,7 @@ function composeBehavior(catalog, options = {}) {
             CONTROL: (s, c) => c && typeof c.key == 'string' && typeof c.name == 'string'
                 ? { ...s, ui: { ...s.ui, [c.key]: { ...s.ui?.[c.key], [c.name]: c.value } } } : ABORT,
             DONE: () => ABORT,
-        },
+        }),
     })(rest);
 }
 
@@ -25822,7 +26276,7 @@ const compose = /*#__PURE__*/ Object.assign((catalog, options) => composeBehavio
  * is gone); set: the array with that element replaced (the state unchanged when it is gone).
  * Side-effect free.
  */
-const byId = (field, id, idKey = 'id') => ({
+const byId = (field, id, idKey = 'id') => Object.defineProperty({
     get: (s) => (Array.isArray(s?.[field]) ? s[field].find((x) => x?.[idKey] === id) : undefined),
     set: (s, v) => {
         const a = s?.[field];
@@ -25830,7 +26284,7 @@ const byId = (field, id, idKey = 'id') => ({
             return s;
         return { ...s, [field]: a.map((x) => (x?.[idKey] === id ? v : x)) };
     },
-});
+}, BINDING, { value: [field, id, idKey] });
 
 /**
  * ESM ports of xstream's `flattenConcurrently` and `flattenSequentially` extras