@pyreon/preact-compat 0.13.1 → 0.14.0

package/lib/jsx-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-runtime.js","names":[],"sources":["../src/jsx-runtime.ts"],"sourcesContent":["/**\n * Compat JSX runtime for Preact compatibility mode.\n *\n * When `jsxImportSource` is redirected to `@pyreon/preact-compat` (via the vite\n * plugin's `compat: \"preact\"` option), OXC rewrites JSX to import from this file.\n *\n * For component VNodes, we wrap the component function so it returns a reactive\n * accessor — enabling Preact-style re-renders on state change while Pyreon's\n * existing renderer handles all DOM work.\n */\n\nimport type { ComponentFn, Props, VNode, VNodeChild } from '@pyreon/core'\nimport { Fragment, h } from '@pyreon/core'\nimport { signal } from '@pyreon/reactivity'\n\nexport { Fragment }\n\n// ─── Render context (used by hooks) ──────────────────────────────────────────\n\nexport interface RenderContext {\n  hooks: unknown[]\n  scheduleRerender: () => void\n  /** Effect entries pending execution after render */\n  pendingEffects: EffectEntry[]\n  /** Layout effect entries pending execution after render */\n  pendingLayoutEffects: EffectEntry[]\n  /** Set to true when the component is unmounted */\n  unmounted: boolean\n}\n\nexport interface EffectEntry {\n  fn: () => (() => void) | void\n  deps: unknown[] | undefined\n  cleanup: (() => void) | undefined\n}\n\nlet _currentCtx: RenderContext | null = null\nlet _hookIndex = 0\n\nexport function getCurrentCtx(): RenderContext | null {\n  return _currentCtx\n}\n\nexport function getHookIndex(): number {\n  return _hookIndex++\n}\n\nexport function beginRender(ctx: RenderContext): void {\n  _currentCtx = ctx\n  _hookIndex = 0\n  ctx.pendingEffects = []\n  ctx.pendingLayoutEffects = []\n}\n\nexport function endRender(): void {\n  _currentCtx = null\n  _hookIndex = 0\n}\n\n// ─── Effect runners ──────────────────────────────────────────────────────────\n\nfunction runLayoutEffects(entries: EffectEntry[]): void {\n  for (const entry of entries) {\n    if (entry.cleanup) entry.cleanup()\n    const cleanup = entry.fn()\n    entry.cleanup = typeof cleanup === 'function' ? cleanup : undefined\n  }\n}\n\nfunction scheduleEffects(ctx: RenderContext, entries: EffectEntry[]): void {\n  if (entries.length === 0) return\n  queueMicrotask(() => {\n    for (const entry of entries) {\n      if (ctx.unmounted) return\n      if (entry.cleanup) entry.cleanup()\n      const cleanup = entry.fn()\n      entry.cleanup = typeof cleanup === 'function' ? cleanup : undefined\n    }\n  })\n}\n\n// ─── Component wrapping ──────────────────────────────────────────────────────\n\nconst _wrapperCache = new WeakMap<Function, ComponentFn>()\n\nfunction wrapCompatComponent(preactComponent: Function): ComponentFn {\n  let wrapped = _wrapperCache.get(preactComponent)\n  if (wrapped) return wrapped\n\n  // The wrapper returns a reactive accessor (() => VNodeChild) which Pyreon's\n  // mountChild treats as a reactive expression via mountReactive.\n  wrapped = ((props: Props) => {\n    const ctx: RenderContext = {\n      hooks: [],\n      scheduleRerender: () => {\n        // Will be replaced below after version signal is created\n      },\n      pendingEffects: [],\n      pendingLayoutEffects: [],\n      unmounted: false,\n    }\n\n    const version = signal(0)\n    let updateScheduled = false\n\n    ctx.scheduleRerender = () => {\n      if (ctx.unmounted || updateScheduled) return\n      updateScheduled = true\n      queueMicrotask(() => {\n        updateScheduled = false\n        if (!ctx.unmounted) version.set(version.peek() + 1)\n      })\n    }\n\n    // Return reactive accessor — Pyreon's mountChild calls mountReactive\n    return () => {\n      version() // tracked read — triggers re-execution when state changes\n      beginRender(ctx)\n      const result = (preactComponent as ComponentFn)(props)\n      const layoutEffects = ctx.pendingLayoutEffects\n      const effects = ctx.pendingEffects\n      endRender()\n\n      runLayoutEffects(layoutEffects)\n      scheduleEffects(ctx, effects)\n\n      return result\n    }\n  }) as unknown as ComponentFn\n\n  _wrapperCache.set(preactComponent, wrapped)\n  return wrapped\n}\n\n// ─── JSX functions ───────────────────────────────────────────────────────────\n\nexport function jsx(\n  type: string | ComponentFn | symbol,\n  props: Props & { children?: VNodeChild | VNodeChild[] },\n  key?: string | number | null,\n): VNode {\n  const { children, ...rest } = props\n  const propsWithKey = (key != null ? { ...rest, key } : rest) as Props\n\n  if (typeof type === 'function') {\n    // Wrap Preact-style component for re-render support\n    const wrapped = wrapCompatComponent(type)\n    const componentProps = children !== undefined ? { ...propsWithKey, children } : propsWithKey\n    return h(wrapped, componentProps)\n  }\n\n  // DOM element or symbol (Fragment): children go in vnode.children\n  const childArray = children === undefined ? [] : Array.isArray(children) ? children : [children]\n\n  return h(type, propsWithKey, ...(childArray as VNodeChild[]))\n}\n\nexport const jsxs = jsx\nexport const jsxDEV = jsx\n"],"mappings":";;;;AAoCA,IAAI,cAAoC;AACxC,IAAI,aAAa;AAUjB,SAAgB,YAAY,KAA0B;AACpD,eAAc;AACd,cAAa;AACb,KAAI,iBAAiB,EAAE;AACvB,KAAI,uBAAuB,EAAE;;AAG/B,SAAgB,YAAkB;AAChC,eAAc;AACd,cAAa;;AAKf,SAAS,iBAAiB,SAA8B;AACtD,MAAK,MAAM,SAAS,SAAS;AAC3B,MAAI,MAAM,QAAS,OAAM,SAAS;EAClC,MAAM,UAAU,MAAM,IAAI;AAC1B,QAAM,UAAU,OAAO,YAAY,aAAa,UAAU;;;AAI9D,SAAS,gBAAgB,KAAoB,SAA8B;AACzE,KAAI,QAAQ,WAAW,EAAG;AAC1B,sBAAqB;AACnB,OAAK,MAAM,SAAS,SAAS;AAC3B,OAAI,IAAI,UAAW;AACnB,OAAI,MAAM,QAAS,OAAM,SAAS;GAClC,MAAM,UAAU,MAAM,IAAI;AAC1B,SAAM,UAAU,OAAO,YAAY,aAAa,UAAU;;GAE5D;;AAKJ,MAAM,gCAAgB,IAAI,SAAgC;AAE1D,SAAS,oBAAoB,iBAAwC;CACnE,IAAI,UAAU,cAAc,IAAI,gBAAgB;AAChD,KAAI,QAAS,QAAO;AAIpB,aAAY,UAAiB;EAC3B,MAAM,MAAqB;GACzB,OAAO,EAAE;GACT,wBAAwB;GAGxB,gBAAgB,EAAE;GAClB,sBAAsB,EAAE;GACxB,WAAW;GACZ;EAED,MAAM,UAAU,OAAO,EAAE;EACzB,IAAI,kBAAkB;AAEtB,MAAI,yBAAyB;AAC3B,OAAI,IAAI,aAAa,gBAAiB;AACtC,qBAAkB;AAClB,wBAAqB;AACnB,sBAAkB;AAClB,QAAI,CAAC,IAAI,UAAW,SAAQ,IAAI,QAAQ,MAAM,GAAG,EAAE;KACnD;;AAIJ,eAAa;AACX,YAAS;AACT,eAAY,IAAI;GAChB,MAAM,SAAU,gBAAgC,MAAM;GACtD,MAAM,gBAAgB,IAAI;GAC1B,MAAM,UAAU,IAAI;AACpB,cAAW;AAEX,oBAAiB,cAAc;AAC/B,mBAAgB,KAAK,QAAQ;AAE7B,UAAO;;;AAIX,eAAc,IAAI,iBAAiB,QAAQ;AAC3C,QAAO;;AAKT,SAAgB,IACd,MACA,OACA,KACO;CACP,MAAM,EAAE,UAAU,GAAG,SAAS;CAC9B,MAAM,eAAgB,OAAO,OAAO;EAAE,GAAG;EAAM;EAAK,GAAG;AAEvD,KAAI,OAAO,SAAS,WAIlB,QAAO,EAFS,oBAAoB,KAAK,EAClB,aAAa,SAAY;EAAE,GAAG;EAAc;EAAU,GAAG,aAC/C;AAMnC,QAAO,EAAE,MAAM,cAAc,GAFV,aAAa,SAAY,EAAE,GAAG,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS,CAEnC;;AAG/D,MAAa,OAAO"}
+{"version":3,"file":"jsx-runtime.js","names":[],"sources":["../src/jsx-runtime.ts"],"sourcesContent":["/**\n * Compat JSX runtime for Preact compatibility mode.\n *\n * When `jsxImportSource` is redirected to `@pyreon/preact-compat` (via the vite\n * plugin's `compat: \"preact\"` option), OXC rewrites JSX to import from this file.\n *\n * For component VNodes, we wrap the component function so it returns a reactive\n * accessor — enabling Preact-style re-renders on state change while Pyreon's\n * existing renderer handles all DOM work.\n */\n\nimport type { ComponentFn, Props, VNode, VNodeChild } from '@pyreon/core'\nimport { Fragment, h, onUnmount } from '@pyreon/core'\nimport { signal } from '@pyreon/reactivity'\nimport type { Component } from './index'\n\nexport { Fragment }\n\n// ─── Render context (used by hooks) ──────────────────────────────────────────\n\nexport interface RenderContext {\n  hooks: unknown[]\n  scheduleRerender: () => void\n  /** Effect entries pending execution after render */\n  pendingEffects: EffectEntry[]\n  /** Layout effect entries pending execution after render */\n  pendingLayoutEffects: EffectEntry[]\n  /** Set to true when the component is unmounted */\n  unmounted: boolean\n}\n\nexport interface EffectEntry {\n  fn: () => (() => void) | void\n  deps: unknown[] | undefined\n  cleanup: (() => void) | undefined\n}\n\nlet _currentCtx: RenderContext | null = null\nlet _hookIndex = 0\n\nexport function getCurrentCtx(): RenderContext | null {\n  return _currentCtx\n}\n\nexport function getHookIndex(): number {\n  return _hookIndex++\n}\n\nexport function beginRender(ctx: RenderContext): void {\n  _currentCtx = ctx\n  _hookIndex = 0\n  ctx.pendingEffects = []\n  ctx.pendingLayoutEffects = []\n}\n\nexport function endRender(): void {\n  _currentCtx = null\n  _hookIndex = 0\n}\n\n// ─── Effect runners ──────────────────────────────────────────────────────────\n\nfunction runLayoutEffects(entries: EffectEntry[]): void {\n  for (const entry of entries) {\n    if (entry.cleanup) entry.cleanup()\n    const cleanup = entry.fn()\n    entry.cleanup = typeof cleanup === 'function' ? cleanup : undefined\n  }\n}\n\nfunction scheduleEffects(ctx: RenderContext, entries: EffectEntry[]): void {\n  if (entries.length === 0) return\n  queueMicrotask(() => {\n    for (const entry of entries) {\n      if (ctx.unmounted) return\n      if (entry.cleanup) entry.cleanup()\n      const cleanup = entry.fn()\n      entry.cleanup = typeof cleanup === 'function' ? cleanup : undefined\n    }\n  })\n}\n\n// ─── Native component marker ────────────────────────────────────────────────\n\nconst NATIVE_COMPONENT = Symbol.for('pyreon:native-compat')\n\n// ─── Class component detection ──────────────────────────────────────────────\n\nfunction isClassComponent(type: Function): boolean {\n  return type.prototype != null && typeof type.prototype.render === 'function'\n}\n\n// ─── Class component wrapping ───────────────────────────────────────────────\n\nfunction wrapClassComponent(ClassComp: Function): ComponentFn {\n  const wrapped = ((props: Props) => {\n    const instance = new (ClassComp as new (props: Props) => Component)(props)\n    const version = signal(0)\n    let updateScheduled = false\n\n    // Override setState to trigger re-render via version signal\n    const origSetState = instance.setState.bind(instance)\n    instance.setState = (partial: Partial<Record<string, unknown>>) => {\n      origSetState(partial)\n      if (!updateScheduled) {\n        updateScheduled = true\n        queueMicrotask(() => {\n          updateScheduled = false\n          version.set(version.peek() + 1)\n        })\n      }\n    }\n\n    // Override forceUpdate\n    instance.forceUpdate = () => {\n      version.set(version.peek() + 1)\n    }\n\n    // Lifecycle: componentWillUnmount\n    let didMountFired = false\n    onUnmount(() => {\n      if (typeof instance.componentWillUnmount === 'function') {\n        instance.componentWillUnmount()\n      }\n    })\n\n    // Return reactive accessor for re-renders\n    return () => {\n      const ver = version() // track for re-renders\n      instance.props = props // update props on re-render\n\n      // shouldComponentUpdate only applies after mount (ver > 0 means setState/forceUpdate)\n      if (didMountFired && ver > 0 && typeof instance.shouldComponentUpdate === 'function') {\n        if (!instance.shouldComponentUpdate(props, instance.state)) {\n          return instance._lastResult // skip render\n        }\n      }\n\n      const result = instance.render()\n      instance._lastResult = result\n\n      // componentDidMount fires once after the initial render settles\n      if (!didMountFired) {\n        didMountFired = true\n        if (typeof instance.componentDidMount === 'function') {\n          queueMicrotask(() => instance.componentDidMount!())\n        }\n      } else if (ver > 0) {\n        // componentDidUpdate only fires on explicit re-renders (setState/forceUpdate)\n        if (typeof instance.componentDidUpdate === 'function') {\n          queueMicrotask(() => instance.componentDidUpdate!())\n        }\n      }\n\n      return result\n    }\n  }) as unknown as ComponentFn\n  return wrapped\n}\n\n// ─── Component wrapping ──────────────────────────────────────────────────────\n\nconst _wrapperCache = new WeakMap<Function, ComponentFn>()\n\nfunction wrapCompatComponent(preactComponent: Function): ComponentFn {\n  let wrapped = _wrapperCache.get(preactComponent)\n  if (wrapped) return wrapped\n\n  // Handle class components (those with prototype.render)\n  if (isClassComponent(preactComponent)) {\n    wrapped = wrapClassComponent(preactComponent)\n    _wrapperCache.set(preactComponent, wrapped)\n    return wrapped\n  }\n\n  // The wrapper returns a reactive accessor (() => VNodeChild) which Pyreon's\n  // mountChild treats as a reactive expression via mountReactive.\n  wrapped = ((props: Props) => {\n    const ctx: RenderContext = {\n      hooks: [],\n      scheduleRerender: () => {\n        // Will be replaced below after version signal is created\n      },\n      pendingEffects: [],\n      pendingLayoutEffects: [],\n      unmounted: false,\n    }\n\n    const version = signal(0)\n    let updateScheduled = false\n\n    ctx.scheduleRerender = () => {\n      if (ctx.unmounted || updateScheduled) return\n      updateScheduled = true\n      queueMicrotask(() => {\n        updateScheduled = false\n        if (!ctx.unmounted) version.set(version.peek() + 1)\n      })\n    }\n\n    // Register cleanup for all hooks on unmount\n    onUnmount(() => {\n      ctx.unmounted = true\n      for (const hook of ctx.hooks) {\n        if (hook && typeof hook === 'object' && 'cleanup' in hook) {\n          const entry = hook as EffectEntry\n          if (typeof entry.cleanup === 'function') entry.cleanup()\n        }\n      }\n    })\n\n    // Return reactive accessor — Pyreon's mountChild calls mountReactive\n    return () => {\n      version() // tracked read — triggers re-execution when state changes\n      beginRender(ctx)\n      const result = (preactComponent as ComponentFn)(props)\n      const layoutEffects = ctx.pendingLayoutEffects\n      const effects = ctx.pendingEffects\n      endRender()\n\n      runLayoutEffects(layoutEffects)\n      scheduleEffects(ctx, effects)\n\n      return result\n    }\n  }) as unknown as ComponentFn\n\n  _wrapperCache.set(preactComponent, wrapped)\n  return wrapped\n}\n\n// ─── JSX functions ───────────────────────────────────────────────────────────\n\nexport function jsx(\n  type: string | ComponentFn | symbol,\n  props: Props & { children?: VNodeChild | VNodeChild[] },\n  key?: string | number | null,\n): VNode {\n  const { children, ...rest } = props\n  const propsWithKey = (key != null ? { ...rest, key } : rest) as Props\n\n  if (typeof type === 'function') {\n    const componentProps = children !== undefined ? { ...propsWithKey, children } : propsWithKey\n    // Native Pyreon components (e.g. context Provider) skip compat wrapping\n    if ((type as unknown as Record<symbol, boolean>)[NATIVE_COMPONENT]) {\n      return h(type as ComponentFn, componentProps)\n    }\n    // Wrap Preact-style component for re-render support\n    const wrapped = wrapCompatComponent(type)\n    return h(wrapped, componentProps)\n  }\n\n  // DOM element or symbol (Fragment): children go in vnode.children\n  const childArray = children === undefined ? [] : Array.isArray(children) ? children : [children]\n\n  // Map Preact-style attributes to standard HTML attributes\n  if (typeof type === 'string') {\n    if (propsWithKey.className !== undefined) {\n      propsWithKey.class = propsWithKey.className\n      delete propsWithKey.className\n    }\n    if (propsWithKey.htmlFor !== undefined) {\n      propsWithKey.for = propsWithKey.htmlFor\n      delete propsWithKey.htmlFor\n    }\n\n    // Preact's onChange fires on every keystroke for form elements (like onInput)\n    if (\n      (type === 'input' || type === 'textarea' || type === 'select') &&\n      propsWithKey.onChange !== undefined\n    ) {\n      if (propsWithKey.onInput === undefined) {\n        propsWithKey.onInput = propsWithKey.onChange\n      }\n      delete propsWithKey.onChange\n    }\n\n    // autoFocus → autofocus\n    if (propsWithKey.autoFocus !== undefined) {\n      propsWithKey.autofocus = propsWithKey.autoFocus\n      delete propsWithKey.autoFocus\n    }\n\n    // defaultValue / defaultChecked → value / checked when no controlled value\n    if (type === 'input' || type === 'textarea') {\n      if (propsWithKey.defaultValue !== undefined && propsWithKey.value === undefined) {\n        propsWithKey.value = propsWithKey.defaultValue\n        delete propsWithKey.defaultValue\n      }\n      if (propsWithKey.defaultChecked !== undefined && propsWithKey.checked === undefined) {\n        propsWithKey.checked = propsWithKey.defaultChecked\n        delete propsWithKey.defaultChecked\n      }\n    }\n\n    // Strip Preact-only props that have no DOM equivalent\n    delete propsWithKey.suppressHydrationWarning\n  }\n\n  return h(type, propsWithKey, ...(childArray as VNodeChild[]))\n}\n\nexport const jsxs = jsx\nexport const jsxDEV = jsx\n"],"mappings":";;;;AAqCA,IAAI,cAAoC;AACxC,IAAI,aAAa;AAUjB,SAAgB,YAAY,KAA0B;AACpD,eAAc;AACd,cAAa;AACb,KAAI,iBAAiB,EAAE;AACvB,KAAI,uBAAuB,EAAE;;AAG/B,SAAgB,YAAkB;AAChC,eAAc;AACd,cAAa;;AAKf,SAAS,iBAAiB,SAA8B;AACtD,MAAK,MAAM,SAAS,SAAS;AAC3B,MAAI,MAAM,QAAS,OAAM,SAAS;EAClC,MAAM,UAAU,MAAM,IAAI;AAC1B,QAAM,UAAU,OAAO,YAAY,aAAa,UAAU;;;AAI9D,SAAS,gBAAgB,KAAoB,SAA8B;AACzE,KAAI,QAAQ,WAAW,EAAG;AAC1B,sBAAqB;AACnB,OAAK,MAAM,SAAS,SAAS;AAC3B,OAAI,IAAI,UAAW;AACnB,OAAI,MAAM,QAAS,OAAM,SAAS;GAClC,MAAM,UAAU,MAAM,IAAI;AAC1B,SAAM,UAAU,OAAO,YAAY,aAAa,UAAU;;GAE5D;;AAKJ,MAAM,mBAAmB,OAAO,IAAI,uBAAuB;AAI3D,SAAS,iBAAiB,MAAyB;AACjD,QAAO,KAAK,aAAa,QAAQ,OAAO,KAAK,UAAU,WAAW;;AAKpE,SAAS,mBAAmB,WAAkC;CAC5D,MAAM,YAAY,UAAiB;EACjC,MAAM,WAAW,IAAK,UAA8C,MAAM;EAC1E,MAAM,UAAU,OAAO,EAAE;EACzB,IAAI,kBAAkB;EAGtB,MAAM,eAAe,SAAS,SAAS,KAAK,SAAS;AACrD,WAAS,YAAY,YAA8C;AACjE,gBAAa,QAAQ;AACrB,OAAI,CAAC,iBAAiB;AACpB,sBAAkB;AAClB,yBAAqB;AACnB,uBAAkB;AAClB,aAAQ,IAAI,QAAQ,MAAM,GAAG,EAAE;MAC/B;;;AAKN,WAAS,oBAAoB;AAC3B,WAAQ,IAAI,QAAQ,MAAM,GAAG,EAAE;;EAIjC,IAAI,gBAAgB;AACpB,kBAAgB;AACd,OAAI,OAAO,SAAS,yBAAyB,WAC3C,UAAS,sBAAsB;IAEjC;AAGF,eAAa;GACX,MAAM,MAAM,SAAS;AACrB,YAAS,QAAQ;AAGjB,OAAI,iBAAiB,MAAM,KAAK,OAAO,SAAS,0BAA0B,YACxE;QAAI,CAAC,SAAS,sBAAsB,OAAO,SAAS,MAAM,CACxD,QAAO,SAAS;;GAIpB,MAAM,SAAS,SAAS,QAAQ;AAChC,YAAS,cAAc;AAGvB,OAAI,CAAC,eAAe;AAClB,oBAAgB;AAChB,QAAI,OAAO,SAAS,sBAAsB,WACxC,sBAAqB,SAAS,mBAAoB,CAAC;cAE5C,MAAM,GAEf;QAAI,OAAO,SAAS,uBAAuB,WACzC,sBAAqB,SAAS,oBAAqB,CAAC;;AAIxD,UAAO;;;AAGX,QAAO;;AAKT,MAAM,gCAAgB,IAAI,SAAgC;AAE1D,SAAS,oBAAoB,iBAAwC;CACnE,IAAI,UAAU,cAAc,IAAI,gBAAgB;AAChD,KAAI,QAAS,QAAO;AAGpB,KAAI,iBAAiB,gBAAgB,EAAE;AACrC,YAAU,mBAAmB,gBAAgB;AAC7C,gBAAc,IAAI,iBAAiB,QAAQ;AAC3C,SAAO;;AAKT,aAAY,UAAiB;EAC3B,MAAM,MAAqB;GACzB,OAAO,EAAE;GACT,wBAAwB;GAGxB,gBAAgB,EAAE;GAClB,sBAAsB,EAAE;GACxB,WAAW;GACZ;EAED,MAAM,UAAU,OAAO,EAAE;EACzB,IAAI,kBAAkB;AAEtB,MAAI,yBAAyB;AAC3B,OAAI,IAAI,aAAa,gBAAiB;AACtC,qBAAkB;AAClB,wBAAqB;AACnB,sBAAkB;AAClB,QAAI,CAAC,IAAI,UAAW,SAAQ,IAAI,QAAQ,MAAM,GAAG,EAAE;KACnD;;AAIJ,kBAAgB;AACd,OAAI,YAAY;AAChB,QAAK,MAAM,QAAQ,IAAI,MACrB,KAAI,QAAQ,OAAO,SAAS,YAAY,aAAa,MAAM;IACzD,MAAM,QAAQ;AACd,QAAI,OAAO,MAAM,YAAY,WAAY,OAAM,SAAS;;IAG5D;AAGF,eAAa;AACX,YAAS;AACT,eAAY,IAAI;GAChB,MAAM,SAAU,gBAAgC,MAAM;GACtD,MAAM,gBAAgB,IAAI;GAC1B,MAAM,UAAU,IAAI;AACpB,cAAW;AAEX,oBAAiB,cAAc;AAC/B,mBAAgB,KAAK,QAAQ;AAE7B,UAAO;;;AAIX,eAAc,IAAI,iBAAiB,QAAQ;AAC3C,QAAO;;AAKT,SAAgB,IACd,MACA,OACA,KACO;CACP,MAAM,EAAE,UAAU,GAAG,SAAS;CAC9B,MAAM,eAAgB,OAAO,OAAO;EAAE,GAAG;EAAM;EAAK,GAAG;AAEvD,KAAI,OAAO,SAAS,YAAY;EAC9B,MAAM,iBAAiB,aAAa,SAAY;GAAE,GAAG;GAAc;GAAU,GAAG;AAEhF,MAAK,KAA4C,kBAC/C,QAAO,EAAE,MAAqB,eAAe;AAI/C,SAAO,EADS,oBAAoB,KAAK,EACvB,eAAe;;CAInC,MAAM,aAAa,aAAa,SAAY,EAAE,GAAG,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS;AAGhG,KAAI,OAAO,SAAS,UAAU;AAC5B,MAAI,aAAa,cAAc,QAAW;AACxC,gBAAa,QAAQ,aAAa;AAClC,UAAO,aAAa;;AAEtB,MAAI,aAAa,YAAY,QAAW;AACtC,gBAAa,MAAM,aAAa;AAChC,UAAO,aAAa;;AAItB,OACG,SAAS,WAAW,SAAS,cAAc,SAAS,aACrD,aAAa,aAAa,QAC1B;AACA,OAAI,aAAa,YAAY,OAC3B,cAAa,UAAU,aAAa;AAEtC,UAAO,aAAa;;AAItB,MAAI,aAAa,cAAc,QAAW;AACxC,gBAAa,YAAY,aAAa;AACtC,UAAO,aAAa;;AAItB,MAAI,SAAS,WAAW,SAAS,YAAY;AAC3C,OAAI,aAAa,iBAAiB,UAAa,aAAa,UAAU,QAAW;AAC/E,iBAAa,QAAQ,aAAa;AAClC,WAAO,aAAa;;AAEtB,OAAI,aAAa,mBAAmB,UAAa,aAAa,YAAY,QAAW;AACnF,iBAAa,UAAU,aAAa;AACpC,WAAO,aAAa;;;AAKxB,SAAO,aAAa;;AAGtB,QAAO,EAAE,MAAM,cAAc,GAAI,WAA4B;;AAG/D,MAAa,OAAO"}

