ink-framework 0.1.0-alpha.10 → 0.1.0-alpha.13

package/src/native-list.ts

@@ -1,10 +1,11 @@
-import { createElement, Fragment, useLayoutEffect, useMemo, useRef, type ComponentProps, type ReactNode } from "./react";
-import { ListLoadError, ReactList, type ListProps } from "./list";
-import { useAction } from "./action";
+import { createElement, useLayoutEffect, useMemo, useRef, useState, type ComponentProps, type ReactNode } from "./react";
+import { ReactList, useListPaginationEvents, type ListPagination, type ListProps } from "./list";
 import type { Row } from "./image";
 import { pressHandler } from "./press";
 import { rememberListPatch, type NativeListItem } from "./list-patch";
 
+export { fixedListRow } from "./fixed-list-row";
+
 type Captured = { value: unknown; prototype?: object | null; fields?: [PropertyKey, boolean, Captured][] };
 type Scope = { identity: string; values: readonly Captured[] };
 type Capture = { identity: string; values: () => readonly unknown[]; usesIndex?: boolean };
@@ -15,6 +16,8 @@ const keys = /* @__PURE__ */ new WeakMap<Function, string>();
 const plainRecords = /* @__PURE__ */ new WeakSet<object>();
 declare const __inkIsProxy: (value: unknown) => boolean;
 const isProxy = typeof __inkIsProxy === "function" ? __inkIsProxy : undefined;
