@unbound-app/api 3.0.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@unbound-app/api",
-	"version": "3.0.0",
+	"version": "3.2.0",
 	"author": {
 		"name": "Mario P.",
 		"email": "contact@marioparaschiv.com",

package/src/_internal.d.ts

@@ -2,7 +2,7 @@
 
 import type { LiteralUnion } from './_types';
 import * as React$1 from 'react';
-import { ComponentType, FunctionComponent, ReactElement, ReactNode } from 'react';
+import { ComponentType, Context, FunctionComponent, ReactElement, ReactNode } from 'react';
 import * as RN from 'react-native';
 import { ImageSourcePropType, ImageStyle, TextStyle, ViewStyle } from 'react-native';
 
@@ -87,12 +87,20 @@ export declare const NATIVE_BRIDGE_CAPABILITIES: readonly [
 	'native.objc.ivars',
 	'native.objc.associations',
 	'native.objc.hooks',
+	'native.objc.blocks',
+	'native.objc.classDefinition',
+	'native.objc.classSearch',
+	'native.objc.inspect',
 	'native.ffi.symbols',
 	'native.ffi.call',
+	'native.ffi.memory',
+	'native.ffi.callbacks',
+	'native.ffi.rebind',
 	'native.fabric.mount',
 	'native.fabric.async',
 	'native.runtime.events',
 	'native.java.classes',
+	'native.java.classSearch',
 	'native.java.construct',
 	'native.java.fields',
 	'native.java.invoke',
@@ -135,8 +143,25 @@ export declare const NATIVE_BRIDGE_METHOD_CAPABILITIES: {
 	readonly 'objc.array': 'native.objc.classes';
 	readonly 'objc.data': 'native.objc.classes';
 	readonly 'objc.hook': 'native.objc.hooks';
+	readonly 'objc.block': 'native.objc.blocks';
+	readonly 'objc.callBlock': 'native.objc.blocks';
+	readonly 'objc.defineClass': 'native.objc.classDefinition';
+	readonly 'objc.findClasses': 'native.objc.classSearch';
+	readonly 'objc.inspectClass': 'native.objc.inspect';
+	readonly 'objc.inspectMembers': 'native.objc.inspect';
+	readonly 'objc.inspectValues': 'native.objc.inspect';
+	readonly 'objc.inspectImages': 'native.objc.inspect';
+	readonly 'objc.inspectClasses': 'native.objc.inspect';
 	readonly 'ffi.symbol': 'native.ffi.symbols';
 	readonly 'ffi.call': 'native.ffi.call';
+	readonly 'ffi.alloc': 'native.ffi.memory';
+	readonly 'ffi.free': 'native.ffi.memory';
+	readonly 'ffi.read': 'native.ffi.memory';
+	readonly 'ffi.write': 'native.ffi.memory';
+	readonly 'ffi.callback': 'native.ffi.callbacks';
+	readonly 'ffi.releaseCallback': 'native.ffi.callbacks';
+	readonly 'ffi.rebind': 'native.ffi.rebind';
+	readonly 'ffi.restore': 'native.ffi.rebind';
 	readonly 'fabric.mount': 'native.fabric.mount';
 	readonly 'fabric.update': 'native.fabric.mount';
 	readonly 'fabric.setSize': 'native.fabric.mount';
@@ -156,6 +181,7 @@ export declare const NATIVE_BRIDGE_METHOD_CAPABILITIES: {
 	readonly 'java.getClass': 'native.java.classes';
 	readonly 'java.className': 'native.java.classes';
 	readonly 'java.describe': 'native.java.classes';
+	readonly 'java.findClasses': 'native.java.classSearch';
 	readonly 'java.construct': 'native.java.construct';
 	readonly 'java.respondsTo': 'native.java.classes';
 	readonly 'java.invoke': 'native.java.invoke';
@@ -180,6 +206,7 @@ export declare const NATIVE_BRIDGE_METHOD_CAPABILITIES: {
 	readonly 'hooks.removeReturnValue': 'native.java.hooks';
 	readonly 'hooks.clearReturnValues': 'native.java.hooks';
 	readonly 'hooks.remove': 'native.java.hooks';
+	readonly 'hooks.proxy': 'native.java.hooks';
 };
 /** The host platforms a native bridge runs on. */
 export declare const NATIVE_BRIDGE_PLATFORMS: readonly ['ios', 'android'];
@@ -194,8 +221,15 @@ export declare const NATIVE_BRIDGE_PLATFORM_CAPABILITIES: {
 		'native.objc.ivars',
 		'native.objc.associations',
 		'native.objc.hooks',
+		'native.objc.blocks',
+		'native.objc.classDefinition',
+		'native.objc.classSearch',
+		'native.objc.inspect',
 		'native.ffi.symbols',
 		'native.ffi.call',
+		'native.ffi.memory',
+		'native.ffi.callbacks',
+		'native.ffi.rebind',
 		'native.fabric.mount',
 		'native.fabric.async',
 		'native.runtime.events',
@@ -205,9 +239,13 @@ export declare const NATIVE_BRIDGE_PLATFORM_CAPABILITIES: {
 	readonly android: readonly [
 		'native.ffi.symbols',
 		'native.ffi.call',
+		'native.ffi.memory',
+		'native.ffi.callbacks',
+		'native.ffi.rebind',
 		'native.fabric.async',
 		'native.runtime.events',
 		'native.java.classes',
+		'native.java.classSearch',
 		'native.java.construct',
 		'native.java.fields',
 		'native.java.invoke',
@@ -1353,6 +1391,8 @@ export type DesignHelpers = {
 	TextStyleSheet: Record<TextVariant, TextStyle>;
 	/** Hook that resolves a semantic colour token, such as `Theme.colors.TEXT_DEFAULT`, to a colour for the current theme. */
 	useToken: (token: SemanticColorToken) => string;
+	/** Whether a row sits in a `TableRowGroup`, which then rounds the group's card itself; rows outside one round their own. */
+	TableRowGroupContext: React$1.Context<boolean>;
 	/** Hook that builds the state a `SegmentedControl` and its `SegmentedControlPages` share. */
 	useSegmentedControlState: (options: SegmentedControlStateOptions) => SegmentedControlState;
 	/** Opens an alert as `openAlert(key, element)`; pass the same key to `dismissAlert` to close it. */
@@ -3415,7 +3455,9 @@ export type LoaderNativeBridge = Pick<
 		readonly java?: NativeJavaBridge & NativeUIScopeFactory;
 	};
 /** The `objc` namespace the loader publishes, before the client adds `create` and scopes it to a plugin. */
-export type LoaderObjCBridge = Omit<NativeObjCBridge, 'create'> & NativeUIScopeFactory;
+export type LoaderObjCBridge = Omit<NativeObjCBridge, 'create'> &
+	Partial<NativeObjCInspector> &
+	NativeUIScopeFactory;
 /**
  * Props of `LoadingButtonPill` (function). Exports: LoadingButtonPill.
  * @see design/components/Button/native/ButtonPill.native.tsx
@@ -3835,6 +3877,9 @@ export type NativeBridgeError = {
 };
 /** The stable `code` on an error the native bridge or its plugin scope throws. */
 export type NativeBridgeErrorCode =
+	| 'INSPECTOR_DISABLED'
+	| 'INSPECTOR_UNAVAILABLE'
+	| 'INSPECTOR_UNKNOWN_CLASS'
 	| 'NATIVE_BRIDGE_ERROR'
 	| 'NATIVE_PLUGIN_API_VERSION_UNSUPPORTED'
 	| 'NATIVE_PLUGIN_CALL_CANCELLED'
@@ -3842,10 +3887,12 @@ export type NativeBridgeErrorCode =
 	| 'NATIVE_PLUGIN_CAPABILITY_DENIED'
 	| 'NATIVE_PLUGIN_SCOPE_DISPOSED'
 	| 'NATIVE_PLUGIN_UNAVAILABLE';
-/** A native bridge method by the path a plugin calls it through, such as `objc.invoke`. */
-export type NativeBridgeMethod = {
-	[N in NativeBridgeNamespace]: `${N}.${keyof NativeBridge[N] & string}`;
-}[NativeBridgeNamespace];
+/** A native bridge method by the path a plugin calls it through, such as `objc.invoke`, or the debugger's `objc.inspect*`. */
+export type NativeBridgeMethod =
+	| {
+			[N in NativeBridgeNamespace]: `${N}.${keyof NativeBridge[N] & string}`;
+	  }[NativeBridgeNamespace]
+	| `objc.${keyof NativeObjCInspector}`;
 /** A {@link NativeBridge} namespace whose methods a plugin calls, such as `objc` or `java`. */
 export type NativeBridgeNamespace = Exclude<
 	keyof NativeBridge,
@@ -3931,12 +3978,89 @@ export type NativeDebugEvaluationLog = {
 	/** The printed text. */
 	message: string;
 };
+/** Memory and thermal pressure, as each platform reports it. */
+export type NativeDeviceState = {
+	/** Memory available to apps, in megabytes. */
+	availableMB?: number;
+	/** Android: the system considers itself low on memory. */
+	lowMemory?: boolean;
+	/** iOS: memory warnings Discord received this session. */
+	memoryWarnings?: number;
+	/** How hot the device runs, as the system rates it. */
+	thermal?: 'nominal' | 'fair' | 'serious' | 'critical';
+	/** Free space on the volume holding Discord's documents, and the size of Unbound's folder there. */
+	freeMB?: number;
+	/** The size of Unbound's folder, in megabytes. */
+	unboundMB?: number;
+	/** The active connection, and whether a VPN, a proxy, a metered plan or Low Data Mode (Data Saver) applies. */
+	network?: NativeNetworkState;
+	/** Other tweaks or modules loaded into Discord: iOS dylib names, Android packages or Magisk modules; older loaders omit it. */
+	injected?: string[];
+};
+/**
+ * The install, binary, device and network facts `/debug` shows, each already a display string.
+ * @internal
+ */
+type NativeEnvironmentReport = {
+	/** iOS: the signing certificate's SHA-256 prefix and issuer. */
+	signer?: string;
+	/** iOS: encryption, UUID, minimum OS, SDK and dylib count of Discord's executable. */
+	binary?: string;
+	/** Android: the APK signer, patch mode, splits and profile. */
+	install?: string;
+	markers?: string[];
+	/** iOS: the OS build number when it is a beta. */
+	osBeta?: string;
+	/** Whether Discord's HTTPS traffic reaches a certificate from a known public CA. */
+	https?: {
+		intercepted: boolean;
+		issuer?: string;
+		failure?: string;
+	};
+};
 /** Calls C functions in images Discord already loaded. An unsigned plugin needs the user's consent to use it. */
 export type NativeFFIBridge = {
 	/** Resolves a symbol in a loaded image, or in every loaded image when `image` is omitted; `null` when not found. */
 	symbol(name: string, image?: string): NativePointer | null;
 	/** Calls a symbol from `symbol` with an explicit signature. */
 	call(pointer: NativePointer, signature: NativeFFISignature, ...args: unknown[]): unknown;
+	/** Allocates zeroed memory for out-parameters and buffers; free it with `free`. Needs `native.ffi.memory`. */
+	alloc(size: number): NativePointer;
+	/** Frees memory from `alloc`; `false` for any other pointer. Needs `native.ffi.memory`. */
+	free(pointer: NativePointer): boolean;
+	/** Reads a value of a type at a pointer, `offset` bytes in, failing safely on an unreadable address. Needs `native.ffi.memory`. */
+	read(pointer: NativePointer, type: NativeFFIType, offset?: number): NativeFFIValue;
+	/** Writes a value of a type into memory from `alloc`, `offset` bytes in. Needs `native.ffi.memory`. */
+	write(
+		pointer: NativePointer,
+		type: NativeFFIType,
+		value: NativeFFIValue,
+		offset?: number,
+	): void;
+	/**
+	 * Makes a C function pointer that runs `implementation` on the JavaScript thread; 32 per return kind live at
+	 * once, so release each with `releaseCallback`. Needs `native.ffi.callbacks`.
+	 */
+	callback(
+		signature: NativeFFISignature,
+		implementation: (...args: never[]) => NativeFFIValue | void,
+	): NativePointer;
+	/** Frees a pointer from `callback`. Needs `native.ffi.callbacks`. */
+	releaseCallback(pointer: NativePointer): boolean;
+	/**
+	 * Points every image's imports of a C function at `replacement`, such as a pointer from `callback`, and returns
+	 * the original to call through; the loader's own calls keep the original. Needs `native.ffi.rebind`.
+	 */
+	rebind(name: string, replacement: NativePointer): NativeFFIRebinding;
+	/** Puts back every import `rebind` changed for a symbol. Needs `native.ffi.rebind`. */
+	restore(name: string): boolean;
+};
+/** What `rebind` changed: the original function and how many import slots now point at the replacement. */
+export type NativeFFIRebinding = {
+	/** The function the import slots pointed at before. */
+	original: NativePointer;
+	/** How many import slots now point at the replacement. */
+	slots: number;
 };
 /** A non-variadic C function signature for `ffi.call`. */
 export type NativeFFISignature = {
@@ -3970,6 +4094,15 @@ export type NativeFFITypeName =
 	| 'object'
 	| 'class'
 	| 'selector';
+/** A value an FFI type reads or writes: a number, `BigInt` for 64-bit integers, a boolean, a string or a pointer. */
+export type NativeFFIValue =
+	| number
+	| bigint
+	| boolean
+	| string
+	| NativePointer
+	| NativeStruct
+	| null;
 /** One surface's changes in a `batchAsync` call, applied as properties, then size, then frame. */
 export type NativeFabricBatchMutation = {
 	/** The surface these changes apply to. */
@@ -4131,6 +4264,10 @@ export type NativeHookOptions<Receiver extends boolean = boolean> = {
 	/** Removes the hook after its first call. */
 	once?: boolean;
 	payload?: NativeHookPayload<Receiver>;
+	/** Also hooks every loaded subclass that implements the selector itself. */
+	subclasses?: boolean;
+	/** Waits for a class that is not loaded yet, retrying with backoff for up to ten minutes. */
+	waitForClass?: boolean;
 } & NativeCallOptions;
 /** Trims what a hook sends to JavaScript per call, to cut crossing cost on hot methods. */
 export type NativeHookPayload<Receiver extends boolean = boolean> = {
@@ -4154,6 +4291,123 @@ export type NativeHookToken = {
 	/** Removes the hook; calling it again does nothing. */
 	remove(): void;
 };
+/** A kind of a class's own members `objc.inspectMembers` lists. */
+export type NativeInspectKind = 'properties' | 'ivars' | 'methods' | 'classMethods' | 'protocols';
+/** Narrows a page of inspected members, images or classes. */
+export type NativeInspectPage = {
+	/** How many matches to skip. */
+	offset?: number;
+	/** At most 200. */
+	limit?: number;
+	/** A case-insensitive substring of the name. */
+	filter?: string;
+};
+/** Options for `objc.inspectValues`. */
+export type NativeInspectValuesOptions = {
+	/** Runs the getters of computed properties, which automatic reads skip. */
+	invokeGetters?: boolean;
+};
+/** One class of an inspected class chain, from the class itself to its root. */
+export type NativeInspectedClass = {
+	/** The class's name. */
+	name: string;
+	/** The superclass's name, or `null` at the root. */
+	superclass: string | null;
+	/** The path of the image that defines the class, or `null` when unknown. */
+	image: string | null;
+	/** The size of an instance, in bytes. */
+	instanceSize: number;
+	/** How many of each kind of member the class itself declares. */
+	counts: Record<NativeInspectKind, number>;
+};
+/** One page of an image's class names, and how many match in all. */
+export type NativeInspectedClasses = {
+	/** How many classes match in all. */
+	total: number;
+	/** This page's class names. */
+	classes: string[];
+};
+/** One loaded image that defines Objective-C classes. */
+export type NativeInspectedImage = {
+	/** The image's path on the device. */
+	path: string;
+	/** The image's file name. */
+	name: string;
+	/** How many classes the image defines. */
+	classCount: number;
+};
+/** One page of loaded images, and how many match in all. */
+export type NativeInspectedImages = {
+	/** How many images match in all. */
+	total: number;
+	/** This page's images. */
+	images: NativeInspectedImage[];
+};
+/** One member of a class; fields that do not apply to its kind are omitted. */
+export type NativeInspectedMember = {
+	/** The member's name, or a method's selector. */
+	name: string;
+	/** The kind of member. */
+	kind: NativeInspectKind;
+	/** The decoded type, such as `NSString *` or `CGRect`. */
+	type?: string;
+	/** The declaration, such as `- (void)setFoo:(id)foo`. */
+	signature?: string;
+	/** A method's decoded return type. */
+	returnType?: string;
+	/** A method's decoded parameter types, in order. */
+	parameters?: string[];
+	/** The raw Objective-C type encoding. */
+	encoding?: string;
+	/** Property attributes, such as `nonatomic`, `strong`, `readonly`, `weak`, `copy` or `class`. */
+	attributes?: string[];
+	/** A property's getter selector. */
+	getter?: string;
+	/** A property's setter selector, absent when it is read-only. */
+	setter?: string;
+	/** The instance variable backing a property. */
+	ivar?: string;
+	/** An instance variable's offset in the object, in bytes. */
+	offset?: number;
+	/** An instance variable's size, in bytes. */
+	size?: number;
+	/** The path of the image that defines a method. */
+	image?: string;
+	/** Whether reading the value runs no code (`auto`), runs a getter (`manual`), or is unsafe (`never`). */
+	read: 'auto' | 'manual' | 'never';
+};
+/** One page of a class's members of one kind, and how many match in all. */
+export type NativeInspectedMembers = {
+	/** How many members match in all. */
+	total: number;
+	/** This page's members. */
+	members: NativeInspectedMember[];
+};
+/** One value read by `objc.inspectValues`; `text` describes it for display. */
+export type NativeInspectedValue = {
+	/** The member the value was read from. */
+	name: string;
+	/** What the value is; `skipped` was not read and `error` failed to read. */
+	kind:
+		| 'nil'
+		| 'number'
+		| 'bool'
+		| 'string'
+		| 'object'
+		| 'class'
+		| 'struct'
+		| 'pointer'
+		| 'selector'
+		| 'other'
+		| 'skipped'
+		| 'error';
+	/** The value as text, strings cut to 500 characters. */
+	text: string;
+	/** A handle to the value, for `kind: 'object'`. */
+	object?: NativeObjectHandle;
+	/** The class of an object or class value. */
+	className?: string;
+};
 /** An argument to a Java call: a tagged value or a handle. */
 export type NativeJavaArgument = NativeJavaValue | NativeJavaHandle;
 /** A key from `java.createAssociationKey` that names one associated value. */
@@ -4177,6 +4431,11 @@ export type NativeJavaBridge = {
 	getClass(name: string): NativeJavaHandle;
 	/** Lists a class's constructors, methods and fields. */
 	describe(name: string): NativeJavaClassDescription;
+	/**
+	 * Finds Discord's classes by shape, so a lookup survives the obfuscated names changing between builds; results
+	 * are cached per Discord build. Needs `native.java.classSearch`.
+	 */
+	findClasses(query: NativeJavaClassQuery): NativeCancelablePromise<string[]>;
 	/** Runs independent operations in one call on the JavaScript thread and returns every result in order. */
 	batch(operations: NativeJavaBatchOperation[]): NativeJavaValue[];
 	/** Runs the operations like `batch`, on the main thread, so views can be read safely. */
@@ -4264,6 +4523,21 @@ export type NativeJavaClassDescription = {
 	/** The fields the class declares. */
 	fields: NativeJavaFieldDescription[];
 };
+/** What `java.findClasses` matches; library packages are skipped unless `package` names one. */
+export type NativeJavaClassQuery = {
+	/** The class name starts with it, such as `com.discord.`. */
+	package?: string;
+	/** The class inherits from it, directly or further up. */
+	extends?: string;
+	/** The class implements every one, directly or through a superclass. */
+	implements?: string[];
+	/** Methods the class must have, every one matching. */
+	methods?: NativeJavaMethodShape[];
+	/** Fields the class must declare, every one matching. */
+	fields?: NativeJavaFieldShape[];
+	/** At most this many names, 50 by default and 1000 at most. */
+	limit?: number;
+};
 /** One field a Java class declares, from `java.describe`. */
 export type NativeJavaFieldDescription = {
 	/** The field name. */
@@ -4273,6 +4547,15 @@ export type NativeJavaFieldDescription = {
 	/** Whether the field is static. */
 	static: boolean;
 };
+/** A field a class from `java.findClasses` must declare. */
+export type NativeJavaFieldShape = {
+	/** The field's name. */
+	name?: string;
+	/** The field type's fully qualified name. */
+	type?: string;
+	/** Whether the field is static. */
+	static?: boolean;
+};
 /** A handle to a Java object or class; the plugin scope releases it on dispose. */
 export type NativeJavaHandle = NativeHandle;
 /** A Java object reference the bridge returns inside a result. */
@@ -4301,8 +4584,19 @@ export type NativeJavaHookOptions<Receiver extends boolean = boolean> = {
 	replace?: boolean;
 	/** Whether the listener hears calls: before the method by default, `after` once it has run, `false` never. */
 	notify?: boolean | 'after';
+	/** Lets a `before` listener hooked from a UI scope return `{ arguments }` to run the method with them instead. */
+	rewriteArguments?: boolean;
 	/** Trims the receiver, arguments and phase each event sends, to cut crossing cost on hot methods. */
 	payload?: NativeHookPayload<Receiver>;
+	/** Also hooks every subclass that declares the method itself, found by `java.findClasses` once it answers. */
+	subclasses?: boolean;
+	/** Waits for a class that is not loaded yet, retrying with backoff for up to ten minutes. */
+	waitForClass?: boolean;
+};
+/** What a `rewriteArguments` listener returns to run the hooked method with other arguments, one per parameter. */
+export type NativeJavaHookRewrite = {
+	/** The arguments to run the method with, in parameter order. */
+	arguments: NativeJavaArgument[];
 };
 /** An installed Java hook; the plugin scope removes it on dispose. */
 export type NativeJavaHookToken = {
@@ -4317,7 +4611,7 @@ export type NativeJavaHooksBridge = {
 		methodName: string,
 		parameterTypes: string[],
 		options?: NativeJavaHookOptions<Receiver>,
-		listener?: (event: NativeJavaHookEvent<Receiver>) => void,
+		listener?: (event: NativeJavaHookEvent<Receiver>) => NativeJavaHookRewrite | void,
 	): NativeJavaHookToken;
 	/** Sets the result a `replace` hook returns for calls with this receiver and these arguments. */
 	setReturnValue(
@@ -4334,8 +4628,16 @@ export type NativeJavaHooksBridge = {
 	): void;
 	/** Removes every result set on a hook. */
 	clearReturnValues(token: NativeJavaHookToken): void;
-	/** Removes a hook. */
+	/** Removes a hook or a proxy. */
 	remove(token: NativeJavaHookToken): void;
+	/**
+	 * Creates a Java object implementing `interfaces`, from a UI scope only. Calls on the main thread run `handler`
+	 * inline and return its value; calls on other threads reach it later and return the type's default.
+	 */
+	proxy(
+		interfaces: string[],
+		handler: (call: NativeJavaProxyCall) => NativeJavaArgument | void,
+	): NativeJavaProxy;
 };
 /** One method a Java class declares, from `java.describe`. */
 export type NativeJavaMethodDescription = {
@@ -4348,6 +4650,33 @@ export type NativeJavaMethodDescription = {
 	/** Whether the method is static. */
 	static: boolean;
 };
+/** A method a class from `java.findClasses` must have; every given part must match. */
+export type NativeJavaMethodShape = {
+	/** The method's name. */
+	name?: string;
+	/** The parameter types' fully qualified names, in order. */
+	parameters?: string[];
+	/** The return type's fully qualified name. */
+	returns?: string;
+	/** Whether the method is static. */
+	static?: boolean;
+	/** Whether the class itself declares it rather than inheriting it; `true` by default. */
+	declared?: boolean;
+};
+/** A Java object implementing interfaces through a handler; remove its token to stop it answering. */
+export type NativeJavaProxy = {
+	/** Removes the proxy with `hooks.remove`; the UI scope removes it on dispose. */
+	token: NativeJavaHookToken;
+	/** The object to pass wherever Java expects one of the interfaces. */
+	object: NativeJavaHandle;
+};
+/** What a proxy handler receives for one call of an interface method. */
+export type NativeJavaProxyCall = {
+	/** The interface method's name, such as `onPreDraw`. */
+	method: string;
+	/** The call's arguments. */
+	args: NativeJavaValue[];
+};
 /** A Java object, as a handle or as a tagged handle value from a result. */
 export type NativeJavaReference = NativeJavaHandle | NativeJavaHandleValue;
 /** A Java value tagged with its type, as the Java bridge returns and accepts it. */
@@ -4420,6 +4749,19 @@ export type NativeMainWorkCounts = {
 	/** The most items one drain ran. */
 	maxDrainItems: number;
 };
+/** The device's active connection. */
+export type NativeNetworkState = {
+	/** The kind of connection, or `offline` with none. */
+	type: 'wifi' | 'cellular' | 'ethernet' | 'other' | 'offline';
+	/** The connection bills by data. */
+	metered?: boolean;
+	/** Low Data Mode (iOS) or Data Saver (Android) is on. */
+	lowData?: boolean;
+	/** Traffic goes through a VPN. */
+	vpn?: boolean;
+	/** A system HTTP proxy is set. */
+	proxy?: boolean;
+};
 /** The iOS bridge to the Objective-C runtime, scoped to the plugin's capabilities. */
 export type NativeObjCBridge = {
 	/** Looks up a class by name, or returns `null` when none is registered. */
@@ -4535,11 +4877,89 @@ export type NativeObjCBridge = {
 		handlers: NativeHookHandlers<Receiver>,
 		options?: NativeHookOptions<Receiver>,
 	): NativeHookToken;
+	/**
+	 * Makes an Objective-C block that calls `implementation` on the JavaScript thread, for completion handlers,
+	 * notification observers and enumeration blocks. Needs `native.objc.blocks`.
+	 */
+	block(
+		signature: NativeFFISignature,
+		implementation: (...args: never[]) => NativeObjCResult | void,
+	): NativeObjectHandle;
+	/** Calls a block, such as a completion handler a hook received, with an explicit signature. Needs `native.objc.blocks`. */
+	callBlock(
+		block: NativeObjectHandle,
+		signature: NativeFFISignature,
+		...args: NativeObjCResult[]
+	): NativeObjCResult;
+	/** Finds loaded classes by shape, so a lookup survives renamed classes. Needs `native.objc.classSearch`. */
+	findClasses(query: NativeObjCClassQuery): string[];
+	/**
+	 * Defines an Objective-C class at runtime whose methods run JavaScript, for delegates, data sources and
+	 * target-action receivers; defining it again replaces its methods. Needs `native.objc.classDefinition`.
+	 */
+	defineClass(
+		name: string,
+		superclass: string,
+		methods: Record<string, NativeObjCMethodDefinition>,
+		protocols?: string[],
+	): NativeClassHandle;
 };
 /** A selector and method signature resolved once by `objc.prepare`, for calling many times without the lookup. */
 export type NativeObjCCallPlan = NativeHandle & {
 	readonly [nativeObjCCallPlan]: true;
 };
+/** What `objc.findClasses` matches; every given part must match, and names come back sorted. */
+export type NativeObjCClassQuery = {
+	/** The class name starts with it. */
+	prefix?: string;
+	/** The path of the image the class is in contains it, such as `Discord.app/Discord`. */
+	image?: string;
+	/** The class inherits from it, directly or further up. */
+	superclass?: string;
+	/** The class conforms to every one. */
+	protocols?: string[];
+	/** The class responds to every instance selector, its own or inherited. */
+	methods?: string[];
+	/** The class itself implements every instance selector. */
+	ownMethods?: string[];
+	/** The class responds to every class selector. */
+	classMethods?: string[];
+	/** At most this many names, 50 by default and 1000 at most. */
+	limit?: number;
+};
+/**
+ * The debugger's Objective-C reflection, iOS only and never in a plugin's scope. Needs `native.objc.inspect`.
+ * Throws `INSPECTOR_DISABLED` without developer mode or the debugger, `INSPECTOR_UNAVAILABLE` when the library cannot load.
+ */
+export type NativeObjCInspector = {
+	/** Describes a class, or an object's class, and its superclasses; throws `INSPECTOR_UNKNOWN_CLASS` for an unknown name. */
+	inspectClass(target: NativeObjectHandle | string): NativeInspectedClass[];
+	/** Lists one page of one kind of a class's own members. */
+	inspectMembers(
+		className: string,
+		kind: NativeInspectKind,
+		page?: NativeInspectPage,
+	): NativeInspectedMembers;
+	/** Reads up to 50 properties or ivars of an object on the main thread; getters run only with `invokeGetters`. */
+	inspectValues(
+		object: NativeObjectHandle,
+		className: string,
+		kind: 'properties' | 'ivars',
+		names: string[],
+		options?: NativeInspectValuesOptions,
+	): NativeCancelablePromise<NativeInspectedValue[]>;
+	/** Lists one page of the loaded images that define Objective-C classes. */
+	inspectImages(page?: NativeInspectPage): NativeInspectedImages;
+	/** Lists one page of the class names an image defines, sorted. */
+	inspectClasses(imagePath: string, page?: NativeInspectPage): NativeInspectedClasses;
+};
+/** One method of a class `objc.defineClass` makes: its signature without `self` and `_cmd`, and what runs. */
+export type NativeObjCMethodDefinition = {
+	/** The method's argument and return types, without `self` and `_cmd`. */
+	signature: NativeFFISignature;
+	/** Runs on the JavaScript thread with the receiver and the method's arguments. */
+	implementation: (self: NativeObjectHandle, ...args: never[]) => NativeObjCResult | void;
+};
 /** What an Objective-C call returns: a plain value, a handle to an object, a 64-bit integer, or nothing for `void`. */
 export type NativeObjCResult = NativeSerializable | NativeHandle | bigint | undefined;
 /** A retained handle to an Objective-C object. */
@@ -4577,6 +4997,10 @@ export type NativePlatformAndroidInstaller = {
 export type NativePlatformApp = {
 	/** Where Discord was installed from, such as `App Store` or `Google Play`. */
 	getAppSource(): string;
+	/** How an iOS install was signed: certificate kind, team, profile expiry, sideload tool marker and entitlement source. */
+	getInstallDetails?(): string;
+	/** What the loader read about the install, the binary and the device for `/debug`; missing on older loaders. */
+	getEnvironment?(): NativeEnvironmentReport;
 	/** The framework that injected the loader, such as Vector or LSPosed on Android and ElleKit on iOS, or an empty string. */
 	getFramework(): string;
 	/** Whether the loader's embedded attestation verified against Unbound's pinned key. False for development builds. */
@@ -4640,6 +5064,8 @@ export type NativePlatformDevice = {
 	isSystemApp(): boolean;
 	/** Whether Discord runs in a simulator, emulator or virtual machine. */
 	isVirtualDevice(): boolean;
+	/** Memory and thermal pressure right now; empty on loaders older than 1.4.0. */
+	getState?(): NativeDeviceState;
 };
 /** File operations inside the Unbound folder in Discord's documents directory. */
 export type NativePlatformFiles = {
@@ -6516,6 +6942,21 @@ export type UnboundAsset = DiscordAsset & {
 	/** The URI of a registered plugin asset at each scale; set while it is registered. */
 	unboundSources?: Record<number, string>;
 };
+/** One design axis of a variable font, such as `wght` from 100 to 900. */
+export type UnboundFontAxis = {
+	/** The four-letter tag, such as `wght`, `wdth` or `slnt`. */
+	tag: string;
+	/** The name the font gives it, such as `Weight`. */
+	name: string;
+	/** The lowest value the axis accepts. */
+	min: number;
+	/** The value a face draws at when the axis is not set. */
+	default: number;
+	/** The highest value the axis accepts. */
+	max: number;
+	/** The font asks apps not to offer it. */
+	hidden: boolean;
+};
 /**
  * One installed face in the loader's font store.
  * @internal
@@ -6533,6 +6974,10 @@ type UnboundInstalledFont = {
 	/** The file's absolute path; `list()` adds it. */
 	path?: string;
 	source: UnboundFontSource;
+	/** A variable font's design axes; absent for a static face. */
+	axes?: UnboundFontAxis[];
+	/** The coordinate on each axis this face draws at, such as `{ wght: 650 }`; absent for a static face. */
+	variations?: Record<string, number>;
 };
 /** A value the generator could not type with confidence, so a loose prop accepts anything for it. */
 export type UncertainValue = any;

package/src/flux.d.ts

@@ -73,6 +73,10 @@ export declare function useStore<const S extends FluxStore | readonly FluxStore[
  * `declare module '@unbound-app/api/flux' { interface FluxActions { MY_ACTION: { id: string } } }`.
  */
 export interface FluxActions {
+	/** Discord moved to the front, the background, or in between, as React Native's `AppState` reports it. */
+	APP_STATE_UPDATE: {
+		state: 'active' | 'background' | 'inactive';
+	};
 	/** A message arrived or was sent; `optimistic` is `true` for the local copy before Discord confirms it. */
 	MESSAGE_CREATE: {
 		channelId: string;

package/src/global.d.ts

@@ -262,10 +262,13 @@ export type {
 	NativeDebugEnvironmentOptions,
 	NativeDebugEvaluation,
 	NativeDebugEvaluationLog,
+	NativeDeviceState,
 	NativeFFIBridge,
+	NativeFFIRebinding,
 	NativeFFISignature,
 	NativeFFIType,
 	NativeFFITypeName,
+	NativeFFIValue,
 	NativeFabricBatchMutation,
 	NativeFabricBridge,
 	NativeFabricFrame,
@@ -281,26 +284,46 @@ export type {
 	NativeHookOptions,
 	NativeHookPayload,
 	NativeHookToken,
+	NativeInspectKind,
+	NativeInspectPage,
+	NativeInspectValuesOptions,
+	NativeInspectedClass,
+	NativeInspectedClasses,
+	NativeInspectedImage,
+	NativeInspectedImages,
+	NativeInspectedMember,
+	NativeInspectedMembers,
+	NativeInspectedValue,
 	NativeJavaArgument,
 	NativeJavaAssociationKey,
 	NativeJavaBatchOperation,
 	NativeJavaBridge,
 	NativeJavaCallPlan,
 	NativeJavaClassDescription,
+	NativeJavaClassQuery,
 	NativeJavaFieldDescription,
+	NativeJavaFieldShape,
 	NativeJavaHandle,
 	NativeJavaHandleValue,
 	NativeJavaHookEvent,
 	NativeJavaHookOptions,
+	NativeJavaHookRewrite,
 	NativeJavaHookToken,
 	NativeJavaHooksBridge,
 	NativeJavaMethodDescription,
+	NativeJavaMethodShape,
+	NativeJavaProxy,
+	NativeJavaProxyCall,
 	NativeJavaReference,
 	NativeJavaValue,
 	NativeMainWaitCounts,
 	NativeMainWorkCounts,
+	NativeNetworkState,
 	NativeObjCBridge,
 	NativeObjCCallPlan,
+	NativeObjCClassQuery,
+	NativeObjCInspector,
+	NativeObjCMethodDefinition,
 	NativeObjCResult,
 	NativeObjectHandle,
 	NativePlatformAddons,
@@ -513,6 +536,7 @@ export type {
 	TransitionState,
 	UnboundAppIcon,
 	UnboundAsset,
+	UnboundFontAxis,
 	UncertainValue,
 	VisualEffectViewProps,
 	VoidIconProps,

package/src/marketplace.d.ts

@@ -28,10 +28,10 @@ export type CatalogQuery = {
 	sort?: CatalogSort;
 };
 /**
- * `name` sorts alphabetically, `popular` puts the most installed addons first, `updated` the most
- * recently published versions.
+ * `new` puts the most recently listed addons first, `name` sorts alphabetically, `popular` the most
+ * installed addons first, `updated` the most recently published versions.
  */
-export type CatalogSort = 'name' | 'popular' | 'updated';
+export type CatalogSort = 'new' | 'name' | 'popular' | 'updated';
 /** One addon the marketplace lists, at its newest version. */
 export type MarketplaceListing = {
 	/** The addon's id from its manifest, which installs and updates key on. */

package/src/metro/components.d.ts

@@ -4,7 +4,14 @@ export type { DesignComponentName, DesignModule } from '../_internal';
 export { DESIGN_COMPONENTS } from '../_internal';
 import type { DesignComponentName, DesignModule } from '../_internal';
 import * as React$1 from 'react';
-import { ComponentProps, ComponentType, ElementType, FunctionComponent, ReactNode } from 'react';
+import {
+	ComponentProps,
+	ComponentType,
+	Context,
+	ElementType,
+	FunctionComponent,
+	ReactNode,
+} from 'react';
 import * as RN from 'react-native';
 import { ColorValue, ImageStyle, TextStyle, ViewStyle } from 'react-native';
 

package/src/metro/index.d.ts

@@ -149,7 +149,14 @@ import type {
 } from '../_internal';
 import type { LiteralUnion, PredicateResult } from '../_types';
 import * as React$1 from 'react';
-import { ComponentProps, ComponentType, ElementType, FunctionComponent, ReactNode } from 'react';
+import {
+	ComponentProps,
+	ComponentType,
+	Context,
+	ElementType,
+	FunctionComponent,
+	ReactNode,
+} from 'react';
 import * as RN from 'react-native';
 import {
 	ColorValue,

package/src/native.d.ts

@@ -43,9 +43,12 @@ export type {
 	NativeJavaHandleValue,
 	NativeJavaHookEvent,
 	NativeJavaHookOptions,
+	NativeJavaHookRewrite,
 	NativeJavaHookToken,
 	NativeJavaHooksBridge,
 	NativeJavaMethodDescription,
+	NativeJavaProxy,
+	NativeJavaProxyCall,
 	NativeJavaReference,
 	NativeJavaValue,
 	NativeObjCBridge,
@@ -72,6 +75,11 @@ import type {
 	NativeBridgeCapability,
 	NativeBridgeMethod,
 	NativeBridgePlatform,
+	NativeJavaBridge,
+	NativeJavaHandleValue,
+	NativeJavaReference,
+	NativeObjCBridge,
+	NativeObjectHandle,
 	NativePlatformBridge,
 	NativeResourceCounts,
 } from './_internal';
@@ -164,6 +172,28 @@ export declare function reload(): Promise<void>;
  * @returns Whether the loader implements it.
  */
 export declare function supports(method: NativeBridgeMethod): boolean;
+/**
+ * @description Holds a Java object weakly, through a `java.lang.ref.WeakReference`, so caching a view does not keep
+ * it alive after Discord drops it.
+ * @param java The plugin's Java bridge.
+ * @param handle The object to hold.
+ * @returns A weak handle whose `deref` gives the object while it lives, then `null`.
+ */
+export declare function weakJava(
+	java: Pick<NativeJavaBridge, 'construct' | 'invoke'>,
+	handle: NativeJavaReference,
+): NativeWeakHandle<NativeJavaHandleValue>;
+/**
+ * @description Holds an Objective-C object weakly, through a `strongToWeakObjectsMapTable`, so caching a view or
+ * controller does not keep it alive after Discord releases it.
+ * @param objc The plugin's Objective-C bridge.
+ * @param handle The object to hold.
+ * @returns A weak handle whose `deref` gives the object while it lives, then `null`.
+ */
+export declare function weakObjC(
+	objc: Pick<NativeObjCBridge, 'getClass' | 'call'>,
+	handle: NativeObjectHandle,
+): NativeWeakHandle<NativeObjectHandle>;
 /** Build and release metadata reported by the native client info module. */
 export type BundleInfoType = {
 	/** Discord's app version, shown in Unbound's settings beside `Build`. */
@@ -265,6 +295,11 @@ export type DeviceInfoType = {
 };
 /** What `HermesInternal.getRuntimeProperties()` reports; empty when the engine is not Hermes. */
 export type HermesRuntimeProperties = ReturnType<HermesInternalObject['getRuntimeProperties']>;
+/** A reference that does not keep its native object alive; `deref` reads `null` once the object is gone. */
+export type NativeWeakHandle<T> = {
+	/** The object while it lives, else `null`. */
+	deref(): T | null;
+};
 /** One Platform handler per platform an addon runs on. */
 export type PlatformHandlers<Handler> = Partial<Record<NativeBridgePlatform, Handler>>;
 /** A native method Discord exposes without documenting what its promise resolves to. */

package/src/ui.d.ts

@@ -10,9 +10,17 @@ import type {
 } from './_internal';
 import type { Without } from './_types';
 import * as React$1 from 'react';
-import { ComponentProps, ComponentType, FunctionComponent, ReactElement, ReactNode } from 'react';
+import {
+	ComponentProps,
+	ComponentType,
+	Context,
+	FunctionComponent,
+	ReactElement,
+	ReactNode,
+	Ref,
+} from 'react';
 import * as RN from 'react-native';
-import { ImageStyle, TextStyle, ViewStyle } from 'react-native';
+import { ImageStyle, ScrollView, ScrollViewProps, TextStyle, ViewStyle } from 'react-native';
 /**
  * @description A pressable `TableRow` in its settings group, as Discord draws actions such as Log Out; it asks first when
  * `confirmation` is set. `danger` draws the label red behind a red trash icon.
@@ -150,7 +158,7 @@ export declare function NumberRow({
  * inset and a 24px gap between form groups, matching how Discord lays out its own settings screens. Use
  * it as the root of every settings page.
  */
-export declare function Page({ children }: PageProps): React$1.ReactElement;
+export declare function Page({ children, ...scroll }: PageProps): React$1.ReactElement;
 /**
  * @description A row showing the picked option that opens Discord's action sheet listing every option, for choices too many for a radio group.
  * @param props The row's label, picked value, options and change handler.
@@ -236,7 +244,7 @@ export declare function SegmentedRow({
 }: SegmentedRowProps): React$1.ReactElement;
 /**
  * @description Discord's `TableSliderRow`, as its own settings draw one: the label and live value over the slider
- * with its default mark. A sub-label, which that row cannot show, moves it to a `TableRow` holding the same slider.
+ * with its default mark. A sub-label, which that row cannot show, draws the same layout by hand with it under the label.
  * The value is saved when the drag ends; Android's slider and iOS's take differently named props, so it passes both.
  * @param props The row's label, value, default, range and change handler.
  * @returns The row, or `null` when Discord's slider is unavailable.
@@ -471,9 +479,14 @@ export type NumberRowProps = NumberConstraints & {
 	onChange: (value: number) => void;
 };
 /** The props of {@link Page}. */
-export type PageProps = {
+export type PageProps = Pick<
+	ScrollViewProps,
+	'onScrollEndDrag' | 'onMomentumScrollEnd' | 'onContentSizeChange'
+> & {
 	/** The page's form groups, laid out top to bottom with a 24px gap. */
 	children: React$1.ReactNode;
+	/** The page's scroll view, for a page that restores its scroll offset. */
+	ref?: React$1.Ref<ScrollView>;
 };
 /** Props for `PickerRow`. */
 export type PickerRowProps = {

package/testing/fake-components.ts

@@ -16,9 +16,12 @@ const BAGS = [
 	'Discord',
 	'FlashList',
 	'Forms',
+	'GorhomSheet',
 	'Media',
 	'Portal',
 	'SafeArea',
+	'SafeAreaContext',
+	'TableRowDividers',
 	'Video',
 ] as const;
 

package/testing/fake-java.ts

@@ -72,10 +72,18 @@ export type FakeJava = {
 	registerClass: (name: string, spec?: JavaClassSpec) => void;
 	/** Makes an object of a registered class, with its fields, as the plugin sees it: a tagged `handle` value. */
 	create: (className: string, fields?: Record<string, JavaPlain>) => NativeJavaValue;
-	/** Forgets every class, object and hook. */
+	/** Calls `method` on a proxy made with `hooks.proxy`, as Java would, and returns what its handler returned. */
+	callProxy: (
+		proxy: NativeJavaArgument,
+		method: string,
+		args?: JavaPlain[],
+	) => NativeJavaArgument | undefined;
+	/** Forgets every class, object, hook and proxy. */
 	reset: () => void;
 };
 
+type ProxyHandler = Parameters<NativeJavaHooksBridge['proxy']>[1];
+
 type HookEntry = {
 	className: string;
 	methodName: string;
@@ -139,6 +147,8 @@ export function createFakeJava(log: NativeCallLog = createCallLog()): FakeJava {
 	const classes = new Map<string, JavaClassSpec>();
 	const objects = new Map<string, JavaObject>();
 	const hookEntries = new Map<string, HookEntry>();
+	const proxyHandlers = new Map<string, ProxyHandler>();
+	const proxyTokens = new Map<string, string>();
 	let next = 0;
 
 	function chain(className: string): string[] {
@@ -496,18 +506,54 @@ export function createFakeJava(log: NativeCallLog = createCallLog()): FakeJava {
 		removeReturnValue: (token, self) =>
 			void hookEntries.get(token.id)?.results.delete(tagKey(self)),
 		clearReturnValues: (token) => hookEntries.get(token.id)?.results.clear(),
-		remove: (token) => void hookEntries.delete(token.id),
+		remove(token) {
+			hookEntries.delete(token.id);
+
+			const object = proxyTokens.get(token.id);
+
+			if (!object) {
+				return;
+			}
+
+			proxyHandlers.delete(object);
+			proxyTokens.delete(token.id);
+		},
+		proxy(interfaces, handler) {
+			const object = spawn(interfaces[0] ?? 'java.lang.Object', false);
+			const id = `proxy-${++next}`;
+
+			log.record({
+				bridge: 'hooks',
+				method: 'proxy',
+				target: interfaces.join(','),
+				name: 'proxy',
+				args: [],
+			});
+			proxyHandlers.set(object.id, handler);
+			proxyTokens.set(id, object.id);
+
+			return { token: { id }, object: brand<NativeJavaHandle>(object) };
+		},
 	});
 
+	function callProxy(proxy: NativeJavaArgument, method: string, args: JavaPlain[] = []) {
+		const object = resolve(proxy as NativeJavaReference, 'callProxy');
+
+		return proxyHandlers.get(object.id)?.({ method, args: args.map(tagged) }) ?? undefined;
+	}
+
 	return {
 		bridge,
 		hooks,
 		registerClass: (name, spec = {}) => void classes.set(name, spec),
 		create: (className, fields) => tagged(brand<NativeJavaHandle>(instance(className, fields))),
+		callProxy,
 		reset() {
 			classes.clear();
 			objects.clear();
 			hookEntries.clear();
+			proxyHandlers.clear();
+			proxyTokens.clear();
 		},
 	};
 }