package/lib/signals.js

@@ -1,4 +1,4 @@
-import { batch as pyreonBatch, computed as computed$1, effect as effect$1, signal as signal$1 } from "@pyreon/reactivity";
+import { batch as pyreonBatch, computed as computed$1, effect as effect$1, runUntracked, signal as signal$1 } from "@pyreon/reactivity";
 
 //#region src/signals.ts
 /**
@@ -37,7 +37,7 @@ function computed(fn) {
 			return c();
 		},
 		peek() {
-			return c();
+			return runUntracked(() => c());
 		}
 	};
 }

package/lib/signals.js.map

@@ -1 +1 @@
-{"version":3,"file":"signals.js","names":["pyreonSignal","pyreonComputed","pyreonEffect"],"sources":["../src/signals.ts"],"sourcesContent":["/**\n * @pyreon/preact-compat/signals\n *\n * Preact Signals compatibility layer (`@preact/signals` style).\n * Wraps Pyreon's signal/computed in `{ value }` accessor objects.\n */\n\nimport type { Effect } from '@pyreon/reactivity'\nimport {\n  batch as pyreonBatch,\n  computed as pyreonComputed,\n  effect as pyreonEffect,\n  signal as pyreonSignal,\n} from '@pyreon/reactivity'\n\n// ─── Signal ──────────────────────────────────────────────────────────────────\n\nexport interface ReadonlySignal<T> {\n  readonly value: T\n  peek(): T\n}\n\nexport interface WritableSignal<T> extends ReadonlySignal<T> {\n  value: T\n}\n\n/**\n * Create a Preact-style signal with `.value` accessor.\n *\n * @example\n * const count = signal(0)\n * count.value++       // write\n * console.log(count.value)  // read (tracked)\n */\nexport function signal<T>(initial: T): WritableSignal<T> {\n  const s = pyreonSignal<T>(initial)\n  return {\n    get value(): T {\n      return s()\n    },\n    set value(v: T) {\n      s.set(v)\n    },\n    peek(): T {\n      return s.peek()\n    },\n  }\n}\n\n// ─── Computed ────────────────────────────────────────────────────────────────\n\n/**\n * Create a Preact-style computed with `.value` accessor.\n *\n * @example\n * const doubled = computed(() => count.value * 2)\n * console.log(doubled.value)\n */\nexport function computed<T>(fn: () => T): ReadonlySignal<T> {\n  const c = pyreonComputed(fn)\n  return {\n    get value(): T {\n      return c()\n    },\n    peek(): T {\n      // computed doesn't have peek — just read the value untracked\n      return c()\n    },\n  }\n}\n\n// ─── Effect ──────────────────────────────────────────────────────────────────\n\n/**\n * Run a side-effect that auto-tracks signal reads.\n * Returns a dispose function.\n */\nexport function effect(fn: () => void | (() => void)): () => void {\n  // Pyreon's effect() natively supports cleanup return values\n  const e: Effect = pyreonEffect(fn)\n  return () => {\n    e.dispose()\n  }\n}\n\n// ─── Batch ───────────────────────────────────────────────────────────────────\n\n/**\n * Batch multiple signal writes into a single update.\n */\nexport { pyreonBatch as batch }\n"],"mappings":";;;;;;;;;;;AAkCA,SAAgB,OAAU,SAA+B;CACvD,MAAM,IAAIA,SAAgB,QAAQ;AAClC,QAAO;EACL,IAAI,QAAW;AACb,UAAO,GAAG;;EAEZ,IAAI,MAAM,GAAM;AACd,KAAE,IAAI,EAAE;;EAEV,OAAU;AACR,UAAO,EAAE,MAAM;;EAElB;;;;;;;;;AAYH,SAAgB,SAAY,IAAgC;CAC1D,MAAM,IAAIC,WAAe,GAAG;AAC5B,QAAO;EACL,IAAI,QAAW;AACb,UAAO,GAAG;;EAEZ,OAAU;AAER,UAAO,GAAG;;EAEb;;;;;;AASH,SAAgB,OAAO,IAA2C;CAEhE,MAAM,IAAYC,SAAa,GAAG;AAClC,cAAa;AACX,IAAE,SAAS"}
+{"version":3,"file":"signals.js","names":["pyreonSignal","pyreonComputed","pyreonRunUntracked","pyreonEffect"],"sources":["../src/signals.ts"],"sourcesContent":["/**\n * @pyreon/preact-compat/signals\n *\n * Preact Signals compatibility layer (`@preact/signals` style).\n * Wraps Pyreon's signal/computed in `{ value }` accessor objects.\n */\n\nimport type { Effect } from '@pyreon/reactivity'\nimport {\n  batch as pyreonBatch,\n  computed as pyreonComputed,\n  effect as pyreonEffect,\n  runUntracked as pyreonRunUntracked,\n  signal as pyreonSignal,\n} from '@pyreon/reactivity'\n\n// ─── Signal ──────────────────────────────────────────────────────────────────\n\nexport interface ReadonlySignal<T> {\n  readonly value: T\n  peek(): T\n}\n\nexport interface WritableSignal<T> extends ReadonlySignal<T> {\n  value: T\n}\n\n/**\n * Create a Preact-style signal with `.value` accessor.\n *\n * @example\n * const count = signal(0)\n * count.value++       // write\n * console.log(count.value)  // read (tracked)\n */\nexport function signal<T>(initial: T): WritableSignal<T> {\n  const s = pyreonSignal<T>(initial)\n  return {\n    get value(): T {\n      return s()\n    },\n    set value(v: T) {\n      s.set(v)\n    },\n    peek(): T {\n      return s.peek()\n    },\n  }\n}\n\n// ─── Computed ────────────────────────────────────────────────────────────────\n\n/**\n * Create a Preact-style computed with `.value` accessor.\n *\n * @example\n * const doubled = computed(() => count.value * 2)\n * console.log(doubled.value)\n */\nexport function computed<T>(fn: () => T): ReadonlySignal<T> {\n  const c = pyreonComputed(fn)\n  return {\n    get value(): T {\n      return c()\n    },\n    peek(): T {\n      return pyreonRunUntracked(() => c())\n    },\n  }\n}\n\n// ─── Effect ──────────────────────────────────────────────────────────────────\n\n/**\n * Run a side-effect that auto-tracks signal reads.\n * Returns a dispose function.\n */\nexport function effect(fn: () => void | (() => void)): () => void {\n  // Pyreon's effect() natively supports cleanup return values\n  const e: Effect = pyreonEffect(fn)\n  return () => {\n    e.dispose()\n  }\n}\n\n// ─── Batch ───────────────────────────────────────────────────────────────────\n\n/**\n * Batch multiple signal writes into a single update.\n */\nexport { pyreonBatch as batch }\n"],"mappings":";;;;;;;;;;;AAmCA,SAAgB,OAAU,SAA+B;CACvD,MAAM,IAAIA,SAAgB,QAAQ;AAClC,QAAO;EACL,IAAI,QAAW;AACb,UAAO,GAAG;;EAEZ,IAAI,MAAM,GAAM;AACd,KAAE,IAAI,EAAE;;EAEV,OAAU;AACR,UAAO,EAAE,MAAM;;EAElB;;;;;;;;;AAYH,SAAgB,SAAY,IAAgC;CAC1D,MAAM,IAAIC,WAAe,GAAG;AAC5B,QAAO;EACL,IAAI,QAAW;AACb,UAAO,GAAG;;EAEZ,OAAU;AACR,UAAOC,mBAAyB,GAAG,CAAC;;EAEvC;;;;;;AASH,SAAgB,OAAO,IAA2C;CAEhE,MAAM,IAAYC,SAAa,GAAG;AAClC,cAAa;AACX,IAAE,SAAS"}

