osra 0.4.5 → 0.5.0

package/build/revivables/abort-signal.d.ts

@@ -9,7 +9,9 @@ type AbortMessage = {
 export type BoxedAbortSignal = BoxBaseType<typeof type> & {
     aborted: boolean;
     reason?: Capable;
-    port: BoxedMessagePort<AbortMessage>;
+    /** Absent when the signal was already aborted at box time — the reason
+     *  rides the wrapper and no live channel is needed. */
+    port?: BoxedMessagePort<AbortMessage>;
 };
 export declare const isType: (value: unknown) => value is AbortSignal;
 export declare const box: <T extends AbortSignal, T2 extends RevivableContext>(value: T, context: T2) => BoxedAbortSignal;

package/build/revivables/async-iterator.d.ts

@@ -0,0 +1,16 @@
+import type { Capable } from '../types.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import { BoxedFunction } from './function.js';
+export declare const type: 'asyncIterator';
+type AnyAsyncIterable = {
+    [Symbol.asyncIterator]: () => AsyncIterator<unknown>;
+};
+export type BoxedAsyncIterator = BoxBaseType<typeof type> & {
+    next: BoxedFunction;
+    return: BoxedFunction;
+    throw: BoxedFunction;
+};
+export declare const isType: (value: unknown) => value is AnyAsyncIterable;
+export declare const box: <T extends AnyAsyncIterable, T2 extends RevivableContext>(value: T, context: T2) => BoxedAsyncIterator;
+export declare const revive: <T extends BoxedAsyncIterator, T2 extends RevivableContext>(value: T, context: T2) => AsyncIterableIterator<Capable>;
+export {};

package/build/revivables/error.d.ts

@@ -6,6 +6,9 @@ export type BoxedError = BoxBaseType<typeof type> & {
     message: string;
     stack: string;
     cause?: Capable;
+    /** AggregateError only */
+    errors?: Capable;
+    isDOMException?: boolean;
 };
 export declare const isType: (value: unknown) => value is Error;
 export declare const box: <T extends Error, T2 extends RevivableContext>(value: T, context: T2) => BoxedError;

package/build/revivables/event-target.d.ts

@@ -10,9 +10,10 @@ export declare const isType: (value: unknown) => value is EventTarget;
 export declare const box: <T extends EventTarget, T2 extends RevivableContext>(value: T, context: T2) => {
     __OSRA_BOX__: 'revivable';
     type: "eventTarget";
-    addListener: import("./function.js").BoxedFunction<(type: string, listener: EventListener, options?: ListenerOpts) => void>;
-    removeListener: import("./function.js").BoxedFunction<(type: string, listener: EventListener, options?: ListenerOpts) => void>;
+    addListener: import("./function.js").BoxedFunction<(eventType: string, listener: EventListener, options?: ListenerOpts) => void>;
+    removeListener: import("./function.js").BoxedFunction<(eventType: string, listener: EventListener, options?: ListenerOpts) => void>;
+    removeAllListeners: import("./function.js").BoxedFunction<() => void>;
 };
 export type BoxedEventTarget = ReturnType<typeof box>;
-export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, context: T2) => EventTarget;
+export declare const revive: <T extends BoxedEventTarget, T2 extends RevivableContext>(value: T, context: T2) => EventTarget;
 export {};

package/build/revivables/index.d.ts

@@ -1,5 +1,5 @@
 import type { BoxBase, RevivableContext } from './utils.js';
-import type { DeepReplaceWithBox, DeepReplaceWithRevive, ReplaceWithBox, ReplaceWithRevive } from '../utils/replace.js';
+import type { DeepReplaceWithBox, DeepReplaceWithRevive } from '../utils/replace.js';
 import type { MessageFields, Capable } from '../types.js';
 import * as arrayBuffer from './array-buffer.js';
 import * as date from './date.js';
@@ -23,6 +23,7 @@ import * as event from './event.js';
 import * as eventTarget from './event-target.js';
 import * as blob from './blob.js';
 import * as symbol from './symbol.js';
