osra 0.2.13 → 0.3.0

package/build/index.d.ts

@@ -1,630 +1,16 @@
-import { Runtime } from 'webextension-polyfill';
-import { TypedEventTarget } from 'typescript-event-target';
-
-declare type AllocatedMessageChannel<T extends StructurableTransferable = StructurableTransferable, T2 extends StructurableTransferable = StructurableTransferable> = {
-    uuid: Uuid;
-    /** Local port */
-    port1: StrictMessagePort<T>;
-    /** Remote port that gets transferred, might be undefined if a remote context created the channel */
-    port2?: StrictMessagePort<T2>;
-};
-
-declare namespace arrayBuffer {
-    export {
-        type,
-        isType,
-        box_2 as box,
-        revive_2 as revive
-    }
-}
-
-export declare type AsCapable<T> = DeepReplaceAsync<T, never, never>;
-
-declare const BadValueType: unique symbol;
-
-export declare type BidirectionalConnectionMessage = {
-    type: 'init';
-    remoteUuid: Uuid;
-    data: Capable;
-}
-/** message not needed if transferring MessagePort is supported */
-| {
-    type: 'message';
-    remoteUuid: Uuid;
-    data: Capable;
-    /** uuid of the messagePort that the message was sent through */
-    portId: Uuid;
-}
-/** message not needed if transferring MessagePort is supported */
-| {
-    type: 'message-port-close';
-    remoteUuid: Uuid;
-    /** uuid of the messagePort that closed */
-    portId: string;
-};
-
-export declare const box: <T extends Capable, T2 extends RevivableContext>(value: T, context: T2) => ReplaceWithBox<T, T2["revivableModules"][number]>;
-
-declare const box_10: <T extends ReadableStream, T2 extends RevivableContext>(value: T, context: T2) => BoxedReadableStream<T>;
-
-declare const box_2: <T extends ArrayBuffer, T2 extends RevivableContext>(value: T, _context: T2) => {
-    type: "arrayBuffer";
-    __OSRA_BOX__: "revivable";
-} & (IsJsonOnlyTransport<T2["transport"]> extends true ? {
-    base64Buffer: string;
-} : IsJsonOnlyTransport<T2["transport"]> extends false ? {
-    arrayBuffer: ArrayBuffer;
-} : {
-    base64Buffer: string;
-} | {
-    arrayBuffer: ArrayBuffer;
-});
-
-declare const box_3: <T extends Date, T2 extends RevivableContext>(value: T, _context: T2) => {
-    type: "date";
-    ISOString: string;
-    __OSRA_BOX__: "revivable";
-};
-
-declare const box_4: <T extends Headers, T2 extends RevivableContext>(value: T, _context: T2) => {
-    type: "headers";
-    entries: [string, string][];
-    __OSRA_BOX__: "revivable";
-};
-
-declare const box_5: <T extends Error, T2 extends RevivableContext>(value: T, _context: T2) => {
-    type: "error";
-    message: string;
-    stack: string;
-    __OSRA_BOX__: "revivable";
-};
-
-declare const box_6: <T extends TypedArray, T2 extends RevivableContext>(value: T, context: T2) => {
-    type: "typedArray";
-    typedArrayType: string;
-    __OSRA_BOX__: "revivable";
-} & (IsJsonOnlyTransport<T2["transport"]> extends true ? {
-    base64Buffer: string;
-} : IsJsonOnlyTransport<T2["transport"]> extends false ? {
-    arrayBuffer: ArrayBuffer;
-} : {
-    base64Buffer: string;
-} | {
-    arrayBuffer: ArrayBuffer;
-}) & {
-    [UnderlyingType]: T;
-};
-
-declare const box_7: <T, T2 extends RevivableContext = RevivableContext>(value: StructurableTransferablePort<T>, context: T2) => ({
-    type: "messagePort";
-    portId: `${string}-${string}-${string}-${string}-${string}`;
-    __OSRA_BOX__: "revivable";
-} & {
-    [UnderlyingType]: StrictMessagePort<ExtractStructurableTransferable<T>>;
-}) | ({
-    type: "messagePort";
-    port: StructurableTransferablePort<T>;
-    __OSRA_BOX__: "revivable";
-} & {
-    [UnderlyingType]: StrictMessagePort<ExtractStructurableTransferable<T>>;
-});
-
-declare const box_8: <T, T2 extends RevivableContext>(value: CapablePromise<T>, context: T2) => BoxedPromise<ExtractCapable<T>>;
-
-declare const box_9: <T extends (...args: any[]) => any, T2 extends RevivableContext>(value: T & CapableFunction<T>, context: T2) => BoxedFunction<T>;
-
-export declare const BoxBase: {
-    readonly __OSRA_BOX__: "revivable";
-    readonly type: string;
-};
-
-export declare type BoxBase<T extends string = string> = typeof BoxBase & {
-    type: T;
-};
-
-declare type BoxedFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = BoxBase<typeof type_7> & {
-    port: BoxedMessagePort;
-} & {
-    [UnderlyingType]: (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
-};
-
-declare type BoxedMessagePort<T extends StructurableTransferable = StructurableTransferable> = BoxBase<typeof type_8> & ({
-    portId: string;
-} | {
-    port: StrictMessagePort<T>;
-}) & {
-    [UnderlyingType]: StrictMessagePort<T>;
-};
-
-declare type BoxedPromise<T extends Capable = Capable> = {
-    __OSRA_BOX__: 'revivable';
-    type: typeof type_6;
-    port: ReturnType<typeof box_7>;
-    [UnderlyingType]: T;
-};
-
-declare type BoxedReadableStream<T extends ReadableStream = ReadableStream> = {
-    __OSRA_BOX__: 'revivable';
-    type: typeof type_9;
-    port: BoxedMessagePort;
-    [UnderlyingType]: T;
-};
-
-declare type CallContext = [
-/** MessagePort or portId that will be used to send the result of the function call */
-MessagePort | string,
-/** Arguments that will be passed to the function call */
-Capable[]
-];
-
-export declare type Capable<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = StructurableTransferable | InferRevivables<TModules> | {
-    [key: string]: Capable;
-} | Array<Capable> | Map<Capable, Capable> | Set<Capable>;
-
-declare type CapableFunction<T> = T extends (...args: infer P) => infer R ? P extends Capable[] ? R extends Capable ? T : never : never : never;
-
-declare type CapablePromise<T> = T extends Promise<infer U> ? U extends Capable ? T : {
-    [ErrorMessage]: 'Value type must extend a Promise that resolves to a Capable';
-    [BadValueType]: U;
-} : {
-    [ErrorMessage]: 'Value type must extend a Promise that resolves to a Capable';
-    [BadValueType]: T;
-};
-
-export declare type ConnectionMessage = BidirectionalConnectionMessage | UnidirectionalConnectionMessage;
-
-declare type Context = {
-    type: 'resolve';
-    data: Capable;
-} | {
-    type: 'reject';
-    error: string;
-};
-
-export declare type CustomEmitTransport = Extract<CustomTransport, {
-    emit: any;
-}>;
-
-export declare type CustomReceiveTransport = Extract<CustomTransport, {
-    receive: any;
-}>;
-
-export declare type CustomTransport = {
-    isJson?: boolean;
-} & ({
-    receive: ReceivePlatformTransport | ((listener: (event: Message, messageContext: MessageContext) => void) => void);
-    emit: EmitPlatformTransport | ((message: Message, transferables?: Transferable[]) => void);
-} | {
-    receive: ReceivePlatformTransport | ((listener: (event: Message, messageContext: MessageContext) => void) => void);
-} | {
-    emit: EmitPlatformTransport | ((message: Message, transferables?: Transferable[]) => void);
-});
-
-declare namespace date {
-    export {
-        type_2 as type,
-        isType_2 as isType,
-        box_3 as box,
-        revive_3 as revive
-    }
-}
-
-export declare type DeepReplace<T, From, To> = T extends From ? DeepReplace<To, From, To> : T extends (...args: infer A) => infer R ? (...args: A) => DeepReplace<R, From, To> : T extends Array<infer U> ? Array<DeepReplace<U, From, To>> : T extends object ? {
-    [K in keyof T]: DeepReplace<T[K], From, To>;
-} : T;
-
-export declare type DeepReplaceAsync<T, From, To> = T extends From ? DeepReplaceAsync<To, From, To> : T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<DeepReplaceAsync<R, From, To>>> : T extends Array<infer U> ? Array<DeepReplaceAsync<U, From, To>> : T extends object ? {
-    [K in keyof T]: DeepReplaceAsync<T[K], From, To>;
-} : T;
-
-declare type DeepReplaceWithBox<T, M> = [
-FindMatchingBox<T, M>
-] extends [never] ? (T extends Array<infer U> ? Array<DeepReplaceWithBox<U, M>> : T extends object ? {
-    [K in keyof T]: DeepReplaceWithBox<T[K], M>;
-} : T) : FindMatchingBox<T, M>;
-
-declare type DeepReplaceWithRevive<T, M> = [
-FindMatchingRevive<T, M>
-] extends [never] ? (T extends Array<infer U> ? Array<DeepReplaceWithRevive<U, M>> : T extends object ? {
-    [K in keyof T]: DeepReplaceWithRevive<T[K], M>;
-} : T) : FindMatchingRevive<T, M>;
-
-export declare type DefaultRevivableModule = DefaultRevivableModules[number];
-
-export declare type DefaultRevivableModules = typeof defaultRevivableModules;
-
-export declare const defaultRevivableModules: readonly [typeof arrayBuffer, typeof date, typeof headers, typeof error, typeof typedArray, typeof promise, typeof func, typeof messagePort, typeof readableStream];
-
-export declare type EmitJsonPlatformTransport = WebSocket | WebExtPort;
-
-export declare type EmitPlatformTransport = EmitJsonPlatformTransport | Window | ServiceWorker | Worker | SharedWorker | MessagePort;
-
-export declare type EmitTransport = EmitPlatformTransport & Extract<CustomTransport, {
-    emit: any;
-}>;
-
-declare namespace error {
-    export {
-        type_4 as type,
-        isType_4 as isType,
-        box_5 as box,
-        revive_5 as revive
-    }
-}
-
-declare const ErrorMessage: unique symbol;
-
-/**
- * Protocol mode:
- * - Bidirectional mode
- * - Unidirectional mode
- *
- * Transport modes:
- * - Capable mode
- * - Jsonable mode
- */
-export declare const expose: <T extends Capable>(value: Capable, { transport: _transport, name, remoteName, key, origin, unregisterSignal, platformCapabilities: _platformCapabilities, transferAll, logger }: {
-    transport: Transport;
-    name?: string;
-    remoteName?: string;
-    key?: string;
-    origin?: string;
-    unregisterSignal?: AbortSignal;
-    platformCapabilities?: PlatformCapabilities;
-    transferAll?: boolean;
-    logger?: {};
-}) => Promise<T>;
-
-declare type ExtractCapable<T> = T extends Promise<infer U> ? U extends Capable ? U : never : never;
-
-declare type ExtractStructurableTransferable<T> = T extends StructurableTransferable ? T : never;
-
-declare type ExtractType<T> = T extends {
-    isType: (value: unknown) => value is infer S;
-} ? S : never;
-
-declare type FindMatchingBox<T, M> = M extends {
-    isType: (value: unknown) => value is infer S;
-    box: (...args: any[]) => infer B;
-} ? T extends S ? B : never : never;
-
-declare type FindMatchingRevive<T, M> = M extends {
-    box: (...args: any[]) => infer S;
-    revive: (...args: any[]) => infer R;
-} ? T extends S ? R : never : never;
-
-export declare const findModuleForValue: <T extends Capable, T2 extends RevivableContext>(value: T, context: T2) => ReplaceWithBox<T, T2["revivableModules"][number]>;
-
-declare namespace func {
-    export {
-        type_7 as type,
-        CallContext,
-        BoxedFunction,
-        isType_7 as isType,
-        box_9 as box,
-        revive_8 as revive
-    }
-}
-
-declare namespace headers {
-    export {
-        type_3 as type,
-        isType_3 as isType,
-        box_4 as box,
-        revive_4 as revive
-    }
-}
-
-declare type InferRevivables<TModules extends readonly unknown[]> = ExtractType<TModules[number]>;
-
-declare type IsJsonOnlyTransport<T extends Transport> = T extends JsonPlatformTransport ? true : false;
-
-declare const isType: (value: unknown) => value is ArrayBuffer;
-
-declare const isType_2: (value: unknown) => value is Date;
-
-declare const isType_3: (value: unknown) => value is Headers;
-
-declare const isType_4: (value: unknown) => value is Error;
-
-declare const isType_5: (value: unknown) => value is TypedArray;
-
-declare const isType_6: (value: unknown) => value is Promise<any>;
-
-declare const isType_7: (value: unknown) => value is (...args: any[]) => any;
-
-declare const isType_8: (value: unknown) => value is MessagePort;
-
-declare const isType_9: (value: unknown) => value is ReadableStream;
-
-export declare type Jsonable = boolean | null | number | string | {
-    [key: string]: Jsonable;
-} | Array<Jsonable>;
-
-export declare type JsonPlatformTransport = {
-    isJson: true;
-} | EmitJsonPlatformTransport | ReceiveJsonPlatformTransport;
-
-declare const makeMessageChannelAllocator: () => {
-    getUniqueUuid: () => `${string}-${string}-${string}-${string}-${string}`;
-    set: (uuid: Uuid, messagePorts: {
-        port1: StrictMessagePort;
-        port2?: StrictMessagePort;
-    }) => void;
-    alloc: (uuid?: Uuid | undefined, messagePorts?: {
-        port1: StrictMessagePort;
-        port2?: StrictMessagePort;
-    }) => {
-        port1: StrictMessagePort;
-        port2?: StrictMessagePort;
-        uuid: `${string}-${string}-${string}-${string}-${string}`;
-    };
-    has: (uuid: string) => boolean;
-    get: (uuid: string) => AllocatedMessageChannel<StructurableTransferable, StructurableTransferable> | undefined;
-    free: (uuid: string) => boolean;
-    getOrAlloc: (uuid?: Uuid | undefined, messagePorts?: {
-        port1: StrictMessagePort;
-        port2?: StrictMessagePort;
-    }) => AllocatedMessageChannel<StructurableTransferable, StructurableTransferable>;
-};
-
-export declare type Message = MessageBase & MessageVariant;
-
-export declare type MessageBase = {
-    [OSRA_KEY]: string;
-    /** UUID of the client that sent the message */
-    uuid: Uuid;
-    name?: string;
-};
-
-declare type MessageChannelAllocator = ReturnType<typeof makeMessageChannelAllocator>;
-
-export declare type MessageContext = {
-    port?: MessagePort | WebExtPort;
-    sender?: WebExtSender;
-    receiveTransport?: ReceivePlatformTransport;
-    source?: MessageEventSource | null;
-};
-
-export declare type MessageEventMap = {
-    message: CustomEvent<Message>;
-};
-
-declare type MessageEventTarget_2 = TypedEventTarget<MessageEventMap>;
-export { MessageEventTarget_2 as MessageEventTarget }
-
-declare namespace messagePort {
-    export {
-        type_8 as type,
-        BoxedMessagePort,
-        isType_8 as isType,
-        box_7 as box,
-        revive_9 as revive
-    }
-}
-
-export declare type MessageVariant = ProtocolMessage | ConnectionMessage;
-
-export declare const OSRA_BOX: "__OSRA_BOX__";
-
-export declare const OSRA_DEFAULT_KEY: "__OSRA_DEFAULT_KEY__";
-
-export declare const OSRA_KEY: "__OSRA_KEY__";
-
-declare type PlatformCapabilities = {
-    jsonOnly: boolean;
-    messagePort: boolean;
-    arrayBuffer: boolean;
-    transferable: boolean;
-    transferableStream: boolean;
-};
-
-export declare type PlatformTransport = EmitPlatformTransport | ReceivePlatformTransport;
-
-declare namespace promise {
-    export {
-        type_6 as type,
-        Context,
-        BoxedPromise,
-        isType_6 as isType,
-        box_8 as box,
-        revive_7 as revive
-    }
-}
-
-export declare type ProtocolMessage = {
-    type: 'announce';
-    /** Only set when acknowledging a remote announcement */
-    remoteUuid?: Uuid;
-} | {
-    /** uuid already taken, try announcing with another one */
-    type: 'reject-uuid-taken';
-    remoteUuid: Uuid;
-} | {
-    type: 'close';
-    remoteUuid: Uuid;
-};
-
-declare type PullContext = {
-    type: 'pull' | 'cancel';
-};
-
-declare namespace readableStream {
-    export {
-        type_9 as type,
-        PullContext,
-        BoxedReadableStream,
-        isType_9 as isType,
-        box_10 as box,
-        revive_10 as revive
-    }
-}
-
-export declare type ReceiveJsonPlatformTransport = WebSocket | WebExtPort | WebExtOnConnect | WebExtOnMessage;
-
-export declare type ReceivePlatformTransport = ReceiveJsonPlatformTransport | Window | ServiceWorker | Worker | SharedWorker | MessagePort;
-
-export declare type ReceiveTransport = ReceivePlatformTransport & Extract<CustomTransport, {
-    receive: any;
-}>;
-
-export declare const recursiveBox: <T extends Capable, T2 extends RevivableContext>(value: T, context: T2) => DeepReplaceWithBox<T, T2["revivableModules"][number]>;
-
-export declare const recursiveRevive: <T extends Capable, T2 extends RevivableContext>(value: T, context: T2) => DeepReplaceWithRevive<T, T2["revivableModules"][number]>;
-
-declare type ReplaceWithBox<T, M> = [
-FindMatchingBox<T, M>
-] extends [never] ? T : FindMatchingBox<T, M>;
-
-declare type ReplaceWithRevive<T, M> = [
-FindMatchingRevive<T, M>
-] extends [never] ? T : FindMatchingRevive<T, M>;
-
-declare type RevivableContext<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = {
-    platformCapabilities: PlatformCapabilities;
-    transport: Transport;
-    remoteUuid: Uuid;
-    messagePorts: Set<MessagePort>;
-    messageChannels: MessageChannelAllocator;
-    sendMessage: (message: ConnectionMessage) => void;
-    revivableModules: TModules;
-    eventTarget: MessageEventTarget_2;
-};
-
-export declare type RevivableModule<T extends string = string, T2 = any, T3 extends BoxBase<T> = any> = {
-    readonly type: T;
-    readonly isType: (value: unknown) => value is T2;
-    readonly box: ((value: T2, context: RevivableContext) => T3) | ((...args: any[]) => any);
-    readonly revive: (value: T3, context: RevivableContext) => T2;
-};
-
-export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, context: T2) => ReplaceWithRevive<T, T2["revivableModules"][number]>;
-
-declare const revive_10: <T extends BoxedReadableStream, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
-
-declare const revive_2: <T extends ReturnType<typeof box_2>, T2 extends RevivableContext>(value: T, _context: T2) => ArrayBuffer;
-
-declare const revive_3: <T extends ReturnType<typeof box_3>, T2 extends RevivableContext>(value: T, _context: T2) => Date;
-
-declare const revive_4: <T extends ReturnType<typeof box_4>, T2 extends RevivableContext>(value: T, _context: T2) => Headers;
-
-declare const revive_5: <T extends ReturnType<typeof box_5>, T2 extends RevivableContext>(value: T, _context: T2) => Error;
-
-declare const revive_6: <T extends ReturnType<typeof box_6>, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
-
-declare const revive_7: <T extends BoxedPromise, T2 extends RevivableContext>(value: T, context: T2) => Promise<T[typeof UnderlyingType]>;
-
-declare const revive_8: <T extends BoxedFunction, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
-
-declare const revive_9: <T extends StructurableTransferable, T2 extends RevivableContext>(value: BoxedMessagePort<T>, context: T2) => StrictMessagePort<T>;
-
-/**
- * A type-safe MessagePort wrapper that provides generic typing for messages.
- * This interface is structurally compatible with MessagePort while adding type safety.
- */
-declare interface StrictMessagePort<T = StructurableTransferable> extends MessagePort {
-    [UnderlyingType]?: T;
-    onmessage: ((this: MessagePort, ev: MessageEvent<T>) => unknown) | null;
-    onmessageerror: ((this: MessagePort, ev: MessageEvent) => unknown) | null;
-    postMessage(message: T, transfer: Transferable[]): void;
-    postMessage(message: T, options?: StructuredSerializeOptions): void;
-    addEventListener<K extends keyof StrictMessagePortEventMap<T>>(type: K, listener: (this: MessagePort, ev: StrictMessagePortEventMap<T>[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof StrictMessagePortEventMap<T>>(type: K, listener: (this: MessagePort, ev: StrictMessagePortEventMap<T>[K]) => unknown, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-}
-
-declare type StrictMessagePortEventMap<T = unknown> = {
-    'message': MessageEvent<T>;
-    'messageerror': MessageEvent;
-};
-
-export declare type Structurable = Jsonable
-/** not really structureable but here for convenience */
-| void | undefined | BigInt | Date | RegExp | Blob | File | FileList | ArrayBuffer | ArrayBufferView | ImageBitmap | ImageData | {
-    [key: string]: Structurable;
-} | Array<Structurable> | Map<Structurable, Structurable> | Set<Structurable>;
-
-export declare type StructurableTransferable = Structurable | Transferable | {
-    [key: string]: StructurableTransferable;
-} | Array<StructurableTransferable> | Map<StructurableTransferable, StructurableTransferable> | Set<StructurableTransferable>;
-
-declare const StructurableTransferableError: unique symbol;
-
-declare type StructurableTransferablePort<T> = T extends StructurableTransferable ? StrictMessagePort<T> : {
-    [StructurableTransferableError]: 'Message type must extend StructurableTransferable';
-    __badType__: T;
-};
-
-export declare type Transport = PlatformTransport | CustomTransport;
-
-declare const type: "arrayBuffer";
-
-declare const type_2: "date";
-
-declare const type_3: "headers";
-
-declare const type_4: "error";
-
-declare const type_5: "typedArray";
-
-declare const type_6: "promise";
-
-declare const type_7: "function";
-
-declare const type_8: "messagePort";
-
-declare const type_9: "readableStream";
-
-declare type TypedArray = typeof typedArrays[number];
-
-declare namespace typedArray {
-    export {
-        type_5 as type,
-        TypedArrayConstructor,
-        TypedArray,
-        typedArrayToType,
-        TypedArrayType,
-        typedArrayTypeToTypedArrayConstructor,
-        isType_5 as isType,
-        box_6 as box,
-        revive_6 as revive
-    }
-}
-
-declare type TypedArrayConstructor = typeof typedArrayConstructors[number];
-
-declare const typedArrayConstructors: (Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float16ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor)[];
-
-declare const typedArrays: (BigInt64Array<ArrayBuffer> | BigUint64Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Float64Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float16Array<ArrayBuffer> | Float32Array<ArrayBuffer> | Uint8Array<ArrayBuffer>)[];
-
-declare const typedArrayToType: <T extends TypedArray>(value: T) => "BigUint64Array" | "BigInt64Array" | "Float64Array" | "Int8Array" | "Uint8ClampedArray" | "Int16Array" | "Uint16Array" | "Int32Array" | "Uint32Array" | "Float16Array" | "Float32Array" | "Uint8Array";
-
-declare type TypedArrayType = ReturnType<typeof typedArrayToType>;
-
-declare const typedArrayTypeToTypedArrayConstructor: (value: TypedArrayType) => TypedArrayConstructor;
-
-export declare const UnderlyingType: unique symbol;
-
-export declare type UnderlyingType = typeof UnderlyingType;
-
-export declare type UnidirectionalConnectionMessage = {
-    type: 'message';
-    remoteUuid: Uuid;
-    data: Capable;
-    portId: Uuid;
-};
-
-export declare type Uuid = `${string}-${string}-${string}-${string}-${string}`;
-
-declare type WebExtOnConnect = WebExtRuntime['onConnect'];
-
-declare type WebExtOnMessage = WebExtRuntime['onMessage'];
-
-declare type WebExtPort = ReturnType<WebExtRuntime['connect']> | Runtime.Port;
-
-declare type WebExtRuntime = typeof browser.runtime;
-
-declare type WebExtSender = NonNullable<WebExtPort['sender']>;
-
-export { }
+import type { Capable } from './types';
+import type { DefaultRevivableModules } from './revivables';
+import type { RevivableModule } from './revivables';
+import type { StartConnectionsOptions } from './connections/utils';
+import type { BadFieldValue, BadFieldPath, BadFieldParent, ErrorMessage, BadValue, Path, ParentObject } from './utils/capable-check';
+export * from './types';
+export * from './revivables';
+export * from './connections';
+export * from './utils';
+type CapableCheck<T, TModules extends readonly RevivableModule[] = DefaultRevivableModules> = T extends Capable<TModules> ? T : T & {
+    [ErrorMessage]: 'Value type must resolve to a Capable';
+    [BadValue]: BadFieldValue<T, Capable<TModules>>;
+    [Path]: BadFieldPath<T, Capable<TModules>>;
+    [ParentObject]: BadFieldParent<T, Capable<TModules>>;
+};
+export declare const expose: <T = unknown, const TUserModules extends readonly RevivableModule[] = readonly [], const TValue = Capable<[...DefaultRevivableModules, ...TUserModules]>>(value: CapableCheck<TValue, [...DefaultRevivableModules, ...TUserModules]>, options: StartConnectionsOptions<TUserModules>) => Promise<T>;