package/lib/types/hooks.d.ts

@@ -4,6 +4,8 @@ import { VNodeChild, onErrorCaptured, useContext } from "@pyreon/core";
 /**
  * Preact-compatible `useState` — returns `[value, setter]`.
  * Triggers a component re-render when the setter is called.
+ *
+ * The setter has stable identity across renders (same reference every time).
  */
 declare function useState<T>(initial: T | (() => T)): [T, (v: T | ((prev: T) => T)) => void];
 /**
@@ -31,8 +33,11 @@ declare function useRef<T>(initial?: T): {
 };
 /**
  * Preact-compatible `useReducer` — returns `[state, dispatch]`.
+ * Supports the 3-argument form: `useReducer(reducer, initialArg, init)`.
+ *
+ * Dispatch has stable identity across renders (same reference every time).
  */
-declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initial: S | (() => S)): [S, (action: A) => void];
+declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initialArg: S | (() => S), init?: (arg: S) => S): [S, (action: A) => void];
 /**
  * Preact-compatible `useId` — returns a stable unique string per hook call.
  */
@@ -40,8 +45,50 @@ declare function useId(): string;
 /**
  * Preact-compatible `memo` — wraps a component to skip re-render when props
  * are shallowly equal.
+ *
+ * Each component INSTANCE gets its own props/result cache via a hook slot,
+ * so two `<MemoComp />` usages don't share memoization state.
  */
 declare function memo<P extends Record<string, unknown>>(component: (props: P) => VNodeChild, areEqual?: (prevProps: P, nextProps: P) => boolean): (props: P) => VNodeChild;