+declare const __inkIsDenseArray: (value: unknown) => boolean;
+const isDenseArray = typeof __inkIsDenseArray === "function" ? __inkIsDenseArray : undefined;
 
 function bareFunctionPrototype(value: unknown, owner: Function): value is object {
   if (value === null || typeof value !== "object" || isProxy?.(value)) return false;
@@ -71,7 +74,7 @@ export function listText(parts: unknown[]): string {
 export function listRowFields(props: ComponentProps<typeof Row>) {
   return { image: props.image, title: props.title, titleMaxLines: props.titleMaxLines,
     titleIcon: props.titleIcon, subtitle: props.subtitle, subtitleIcon: props.subtitleIcon,
-    onLongPress: props.onLongPress,
+    selected: props.selected, onLongPress: props.onLongPress,
     onPress: pressHandler(props) ?? (props.onLongPress ? () => {} : undefined) };
 }
 
@@ -99,21 +102,73 @@ function nativeValue(value: unknown, previous?: unknown): unknown {
 }
 
 type NativeItem = NativeListItem;
-type RowRecord<T> = { item: T; index: number; native: NativeItem };
-type Records<T> = { data: NativeItem[]; rows: Map<string, RowRecord<T>>; template: string;
+type Records<T> = { data: NativeItem[]; positions: Map<string, number>; template: string;
   items: readonly T[]; key: string | Function; measurementKey?: string | number; scope?: Scope };
+const cooperativeListSize = 512;
+const preparationBudget = 4;
+const minimumPreparationRows = 32;
+const maximumPreparationRows = 128;
+type Preparation<T> = { steps: Generator<void, Records<T> | null>; result?: { value: Records<T> | null }; error?: { value: unknown } };
+type Request<T> = { items: readonly T[]; key: string | Function; plan: Plan<T>;
+  measurementKey?: string | number; scope?: Scope; preparation: Preparation<T>; synchronous?: { value: Records<T> | null };
+  eventPositions: Map<string, number | undefined> };
+type Prepared<T> = { request: Request<T>; generation: number } &
+  ({ status: "ready"; value: Records<T> | null } | { status: "error"; error: unknown });
+
+function listItem<T>(items: readonly T[], index: number): T {
+  const property = Object.getOwnPropertyDescriptor(items, index);
+  if (!property || !("value" in property)) throw needsReact;
+  return property.value;
+}
+
+/**
+ * Reproject only the items replaced in place, when every key stays at its position.
+ * Returns undefined when keys move, so the caller rebuilds the whole list.
+ */
+function* replaceInPlace<T>(previous: Records<T>, items: readonly T[], plan: Plan<T>,
+  keyExtractor: ListProps<T>["keyExtractor"], dense: boolean): Generator<void, Records<T> | undefined> {
+  let data: NativeItem[] | undefined;
+  const changes: NativeItem[] = [];
+  const length = items.length;
+  for (let index = 0; index < length; index++) {
+    const item = dense ? items[index] : listItem(items, index);
+    if (item === previous.items[index]) continue;
+    const before = previous.data[index];
+    if (!plainData(item)) throw needsReact;
+    if (keyExtractor(item, index) !== before.key) return undefined;
+    const projected = nativeValue(plan.project(item, index), before.values);
+    if (projected !== before.values) {
+      const record = { key: before.key, values: projected, measurementKey: before.measurementKey };
+      (data ??= previous.data.slice())[index] = record;
+      changes.push(record);
+    }
+    yield;
+  }
+  if (data) rememberListPatch(data, { previous: previous.data, changes });
+  return { ...previous, data: data ?? previous.data, items };
+}
 
-function captureValue(value: unknown, cache: WeakMap<object, Captured>): Captured {
+function captureValue(value: unknown, cache: WeakMap<object, Captured>, visiting = new Set<object>()): Captured {
   if (value === null || typeof value !== "object" && typeof value !== "function") return { value };
   const previous = cache.get(value);
-  if (previous) return previous;
+  if (previous && isProxy) return previous;
+  if (isProxy?.(value) || visiting.has(value) || visiting.size >= 64) throw needsReact;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && prototype !== Array.prototype
+    && !(typeof value === "function" && prototype === Function.prototype)) throw needsReact;
+  visiting.add(value);
   const properties: Record<PropertyKey, PropertyDescriptor> = Object.getOwnPropertyDescriptors(value);
-  const captured: Captured = { value, prototype: Object.getPrototypeOf(value), fields: Reflect.ownKeys(properties).map(key => {
+  const fields: NonNullable<Captured["fields"]> = [];
+  for (const key of Reflect.ownKeys(properties)) {
     const property = properties[key];
+    if (!("value" in property)) throw needsReact;
+    if (["toString", "valueOf", Symbol.toPrimitive].includes(key) && typeof property.value === "function") throw needsReact;
     const field = key === "prototype" && typeof value === "function" && bareFunctionPrototype(property.value, value)
-      ? { value: property.value } : captureValue(property.value, cache);
-    return [key, !!property.enumerable, field];
-  }) };
+      ? { value: property.value } : captureValue(property.value, cache, visiting);
+    fields.push([key, !!property.enumerable, field]);
+  }
+  visiting.delete(value);
+  const captured: Captured = { value, prototype, fields };
   cache.set(value, captured);
   return captured;
 }
@@ -135,64 +190,146 @@ function sameScopeValues(before: readonly Captured[], after: readonly Captured[]
   return before.length === after.length && after.every((value, index) => sameCapture(before[index], value, seen));
 }
 
+function captureScope<T>(plan: Plan<T>, items: readonly T[]): Scope | undefined {
+  if (!plan.scope) return;
+  const captured = items.length ? plan.scope.values() : [];
+  // Captures can mutate between slices; validate each fresh snapshot without the row cache.
+  return { identity: plan.scope.identity, values: captured.map(value => captureValue(value, new WeakMap())) };
+}
+
+function sameScope(before?: Scope, after?: Scope): boolean {
+  return !!before && !!after && before.identity === after.identity && sameScopeValues(before.values, after.values);
+}
+
+function capturesMatch<T>(request: Request<T>, latestPlan: Plan<T> | null): boolean {
+  return !!latestPlan && sameScope(request.scope, captureScope(request.plan, request.items))
+    && (latestPlan === request.plan || sameScope(request.scope, captureScope(latestPlan, request.items)));
+}
+
+function* prepareRecords<T>(previous: Records<T> | null, items: readonly T[], plan: Plan<T>,
+  keyExtractor: ListProps<T>["keyExtractor"], keyIdentity: string | Function,
+  measurementKey: string | number | undefined, scope: Scope | undefined, dense: boolean): Generator<void, Records<T> | null> {
+  try {
+    if (isProxy?.(items) || Object.getPrototypeOf(items) !== Array.prototype) throw needsReact;
+    const length = items.length;
+    const unchangedScope = sameScope(previous?.scope, scope);
+    if (previous && previous.items === items && previous.key === keyIdentity
+      && previous.template === plan.template && previous.measurementKey === measurementKey
+      && unchangedScope) return previous;
+    if (previous && unchangedScope && typeof keyIdentity === "string" && previous.key === keyIdentity
+      && previous.template === plan.template && previous.measurementKey === measurementKey
+      && previous.items.length === length) {
+      const patched = yield* replaceInPlace(previous, items, plan, keyExtractor, dense);
+      if (patched !== undefined) return { ...patched, scope };
+    }
+    const positions = new Map<string, number>();
+    let unchanged = length === previous?.data.length;
+    let reordered = !unchanged;
+    const changes: NativeItem[] = [];
+    let data: NativeItem[] = [];
+    const itemKeys: string[] = [];
+    for (let index = 0; index < length; index++) {
+      const item = dense ? items[index] : listItem(items, index);
+      if (!plainData(item)) throw needsReact;
+      const key = typeof keyIdentity === "string" && previous?.key === keyIdentity && previous.items[index] === item
+        ? previous.data[index].key : keyExtractor(item, index);
+      if (typeof key !== "string" || positions.has(key)) throw new Error("List keys must be unique strings");
+      const beforeIndex = previous?.template === plan.template ? previous.positions.get(key) : undefined;
+      const before = previous && beforeIndex !== undefined ? previous.data[beforeIndex] : undefined;
+      const projected = previous && beforeIndex !== undefined && unchangedScope && previous.items[beforeIndex] === item
+        && (beforeIndex === index || plan.scope?.usesIndex === false)
+        ? previous.data[beforeIndex].values : nativeValue(plan.project(item, index), before?.values);
+      const measurement = measurementKey ?? null;
+      const record = before && before.values === projected && before.measurementKey === measurement
+        ? before : { key, values: projected, measurementKey: measurement };
+      positions.set(key, index);
+      itemKeys.push(key);
+      if (record !== previous?.data[index]) {
+        unchanged = false;
+        if (record !== before) changes.push(record);
+        if (key !== previous?.data[index]?.key) reordered = true;
+      }
+      data.push(record);
+      yield;
+    }
+    if (unchanged && previous) data = previous.data;
+    else if (previous) rememberListPatch(data, { previous: previous.data, changes,
+      ...(reordered ? { keys: itemKeys } : {}) });
+    return { data, positions, template: plan.template, items, key: keyIdentity, measurementKey, scope };
+  } catch (error) {
+    if (error !== needsReact) throw error;
+    return null;
+  }
+}
+
+function advancePreparation<T>(preparation: Preparation<T>, cooperative: boolean) {
+  if (preparation.result) return preparation.result;
+  if (preparation.error) throw preparation.error.value;
+  const started = cooperative ? performance.now() : 0;
+  let rows = 0;
+  while (true) {
+    let step;
+    try {
+      step = preparation.steps.next();
+    } catch (error) {
+      preparation.error = { value: error };
+      throw error;
+    }
+    if (step.done) return preparation.result = { value: step.value };
+    rows++;
+    // Identity-only sparse scans do not yield: a single replaced row stays synchronous.
+    if (cooperative && (rows >= maximumPreparationRows
+      || rows >= minimumPreparationRows && performance.now() - started >= preparationBudget)) return;
+  }
+}
+
 export function nativeListPlan<T>(render: ListProps<T>["renderItem"]): Plan<T> | undefined {
   return plans.get(render) as Plan<T> | undefined;
 }
 
-export function CompiledList<T>({ plan, ...props }: ListProps<T> & { plan: Plan<T> }) {
-  const { items, keyExtractor, gap = 47, followEnd, initialPosition, measurementKey, onLoadMore, onLoadOlder, hasMore = false, hasOlder = false } = props;
+export function CompiledList<T>({ plan, pagination, ...props }: ListProps<T> & { plan: Plan<T>; pagination: ListPagination }) {
+  const { items, keyExtractor, gap = 47, followEnd, initialPosition, measurementKey } = props;
   if (!Number.isFinite(gap) || gap < 0) throw new Error("List gap must be finite and non-negative");
-  const load = useAction(() => onLoadMore?.());
-  const older = useAction(() => onLoadOlder?.());
   const committed = useRef<Records<T> | null>(null);
-  const records = useMemo(() => {
-    const previous = committed.current;
+  const committedRequest = useRef<Request<T> | null>(null);
+  const committedPlan = useRef<Plan<T> | null>(null);
+  const generation = useRef(0);
+  const [prepared, setPrepared] = useState<Prepared<T> | null>(null);
+  const request = useMemo<Request<T>>(() => {
     const keyIdentity = keys.get(keyExtractor) ?? keyExtractor;
-    const captured = plan.scope && (items.length ? plan.scope.values() : []);
-    if (captured && !captured.every(value => plainData(value, new WeakSet()))) return null;
-    const snapshots = new WeakMap<object, Captured>();
-    const scope = plan.scope && { identity: plan.scope.identity, values: captured?.map(value => captureValue(value, snapshots)) ?? [] };
-    const sameScope = scope && previous?.scope?.identity === scope.identity && sameScopeValues(previous.scope.values, scope.values);
-    if (previous && previous.items === items && previous.key === keyIdentity
-      && previous.template === plan.template && previous.measurementKey === measurementKey
-      && sameScope) return previous;
-    const rows = new Map<string, RowRecord<T>>();
-    let unchanged = items.length === previous?.data.length;
-    let reordered = !unchanged;
-    const changes: NativeItem[] = [];
-    let data;
+    let scope: Scope | undefined;
     try {
-      if (!items.every(item => plainData(item))) throw needsReact;
-      data = items.map((item, index) => {
-        const key = typeof keyIdentity === "string" && previous?.key === keyIdentity && previous.items[index] === item
-          ? previous.data[index].key : keyExtractor(item, index);
-        if (typeof key !== "string" || rows.has(key)) throw new Error("List keys must be unique strings");
-        const beforeRow = previous?.template === plan.template ? previous.rows.get(key) : undefined;
-        const before = beforeRow?.native;
-        const projected = beforeRow && sameScope && beforeRow.item === item
-          && (beforeRow.index === index || plan.scope?.usesIndex === false)
-          ? beforeRow.native.values : nativeValue(plan.project(item, index), before?.values);
-        const measurement = measurementKey ?? null;
-        const record = before && before.values === projected && before.measurementKey === measurement
-          ? before : { key, values: projected, measurementKey: measurement };
-        rows.set(key, { item, index, native: record });
-        if (record !== previous?.data[index]) {
-          unchanged = false;
-          if (record !== before) changes.push(record);
-          if (key !== previous?.data[index]?.key) reordered = true;
-        }
-        return record;
-      });
+      scope = captureScope(plan, items);
     } catch (error) {
       if (error !== needsReact) throw error;
-      return null;
+      const preparation: Preparation<T> = { steps: (function* () { return null; })(), result: { value: null } };
+      return { items, key: keyIdentity, plan, measurementKey, preparation, synchronous: preparation.result, eventPositions: new Map() };
     }
-    if (unchanged && previous) data = previous.data;
-    else if (previous) rememberListPatch(data, { previous: previous.data, changes,
-      ...(reordered ? { keys: data.map(item => item.key) } : {}) });
-    return { data, rows, template: plan.template, items, key: keyIdentity, measurementKey, scope };
+    const pending = committedRequest.current;
+    if (pending && pending.items === items && pending.key === keyIdentity
+      && pending.plan.template === plan.template && pending.measurementKey === measurementKey
+      && sameScope(pending.scope, scope)) return pending;
+    const previous = committed.current;
+    const dense = isDenseArray?.(items) ?? false;
+    const preparation: Preparation<T> = { steps: prepareRecords(previous, items, plan, keyExtractor, keyIdentity, measurementKey, scope, dense) };
+    // First population must exist when List's one-shot initialPosition effect scrolls its Screen.
+    const cooperative = !!isProxy && !!scope && typeof keyIdentity === "string"
+      && !!previous?.items.length && previous.template === plan.template && items.length >= cooperativeListSize;
+    const synchronous = advancePreparation(preparation, cooperative);
+    return { items, key: keyIdentity, plan, measurementKey, scope, preparation, synchronous, eventPositions: new Map() };
   }, [items, keyExtractor, plan, measurementKey]);
-  useLayoutEffect(() => { committed.current = records; }, [records]);
+  const outcome = prepared?.request === request && prepared.generation === generation.current ? prepared : undefined;
+  let records = outcome?.status === "ready" ? outcome.value
+    : request.synchronous ? request.synchronous.value : committed.current;
+  if (outcome?.status === "ready" && !request.synchronous) {
+    try {
+      if (!capturesMatch(request, committedPlan.current)) records = null;
+    } catch (error) {
+      if (error !== needsReact) throw error;
+      records = null;
+    }
+  }
+  const preparing = !request.synchronous && outcome?.status !== "ready";
   const targets = useMemo(() => {
     type Template = { id: number; props: Record<string, unknown>; children: Template[] };
     const targets = new Map<number, Record<string, (string | number)[]>>();
@@ -210,28 +347,90 @@ export function CompiledList<T>({ plan, ...props }: ListProps<T> & { plan: Plan<
     visit(JSON.parse(plan.template) as Template);
     return targets;
   }, [plan.template]);
-  if (!records) return createElement(ReactList<T>, props);
+  const events = useRef<{
+    items: readonly T[]; keyExtractor: ListProps<T>["keyExtractor"]; plan: Plan<T>;
+    targets: typeof targets; positions: Map<string, number | undefined>;
+  } | null>(null);
+  useLayoutEffect(() => {
+    committed.current = records;
+    committedRequest.current = request;
+    committedPlan.current = plan;
+    events.current = { items, keyExtractor, plan, targets, positions: request.eventPositions };
+    return () => {
+      events.current = null;
+      committedRequest.current = null;
+      committedPlan.current = null;
+    };
+  });
+  useLayoutEffect(() => {
+    const currentGeneration = ++generation.current;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const current = () => generation.current === currentGeneration && committedRequest.current === request;
+    const run = () => {
+      if (!current()) return;
+      try {
+        const result = capturesMatch(request, committedPlan.current)
+          ? advancePreparation(request.preparation, true) : { value: null };
+        if (!current()) return;
+        if (result) setPrepared({ request, generation: currentGeneration, status: "ready", value: result.value });
+        else timer = setTimeout(run, 0);
+      } catch (error) {
+        if (!current()) return;
+        setPrepared(error === needsReact
+          ? { request, generation: currentGeneration, status: "ready", value: null }
+          : { request, generation: currentGeneration, status: "error", error });
+      }
+    };
+    if (!request.synchronous) timer = setTimeout(run, 0);
+    return () => {
+      generation.current++;
+      if (timer !== undefined) clearTimeout(timer);
+    };
+  }, [request]);
+  const paginationProps = useListPaginationEvents(pagination, preparing || !records,
+    records?.data.length ?? 0, records?.data[0]?.key, records?.data.at(-1)?.key);
+  if (outcome?.status === "error") throw outcome.error;
+  if (!records) return createElement(ReactList<T>, { ...props, pagination });
   const nativeProps = {
-    items: records.data, keyField: "key", template: plan.template, gap, followEnd, initialEnd: initialPosition === "end",
-    hasMore: hasMore && load.status !== "pending" && load.status !== "error",
-    hasOlder: hasOlder && older.status !== "pending" && older.status !== "error",
-    onEndReached: onLoadMore ? load.run : undefined,
-    onStartReached: onLoadOlder ? older.run : undefined,
+    items: records.data, keyField: "key", template: records.template, gap, followEnd, initialEnd: initialPosition === "end",
+    ...paginationProps,
     onRowEvent(key: string, target: number, name: string, ...args: unknown[]) {
-      const path = targets.get(target)?.[name];
-      const row = records.rows.get(key);
-      let callback: unknown = row && path ? plan.project(row.item, row.index) : undefined;
-      for (const part of path ?? []) {
+      const latest = events.current;
+      const path = latest?.targets.get(target)?.[name];
+      if (!latest || !path || isProxy?.(latest.items)) return;
+      const matches = (index: number) => {
+        const property = Object.getOwnPropertyDescriptor(latest.items, index);
+        return !!property && "value" in property && plainData(property.value)
+          && latest.keyExtractor(property.value, index) === key;
+      };
+      let index = latest.items === records.items ? records.positions.get(key) : latest.positions.get(key);
+      if (latest.items !== records.items && !latest.positions.has(key)) {
+        const beforeIndex = records.positions.get(key);
+        if (beforeIndex !== undefined && matches(beforeIndex)) index = beforeIndex;
+        else {
+          for (let candidate = 0; candidate < latest.items.length; candidate++) {
+            if (matches(candidate)) { index = candidate; break; }
+          }
+        }
+        latest.positions.set(key, index);
+      }
+      if (index === undefined) return;
+      let callback: unknown;
+      try {
+        const item = listItem(latest.items, index);
+        if (!plainData(item)) return;
+        callback = latest.plan.project(item, index);
+      } catch (error) {
+        if (error === needsReact) return;
+        throw error;
+      }
+      for (const part of path) {
         callback = callback != null && typeof callback === "object" ? Reflect.get(callback, part) : undefined;
       }
-      if (path && typeof callback === "function") callback(...args);
+      if (typeof callback === "function") callback(...args);
     },
   };
-  return createElement(Fragment, null,
-    older.status === "error" && createElement(ListLoadError, { message: older.error.message, onRetry: older.run }),
-    createElement("NativeList", nativeProps),
-    load.status === "error" && createElement(ListLoadError, { message: load.error.message, onRetry: load.run }),
-  );
+  return createElement("NativeList", nativeProps);
 }
 
 /** @internal Fixed native descriptions for Ink's own list components. */

package/src/native.ts

@@ -34,6 +34,14 @@ Object.defineProperty(globalThis, "__inkReceive", {
   },
 });
 
+Object.defineProperty(globalThis, "__inkResolveNativeResult", {
+  value: (id: number, value?: string, kind?: string, message?: string, retryable?: boolean) => {
+    listeners.get("result")?.(typeof value === "string"
+      ? { id, type: "result", value }
+      : { id, kind, message, retryable, type: "result" });
+  },
+});
+
 onNativeMessage("result", message => {
   if (typeof message.id !== "number") throw new Error("Invalid native result ID");
   const request = pending.get(message.id);

package/src/prefresh.d.ts

@@ -0,0 +1,3 @@
+declare module "@prefresh/utils" {
+  export function flush(): void;
+}

package/src/react-compat.ts

@@ -0,0 +1,24 @@
+import React from "preact/compat";
+import { cloneElement, isValidElement } from "preact";
+import { Activity, useEffect, useLayoutEffect, useSyncExternalStore, useImperativeHandle } from "./visibility";
+import { useRef, useCallback, useLayoutEffect as commitLayoutEffect } from "preact/hooks";
+const compatibleReact = /* @__PURE__ */ Object.assign({}, React, { Activity, cloneElement, isValidElement, useEffect, useLayoutEffect, useSyncExternalStore, useImperativeHandle, useEffectEvent });
+export default compatibleReact;
+export {
+  Children, Component, Fragment, PureComponent, StrictMode, Suspense, SuspenseList,
+  createContext, createElement, createFactory, createPortal, createRef,
+  findDOMNode, flushSync, forwardRef, hydrate, lazy, memo, render,
+  startTransition, unmountComponentAtNode, unstable_batchedUpdates,
+  useCallback, useContext, useDebugValue, useDeferredValue,
+  useId, useInsertionEffect, useMemo, useReducer,
+  useRef, useState, useTransition, version,
+} from "preact/compat";
+export { cloneElement, isValidElement } from "preact";
+export { Activity, useEffect, useLayoutEffect, useSyncExternalStore, useImperativeHandle } from "./visibility";
+
+/** Effect events retain their identity and read the latest committed callback. */
+export function useEffectEvent<T extends (...args: never[]) => unknown>(callback: T): T {
+  const current = useRef(callback);
+  commitLayoutEffect(() => { current.current = callback; });
+  return useCallback(((...args: Parameters<T>) => current.current(...args)) as T, []);
+}

package/src/react.ts

@@ -1,6 +1,26 @@
-// Share the CommonJS React import so unused component modules contribute no wrapper code.
-export {
-  Activity, Children, Fragment, createContext, createElement, isValidElement, memo,
-  useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState,
-  useSyncExternalStore, type ComponentProps, type ReactElement, type ReactNode,
-} from "react";
+import { createElement as element, createContext as context, isValidElement as valid, Fragment as fragment, Component, type ComponentChildren } from "preact";
+import { useCallback, useContext as contextValue, useMemo, useRef, useState } from "preact/hooks";
+import type * as React from "react";
+
+// Keep the public React declarations while executing Preact core in Ink.
+export const createElement = element as unknown as typeof React.createElement;
+export const createContext = context as unknown as typeof React.createContext;
+export const useContext = contextValue as unknown as typeof React.useContext;
+export const isValidElement = valid as unknown as typeof React.isValidElement;
+export const Fragment = fragment as unknown as typeof React.Fragment;
+export { Children } from "preact/compat";
+export { useCallback, useMemo, useRef, useState };
+export { Activity, useEffect, useLayoutEffect, useSyncExternalStore } from "./visibility";
+export type { ComponentProps, ComponentType, ReactElement, ReactNode } from "react";
+
+// A single core component avoids compat memo's extra function-component layer.
+export function memo<P extends object>(render: (props: P) => React.ReactNode) {
+  return class extends Component<P> {
+    shouldComponentUpdate(next: P) {
+      const previous = this.props;
+      const keys = Object.keys(next) as (keyof P)[];
+      return keys.length !== Object.keys(previous).length || keys.some(key => !Object.is(previous[key], next[key]));
+    }
+    render() { return render(this.props) as ComponentChildren; }
+  } as unknown as (props: P) => React.ReactNode;
+}

package/src/refresh.ts

@@ -0,0 +1,29 @@
+import "@prefresh/core";
+import { flush } from "@prefresh/utils";
+
+declare const self: { __PREFRESH__: {
+  register(type: unknown, id: string): void;
+  sign(type: unknown, key: string, forceReset: boolean, getCustomHooks: (() => unknown[]) | undefined, status: string): string;
+} };
+
+export const register = (type: unknown, id: string) => self.__PREFRESH__.register(type, id);
+export const performReactRefresh = flush;
+
+// Oxc emits React Refresh's signature protocol; translate it to Prefresh.
+export function createSignatureFunctionForTransform() {
+  let savedType: unknown;
+  let savedKey = "";
+  let savedReset = false;
+  let savedHooks: (() => unknown[]) | undefined;
+  let status = "begin";
+  return (type?: unknown, key?: string, forceReset = false, getCustomHooks?: () => unknown[]) => {
+    if (type) {
+      savedType = type;
+      savedKey = key ?? "";
+      savedReset = forceReset;
+      savedHooks = getCustomHooks;
+    }
+    status = self.__PREFRESH__.sign(savedType, savedKey, savedReset, savedHooks, status);
+    return type;
+  };
+}