+import * as asyncIterator from './async-iterator.js';
 export { identity } from './identity.js';
 export { transfer } from './transfer.js';
 export * from './utils.js';
@@ -34,7 +35,17 @@ export type RevivableModule<T extends string = string, T2 = any, T3 extends BoxB
     readonly init?: (context: RevivableContext<any>) => void;
     readonly Messages?: T4;
 };
-export declare const defaultRevivableModules: readonly [typeof transfer, typeof identity, typeof arrayBuffer, typeof date, typeof headers, typeof error, typeof typedArray, typeof blob, typeof promise, typeof func, typeof messagePort, typeof readableStream, typeof writableStream, typeof abortSignal, typeof response, typeof request, typeof map, typeof set, typeof bigInt, typeof symbol, typeof event, {
+export declare const defaultRevivableModules: readonly [typeof transfer, typeof identity, typeof arrayBuffer, typeof date, typeof headers, typeof error, typeof typedArray, typeof blob, typeof promise, typeof func, typeof messagePort, typeof readableStream, typeof writableStream, typeof abortSignal, typeof response, typeof request, typeof map, typeof set, typeof bigInt, typeof symbol, typeof event, typeof asyncIterator, {
+    readonly type: 'nonFiniteNumber';
+    readonly isType: (value: unknown) => value is number;
+    readonly box: (value: number, context: RevivableContext<any>) => import("./json-primitives.js").BoxedNonFiniteNumber | number;
+    readonly revive: (value: import("./json-primitives.js").BoxedNonFiniteNumber, _context: RevivableContext<any>) => number;
+}, {
+    readonly type: 'undefined';
+    readonly isType: (value: unknown) => value is undefined;
+    readonly box: (value: undefined, context: RevivableContext<any>) => import("./json-primitives.js").BoxedUndefined | undefined;
+    readonly revive: (_value: import("./json-primitives.js").BoxedUndefined, _context: RevivableContext<any>) => undefined;
+}, {
     readonly type: 'clonable';
     readonly capableOnly: true;
     readonly isType: (value: unknown) => value is import("./fallbacks.js").Clonable;
@@ -54,7 +65,5 @@ export declare const defaultRevivableModules: readonly [typeof transfer, typeof
 }];
 export type DefaultRevivableModules = typeof defaultRevivableModules;
 export type DefaultRevivableModule = DefaultRevivableModules[number];
-export declare const box: <T extends Capable, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>) => ReplaceWithBox<T, TModules[number]>;
 export declare const recursiveBox: <T extends Capable, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>) => DeepReplaceWithBox<T, TModules[number]>;
-export declare const revive: <T extends ReturnType<typeof box>, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>) => ReplaceWithRevive<T, TModules[number]>;
 export declare const recursiveRevive: <T extends Capable, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>) => DeepReplaceWithRevive<T, TModules[number]>;

package/build/revivables/json-primitives.d.ts

@@ -0,0 +1,17 @@
+import type { BoxBase as BoxBaseType, RevivableContext } from './utils.js';
+export type BoxedNonFiniteNumber = BoxBaseType<'nonFiniteNumber'> & {
+    value: 'NaN' | 'Infinity' | '-Infinity';
+};
+export declare const nonFiniteNumber: {
+    readonly type: 'nonFiniteNumber';
+    readonly isType: (value: unknown) => value is number;
+    readonly box: (value: number, context: RevivableContext<any>) => BoxedNonFiniteNumber | number;
+    readonly revive: (value: BoxedNonFiniteNumber, _context: RevivableContext<any>) => number;
+};
+export type BoxedUndefined = BoxBaseType<'undefined'>;
+export declare const undefinedValue: {
+    readonly type: 'undefined';
+    readonly isType: (value: unknown) => value is undefined;
+    readonly box: (value: undefined, context: RevivableContext<any>) => BoxedUndefined | undefined;
+    readonly revive: (_value: BoxedUndefined, _context: RevivableContext<any>) => undefined;
+};