+/**
+ * Preact-compatible `forwardRef` — pass-through in Pyreon.
+ * Refs are regular props in Pyreon, so no wrapper is needed.
+ * The render function receives (props, ref) — we merge ref into props.
+ */
+declare function forwardRef<P extends Record<string, unknown>>(render: (props: P, ref: {
+  current: unknown;
+} | null) => VNodeChild): (props: P & {
+  ref?: {
+    current: unknown;
+  } | null;
+}) => VNodeChild;
+/**
+ * Preact-compatible `useImperativeHandle`.
+ */
+declare function useImperativeHandle<T>(ref: {
+  current: T | null;
+} | null | undefined, init: () => T, deps?: unknown[]): void;
+/**
+ * Preact-compatible `useDebugValue` — no-op in Pyreon (no Preact DevTools integration).
+ */
+declare function useDebugValue<T>(_value: T, _format?: (v: T) => unknown): void;
+/**
+ * Preact-compatible `useTransition` — returns `[isPending, startTransition]`.
+ *
+ * In Pyreon's signal-based reactivity there is no concept of concurrent
+ * rendering lanes. The callback is executed synchronously and `isPending`
+ * is always `false`. This shim exists so Preact/React code that uses
+ * `useTransition` compiles and runs without changes.
+ */
+declare function useTransition(): [boolean, (fn: () => void) => void];
+/**
+ * Preact-compatible `useDeferredValue` — returns the value as-is.
+ *
+ * In Pyreon's signal-based reactivity there are no concurrent rendering lanes,
+ * so the value is never "deferred". This shim exists so Preact/React code that
+ * uses `useDeferredValue` compiles and runs without changes.
+ */
+declare function useDeferredValue<T>(value: T): T;
 //#endregion
