@shenora/react 0.12.0 → 0.14.0

package/dist/segmentBinder.js

@@ -169,6 +169,33 @@ export async function bindSegmentStream(options) {
      * completes, and two concurrent `appendBuffer` calls on one SourceBuffer throw `InvalidStateError`,
      * which surfaces as a stall with no obvious cause.
      */
+    /** Consecutive 503s, so a source that is slow to produce backs off instead of hammering. */
+    let waits = 0;
+    let waitTimer = null;
+    /**
+     * Come back for a segment the host has not finished producing.
+     *
+     * ⚠ Bounded, and it says so when it gives up: a wait that retries for ever is the same permanent
+     * spinner by a slower route. The cap is generous because the host's own 503 already means it is
+     * working — this is not a failure budget, it is a politeness one.
+     */
+    const retryLater = (uri) => {
+        if (disposed)
+            return;
+        if (++waits > 40) {
+            fail(`segments: ${uri} still answering 503 after ${waits} attempts — giving up`);
+            return;
+        }
+        const delay = Math.min(2000, 100 * waits);
+        say(`segments: ${uri} not ready (503) — retrying in ${delay}ms`);
+        if (waitTimer !== null)
+            clearTimeout(waitTimer);
+        waitTimer = setTimeout(() => {
+            waitTimer = null;
+            if (!disposed)
+                void pump();
+        }, delay);
+    };
     const pump = async () => {
         if (pumping || disposed)
             return;
@@ -184,12 +211,20 @@ export async function bindSegmentStream(options) {
                 const response = await doFetch(resolve(manifestUrl, entry.uri));
                 if (disposed)
                     return;
+                if (response.status === 503) {
+                    // 🔴 503 IS THE HOST SAYING "still producing" — a WAIT, and it must actually be waited FOR.
+                    // This used to say exactly that in a comment and then `fail()` and break, with nothing
+                    // scheduled to resume: a permanent spinner, on the one path the segment route uses to mean
+                    // "ask again". The producing side waits its own budget before answering, so both halves said
+                    // "wait" and neither came back.
+                    retryLater(entry.uri);
+                    break;
+                }
                 if (!response.ok) {
-                    // 503 is the host saying "still producing" — a WAIT, not a failure. The route answers it
-                    // rather than 404ing a source that is merely not ready yet.
                     fail(`segments: ${entry.uri} answered ${response.status}`);
                     break;
                 }
+                waits = 0; // progress: the next stall starts its backoff from the bottom again
                 await append(new Uint8Array(await response.arrayBuffer()));
                 appended.add(index);
                 if (disposed)
@@ -227,6 +262,11 @@ export async function bindSegmentStream(options) {
             if (disposed)
                 return;
             disposed = true;
+            // The 503 retry must not outlive the binding — it would re-enter a pump over a torn-down source.
+            if (waitTimer !== null) {
+                clearTimeout(waitTimer);
+                waitTimer = null;
+            }
             source.removeEventListener('startstreaming', onStart);
             source.removeEventListener('endstreaming', onEnd);
             element.removeEventListener('timeupdate', wake);

package/dist/segmentStream.js

@@ -168,6 +168,48 @@ export function codecsFromInitSegment(init) {
             at += size;
         }
     };
+    /**
+     * An ISO 14496-1 "expandable" descriptor length: 1–4 bytes, each with the high bit meaning "continue".
+     * Returns the value and the offset just past it.
+     */
+    const expandable = (at) => {
+        let value = 0;
+        let p = at;
+        for (let i = 0; i < 4; i++) {
+            const b = u8(p++);
+            value = (value << 7) | (b & 0x7f);
+            if ((b & 0x80) === 0)
+                break;
+        }
+        return [value, p];
+    };
+    /**
+     * The AAC audio object type declared inside an `esds`, or null when it cannot be read.
+     *
+     * Tolerant by design: it finds the DecoderConfigDescriptor rather than parsing the ES_Descriptor's
+     * optional fields, then steps its FIXED 13 bytes to the nested DecoderSpecificInfo, whose first 5 bits
+     * are the object type (2 = AAC-LC, 5 = HE-AAC, 29 = HE-AACv2, 42 = xHE-AAC).
+     */
+    const audioObjectType = (from, to) => {
+        for (let p = from; p + 2 < to; p++) {
+            if (u8(p) !== 0x04)
+                continue; // DecoderConfigDescriptor
+            const [, afterLength] = expandable(p + 1);
+            if (afterLength >= to || u8(afterLength) !== 0x40)
+                continue; // MPEG-4 Audio, or not ours
+            // objectTypeIndication(1) streamType(1) bufferSizeDB(3) maxBitrate(4) avgBitrate(4)
+            const nested = afterLength + 13;
+            if (nested + 1 >= to || u8(nested) !== 0x05)
+                continue; // DecoderSpecificInfo
+            const [, config] = expandable(nested + 1);
+            if (config >= to)
+                continue;
+            const aot = u8(config) >> 3;
+            // 31 is the escape for an extended type; not worth decoding for a codec string, and 0 is invalid.
+            return aot === 0 || aot === 31 ? null : aot;
+        }
+        return null;
+    };
     /** The `avcC`/`hvcC`/`esds` inside a sample entry, whose own fields come first. */
     const configuration = (format, start, end) => {
         // The child boxes start after the sample entry's own fields: the 8-byte SampleEntry base
@@ -196,17 +238,16 @@ export function codecsFromInitSegment(init) {
                 derived = `${format}.${spaces}${idc}.${(reversed >>> 0).toString(16).toUpperCase()}.` +
                     `${tier ? 'H' : 'L'}${level}`;
             }
-            else if (type === 'esds' && s + 21 <= end) {
-                // The audio object type, from the DecoderSpecificInfo's first 5 bits. Only AAC is ever copied
-                // here, so the walk stays a search rather than a full descriptor parser.
-                for (let p = s; p + 2 < end; p++) {
-                    if (u8(p) === 0x04 && u8(p + 2) === 0x40) {
-                        derived = `mp4a.40.${u8(p + 3) || 2}`;
-                        break;
-                    }
-                }
-                if (!derived)
-                    derived = 'mp4a.40.2';
+            else if (type === 'esds' && s + 8 <= end) {
+                // 🔴 THE AUDIO OBJECT TYPE LIVES IN THE DecoderSpecificInfo, not beside objectTypeIndication.
+                // This used to read the byte straight after the `0x40`, which is the STREAM TYPE — for audio
+                // that is `(5 << 2) | 1` = 0x15, so every short-form esds produced `mp4a.40.21`,
+                // `addSourceBuffer` threw, and nothing played. It also assumed a ONE-byte descriptor length; the
+                // length is "expandable" (up to 4 bytes, high bit continues). The kit's own muxer always writes
+                // the 4-byte form, so the old scan never matched OUR files and the fallback hid it — the bug was
+                // reachable only from a foreign muxer, which is exactly what this parser is for.
+                const aot = audioObjectType(s, end);
+                derived = `mp4a.40.${aot ?? 2}`;
             }
         });
         if (derived)

package/dist/store.js

@@ -13,12 +13,44 @@ function equivalent(a, b) {
         return true;
     if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
         return false;
-    // Arrays and plain objects only — anything exotic (Map, Date, a class) falls back to identity above.
-    if (Array.isArray(a) !== Array.isArray(b))
+    // Two different classes are never the same value, and this also separates an array from a bag.
+    const proto = Object.getPrototypeOf(a);
+    if (proto !== Object.getPrototypeOf(b))
         return false;
+    // 🔴 A Date, a Set and a Map keep their contents in INTERNAL SLOTS, so `Object.keys` is `[]` for every
+    // one of them — the key compare below then reports two of different contents EQUAL, which pinned such
+    // a selector to its first value for the component's life. Silent: the early return also skips the cache
+    // refresh, so it never self-corrects. These three answer for themselves.
+    if (a instanceof Date)
+        return Object.is(a.getTime(), b.getTime());
+    if (a instanceof Set) {
+        const setB = b;
+        if (a.size !== setB.size)
+            return false;
+        for (const value of a)
+            if (!setB.has(value))
+                return false;
+        return true;
+    }
+    if (a instanceof Map) {
+        const mapB = b;
+        if (a.size !== mapB.size)
+            return false;
+        for (const [key, value] of a) {
+            if (!mapB.has(key) || !Object.is(mapB.get(key), value))
+                return false;
+        }
+        return true;
+    }
     const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
+    if (aKeys.length !== Object.keys(b).length)
+        return false;
+    // ⚠ ZERO own keys on anything else exotic — a RegExp, a Promise, a class whose state is all private —
+    // means this compare learned NOTHING, so it must not answer "equal". A plain bag or an array genuinely
+    // IS empty. Class instances carrying own fields still compare shallowly, which is why the gate is on
+    // emptiness rather than on being a plain object: rejecting those would trade a stale render for
+    // React's "getSnapshot should be cached" loop.
+    if (aKeys.length === 0 && !Array.isArray(a) && proto !== Object.prototype && proto !== null)
         return false;
     return aKeys.every((k) => Object.prototype.hasOwnProperty.call(b, k)
         && Object.is(a[k], b[k]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shenora/react",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "React client for Shenora hosts on Windows, Android and iOS: correlated invoke/send/subscribe over the desktop postMessage bridge or the MAUI HybridWebView transport, typed module services, host-backed stores, and hooks for request tracking and media playback. Drop zones and window commands are desktop-only, because the capabilities are. Ships a browser fallback for pure-UI development.",
   "license": "MIT",
   "author": "Jiarong Gu",