package/build/revivables/readable-stream.d.ts

@@ -1,9 +1,13 @@
+import type { Capable } from '../types.js';
 import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
 import type { UnderlyingType } from './index.js';
 import { BoxedMessagePort } from './message-port.js';
 export declare const type: 'readableStream';
 export type PullContext = {
-    type: 'pull' | 'cancel';
+    type: 'pull';
+} | {
+    type: 'cancel';
+    reason?: Capable;
 };
 type ChunkMessage<T = unknown> = Promise<ReadableStreamReadResult<T>>;
 type Msg = PullContext | ChunkMessage;

package/build/revivables/request.d.ts

@@ -14,10 +14,12 @@ export declare const box: <T extends Request, T2 extends RevivableContext>(value
     body: import("./readable-stream.js").BoxedReadableStream<ReadableStream<Uint8Array<ArrayBuffer>>> | null;
     credentials: RequestCredentials;
     cache: RequestCache;
+    mode: RequestMode;
     redirect: RequestRedirect;
     referrer: string;
     referrerPolicy: ReferrerPolicy;
     integrity: string;
     keepalive: boolean;
+    signal: import("./abort-signal.js").BoxedAbortSignal;
 };
 export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, context: T2) => Request;

package/build/revivables/symbol.d.ts

@@ -4,8 +4,10 @@ export declare const isType: (value: unknown) => value is symbol;
 export declare const box: <T extends symbol, T2 extends RevivableContext>(value: T, context: T2) => {
     __OSRA_BOX__: 'revivable';
     type: "symbol";
-    description: string | undefined;
+    registryKey: string;
 } | import("./identity.js").BoxedIdentity<import("../types.js").Capable>;
 export declare const revive: <T extends {
+    registryKey: string;
+} | {
     description: string | undefined;
 }, T2 extends RevivableContext>(value: T, _context: T2) => symbol;

package/build/revivables/utils.d.ts