-export { memo, useCallback, useContext, useEffect, onErrorCaptured as useErrorBoundary, useId, useLayoutEffect, useMemo, useReducer, useRef, useState };
+export { forwardRef, memo, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, onErrorCaptured as useErrorBoundary, useId, useImperativeHandle, useLayoutEffect, useMemo, useReducer, useRef, useState, useTransition };
 //# sourceMappingURL=hooks2.d.ts.map

package/lib/types/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks2.d.ts","names":[],"sources":["../../../src/hooks.ts"],"mappings":";;;;;;;iBAwCgB,QAAA,GAAA,CAAY,OAAA,EAAS,CAAA,UAAW,CAAA,KAAM,CAAA,GAAI,CAAA,EAAG,CAAA,KAAM,IAAA,EAAM,CAAA,KAAM,CAAA;;;;;iBA0B/D,SAAA,CAAU,EAAA,6BAA+B,IAAA;;;;iBAwBzC,eAAA,CAAgB,EAAA,6BAA+B,IAAA;AAxB/D;;;AAAA,iBA+CgB,OAAA,GAAA,CAAW,EAAA,QAAU,CAAA,EAAG,IAAA,cAAkB,CAAA;;AAvB1D;;iBA8CgB,WAAA,eAA0B,IAAA,sBAAA,CAA2B,EAAA,EAAI,CAAA,EAAG,IAAA,cAAkB,CAAA;;;AAvB9F;iBAgCgB,MAAA,GAAA,CAAU,OAAA,GAAU,CAAA;EAAM,OAAA,EAAS,CAAA;AAAA;;;;iBAiBnC,UAAA,MAAA,CACd,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,OAAA,EAAS,CAAA,UAAW,CAAA,KAClB,CAAA,GAAI,MAAA,EAAQ,CAAA;;;;iBA2BA,KAAA,CAAA;;;;;iBAiBA,IAAA,WAAe,MAAA,kBAAA,CAC7B,SAAA,GAAY,KAAA,EAAO,CAAA,KAAM,UAAA,EACzB,QAAA,IAAY,SAAA,EAAW,CAAA,EAAG,SAAA,EAAW,CAAA,gBACnC,KAAA,EAAO,CAAA,KAAM,UAAA"}
+{"version":3,"file":"hooks2.d.ts","names":[],"sources":["../../../src/hooks.ts"],"mappings":";;;;;;;;;iBAoDgB,QAAA,GAAA,CAAY,OAAA,EAAS,CAAA,UAAW,CAAA,KAAM,CAAA,GAAI,CAAA,EAAG,CAAA,KAAM,IAAA,EAAM,CAAA,KAAM,CAAA;;;;;iBA6B/D,SAAA,CAAU,EAAA,6BAA+B,IAAA;;;AAAzD;iBAwBgB,eAAA,CAAgB,EAAA,6BAA+B,IAAA;;;;iBAuB/C,OAAA,GAAA,CAAW,EAAA,QAAU,CAAA,EAAG,IAAA,cAAkB,CAAA;;;;iBAuB1C,WAAA,eAA0B,IAAA,sBAAA,CAA2B,EAAA,EAAI,CAAA,EAAG,IAAA,cAAkB,CAAA;AAvB9F;;;AAAA,iBAgCgB,MAAA,GAAA,CAAU,OAAA,GAAU,CAAA;EAAM,OAAA,EAAS,CAAA;AAAA;;;;;;AATnD;iBA6BgB,UAAA,MAAA,CACd,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,UAAA,EAAY,CAAA,UAAW,CAAA,GACvB,IAAA,IAAQ,GAAA,EAAK,CAAA,KAAM,CAAA,IACjB,CAAA,GAAI,MAAA,EAAQ,CAAA;;;;iBAqCA,KAAA,CAAA;;;;;;;AA7DhB;iBAiFgB,IAAA,WAAe,MAAA,kBAAA,CAC7B,SAAA,GAAY,KAAA,EAAO,CAAA,KAAM,UAAA,EACzB,QAAA,IAAY,SAAA,EAAW,CAAA,EAAG,SAAA,EAAW,CAAA,gBACnC,KAAA,EAAO,CAAA,KAAM,UAAA;;;;;;iBA6CD,UAAA,WAAqB,MAAA,kBAAA,CACnC,MAAA,GAAS,KAAA,EAAO,CAAA,EAAG,GAAA;EAAO,OAAA;AAAA,aAA8B,UAAA,IACtD,KAAA,EAAO,CAAA;EAAM,GAAA;IAAQ,OAAA;EAAA;AAAA,MAAgC,UAAA;;;;iBAezC,mBAAA,GAAA,CACd,GAAA;EAAO,OAAA,EAAS,CAAA;AAAA,sBAChB,IAAA,QAAY,CAAA,EACZ,IAAA;;;;iBAec,aAAA,GAAA,CAAiB,MAAA,EAAQ,CAAA,EAAG,OAAA,IAAW,CAAA,EAAG,CAAA;;;;;;;;;iBAY1C,aAAA,CAAA,cAA4B,EAAA;;;;;;;;iBAa5B,gBAAA,GAAA,CAAoB,KAAA,EAAO,CAAA,GAAI,CAAA"}

