osra 0.4.4 → 0.5.0

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

@@ -1,6 +1,6 @@
-import type { Capable } from '../types';
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { BoxedMessagePort } from './message-port';
+import type { Capable } from '../types.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import type { BoxedMessagePort } from './message-port.js';
 export declare const type: 'abortSignal';
 type AbortMessage = {
     type: 'abort';
@@ -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/array-buffer.d.ts

@@ -1,8 +1,8 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'arrayBuffer';
 export declare const isType: (value: unknown) => value is ArrayBuffer;
 export declare const box: <T extends ArrayBuffer, T2 extends RevivableContext>(value: T, context: T2) => {
     __OSRA_BOX__: 'revivable';
     type: "arrayBuffer";
-} & import("./utils").BoxedBuffer<T2>;
+} & import("./utils.js").BoxedBuffer<T2>;
 export declare const revive: <T extends ReturnType<typeof box>>(value: T, _context: RevivableContext) => ArrayBuffer;

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/bigint.d.ts

@@ -1,4 +1,4 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'bigint';
 export declare const isType: (value: unknown) => value is bigint;
 export declare const box: <T extends bigint, T2 extends RevivableContext>(value: T, _context: T2) => {

package/build/revivables/blob.d.ts

@@ -1,6 +1,6 @@
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { UnderlyingType } from '../utils/type';
-import type { BoxedPromise } from './promise';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import type { UnderlyingType } from '../utils/type.js';
+import type { BoxedPromise } from './promise.js';
 export declare const type: 'blob';
 export type BoxedBlob<T extends Blob = Blob> = BoxBaseType<typeof type> & {
     mimeType: string;

package/build/revivables/date.d.ts

@@ -1,4 +1,4 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'date';
 export declare const isType: (value: unknown) => value is Date;
 export declare const box: <T extends Date, T2 extends RevivableContext>(value: T, _context: T2) => {

package/build/revivables/error.d.ts

@@ -1,11 +1,14 @@
-import type { Capable } from '../types';
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
+import type { Capable } from '../types.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'error';
 export type BoxedError = BoxBaseType<typeof type> & {
     name: string;
     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

@@ -1,4 +1,4 @@
-import { type RevivableContext } from './utils';
+import { type RevivableContext } from './utils.js';
 export declare const type: 'eventTarget';
 type ListenerOpts = boolean | {
     capture?: boolean;
@@ -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").BoxedFunction<(type: string, listener: EventListener, options?: ListenerOpts) => void>;
-    removeListener: import("./function").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/event.d.ts

@@ -1,5 +1,5 @@
-import type { Capable } from '../types';
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
+import type { Capable } from '../types.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'event';
 /** Boxes Event/CustomEvent only. Subclass-specific fields (MessageEvent.data,
  *  ErrorEvent.error, ProgressEvent.loaded, etc.) are dropped on the wire. */

package/build/revivables/fallbacks.d.ts

@@ -1,4 +1,4 @@
-import type { BoxBase as BoxBaseType, RevivableContext } from './utils';
+import type { BoxBase as BoxBaseType, RevivableContext } from './utils.js';
 declare const TYPED_CLONABLE_CTORS: readonly [{
     new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
     prototype: File;

package/build/revivables/function.d.ts

@@ -1,7 +1,7 @@
-import type { Capable } from '../types';
-import type { UnderlyingType, RevivableContext, BoxBase as BoxBaseType } from './utils';
-import { type EventPort } from '../utils/event-channel';
-import { BoxedMessagePort } from './message-port';
+import type { Capable } from '../types.js';
+import type { UnderlyingType, RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import { type EventPort } from '../utils/event-channel.js';
+import { BoxedMessagePort } from './message-port.js';
 export declare const type: 'function';
 type CallContext = [EventPort<Capable>, Capable[]];
 export type BoxedFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = BoxBaseType<typeof type> & {

package/build/revivables/headers.d.ts

@@ -1,4 +1,4 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'headers';
 export declare const isType: (value: unknown) => value is Headers;
 export declare const box: <T extends Headers, T2 extends RevivableContext>(value: T, _context: T2) => {

package/build/revivables/identity.d.ts

@@ -1,6 +1,6 @@
-import type { Capable, Uuid } from '../types';
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { UnderlyingType } from '../utils/type';
+import type { Capable, Uuid } from '../types.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import type { UnderlyingType } from '../utils/type.js';
 export declare const type: 'identity';
 export type Messages = {
     type: 'identity-dispose';

package/build/revivables/index.d.ts

@@ -1,31 +1,32 @@
-import type { BoxBase, RevivableContext } from './utils';
-import type { DeepReplaceWithBox, DeepReplaceWithRevive, ReplaceWithBox, ReplaceWithRevive } from '../utils/replace';
-import type { MessageFields, Capable } from '../types';
-import * as arrayBuffer from './array-buffer';
-import * as date from './date';
-import * as headers from './headers';
-import * as error from './error';
-import * as typedArray from './typed-array';
-import * as promise from './promise';
-import * as func from './function';
-import * as messagePort from './message-port';
-import * as readableStream from './readable-stream';
-import * as writableStream from './writable-stream';
-import * as abortSignal from './abort-signal';
-import * as response from './response';
-import * as request from './request';
-import * as identity from './identity';
-import * as transfer from './transfer';
-import * as map from './map';
-import * as set from './set';
-import * as bigInt from './bigint';
-import * as event from './event';
-import * as eventTarget from './event-target';
-import * as blob from './blob';
-import * as symbol from './symbol';
-export { identity } from './identity';
-export { transfer } from './transfer';
-export * from './utils';
+import type { BoxBase, RevivableContext } from './utils.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';
+import * as headers from './headers.js';
+import * as error from './error.js';
+import * as typedArray from './typed-array.js';
+import * as promise from './promise.js';
+import * as func from './function.js';
+import * as messagePort from './message-port.js';
+import * as readableStream from './readable-stream.js';
+import * as writableStream from './writable-stream.js';
+import * as abortSignal from './abort-signal.js';
+import * as response from './response.js';
+import * as request from './request.js';
+import * as identity from './identity.js';
+import * as transfer from './transfer.js';
+import * as map from './map.js';
+import * as set from './set.js';
+import * as bigInt from './bigint.js';
+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';
 export type RevivableModule<T extends string = string, T2 = any, T3 extends BoxBase<T> = any, T4 extends MessageFields = MessageFields> = {
     readonly type: T;
     readonly isType: (value: unknown) => value is T2;
@@ -34,27 +35,35 @@ 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").Clonable;
-    readonly box: (value: import("./fallbacks").Clonable, _context: RevivableContext<any>) => import("./fallbacks").Clonable;
-    readonly revive: (value: import("./fallbacks").BoxedClonable, _context: RevivableContext<any>) => import("./fallbacks").Clonable;
+    readonly isType: (value: unknown) => value is import("./fallbacks.js").Clonable;
+    readonly box: (value: import("./fallbacks.js").Clonable, _context: RevivableContext<any>) => import("./fallbacks.js").Clonable;
+    readonly revive: (value: import("./fallbacks.js").BoxedClonable, _context: RevivableContext<any>) => import("./fallbacks.js").Clonable;
 }, {
     readonly type: 'transferable';
     readonly capableOnly: true;
-    readonly isType: (value: unknown) => value is import("./fallbacks").Transferable;
-    readonly box: (value: import("./fallbacks").Transferable, _context: RevivableContext<any>) => import("./fallbacks").Transferable;
-    readonly revive: (value: import("./fallbacks").BoxedTransferable, _context: RevivableContext<any>) => import("./fallbacks").Transferable;
+    readonly isType: (value: unknown) => value is import("./fallbacks.js").Transferable;
+    readonly box: (value: import("./fallbacks.js").Transferable, _context: RevivableContext<any>) => import("./fallbacks.js").Transferable;
+    readonly revive: (value: import("./fallbacks.js").BoxedTransferable, _context: RevivableContext<any>) => import("./fallbacks.js").Transferable;
 }, typeof eventTarget, {
     readonly type: 'unclonable';
     readonly isType: (value: unknown) => value is never;
-    readonly box: (_value: never, _context: RevivableContext<any>) => import("./fallbacks").BoxedUnclonable;
-    readonly revive: (_value: import("./fallbacks").BoxedUnclonable, _context: RevivableContext<any>) => Record<string, never>;
+    readonly box: (_value: never, _context: RevivableContext<any>) => import("./fallbacks.js").BoxedUnclonable;
+    readonly revive: (_value: import("./fallbacks.js").BoxedUnclonable, _context: RevivableContext<any>) => Record<string, never>;
 }];
 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/map.d.ts

@@ -1,5 +1,5 @@
-import type { Capable } from '../types';
-import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils';
+import type { Capable } from '../types.js';
+import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'map';
 export type BoxedMap<T extends Map<Capable, Capable> = Map<Capable, Capable>> = BoxBaseType<typeof type> & {
     entries: Array<[Capable, Capable]>;

package/build/revivables/message-port.d.ts

@@ -1,9 +1,9 @@
-import type { Capable, StructurableTransferable, Uuid } from '../types';
-import type { TypedMessagePort } from '../utils/typed-message-channel';
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { UnderlyingType } from '../utils/type';
-import type { BadFieldValue, BadFieldPath, BadFieldParent, ErrorMessage, BadValue, Path, ParentObject } from '../utils/capable-check';
-import { EventPort } from '../utils/event-channel';
+import type { Capable, StructurableTransferable, Uuid } from '../types.js';
+import type { TypedMessagePort } from '../utils/typed-message-channel.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import type { UnderlyingType } from '../utils/type.js';
+import type { BadFieldValue, BadFieldPath, BadFieldParent, ErrorMessage, BadValue, Path, ParentObject } from '../utils/capable-check.js';
+import { EventPort } from '../utils/event-channel.js';
 export declare const type: 'messagePort';
 export type Messages = {
     type: 'message';

package/build/revivables/promise.d.ts

@@ -1,8 +1,8 @@
-import type { Capable } from '../types';
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { UnderlyingType } from '.';
-import type { BadFieldValue, BadFieldPath, BadFieldParent, ErrorMessage, BadValue, Path, ParentObject } from '../utils/capable-check';
-import { BoxedMessagePort } from './message-port';
+import type { Capable } from '../types.js';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import type { UnderlyingType } from './index.js';
+import type { BadFieldValue, BadFieldPath, BadFieldParent, ErrorMessage, BadValue, Path, ParentObject } from '../utils/capable-check.js';
+import { BoxedMessagePort } from './message-port.js';
 export declare const type: 'promise';
 export type Context = {
     type: 'resolve';

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

@@ -1,9 +1,13 @@
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { UnderlyingType } from '.';
-import { BoxedMessagePort } from './message-port';
+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

@@ -1,4 +1,4 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'request';
 export declare const isType: (value: unknown) => value is Request;
 export declare const box: <T extends Request, T2 extends RevivableContext>(value: T, context: T2) => {
@@ -11,13 +11,15 @@ export declare const box: <T extends Request, T2 extends RevivableContext>(value
         type: "headers";
         entries: [string, string][];
     };
-    body: import("./readable-stream").BoxedReadableStream<ReadableStream<Uint8Array<ArrayBuffer>>> | null;
+    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/response.d.ts

@@ -1,4 +1,4 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'response';
 export declare const isType: (value: unknown) => value is Response;
 export declare const box: <T extends Response, T2 extends RevivableContext>(value: T, context: T2) => {
@@ -11,7 +11,7 @@ export declare const box: <T extends Response, T2 extends RevivableContext>(valu
         type: "headers";
         entries: [string, string][];
     };
-    body: import("./readable-stream").BoxedReadableStream<ReadableStream<Uint8Array<ArrayBuffer>>> | null;
+    body: import("./readable-stream.js").BoxedReadableStream<ReadableStream<Uint8Array<ArrayBuffer>>> | null;
     url: string;
     redirected: boolean;
 };

package/build/revivables/set.d.ts

@@ -1,5 +1,5 @@
-import type { Capable } from '../types';
-import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils';
+import type { Capable } from '../types.js';
+import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'set';
 export type BoxedSet<T extends Set<Capable> = Set<Capable>> = BoxBaseType<typeof type> & {
     values: Array<Capable>;

package/build/revivables/symbol.d.ts

@@ -1,11 +1,13 @@
-import type { RevivableContext } from './utils';
+import type { RevivableContext } from './utils.js';
 export declare const type: 'symbol';
 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;
-} | import("./identity").BoxedIdentity<import("..").Capable>;
+    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/transfer.d.ts

@@ -1,5 +1,5 @@
-import type { Capable } from '../types';
-import type { BoxBase as BoxBaseType, RevivableContext, UnderlyingType } from './utils';
+import type { Capable } from '../types.js';
+import type { BoxBase as BoxBaseType, RevivableContext, UnderlyingType } from './utils.js';
 export declare const type: 'transfer';
 declare const TRANSFER_MARKER: unique symbol;
 type TransferWrapper<T = unknown> = {

package/build/revivables/typed-array.d.ts

@@ -1,6 +1,6 @@
-import type { RevivableContext, UnderlyingType, BoxedBuffer } from './utils';
-import type { TypedArray, TypedArrayType } from '../utils/type-guards';
-import { BoxBase } from './utils';
+import type { RevivableContext, UnderlyingType, BoxedBuffer } from './utils.js';
+import type { TypedArray, TypedArrayType } from '../utils/type-guards.js';
+import { BoxBase } from './utils.js';
 export declare const type: 'typedArray';
 type BoxedTypedArray<T extends TypedArray, T2 extends RevivableContext> = typeof BoxBase & {
     type: typeof type;

package/build/revivables/utils.d.ts

@@ -1,8 +1,8 @@
-import type { DefaultRevivableModules, RevivableModule } from '.';
-import type { MessageEventTarget, MessageFields, Uuid } from '../types';
-import type { Transport } from '../utils/transport';
-import type { IsJsonOnlyTransport } from '../utils/type-guards';
-export type { UnderlyingType } from '../utils/type';
+import type { DefaultRevivableModules, RevivableModule } from './index.js';
+import type { MessageEventTarget, MessageFields, Uuid } from '../types.js';
+import type { Transport } from '../utils/transport.js';
+import type { IsJsonOnlyTransport } from '../utils/type-guards.js';
+export type { UnderlyingType } from '../utils/type.js';
 export declare const BoxBase: {
     readonly __OSRA_BOX__: 'revivable';
 };
@@ -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/revivables/writable-stream.d.ts

@@ -1,7 +1,7 @@
-import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
-import type { UnderlyingType } from '.';
-import type { Capable } from '../types';
-import { BoxedMessagePort } from './message-port';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
+import type { UnderlyingType } from './index.js';
+import type { Capable } from '../types.js';
+import { BoxedMessagePort } from './message-port.js';
 export declare const type: 'writableStream';
 export type WriteContext = {
     type: 'write';

package/build/types.d.ts

@@ -1,7 +1,7 @@
-import type { ConnectionMessage } from './connections';
-import type { TypedEventTarget } from './utils';
-import type { IsJsonOnlyTransport } from './utils/type-guards';
-import type { DefaultRevivableModules, RevivableModule, InferMessages, InferRevivables, RevivableContext } from './revivables';
+import type { ConnectionMessage } from './connections/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__';
 export declare const OSRA_DEFAULT_KEY: '__OSRA_DEFAULT_KEY__';
 export declare const OSRA_BOX: '__OSRA_BOX__';
@@ -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/event-channel.d.ts

@@ -1,4 +1,4 @@
-import type { TypedMessagePort, TypedMessagePortEventMap } from './typed-message-channel';
+import type { TypedMessagePort, TypedMessagePortEventMap } from './typed-message-channel.js';
 export declare class EventPort<T> extends EventTarget {
     addEventListener<K extends keyof TypedMessagePortEventMap<T> & string>(type: K, listener: ((event: TypedMessagePortEventMap<T>[K]) => void) | null, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;

package/build/utils/index.d.ts

@@ -1,12 +1,11 @@
-export * from './transport';
-export * from '../revivables';
-export * from './replace';
-export * from '../connections';
-export * from './transferable';
-export * from './type-guards';
-export * from './typed-event-target';
-export * from './typed-message-channel';
-export * from './event-channel';
-export * from './type';
-export * from './capable-check';
-export * from './gc-tracker';
+export * from './transport.js';
+export * from './replace.js';
+export * from './transferable.js';
+export * from './type-guards.js';
+export * from './typed-event-target.js';
+export * from './typed-message-channel.js';
+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/transferable.d.ts

@@ -1,4 +1,4 @@
-import { transfer } from '../revivables/transfer';
+import { transfer } from '../revivables/transfer.js';
 export { transfer };
 /** Walk a boxed message and collect Transferables to move (rather than copy)
  *  on postMessage: