@unbound-app/api 3.0.0 → 3.1.0

package/package.json

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

package/src/_internal.d.ts

@@ -180,6 +180,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'];
@@ -4301,9 +4302,16 @@ 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>;
 };
+/** 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 = {
 	/** The id the loader issued, such as `hook-1`. */
@@ -4317,7 +4325,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 +4342,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 +4364,20 @@ export type NativeJavaMethodDescription = {
 	/** Whether the method is static. */
 	static: 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. */
@@ -4577,6 +4607,8 @@ 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;
 	/** 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. */
@@ -6516,6 +6548,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 +6580,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/global.d.ts

@@ -292,9 +292,12 @@ export type {
 	NativeJavaHandleValue,
 	NativeJavaHookEvent,
 	NativeJavaHookOptions,
+	NativeJavaHookRewrite,
 	NativeJavaHookToken,
 	NativeJavaHooksBridge,
 	NativeJavaMethodDescription,
+	NativeJavaProxy,
+	NativeJavaProxyCall,
 	NativeJavaReference,
 	NativeJavaValue,
 	NativeMainWaitCounts,
@@ -513,6 +516,7 @@ export type {
 	TransitionState,
 	UnboundAppIcon,
 	UnboundAsset,
+	UnboundFontAxis,
 	UncertainValue,
 	VisualEffectViewProps,
 	VoidIconProps,

package/src/native.d.ts

@@ -43,9 +43,12 @@ export type {
 	NativeJavaHandleValue,
 	NativeJavaHookEvent,
 	NativeJavaHookOptions,
+	NativeJavaHookRewrite,
 	NativeJavaHookToken,
 	NativeJavaHooksBridge,
 	NativeJavaMethodDescription,
+	NativeJavaProxy,
+	NativeJavaProxyCall,
 	NativeJavaReference,
 	NativeJavaValue,
 	NativeObjCBridge,

package/testing/fake-java.ts

@@ -8,6 +8,7 @@ import type {
 	NativeJavaHookEvent,
 	NativeJavaHookOptions,
 	NativeJavaHooksBridge,
+	NativeJavaProxyCall,
 	NativeJavaReference,
 	NativeJavaValue,
 } from '../src/native';
@@ -72,7 +73,9 @@ 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[]) => unknown;
+	/** Forgets every class, object, hook and proxy. */
 	reset: () => void;
 };
 
@@ -139,6 +142,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, (call: NativeJavaProxyCall) => unknown>();
+	const proxyTokens = new Map<string, string>();
 	let next = 0;
 
 	function chain(className: string): string[] {
@@ -496,18 +501,52 @@ 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) {
+				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) });
+	}
+
 	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();
 		},
 	};
 }