package/lib/types/index.d.ts

@@ -1,4 +1,5 @@
-import { ComponentFn, Fragment, Props, VNode, VNodeChild, createRef, h as pyreonH, useContext } from "@pyreon/core";
+import { ComponentFn, ErrorBoundary, Fragment, Props, Suspense, VNode, VNodeChild, createRef, h as pyreonH, lazy, useContext } from "@pyreon/core";
+import { signal } from "@pyreon/reactivity";
 
 //#region src/index.d.ts
 /** Alias: Preact also exports createElement */
@@ -34,7 +35,12 @@ declare function createContext<T>(defaultValue: T): PreactContext<T>;
 declare class Component<P extends Props = Props, S extends Record<string, unknown> = Record<string, unknown>> {
   props: P;
   state: S;
-  private _stateSignal;
+  _stateSignal: ReturnType<typeof signal<S>>;
+  _lastResult?: VNodeChild;
+  componentDidMount?(): void;
+  componentDidUpdate?(): void;
+  componentWillUnmount?(): void;
+  shouldComponentUpdate?(nextProps: P, nextState: S): boolean;
   constructor(props: P);
   /**
    * Update state — accepts a partial state object or an updater function.
@@ -50,6 +56,12 @@ declare class Component<P extends Props = Props, S extends Record<string, unknow
    */
   render(): VNodeChild;
 }
+/**
+ * Preact-compatible PureComponent — extends Component.
+ * In Pyreon's compat layer this behaves identically to Component
+ * (signal-based reactivity already avoids unnecessary re-renders).
+ */
+declare class PureComponent<P extends Props = Props, S extends Record<string, unknown> = Record<string, unknown>> extends Component<P, S> {}
 /**
  * Clone a VNode with merged props (like Preact's cloneElement).
  */