@@ -12,7 +12,6 @@ export type BoxBase<T extends string = string> = typeof BoxBase & {
 export type RevivableContext<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = {
     transport: Transport;
     remoteUuid: Uuid;
-    unregisterSignal?: AbortSignal;
     /** Typed as a broad dispatcher so revivables can post their own message
      *  variants without triggering contravariant function-parameter mismatches
      *  across modules. The shape is enforced structurally via `MessageFields`. */
@@ -30,9 +29,6 @@ export type ExtractType<T, Ctx extends RevivableContext = RevivableContext> = T
 } ? S : never : T extends {
     isType: (value: unknown) => value is infer S;
 } ? S : never;
-export type ExtractBox<T> = T extends {
-    box: (...args: any[]) => infer B;
-} ? B : never;
 export type ExtractMessages<T> = T extends {
     Messages?: infer B;
 } ? B extends {
@@ -40,7 +36,6 @@ export type ExtractMessages<T> = T extends {
 } ? string extends B['type'] ? never : B : never : never;
 export type InferMessages<TModules extends readonly unknown[]> = ExtractMessages<TModules[number]>;
 export type InferRevivables<TModules extends readonly unknown[], Ctx extends RevivableContext = RevivableContext> = ExtractType<TModules[number], Ctx>;
-export type InferRevivableBox<TModules extends readonly unknown[]> = ExtractBox<TModules[number]>;
 export declare const isRevivableBox: (value: unknown) => value is BoxBase;
 /** Wire shape for an ArrayBuffer: base64 on JSON, raw on clone. */
 export type BoxedBuffer<TCtx extends RevivableContext = RevivableContext> = IsJsonOnlyTransport<TCtx['transport']> extends true ? {

package/build/types.d.ts

@@ -1,5 +1,5 @@
 import type { ConnectionMessage } from './connections/index.js';
-import type { TypedEventTarget } from './utils/index.js';
+import type { TypedEventTarget } from './utils/typed-event-target.js';
 import type { IsJsonOnlyTransport } from './utils/type-guards.js';
 import type { DefaultRevivableModules, RevivableModule, InferMessages, InferRevivables, RevivableContext } from './revivables/index.js';
 export declare const OSRA_KEY: '__OSRA_KEY__';
@@ -25,6 +25,14 @@ type CapableBase<Ctx extends RevivableContext> = IsJsonOnlyTransport<Ctx['transp
 export type Capable<TModules extends readonly RevivableModule[] = DefaultRevivableModules, Ctx extends RevivableContext = RevivableContext> = CapableBase<Ctx> | InferRevivables<TModules, Ctx> | {
     [key: string]: Capable<TModules, Ctx>;
 } | Array<Capable<TModules, Ctx>> | Map<Capable<TModules, Ctx>, Capable<TModules, Ctx>> | Set<Capable<TModules, Ctx>>;
+/** What a value looks like from the far side of the connection: functions
+ *  become async (calls cross the wire), Blobs arrive as Promise<Blob>,
+ *  containers map recursively, everything else revives as itself. */
+export type Remote<T> = T extends (...args: infer P) => infer R ? (...args: P) => Promise<Remote<Awaited<R>>> : T extends Blob ? Promise<T> : T extends Promise<infer U> ? Promise<Remote<U>> : T extends Map<any, any> | Set<any> | Date | Error | RegExp | ArrayBuffer | ArrayBufferView | ReadableStream | WritableStream | MessagePort | EventTarget | Request | Response | Headers ? T : T extends AsyncIterable<infer U> ? AsyncIterableIterator<Remote<U>> : T extends ReadonlyArray<unknown> ? {
+    [K in keyof T]: Remote<T[K]>;
+} : T extends object ? {
+    [K in keyof T]: Remote<T[K]>;
+} : T;
 export type MessageFields = {
     type: string;
     remoteUuid: Uuid;

package/build/utils/index.d.ts

@@ -1,7 +1,5 @@
 export * from './transport.js';
-export * from '../revivables/index.js';
 export * from './replace.js';
-export * from '../connections/index.js';
 export * from './transferable.js';
 export * from './type-guards.js';
 export * from './typed-event-target.js';
@@ -10,3 +8,4 @@ export * from './event-channel.js';
 export * from './type.js';
 export * from './capable-check.js';
 export * from './gc-tracker.js';
+export * from './teardown.js';

package/build/utils/replace.d.ts

@@ -14,9 +14,6 @@ type FindMatchingRevive<T, M> = M extends {
     box: (...args: any[]) => infer S;
     revive: (...args: any[]) => infer R;
 } ? T extends S ? R : never : never;
-export type ReplaceWithRevive<T, M> = [
-    FindMatchingRevive<T, M>
-] extends [never] ? T : FindMatchingRevive<T, M>;
 export type DeepReplaceWithRevive<T, M> = [
     FindMatchingRevive<T, M>
 ] extends [never] ? T extends Array<infer U> ? Array<DeepReplaceWithRevive<U, M>> : T extends object ? {

package/build/utils/teardown.d.ts

@@ -0,0 +1,7 @@
+/** Per-connection teardown registry. Revivables register cleanup for state
+ *  tied to a connection (pending RPC settlements, port routing, caches);
+ *  the connection layer runs it on protocol close or unregisterSignal abort.
+ *  Registering against an already-torn-down scope runs the callback
+ *  immediately so late registrations fail fast instead of leaking. */
+export declare const onTeardown: (scope: WeakKey, fn: () => void) => (() => void);
+export declare const runTeardown: (scope: WeakKey) => void;

package/build/utils/transport.d.ts

@@ -1,3 +1,4 @@
+import type { Browser } from 'webextension-polyfill';
 import type { Message } from '../types.js';
 import type { WebExtOnConnect, WebExtOnMessage, WebExtPort, WebExtRuntime, WebExtSender } from './type-guards.js';
 export type MessageContext = {
@@ -5,8 +6,9 @@ export type MessageContext = {
     sender?: WebExtSender;
     receiveTransport?: ReceivePlatformTransport;
     source?: MessageEventSource | null;
+    origin?: string;
 };
-export type ReceiveHandler = (listener: (event: Message, messageContext: MessageContext) => void) => void;
+export type ReceiveHandler = (listener: (event: Message, messageContext: MessageContext) => void) => void | (() => void);
 export type EmitHandler = (message: Message, transferables?: Transferable[]) => void;
 type CustomReceive = ReceivePlatformTransport | ReceiveHandler;
 type CustomEmit = EmitPlatformTransport | EmitHandler;
@@ -31,25 +33,21 @@ export type ReceiveJsonPlatformTransport = WebSocket | WebExtPort | WebExtOnConn
 export type JsonPlatformTransport = {
     isJson: true;
 } | EmitJsonPlatformTransport | ReceiveJsonPlatformTransport;
-type StructuredClonePlatformTransport = Window | ServiceWorker | Worker | SharedWorker | MessagePort;
-export type EmitPlatformTransport = EmitJsonPlatformTransport | StructuredClonePlatformTransport;
-export type ReceivePlatformTransport = ReceiveJsonPlatformTransport | StructuredClonePlatformTransport;
+export type EmitPlatformTransport = EmitJsonPlatformTransport | Window | ServiceWorker | Worker | SharedWorker | MessagePort;
+export type ReceivePlatformTransport = ReceiveJsonPlatformTransport | Window | ServiceWorkerContainer | Worker | SharedWorker | MessagePort;
 export type PlatformTransport = EmitPlatformTransport | ReceivePlatformTransport;
-export type EmitTransport = EmitPlatformTransport & Extract<CustomTransport, {
-    emit: any;
-}>;
-export type ReceiveTransport = ReceivePlatformTransport & Extract<CustomTransport, {
-    receive: any;
-}>;
+export type EmitTransport = EmitPlatformTransport | CustomEmitTransport;
+export type ReceiveTransport = ReceivePlatformTransport | CustomReceiveTransport;
 export type Transport = PlatformTransport | CustomTransport;
-export declare const getWebExtensionGlobal: () => typeof browser;
-export declare const getWebExtensionRuntime: () => typeof browser.runtime;
+export declare const getWebExtensionGlobal: () => Browser | undefined;
+export declare const getWebExtensionRuntime: () => import("webextension-polyfill").Runtime.Static | undefined;
 export declare const checkOsraMessageKey: (message: any, key: string) => message is Message;
-export declare const registerOsraMessageListener: ({ listener, transport, remoteName, key, unregisterSignal }: {
+export declare const registerOsraMessageListener: ({ listener, transport, remoteName, key, origin, unregisterSignal }: {
     listener: (message: Message, messageContext: MessageContext) => void;
     transport: ReceiveTransport;
     remoteName?: string;
     key?: string;
+    origin?: string;
     unregisterSignal?: AbortSignal;
 }) => void;
 export declare const sendOsraMessage: (transport: EmitTransport, message: Message, origin?: string, transferables?: Transferable[]) => void;

package/build/utils/type-guards.d.ts

@@ -23,17 +23,25 @@ export declare const typedArrayTypeToTypedArrayConstructor: (value: TypedArrayTy
 export declare const isTypedArray: (value: unknown) => value is TypedArray;
 export declare const isWebSocket: (value: unknown) => value is WebSocket;
 export declare const isServiceWorkerContainer: (value: unknown) => value is ServiceWorkerContainer;
+export declare const isServiceWorker: (value: unknown) => value is ServiceWorker;
 export declare const isWorker: (value: unknown) => value is Worker;
-export declare const isDedicatedWorker: (value: unknown) => value is DedicatedWorkerGlobalScope;
+export type DedicatedWorkerGlobalScopeLike = typeof globalThis & {
+    postMessage: (message: unknown, transfer?: Transferable[]) => void;
+    name: string;
+};
+export declare const isDedicatedWorker: (value: unknown) => value is DedicatedWorkerGlobalScopeLike;
 export declare const isSharedWorker: (value: unknown) => value is SharedWorker;
 export declare const isOsraMessage: (value: unknown) => value is Message;
 type AnyConstructor = abstract new (...args: any[]) => unknown;
 /** True if `value` is an instance of any of the given constructors.
  *  Tolerates undefined entries (constructors missing on this platform). */
 export declare const instanceOfAny: (value: unknown, ctors: readonly (AnyConstructor | undefined)[]) => boolean;
+export declare const isSharedArrayBuffer: (value: unknown) => boolean;
+/** @deprecated Renamed — this only ever checked SharedArrayBuffer, unlike
+ *  the unrelated clonable fallback module. Use isSharedArrayBuffer. */
 export declare const isClonable: (value: unknown) => boolean;
 export declare const isTransferable: (value: unknown) => value is Transferable;
-export type WebExtRuntime = typeof browser.runtime;
+export type WebExtRuntime = Runtime.Static;
 export declare const isWebExtensionRuntime: (value: unknown) => value is WebExtRuntime;
 export type WebExtPort = ReturnType<WebExtRuntime['connect']> | Runtime.Port;
 export declare const isWebExtensionPort: (value: unknown, connectPort?: boolean) => value is WebExtPort;

package/build/utils/typed-message-channel.d.ts

@@ -3,6 +3,7 @@ import type { TypedEventTarget } from './typed-event-target.js';
 export type TypedMessagePortEventMap<T = unknown> = {
     'message': MessageEvent<T>;
     'messageerror': MessageEvent;
+    'close': Event;
 };
 export interface TypedMessagePort<T = unknown> extends Omit<TypedEventTarget<TypedMessagePortEventMap<T>>, typeof UnderlyingType> {
     [UnderlyingType]?: T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osra",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "Easy communication between workers",
   "files": [
     "build"
@@ -11,7 +11,8 @@
     ".": {
       "types": "./build/index.d.ts",
       "import": "./build/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "type": "module",
   "scripts": {
@@ -24,16 +25,17 @@
     "dev": "concurrently \"npm run build-test-watch\"",
     "_dev": "concurrently \"npm run build-watch\" \"npm run build-test-watch\" \"npm run test-watch\"",
     "dev2": "concurrently \"npm run build-watch\" \"npm run build-test-watch\" \"npm run test-watch-headful\"",
-    "test": "npm run build-test && npx playwright test",
+    "test": "npm run build && npm run build-test && npx playwright test",
     "test-watch": "set PWTEST_WATCH=1 & npx playwright test",
-    "test-watch-headful": "nodemon --watch build --exec \"npx playwright test --headed\"",
+    "test-watch-headful": "nodemon --watch build-test --exec \"npx playwright test --headed\"",
     "test-with-coverage": "npm run build-test && npx playwright test && npm run print-coverage && npm run clean-coverage",
     "print-coverage": "npx nyc report",
     "clean-coverage": "rimraf .nyc_output coverage",
     "type-check": "tsgo --noEmit && tsgo --noEmit -p tsconfig.tests.json",
     "start-server": "http-server -p 3000",
     "build-extension-test": "node build-extension-test.mjs",
-    "test-extension": "npm run build-extension-test && npx playwright test -c playwright.extension.config.ts"
+    "test-extension": "npm run build-extension-test && npx playwright test -c playwright.extension.config.ts",
+    "check-consumer-types": "npm run build && tsgo --noEmit -p tsconfig.consumer.json"
   },
   "repository": {
     "type": "git",
@@ -65,6 +67,8 @@
     "nyc": "^17.1.0",
     "playwright": "^1.58.2",
     "vite": "^8.0.3",
-    "vite-plugin-istanbul": "^8.0.0"
-  }
+    "vite-plugin-istanbul": "^8.0.0",
+    "ws": "^8.21.0"
+  },
+  "sideEffects": false
 }