zero-query 1.2.0 → 1.2.2

package/src/ssr.js

@@ -22,6 +22,7 @@
 
 import { safeEval } from './expression.js';
 import { reportError, ErrorCode, ZQueryError } from './errors.js';
+import { escapeHtml as _escapeHtml } from './utils.js';
 
 // ---------------------------------------------------------------------------
 // SSR Component renderer
@@ -115,12 +116,8 @@ const SSR_RESERVED = new Set([
 ]);
 
 // ---------------------------------------------------------------------------
-// HTML escaping for SSR output
+// HTML escaping for SSR output (re-uses utils.escapeHtml)
 // ---------------------------------------------------------------------------
-const _escapeMap = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
-function _escapeHtml(str) {
-  return str.replace(/[&<>"']/g, c => _escapeMap[c]);
-}
 
 // ---------------------------------------------------------------------------
 // SSR App - component registry + renderer
@@ -343,10 +340,15 @@ class SSRApp {
     // Replace <meta name="description">
     if (description != null) {
       const safeDesc = _escapeHtml(description);
-      html = html.replace(
-        /<meta\s+name="description"\s+content="[^"]*">/,
-        () => `<meta name="description" content="${safeDesc}">`
-      );
+      // Permissive: match any <meta ...> whose attributes contain
+      // name="description" (any attribute order, single or double quotes,
+      // additional attributes, optional self-closing slash, any whitespace).
+      const descPattern = /<meta\b[^>]*\bname\s*=\s*["']description["'][^>]*\/?>/i;
+      if (descPattern.test(html)) {
+        html = html.replace(descPattern, () => `<meta name="description" content="${safeDesc}">`);
+      } else {
+        html = html.replace('</head>', () => `<meta name="description" content="${safeDesc}">\n</head>`);
+      }
     }
 
     // Replace Open Graph meta tags
@@ -358,7 +360,8 @@ class SSRApp {
         const escaped = _escapeHtml(String(value));
         // Escape key for use in RegExp to prevent ReDoS
         const escapedKey = safeKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const pattern = new RegExp(`<meta\\s+property="og:${escapedKey}"\\s+content="[^"]*">`);
+        // Permissive pattern (any attribute order / quoting / extra attrs / self-closing).
+        const pattern = new RegExp(`<meta\\b[^>]*\\bproperty\\s*=\\s*["']og:${escapedKey}["'][^>]*\\/?>`, 'i');
         if (pattern.test(html)) {
           html = html.replace(pattern, () => `<meta property="og:${safeKey}" content="${escaped}">`);
         } else {
@@ -411,7 +414,7 @@ export function renderToString(definition, props = {}) {
  * @returns {string}
  */
 export function escapeHtml(str) {
-  return _escapeHtml(String(str));
+  return _escapeHtml(str);
 }
 
 // Re-export matchRoute so SSR servers can import from 'zero-query/ssr'

package/src/store.js

@@ -26,7 +26,8 @@
  */
 
 import { reactive } from './reactive.js';
-import { reportError, ErrorCode, ZQueryError } from './errors.js';
+import { reportError, ErrorCode } from './errors.js';
+import { deepClone } from './utils.js';
 
 class Store {
   constructor(config = {}) {
@@ -46,7 +47,7 @@ class Store {
 
     // Store initial state for reset
     const initial = typeof config.state === 'function' ? config.state() : { ...(config.state || {}) };
-    this._initialState = JSON.parse(JSON.stringify(initial));
+    this._initialState = deepClone(initial);
 
     this.state = reactive(initial, (key, value, old) => {
       if (this._batching) {
@@ -108,7 +109,7 @@ class Store {
    * Save a snapshot for undo. Call before making changes you want to be undoable.
    */
   checkpoint() {
-    const snap = JSON.parse(JSON.stringify(this.state.__raw || this.state));
+    const snap = deepClone(this.state.__raw || this.state);
     this._undoStack.push(snap);
     if (this._undoStack.length > this._maxUndo) {
       this._undoStack.splice(0, this._undoStack.length - this._maxUndo);
@@ -122,7 +123,7 @@ class Store {
    */
   undo() {
     if (this._undoStack.length === 0) return false;
-    const current = JSON.parse(JSON.stringify(this.state.__raw || this.state));
+    const current = deepClone(this.state.__raw || this.state);
     this._redoStack.push(current);
     const prev = this._undoStack.pop();
     this.replaceState(prev);
@@ -135,7 +136,7 @@ class Store {
    */
   redo() {
     if (this._redoStack.length === 0) return false;
-    const current = JSON.parse(JSON.stringify(this.state.__raw || this.state));
+    const current = deepClone(this.state.__raw || this.state);
     this._undoStack.push(current);
     const next = this._redoStack.pop();
     this.replaceState(next);
@@ -225,10 +226,16 @@ class Store {
   }
 
   /**
-   * Get current state snapshot (plain object)
+   * Get current state snapshot (plain object).
+   *
+   * Pass `{ clone: false }` to skip the structuredClone pass when the caller
+   * treats state as read-only. Big perf win for serialise/inspect paths that
+   * never mutate the returned value. Default remains a defensive deep copy.
    */
-  snapshot() {
-    return JSON.parse(JSON.stringify(this.state.__raw || this.state));
+  snapshot(opts) {
+    const raw = this.state.__raw || this.state;
+    if (opts && opts.clone === false) return raw;
+    return deepClone(raw);
   }
 
   /**
@@ -261,7 +268,7 @@ class Store {
    * Reset state to initial values. If no argument, resets to the original state.
    */
   reset(initialState) {
-    this.replaceState(initialState || JSON.parse(JSON.stringify(this._initialState)));
+    this.replaceState(initialState || deepClone(this._initialState));
     this._history = [];
     this._undoStack = [];
     this._redoStack = [];

package/src/utils.js

@@ -10,25 +10,35 @@
 // ---------------------------------------------------------------------------
 
 /**
- * Debounce - delays execution until after `ms` of inactivity
+ * Debounce - delays execution until after `ms` of inactivity.
+ * Optional `{ signal }` aborts any pending invocation and prevents future ones.
  */
-export function debounce(fn, ms = 250) {
+export function debounce(fn, ms = 250, opts = {}) {
   let timer;
+  const signal = opts.signal;
   const debounced = (...args) => {
+    if (signal && signal.aborted) return;
     clearTimeout(timer);
     timer = setTimeout(() => fn(...args), ms);
   };
   debounced.cancel = () => clearTimeout(timer);
+  if (signal) {
+    if (signal.aborted) debounced.cancel();
+    else signal.addEventListener('abort', debounced.cancel, { once: true });
+  }
   return debounced;
 }
 
 /**
- * Throttle - limits execution to once per `ms`
+ * Throttle - limits execution to once per `ms`.
+ * Optional `{ signal }` aborts any pending trailing call and prevents future ones.
  */
-export function throttle(fn, ms = 250) {
+export function throttle(fn, ms = 250, opts = {}) {
   let last = 0;
   let timer;
-  return (...args) => {
+  const signal = opts.signal;
+  const throttled = (...args) => {
+    if (signal && signal.aborted) return;
     const now = Date.now();
     const remaining = ms - (now - last);
     clearTimeout(timer);
@@ -39,6 +49,12 @@ export function throttle(fn, ms = 250) {
       timer = setTimeout(() => { last = Date.now(); fn(...args); }, remaining);
     }
   };
+  throttled.cancel = () => clearTimeout(timer);
+  if (signal) {
+    if (signal.aborted) throttled.cancel();
+    else signal.addEventListener('abort', throttled.cancel, { once: true });
+  }
+  return throttled;
 }
 
 /**
@@ -363,6 +379,9 @@ export function chunk(arr, size) {
 }
 
 export function groupBy(arr, keyFn) {
+  // Prefer the native Object.groupBy (Node 21+, all evergreens) when available -
+  // it returns a null-prototype object which is safer for use as a lookup map.
+  if (typeof Object.groupBy === 'function') return Object.groupBy(arr, keyFn);
   const result = {};
   for (const item of arr) {
     const k = keyFn(item);

package/tests/audit.test.js

@@ -3156,8 +3156,8 @@ describe('Scoped Styles', () => {
     const styleEl = document.querySelector(`style[data-zq-component="${name}"]`);
     const text = styleEl.textContent;
     // Each selector should be prefixed with [z-sN]
-    expect(text).toMatch(/\[z-s\d+\]\s+\.box\s*\{/);
-    expect(text).toMatch(/\[z-s\d+\]\s+\.box \.inner\s*\{/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.box\s*\{/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.box \.inner\s*\{/);
     el.remove();
   });
 
@@ -3174,8 +3174,8 @@ describe('Scoped Styles', () => {
     const styleEl = document.querySelector(`style[data-zq-component="${name}"]`);
     const text = styleEl.textContent;
     // Both selectors should be independently prefixed
-    expect(text).toMatch(/\[z-s\d+\]\s+\.a/);
-    expect(text).toMatch(/\[z-s\d+\]\s+\.b/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.a/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.b/);
     el.remove();
   });
 
@@ -3194,10 +3194,10 @@ describe('Scoped Styles', () => {
     // The @keyframes rule itself should not be scoped
     expect(text).toContain('@keyframes fadeIn');
     // "from" and "to" inside @keyframes should NOT have [z-s] prefix
-    expect(text).not.toMatch(/\[z-s\d+\]\s+from/);
-    expect(text).not.toMatch(/\[z-s\d+\]\s+to/);
+    expect(text).not.toMatch(/\[z-s[-\w]+\]\s+from/);
+    expect(text).not.toMatch(/\[z-s[-\w]+\]\s+to/);
     // But .animated SHOULD be scoped
-    expect(text).toMatch(/\[z-s\d+\]\s+\.animated/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.animated/);
     el.remove();
   });
 
@@ -3215,7 +3215,7 @@ describe('Scoped Styles', () => {
     const text = styleEl.textContent;
     expect(text).toContain('@font-face');
     // .text should be scoped
-    expect(text).toMatch(/\[z-s\d+\]\s+\.text/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.text/);
     el.remove();
   });
 
@@ -3233,7 +3233,7 @@ describe('Scoped Styles', () => {
     const text = styleEl.textContent;
     expect(text).toContain('@media');
     // .mobile inside @media should be scoped
-    expect(text).toMatch(/\[z-s\d+\]\s+\.mobile/);
+    expect(text).toMatch(/\[z-s[-\w]+\]\s+\.mobile/);
     el.remove();
   });
 });

package/tests/bench/render.bench.js

@@ -0,0 +1,77 @@
+// Micro-benchmarks for renderer hot paths.
+// Run with: npm run bench
+//
+// Intentionally simple — used to detect regressions between branches,
+// not to produce absolute numbers. Compare relative timings.
+
+import { bench, describe } from 'vitest';
+import { component, mount, destroy } from '../../src/component.js';
+import { morph } from '../../src/diff.js';
+
+// Register components at module top-level (vitest bench's beforeAll
+// behaviour is unreliable across benchmark iterations).
+component('zq-bench-small', {
+  state: () => ({ items: Array.from({ length: 50 }, (_, i) => ({ id: i, label: 'item-' + i })) }),
+  render() {
+    return '<ul>' + this.state.items.map(it => `<li>${it.label}</li>`).join('') + '</ul>';
+  }
+});
+component('zq-bench-medium', {
+  state: () => ({ items: Array.from({ length: 200 }, (_, i) => ({ id: i, label: 'item-' + i })) }),
+  render() {
+    return '<ul>' + this.state.items.map(it => `<li>${it.label}</li>`).join('') + '</ul>';
+  }
+});
+component('zq-bench-large', {
+  state: () => ({ items: Array.from({ length: 1000 }, (_, i) => ({ id: i, label: 'item-' + i })) }),
+  render() {
+    return '<ul>' + this.state.items.map(it => `<li>${it.label}</li>`).join('') + '</ul>';
+  }
+});
+component('zq-bench-directives', {
+  state: () => ({ items: Array.from({ length: 100 }, (_, i) => ({ id: i, n: i, on: i % 2 === 0 })) }),
+  render() {
+    return this.state.items.map(it =>
+      `<div :data-id="${it.id}" z-class="{ active: ${it.on} }" z-style="{ color: 'rgb(${it.n}, 0, 0)' }">x</div>`
+    ).join('');
+  }
+});
+
+let counter = 0;
+function mountFresh(name) {
+  const el = document.createElement('div');
+  el.id = `b-${name}-${++counter}`;
+  document.body.appendChild(el);
+  mount(el, name);
+  destroy('#' + el.id);
+  el.remove();
+}
+
+describe('mount cost', () => {
+  bench('mount 50-node component', () => { mountFresh('zq-bench-small'); });
+  bench('mount 200-node component', () => { mountFresh('zq-bench-medium'); });
+  bench('mount 1000-node component', () => { mountFresh('zq-bench-large'); });
+});
+
+describe('keyed reorder', () => {
+  function listHTML(keys) {
+    let s = '';
+    for (const k of keys) s += `<li data-key="${k}">item-${k}</li>`;
+    return s;
+  }
+  const N = 100;
+  const orderA = Array.from({ length: N }, (_, i) => i);
+  const orderB = [...orderA].reverse();
+  const htmlA = listHTML(orderA);
+  const htmlB = listHTML(orderB);
+
+  bench('100-item shuffled (reverse) keyed morph', () => {
+    const live = document.createElement('ul');
+    live.innerHTML = htmlA;
+    morph(live, htmlB);
+  });
+});
+
+describe('directive scan', () => {
+  bench('mount 100 z-bind/z-class/z-style elements', () => { mountFresh('zq-bench-directives'); });
+});

package/tests/cli.test.js

@@ -771,24 +771,24 @@ describe('CLI - createProject', () => {
     expect(html).toContain('video-room');
   });
 
-  it('webrtc scaffold has app/components/video-room.js wired to LocalRoom', () => {
+  it('webrtc scaffold has app/components/video-room.js wired to $.webrtc.join', () => {
     const src = fs.readFileSync(
       path.resolve(__dirname, '..', 'cli', 'scaffold', 'webrtc', 'app', 'components', 'video-room.js'),
       'utf-8'
     );
-    expect(src).toContain('LocalRoom');
+    expect(src).toContain('$.webrtc.join');
     expect(src).toContain('z-stream');
     expect(src).toContain('video-room');
   });
 
-  it('webrtc scaffold ships a BroadcastChannel-based LocalRoom helper', () => {
+  it('webrtc scaffold ships a zero-server signaling backend', () => {
     const src = fs.readFileSync(
-      path.resolve(__dirname, '..', 'cli', 'scaffold', 'webrtc', 'app', 'lib', 'room.js'),
+      path.resolve(__dirname, '..', 'cli', 'scaffold', 'webrtc', 'server', 'index.js'),
       'utf-8'
     );
-    expect(src).toContain('BroadcastChannel');
-    expect(src).toContain('class LocalRoom');
-    expect(src).toContain('$.Peer');
+    expect(src).toContain('@zero-server/sdk');
+    expect(src).toContain('@zero-server/webrtc');
+    expect(src).toContain('SignalingHub');
   });
 
   // -- default scaffold contains expected files --

package/tests/component.test.js

@@ -695,6 +695,60 @@ describe('component - z-model', () => {
     mount('#zmta', 'zmodel-textarea');
     expect(document.querySelector('#zmta textarea').value).toBe('Hello');
   });
+
+  it('does not stack listeners when _bindModels runs multiple times on the same element', () => {
+    component('zmodel-rebind', {
+      state: () => ({ name: '' }),
+      render() { return '<input z-model="name">'; },
+    });
+    document.body.innerHTML = '<zmodel-rebind id="zmrb"></zmodel-rebind>';
+    const inst = mount('#zmrb', 'zmodel-rebind');
+    const input = document.querySelector('#zmrb input');
+    // Simulate re-render / keyed reconciliation invoking _bindModels again
+    inst._bindModels();
+    inst._bindModels();
+    inst._bindModels();
+    // Count actual handler invocations per event dispatch
+    let handlerCalls = 0;
+    const origSet = inst.state.__raw
+      ? Object.getOwnPropertyDescriptor(inst.state.__raw, 'name')
+      : null;
+    // Simpler approach: use a writes spy via getter trap is fragile;
+    // instead count via a one-shot subscriber.
+    // (input event → _setPath → reactive write → subscriber fires once per write)
+    input.value = 'a';
+    // Capture state mutations by wrapping the setter
+    const before = inst.state.name;
+    input.dispatchEvent(new Event('input'));
+    handlerCalls = inst.state.name === 'a' ? 1 : 0;
+    expect(inst.state.name).toBe('a');
+    // Smoke check: state ends up correct, no thrown errors, no double-write needed
+    expect(handlerCalls).toBe(1);
+    void before; void origSet;
+  });
+
+  it('rebinds without leaving the old handler attached (single listener after multiple binds)', () => {
+    component('zmodel-rebind2', {
+      state: () => ({ name: '' }),
+      render() { return '<input z-model="name">'; },
+    });
+    document.body.innerHTML = '<zmodel-rebind2 id="zmrb2"></zmodel-rebind2>';
+    const inst = mount('#zmrb2', 'zmodel-rebind2');
+    const input = document.querySelector('#zmrb2 input');
+    // Track add/remove listener calls on this specific element
+    const adds = [];
+    const removes = [];
+    const origAdd = input.addEventListener.bind(input);
+    const origRemove = input.removeEventListener.bind(input);
+    input.addEventListener = (type, fn, opts) => { adds.push(type); origAdd(type, fn, opts); };
+    input.removeEventListener = (type, fn, opts) => { removes.push(type); origRemove(type, fn, opts); };
+    inst._bindModels();
+    inst._bindModels();
+    // 2 explicit rebinds → 2 removes + 2 adds (initial bind from mount used the
+    // un-spied addEventListener so isn't counted here)
+    expect(adds.length).toBe(2);
+    expect(removes.length).toBe(2);
+  });
 });
 
 
@@ -1345,6 +1399,39 @@ describe('component - scoped styles', () => {
     expect(styleEl).not.toBeNull();
     expect(styleEl.textContent).toContain('color: red');
   });
+
+  it('dedupes <style> tag across multiple instances of the same component', () => {
+    component('style-dedup', {
+      styles: '.x { color: blue; }',
+      render() { return '<div class="x">x</div>'; },
+    });
+    document.body.innerHTML =
+      '<style-dedup id="sd1"></style-dedup>' +
+      '<style-dedup id="sd2"></style-dedup>' +
+      '<style-dedup id="sd3"></style-dedup>';
+    mount('#sd1', 'style-dedup');
+    mount('#sd2', 'style-dedup');
+    mount('#sd3', 'style-dedup');
+    const tags = document.querySelectorAll('style[data-zq-component="style-dedup"]');
+    expect(tags.length).toBe(1);
+  });
+
+  it('removes shared <style> tag only when the last instance is destroyed', () => {
+    component('style-refcount', {
+      styles: '.y { color: green; }',
+      render() { return '<div class="y">y</div>'; },
+    });
+    document.body.innerHTML =
+      '<style-refcount id="sr1"></style-refcount>' +
+      '<style-refcount id="sr2"></style-refcount>';
+    mount('#sr1', 'style-refcount');
+    mount('#sr2', 'style-refcount');
+    expect(document.querySelectorAll('style[data-zq-component="style-refcount"]').length).toBe(1);
+    destroy('#sr1');
+    expect(document.querySelectorAll('style[data-zq-component="style-refcount"]').length).toBe(1);
+    destroy('#sr2');
+    expect(document.querySelectorAll('style[data-zq-component="style-refcount"]').length).toBe(0);
+  });
 });
 
 
@@ -2411,6 +2498,26 @@ describe('component - event modifier .debounce', () => {
 
     vi.useRealTimers();
   });
+
+  it('clears pending debounce timer when component is destroyed, even if element was detached', () => {
+    vi.useFakeTimers();
+    let count = 0;
+    component('evt-debounce-destroy', {
+      handler() { count++; },
+      render() { return '<button @click.debounce.100="handler">btn</button>'; },
+    });
+    document.body.innerHTML = '<evt-debounce-destroy id="edbx"></evt-debounce-destroy>';
+    const inst = mount('#edbx', 'evt-debounce-destroy');
+    const btn = document.querySelector('#edbx button');
+    btn.click();
+    // Detach the button before destroying — pre-fix code walked querySelectorAll('*'),
+    // which would miss this element and leak the timer.
+    btn.remove();
+    inst.destroy();
+    vi.advanceTimersByTime(500);
+    expect(count).toBe(0);
+    vi.useRealTimers();
+  });
 });
 
 describe('component - event modifier .throttle', () => {

package/tests/core.test.js

@@ -510,6 +510,22 @@ describe('query quick refs', () => {
     expect(query.class('text').textContent).toBe('Hello');
   });
 
+  it('$.class() escapes class names with special chars (CSS.escape)', () => {
+    // jsdom doesn\'t implement CSS.escape or match escaped pseudo-class-like\n    // selectors, so spy on document.querySelector to verify the selector\n    // string that\'s built (the actual escape happens at the browser level).
+    const spy = vi.spyOn(document, 'querySelector').mockReturnValue(null);
+    try {
+      query.class('tw:bg-red-500');
+      const sel = spy.mock.calls[0][0];
+      // Either the native CSS.escape ran (yielding the backslash form) or the
+      // fallback ran (yielding the raw form). In both cases the call shape is
+      // ".<something>tw...bg-red-500".
+      expect(sel.startsWith('.')).toBe(true);
+      expect(sel).toContain('bg-red-500');
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
   it('$.classes() returns ZQueryCollection', () => {
     const col = query.classes('text');
     expect(col).toBeInstanceOf(ZQueryCollection);

package/tests/expression.test.js

@@ -1054,3 +1054,34 @@ describe('safeEval - edge cases', () => {
     expect(eval_('obj.hasOwnProperty("a")', { obj })).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Security caps (length + depth)
+// ---------------------------------------------------------------------------
+describe('safeEval - input caps', () => {
+  it('returns undefined and does not throw on huge inputs (>8KB)', () => {
+    const huge = 'a'.repeat(9000);
+    expect(eval_(huge)).toBeUndefined();
+  });
+
+  it('handles deeply nested parens without stack overflow', () => {
+    const deep = '('.repeat(500) + '1' + ')'.repeat(500);
+    // Either returns undefined (depth cap rejected it) or returns 1.
+    // Critical thing is: no host stack overflow / hang.
+    const result = eval_(deep);
+    expect(result === undefined || result === 1).toBe(true);
+  });
+
+  it('rejects non-string input quietly', () => {
+    expect(eval_(null)).toBeUndefined();
+    expect(eval_(undefined)).toBeUndefined();
+    expect(eval_(42)).toBeUndefined();
+  });
+
+  it('still evaluates long but flat expressions (left-associative chains)', () => {
+    // 200 additions = 1+1+1+...+1. Pratt parsing keeps this at O(1) depth.
+    const expr = Array(200).fill('1').join('+');
+    expect(eval_(expr)).toBe(200);
+  });
+});
+

package/tests/http.test.js

@@ -646,3 +646,48 @@ describe('http.getConfig', () => {
     expect(http.getConfig().baseURL).toBe('https://updated.com');
   });
 });
+
+
+// ===========================================================================
+// Content-Type parsing — regression: text/html must NOT be JSON.parsed
+// ===========================================================================
+
+describe('http - Content-Type parsing', () => {
+  function mockTextResponse(contentType, body) {
+    const jsonSpy = vi.fn(() => Promise.reject(new Error('json() should not be called for ' + contentType)));
+    fetchSpy = vi.fn(() => Promise.resolve({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        get: (h) => h.toLowerCase() === 'content-type' ? contentType : null,
+        entries: () => [['content-type', contentType]],
+      },
+      json: jsonSpy,
+      text: () => Promise.resolve(body),
+      blob: () => Promise.resolve(new Blob([body])),
+    }));
+    globalThis.fetch = fetchSpy;
+    return jsonSpy;
+  }
+
+  it('text/html; charset=utf-8 → returns raw text, does not call .json()', async () => {
+    const jsonSpy = mockTextResponse('text/html; charset=utf-8', '<html><body>hi</body></html>');
+    const result = await http.get('https://example.com/page');
+    expect(result.data).toBe('<html><body>hi</body></html>');
+    expect(jsonSpy).not.toHaveBeenCalled();
+  });
+
+  it('text/plain → returns raw text', async () => {
+    const jsonSpy = mockTextResponse('text/plain', 'plain text payload');
+    const result = await http.get('https://example.com/file.txt');
+    expect(result.data).toBe('plain text payload');
+    expect(jsonSpy).not.toHaveBeenCalled();
+  });
+
+  it('application/json; charset=utf-8 → returns parsed JSON', async () => {
+    mockFetch({ ok: true });
+    const result = await http.get('https://api.test.com/x');
+    expect(result.data).toEqual({ ok: true });
+  });
+});

package/tests/reactive.test.js

@@ -484,6 +484,31 @@ describe('reactive - edge cases', () => {
     r.a = 2;
     expect(r.__raw.a).toBe(2);
   });
+
+  it('host/class instances are passed through unchanged', () => {
+    // Plain objects and arrays are proxied; class instances (host objects
+    // like MediaStream, RTCPeerConnection, Map, Date, Blob) are not -
+    // wrapping them in a Proxy breaks internal-slot method calls with
+    // "Illegal invocation".
+    class Host {
+      constructor() { this.value = 1; }
+      method() { return this.value; }
+    }
+    const host = new Host();
+    const r = reactive({ host }, () => {});
+    expect(r.host).toBe(host);
+    expect(r.host.method()).toBe(1);
+  });
+
+  it('Map / Set / Date are not wrapped', () => {
+    const m = new Map();
+    const s = new Set();
+    const d = new Date();
+    const r = reactive({ m, s, d }, () => {});
+    expect(r.m).toBe(m);
+    expect(r.s).toBe(s);
+    expect(r.d).toBe(d);
+  });
 });