@@ -64,11 +76,16 @@ declare function toChildArray(children: NestedChildren): VNodeChild[];
  * Check if a value is a VNode (like Preact's isValidElement).
  */
 declare function isValidElement(x: unknown): x is VNode;
+/**
+ * Preact-compatible `createPortal(children, target)`.
+ */
+declare function createPortal(children: VNodeChild, target: Element): VNodeChild;
 /**
  * Preact's plugin/hook system. Exposed as an empty object for compatibility
  * with libraries that check for `options._hook`, `options.vnode`, etc.
  */
 declare const options: Record<string, unknown>;
+declare const version = "10.0.0-pyreon";
 //#endregion
-export { Component, Fragment, PreactContext, cloneElement, createContext, createElement, createRef, pyreonH as h, hydrate, isValidElement, options, render, toChildArray, useContext };
+export { Component, ErrorBoundary, Fragment, PreactContext, PureComponent, Suspense, cloneElement, createContext, createElement, createPortal, createRef, pyreonH as h, hydrate, isValidElement, lazy, options, render, toChildArray, useContext, version };
 //# sourceMappingURL=index2.d.ts.map

package/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/index.ts"],"mappings":";;;;cA+Ba,aAAA,SAAa,OAAA;;;;;iBAUV,MAAA,CAAO,KAAA,EAAO,UAAA,EAAY,SAAA,EAAW,OAAA;;;;;iBAQrC,OAAA,CAAQ,KAAA,EAAO,UAAA,EAAY,SAAA,EAAW,OAAA;AAAA,UAMrC,aAAA;EAAA,SACN,EAAA;EAAA,SACA,YAAA,EAAc,CAAA;EACvB,QAAA,EAAU,WAAA;IAAc,KAAA,EAAO,CAAA;IAAG,QAAA,GAAW,UAAA;EAAA;AAAA;;;;iBAM/B,aAAA,GAAA,CAAiB,YAAA,EAAc,CAAA,GAAI,aAAA,CAAc,CAAA;;;;;;;cAuBpD,SAAA,WACD,KAAA,GAAQ,KAAA,YACR,MAAA,oBAA0B,MAAA;EAEpC,KAAA,EAAO,CAAA;EACP,KAAA,EAAO,CAAA;EAAA,QACC,YAAA;cAEI,KAAA,EAAO,CAAA;EA/B8B;;;;EAyCjD,QAAA,CAAS,OAAA,EAAS,OAAA,CAAQ,CAAA,MAAO,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,CAAA;EAzCtB;;;EAuD/B,WAAA,CAAA;EAvDgE;AAuBlE;;EAuCE,MAAA,CAAA,GAAU,UAAA;AAAA;;;;iBAUI,YAAA,CAAa,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA,KAAU,QAAA,EAAU,UAAA,KAAe,KAAA;;;;;KAiBjF,cAAA,GAAiB,UAAA,GAAa,cAAA;AAAA,iBAEnB,YAAA,CAAa,QAAA,EAAU,cAAA,GAAiB,UAAA;;;;iBAsBxC,cAAA,CAAe,CAAA,YAAa,CAAA,IAAK,KAAA;;;;;cAgBpC,OAAA,EAAS,MAAA"}
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/index.ts"],"mappings":";;;;;cAoCa,aAAA,SAAa,OAAA;;;;;iBAUV,MAAA,CAAO,KAAA,EAAO,UAAA,EAAY,SAAA,EAAW,OAAA;;;;AAcrD;iBANgB,OAAA,CAAQ,KAAA,EAAO,UAAA,EAAY,SAAA,EAAW,OAAA;AAAA,UAMrC,aAAA;EAAA,SACN,EAAA;EAAA,SACA,YAAA,EAAc,CAAA;EACvB,QAAA,EAAU,WAAA;IAAc,KAAA,EAAO,CAAA;IAAG,QAAA,GAAW,UAAA;EAAA;AAAA;;;;iBAS/B,aAAA,GAAA,CAAiB,YAAA,EAAc,CAAA,GAAI,aAAA,CAAc,CAAA;;;;;;AAAjE;cAyBa,SAAA,WACD,KAAA,GAAQ,KAAA,YACR,MAAA,oBAA0B,MAAA;EAEpC,KAAA,EAAO,CAAA;EACP,KAAA,EAAO,CAAA;EACP,YAAA,EAAc,UAAA,QAAkB,MAAA,CAAO,CAAA;EACvC,WAAA,GAAc,UAAA;EAGd,iBAAA,CAAA,CAAA;EACA,kBAAA,CAAA,CAAA;EACA,oBAAA,CAAA,CAAA;EACA,qBAAA,CAAA,CAAuB,SAAA,EAAW,CAAA,EAAG,SAAA,EAAW,CAAA;cAEpC,KAAA,EAAO,CAAA;EAxC8B;;;;EAkDjD,QAAA,CAAS,OAAA,EAAS,OAAA,CAAQ,CAAA,MAAO,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,CAAA;EAzBjC;;;EAuCpB,WAAA,CAAA;EArCU;;;EA4CV,MAAA,CAAA,GAAU,UAAA;AAAA;;;;;;cAYC,aAAA,WACD,KAAA,GAAQ,KAAA,YACR,MAAA,oBAA0B,MAAA,2BAC5B,SAAA,CAAU,CAAA,EAAG,CAAA;;;;iBAOP,YAAA,CAAa,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA,KAAU,QAAA,EAAU,UAAA,KAAe,KAAA;;;;;KAiBjF,cAAA,GAAiB,UAAA,GAAa,cAAA;AAAA,iBAEnB,YAAA,CAAa,QAAA,EAAU,cAAA,GAAiB,UAAA;;;;iBAsBxC,cAAA,CAAe,CAAA,YAAa,CAAA,IAAK,KAAA;;;;iBAejC,YAAA,CAAa,QAAA,EAAU,UAAA,EAAY,MAAA,EAAQ,OAAA,GAAU,UAAA;;;;;cAcxD,OAAA,EAAS,MAAA;AAAA,cAIT,OAAA"}

package/lib/types/jsx-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-runtime2.d.ts","names":[],"sources":["../../../src/jsx-runtime.ts"],"mappings":";;;iBAwIgB,GAAA,CACd,IAAA,WAAe,WAAA,WACf,KAAA,EAAO,KAAA;EAAU,QAAA,GAAW,UAAA,GAAa,UAAA;AAAA,GACzC,GAAA,4BACC,KAAA;AAAA,cAiBU,IAAA,SAAI,GAAA"}
+{"version":3,"file":"jsx-runtime2.d.ts","names":[],"sources":["../../../src/jsx-runtime.ts"],"mappings":";;;iBAyOgB,GAAA,CACd,IAAA,WAAe,WAAA,WACf,KAAA,EAAO,KAAA;EAAU,QAAA,GAAW,UAAA,GAAa,UAAA;AAAA,GACzC,GAAA,4BACC,KAAA;AAAA,cAiEU,IAAA,SAAI,GAAA"}

package/lib/types/signals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signals2.d.ts","names":[],"sources":["../../../src/signals.ts"],"mappings":";;;UAiBiB,cAAA;EAAA,SACN,KAAA,EAAO,CAAA;EAChB,IAAA,IAAQ,CAAA;AAAA;AAAA,UAGO,cAAA,YAA0B,cAAA,CAAe,CAAA;EACxD,KAAA,EAAO,CAAA;AAAA;AADT;;;;;;;;AAAA,iBAYgB,MAAA,GAAA,CAAU,OAAA,EAAS,CAAA,GAAI,cAAA,CAAe,CAAA;;;;;;;AAAtD;iBAwBgB,QAAA,GAAA,CAAY,EAAA,QAAU,CAAA,GAAI,cAAA,CAAe,CAAA;;;;;iBAmBzC,MAAA,CAAO,EAAA"}
+{"version":3,"file":"signals2.d.ts","names":[],"sources":["../../../src/signals.ts"],"mappings":";;;UAkBiB,cAAA;EAAA,SACN,KAAA,EAAO,CAAA;EAChB,IAAA,IAAQ,CAAA;AAAA;AAAA,UAGO,cAAA,YAA0B,cAAA,CAAe,CAAA;EACxD,KAAA,EAAO,CAAA;AAAA;AADT;;;;;;;;AAAA,iBAYgB,MAAA,GAAA,CAAU,OAAA,EAAS,CAAA,GAAI,cAAA,CAAe,CAAA;;;;;;;AAAtD;iBAwBgB,QAAA,GAAA,CAAY,EAAA,QAAU,CAAA,GAAI,cAAA,CAAe,CAAA;;;;;iBAkBzC,MAAA,CAAO,EAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/preact-compat",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Preact-compatible API shim for Pyreon — write Preact-style code that runs on Pyreon's reactive engine",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/preact-compat#readme",
   "bugs": {
@@ -62,9 +62,9 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/core": "^0.13.1",
-    "@pyreon/reactivity": "^0.13.1",
-    "@pyreon/runtime-dom": "^0.13.1"
+    "@pyreon/core": "^0.14.0",
+    "@pyreon/reactivity": "^0.14.0",
+    "@pyreon/runtime-dom": "^0.14.0"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.9",

package/src/hooks.ts

@@ -32,30 +32,45 @@ function depsChanged(a: unknown[] | undefined, b: unknown[] | undefined): boolea
   return false
 }
 
+function shallowEqual<P extends Record<string, unknown>>(a: P, b: P): boolean {
+  const keysA = Object.keys(a)
+  const keysB = Object.keys(b)
+  if (keysA.length !== keysB.length) return false
+  for (const k of keysA) {
+    if (!Object.is(a[k], b[k])) return false
+  }
+  return true
+}
+
 // ─── useState ────────────────────────────────────────────────────────────────
 
 /**
  * Preact-compatible `useState` — returns `[value, setter]`.
  * Triggers a component re-render when the setter is called.
+ *
+ * The setter has stable identity across renders (same reference every time).
  */
 export function useState<T>(initial: T | (() => T)): [T, (v: T | ((prev: T) => T)) => void] {
   const ctx = requireCtx()
   const idx = getHookIndex()
 
   if (ctx.hooks.length <= idx) {
-    ctx.hooks.push(typeof initial === 'function' ? (initial as () => T)() : initial)
-  }
-
-  const value = ctx.hooks[idx] as T
-  const setter = (v: T | ((prev: T) => T)) => {
-    const current = ctx.hooks[idx] as T
-    const next = typeof v === 'function' ? (v as (prev: T) => T)(current) : v
-    if (Object.is(current, next)) return
-    ctx.hooks[idx] = next
-    ctx.scheduleRerender()
+    const val = typeof initial === 'function' ? (initial as () => T)() : initial
+    // Store both value and a STABLE setter in one hook slot so setter identity
+    // never changes across renders (Preact/React guarantee).
+    const entry = { value: val, setter: null as unknown as (v: T | ((prev: T) => T)) => void }
+    entry.setter = (v: T | ((prev: T) => T)) => {
+      const current = entry.value
+      const next = typeof v === 'function' ? (v as (prev: T) => T)(current) : v
+      if (Object.is(current, next)) return
+      entry.value = next
+      ctx.scheduleRerender()
+    }
+    ctx.hooks.push(entry)
   }
 
-  return [value, setter]
+  const entry = ctx.hooks[idx] as { value: T; setter: (v: T | ((prev: T) => T)) => void }
+  return [entry.value, entry.setter]
 }
 
 // ─── useEffect ───────────────────────────────────────────────────────────────
@@ -159,28 +174,42 @@ export function useRef<T>(initial?: T): { current: T | null } {
 
 /**
  * Preact-compatible `useReducer` — returns `[state, dispatch]`.
+ * Supports the 3-argument form: `useReducer(reducer, initialArg, init)`.
+ *
+ * Dispatch has stable identity across renders (same reference every time).
  */
 export function useReducer<S, A>(
   reducer: (state: S, action: A) => S,
-  initial: S | (() => S),
+  initialArg: S | (() => S),
+  init?: (arg: S) => S,
 ): [S, (action: A) => void] {
   const ctx = requireCtx()
   const idx = getHookIndex()
 
   if (ctx.hooks.length <= idx) {
-    ctx.hooks.push(typeof initial === 'function' ? (initial as () => S)() : initial)
-  }
-
-  const state = ctx.hooks[idx] as S
-  const dispatch = (action: A) => {
-    const current = ctx.hooks[idx] as S
-    const next = reducer(current, action)
-    if (Object.is(current, next)) return
-    ctx.hooks[idx] = next
-    ctx.scheduleRerender()
+    let initial: S
+    if (init) {
+      initial = init(initialArg as S)
+    } else if (typeof initialArg === 'function') {
+      initial = (initialArg as () => S)()
+    } else {
+      initial = initialArg
+    }
+    // Store both value and a STABLE dispatch in one hook slot so dispatch identity
+    // never changes across renders (Preact/React guarantee).
+    const entry = { value: initial, dispatch: null as unknown as (action: A) => void }
+    entry.dispatch = (action: A) => {
+      const current = entry.value
+      const next = reducer(current, action)
+      if (Object.is(current, next)) return
+      entry.value = next
+      ctx.scheduleRerender()
+    }
+    ctx.hooks.push(entry)
   }
 
-  return [state, dispatch]
+  const entry = ctx.hooks[idx] as { value: S; dispatch: (action: A) => void }
+  return [entry.value, entry.dispatch]
 }
 
 // ─── useId ───────────────────────────────────────────────────────────────────
@@ -206,34 +235,120 @@ export function useId(): string {
 /**
  * Preact-compatible `memo` — wraps a component to skip re-render when props
  * are shallowly equal.
+ *
+ * Each component INSTANCE gets its own props/result cache via a hook slot,
+ * so two `<MemoComp />` usages don't share memoization state.
  */
 export function memo<P extends Record<string, unknown>>(
   component: (props: P) => VNodeChild,
   areEqual?: (prevProps: P, nextProps: P) => boolean,
 ): (props: P) => VNodeChild {
-  const compare =
-    areEqual ??
-    ((a: P, b: P) => {
-      const keysA = Object.keys(a)
-      const keysB = Object.keys(b)
-      if (keysA.length !== keysB.length) return false
-      for (const k of keysA) {
-        if (!Object.is(a[k], b[k])) return false
+  const compare = areEqual ?? shallowEqual
+
+  // Fallback closure-level cache for calls outside a compat render context
+  // (e.g. direct function calls in tests). Inside a render context, each
+  // component instance gets its own cache via a hook slot.
+  let _fallbackPrevProps: P | null = null
+  let _fallbackPrevResult: VNodeChild = null
+
+  const memoized = (props: P) => {
+    const ctx = getCurrentCtx()
+    if (ctx) {
+      // Per-instance cache via hook slot
+      const idx = getHookIndex()
+      if (ctx.hooks.length <= idx) {
+        ctx.hooks.push({ prevProps: null as P | null, prevResult: null as VNodeChild })
       }
-      return true
-    })
+      const cache = ctx.hooks[idx] as { prevProps: P | null; prevResult: VNodeChild }
+      if (cache.prevProps !== null && compare(cache.prevProps, props)) {
+        return cache.prevResult
+      }
+      cache.prevProps = props
+      cache.prevResult = component(props)
+      return cache.prevResult
+    }
+    // No compat context — use closure-level fallback cache
+    if (_fallbackPrevProps !== null && compare(_fallbackPrevProps, props)) {
+      return _fallbackPrevResult
+    }
+    _fallbackPrevProps = props
+    _fallbackPrevResult = component(props)
+    return _fallbackPrevResult
+  }
+  memoized.displayName =
+    (component as unknown as { displayName?: string }).displayName || component.name || 'Memo'
+  return memoized
+}
 
-  let prevProps: P | null = null
-  let prevResult: VNodeChild = null
+// ─── forwardRef ─────────────────────────────────────────────────────────────
 
-  return (props: P) => {
-    if (prevProps !== null && compare(prevProps, props)) {
-      return prevResult
-    }
-    prevProps = props
-    prevResult = (component as (p: P) => VNodeChild)(props)
-    return prevResult
+/**
+ * Preact-compatible `forwardRef` — pass-through in Pyreon.
+ * Refs are regular props in Pyreon, so no wrapper is needed.
+ * The render function receives (props, ref) — we merge ref into props.
+ */
+export function forwardRef<P extends Record<string, unknown>>(
+  render: (props: P, ref: { current: unknown } | null) => VNodeChild,
+): (props: P & { ref?: { current: unknown } | null }) => VNodeChild {
+  const forwarded = (props: P & { ref?: { current: unknown } | null }) => {
+    const { ref, ...rest } = props
+    return render(rest as P, ref ?? null)
   }
+  forwarded.displayName =
+    (render as unknown as { displayName?: string }).displayName || render.name || 'ForwardRef'
+  return forwarded
+}
+
+// ─── useImperativeHandle ────────────────────────────────────────────────────
+
+/**
+ * Preact-compatible `useImperativeHandle`.
+ */
+export function useImperativeHandle<T>(
+  ref: { current: T | null } | null | undefined,
+  init: () => T,
+  deps?: unknown[],
+): void {
+  useLayoutEffect(() => {
+    if (ref) ref.current = init()
+    return () => {
+      if (ref) ref.current = null
+    }
+  }, deps)
+}
+
+// ─── useDebugValue ──────────────────────────────────────────────────────────
+
+/**
+ * Preact-compatible `useDebugValue` — no-op in Pyreon (no Preact DevTools integration).
+ */
+export function useDebugValue<T>(_value: T, _format?: (v: T) => unknown): void {}
+
+// ─── useTransition ──────────────────────────────────────────────────────
+
+/**
+ * Preact-compatible `useTransition` — returns `[isPending, startTransition]`.
+ *
+ * In Pyreon's signal-based reactivity there is no concept of concurrent
+ * rendering lanes. The callback is executed synchronously and `isPending`
+ * is always `false`. This shim exists so Preact/React code that uses
+ * `useTransition` compiles and runs without changes.
+ */
+export function useTransition(): [boolean, (fn: () => void) => void] {
+  return [false, (fn) => fn()]
+}
+
+// ─── useDeferredValue ───────────────────────────────────────────────────
+
+/**
+ * Preact-compatible `useDeferredValue` — returns the value as-is.
+ *
+ * In Pyreon's signal-based reactivity there are no concurrent rendering lanes,
+ * so the value is never "deferred". This shim exists so Preact/React code that
+ * uses `useDeferredValue` compiles and runs without changes.
+ */
+export function useDeferredValue<T>(value: T): T {
+  return value
 }
 
 // ─── useErrorBoundary ────────────────────────────────────────────────────────

package/src/index.ts

@@ -4,8 +4,9 @@
  * Preact-compatible API shim that runs on Pyreon's reactive engine.
  *
  * Provides the core Preact API surface: h, Fragment, render, hydrate,
- * Component class, createContext, createRef, cloneElement, toChildArray,
- * isValidElement, and the options hook object.
+ * Component class, PureComponent, createContext, createRef, cloneElement,
+ * toChildArray, isValidElement, createPortal, lazy, Suspense, ErrorBoundary,
+ * and the options hook object.
  *
  * For hooks, import from "@pyreon/preact-compat/hooks".
  * For signals, import from "@pyreon/preact-compat/signals".
@@ -14,8 +15,12 @@
 import type { ComponentFn, Props, VNode, VNodeChild } from '@pyreon/core'
 import {
   createRef,
+  ErrorBoundary,
   Fragment,
+  lazy,
+  Portal,
   provide,
+  Suspense,
   createContext as pyreonCreateContext,
   h as pyreonH,
   useContext,
@@ -59,6 +64,9 @@ export interface PreactContext<T> {
   Provider: ComponentFn<{ value: T; children?: VNodeChild }>
 }
 
+// Tag the Provider so wrapCompatComponent skips it (it's already a native component)
+const NATIVE_COMPONENT = Symbol.for('pyreon:native-compat')
+
 /**
  * Preact-compatible createContext — returns a context with a `.Provider` component.
  */
@@ -68,6 +76,8 @@ export function createContext<T>(defaultValue: T): PreactContext<T> {
     provide(ctx, props.value)
     return props.children
   }) as ComponentFn<{ value: T; children?: VNodeChild }>
+  // Mark as native so jsx() doesn't wrap it with wrapCompatComponent
+  ;(Provider as unknown as Record<symbol, boolean>)[NATIVE_COMPONENT] = true
   return { ...ctx, Provider }
 }
 
@@ -91,7 +101,14 @@ export class Component<
 > {
   props: P
   state: S
-  private _stateSignal: ReturnType<typeof signal<S>>
+  _stateSignal: ReturnType<typeof signal<S>>
+  _lastResult?: VNodeChild
+
+  // Lifecycle methods (overridden by subclasses)
+  componentDidMount?(): void
+  componentDidUpdate?(): void
+  componentWillUnmount?(): void
+  shouldComponentUpdate?(nextProps: P, nextState: S): boolean
 
   constructor(props: P) {
     this.props = props
@@ -129,13 +146,25 @@ export class Component<
   }
 }
 
+// ─── PureComponent ──────────────────────────────────────────────────────────
+
+/**
+ * Preact-compatible PureComponent — extends Component.
+ * In Pyreon's compat layer this behaves identically to Component
+ * (signal-based reactivity already avoids unnecessary re-renders).
+ */
+export class PureComponent<
+  P extends Props = Props,
+  S extends Record<string, unknown> = Record<string, unknown>,
+> extends Component<P, S> {}
+
 // ─── cloneElement ────────────────────────────────────────────────────────────
 
 /**
  * Clone a VNode with merged props (like Preact's cloneElement).
  */
 export function cloneElement(vnode: VNode, props?: Props, ...children: VNodeChild[]): VNode {
-  const mergedProps = { ...vnode.props, ...(props ?? {}) }
+  const mergedProps = props ? { ...vnode.props, ...props } : { ...vnode.props }
   const mergedChildren = children.length > 0 ? children : vnode.children
   return {
     type: vnode.type,
@@ -185,6 +214,19 @@ export function isValidElement(x: unknown): x is VNode {
   )
 }
 
+// ─── createPortal ───────────────────────────────────────────────────────────
+
+/**
+ * Preact-compatible `createPortal(children, target)`.
+ */
+export function createPortal(children: VNodeChild, target: Element): VNodeChild {
+  return Portal({ target, children })
+}
+
+// ─── Suspense / lazy / ErrorBoundary ─────────────────────────────────────────
+
+export { ErrorBoundary, lazy, Suspense }
+
 // ─── options ─────────────────────────────────────────────────────────────────
 
 /**
@@ -192,3 +234,7 @@ export function isValidElement(x: unknown): x is VNode {
  * with libraries that check for `options._hook`, `options.vnode`, etc.
  */
 export const options: Record<string, unknown> = {}
+
+// ─── version ────────────────────────────────────────────────────────────────
+
+export const version = '10.0.0-pyreon'