osra 0.2.13 → 0.3.0

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

@@ -0,0 +1,20 @@
+import type { Capable } from '../types';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
+import type { UnderlyingType } from '../utils/type';
+import type { BoxedMessagePort } from './message-port';
+export declare const type: 'abortSignal';
+type AbortMessage = {
+    type: 'abort';
+    reason?: Capable;
+};
+export type BoxedAbortSignal<T extends AbortSignal = AbortSignal> = BoxBaseType<typeof type> & {
+    aborted: boolean;
+    reason?: Capable;
+    port: BoxedMessagePort<AbortMessage>;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is AbortSignal;
+export declare const box: <T extends AbortSignal, T2 extends RevivableContext>(value: T, context: T2) => BoxedAbortSignal<T>;
+export declare const revive: <T extends BoxedAbortSignal, T2 extends RevivableContext>(value: T, context: T2) => AbortSignal;
+export {};

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

@@ -0,0 +1,12 @@
+import type { RevivableContext, UnderlyingType, BoxedBuffer } from './utils';
+import { BoxBase } from './utils';
+export declare const type: 'arrayBuffer';
+type BoxedArrayBuffer<T extends ArrayBuffer, T2 extends RevivableContext> = typeof BoxBase & {
+    type: typeof type;
+} & BoxedBuffer<T2> & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is ArrayBuffer;
+export declare const box: <T extends ArrayBuffer, T2 extends RevivableContext>(value: T, context: T2) => BoxedArrayBuffer<T, T2>;
+export declare const revive: <T extends BoxedArrayBuffer<ArrayBuffer, RevivableContext>>(value: T, _context: RevivableContext) => T[UnderlyingType];
+export {};

package/build/revivables/bigint.d.ts

@@ -0,0 +1,14 @@
+import type { RevivableContext, UnderlyingType } from './utils';
+import { BoxBase } from './utils';
+export declare const type: 'bigint';
+type BoxedBigInt<T extends bigint> = typeof BoxBase & {
+    type: typeof type;
+} & {
+    value: string;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is bigint;
+export declare const box: <T extends bigint, T2 extends RevivableContext>(value: T, _context: T2) => BoxedBigInt<T>;
+export declare const revive: <T extends BoxedBigInt<bigint>>(value: T, _context: RevivableContext) => T[UnderlyingType];
+export {};

package/build/revivables/date.d.ts

@@ -0,0 +1,9 @@
+import type { RevivableContext } from './utils';
+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) => {
+    __OSRA_BOX__: 'revivable';
+    type: "date";
+    ISOString: string;
+};
+export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, _context: T2) => Date;

package/build/revivables/error.d.ts

@@ -0,0 +1,10 @@
+import type { RevivableContext } from './utils';
+export declare const type: 'error';
+export declare const isType: (value: unknown) => value is Error;
+export declare const box: <T extends Error, T2 extends RevivableContext>(value: T, _context: T2) => {
+    __OSRA_BOX__: 'revivable';
+    type: "error";
+    message: string;
+    stack: string;
+};
+export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, _context: T2) => Error;

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

@@ -0,0 +1,29 @@
+import type { Capable } from '../types';
+import type { RevivableContext, BoxBase as BoxBaseType, UnderlyingType } from './utils';
+import type { BoxedMessagePort } from './message-port';
+export declare const type: 'eventTarget';
+type EventTargetMessage = {
+    kind: 'subscribe';
+    eventType: string;
+} | {
+    kind: 'unsubscribe';
+    eventType: string;
+} | {
+    kind: 'close';
+} | {
+    kind: 'event';
+    eventType: string;
+    bubbles: boolean;
+    cancelable: boolean;
+    composed: boolean;
+    detail?: Capable;
+};
+export type BoxedEventTarget<T extends EventTarget = EventTarget> = BoxBaseType<typeof type> & {
+    port: BoxedMessagePort<EventTargetMessage>;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is EventTarget;
+export declare const box: <T extends EventTarget, T2 extends RevivableContext>(value: T, context: T2) => BoxedEventTarget<T>;
+export declare const revive: <T extends BoxedEventTarget, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+export {};

package/build/revivables/function.d.ts

@@ -0,0 +1,29 @@
+import type { Capable } from '../types';
+import type { UnderlyingType, RevivableContext, BoxBase as BoxBaseType } from './utils';
+import type { AnyPort } from './message-port';
+import { BoxedMessagePort } from './message-port';
+export declare const type: 'function';
+type ResultMessage = {
+    __osra_ok__: true;
+    value: Capable;
+} | {
+    __osra_err__: true;
+    error: string;
+};
+type CallMessage = CallContext | {
+    __osra_close__: true;
+};
+/** Call-site payload as received by the callee, after box-side revival: the
+ *  return port is now a live AnyPort<ResultMessage> (ProtocolPort on clone,
+ *  EventPort on JSON); args are revived. */
+export type CallContext = [AnyPort<ResultMessage>, Capable[]];
+export type BoxedFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = BoxBaseType<typeof type> & {
+    port: BoxedMessagePort<CallMessage>;
+} & {
+    [UnderlyingType]: (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+};
+type CapableFunction<T> = T extends (...args: infer P) => infer R ? P extends Capable[] ? R extends Capable ? T : never : never : never;
+export declare const isType: (value: unknown) => value is (...args: any[]) => any;
+export declare const box: <T extends (...args: any[]) => any, T2 extends RevivableContext>(value: T & CapableFunction<T>, context: T2) => BoxedFunction<T>;
+export declare const revive: <T extends BoxedFunction, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+export {};

package/build/revivables/headers.d.ts

@@ -0,0 +1,9 @@
+import type { RevivableContext } from './utils';
+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) => {
+    __OSRA_BOX__: 'revivable';
+    type: "headers";
+    entries: [string, string][];
+};
+export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, _context: T2) => Headers;

package/build/revivables/identity.d.ts

@@ -0,0 +1,39 @@
+import type { Capable, Uuid } from '../types';
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
+import type { UnderlyingType } from '../utils/type';
+export declare const type: 'identity';
+export type Messages = {
+    type: 'identity-dispose';
+    remoteUuid: Uuid;
+    /** id of the identity-wrapped value that was collected */
+    id: string;
+};
+export declare const Messages: Messages;
+declare const IDENTITY_MARKER: unique symbol;
+type IdentityWrapper<T = unknown> = {
+    readonly [IDENTITY_MARKER]: true;
+    readonly value: T;
+};
+export type BoxedIdentity<T extends Capable = Capable> = BoxBaseType<typeof type> & {
+    id: string;
+    inner?: Capable;
+    [UnderlyingType]: T;
+};
+/**
+ * Wrap a value so that osra preserves its reference identity across the
+ * RPC boundary, per connection. Calling identity(X) twice on the same
+ * value produces the same wrapper, and both wrapper sends resolve to the
+ * same revived reference on the remote side.
+ *
+ * - Primitives pass through unchanged (there is no identity to preserve).
+ * - Already-wrapped values pass through unchanged (idempotent).
+ *
+ * NOTE: This lies at the type level — the runtime value for object/function
+ * inputs is an IdentityWrapper<T>, typed as T so the user's surrounding
+ * code stays unchanged. The box-site unwraps it.
+ */
+export declare const identity: <T>(value: T) => T;
+export declare const isType: (value: unknown) => value is IdentityWrapper;
+export declare const box: <T extends Capable, TContext extends RevivableContext>(wrapper: IdentityWrapper<T>, context: TContext) => BoxedIdentity<T>;
+export declare const revive: <T extends BoxedIdentity, TContext extends RevivableContext>(value: T, context: TContext) => T[UnderlyingType];
+export {};

package/build/revivables/index.d.ts

@@ -0,0 +1,39 @@
+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 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 eventTarget from './event-target';
+export { identity } from './identity';
+export { transfer } from './transfer';
+export * from './utils';
+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;
+    readonly box: ((value: T2, context: RevivableContext<any>) => T3) | ((...args: any[]) => any);
+    readonly revive: (value: T3, context: RevivableContext<any>) => T2;
+    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 promise, typeof func, typeof messagePort, typeof readableStream, typeof abortSignal, typeof response, typeof request, typeof map, typeof set, typeof bigInt, typeof eventTarget];
+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/map.d.ts

@@ -0,0 +1,11 @@
+import type { Capable } from '../types';
+import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils';
+export declare const type: 'map';
+export type BoxedMap<T extends Map<Capable, Capable> = Map<Capable, Capable>> = BoxBaseType<typeof type> & {
+    entries: Array<[Capable, Capable]>;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is Map<unknown, unknown>;
+export declare const box: <T extends Map<Capable, Capable>, T2 extends RevivableContext>(value: T, context: T2) => BoxedMap<T>;
+export declare const revive: <T extends BoxedMap, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];

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

@@ -0,0 +1,83 @@
+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';
+export declare const type: 'messagePort';
+export type Messages = {
+    type: 'message';
+    remoteUuid: Uuid;
+    data: Capable;
+    /** uuid of the messagePort that the message was sent through */
+    portId: Uuid;
+} | {
+    type: 'message-port-close';
+    remoteUuid: Uuid;
+    /** uuid of the messagePort that closed */
+    portId: Uuid;
+};
+export declare const Messages: Messages;
+/** Any port-shape the message-port revivable is happy to accept. Real
+ *  MessagePorts (from `new MessageChannel()`) and synthetic EventPorts
+ *  (from `new EventChannel()`) both flow through here. Messages can be any
+ *  Capable value — message-port boxes/revives as they cross the transport,
+ *  and the in-realm side uses pass-by-reference via EventChannel. */
+export type AnyPort<T = Capable> = TypedMessagePort<T> | EventPort<T>;
+export type BoxedMessagePort<T = Capable> = BoxBaseType<typeof type> & (
+/** The origin was a synthetic EventPort — revive must reproduce an
+ *  EventPort on the other side so live (non-clonable) Promises/Functions
+ *  etc. can flow through by reference. */
+{
+    portId: Uuid;
+    synthetic: true;
+}
+/** The origin was a real MessagePort but the transport can't carry
+ *  ports (JSON-only) — revive produces a real MessagePort proxy so the
+ *  receiver sees it as if it had been transferred. Payloads must be
+ *  structured-clonable; live (non-clonable) values nested in a
+ *  user-level MessagePort aren't supported in this mode. */
+ | {
+    portId: Uuid;
+    synthetic: false;
+}
+/** The origin was a real MessagePort and the transport supports
+ *  structured clone — the port is transferred on the wire. When
+ *  `autoBox` is true, the revive side wraps it in a `ProtocolPort`
+ *  that auto-boxes outgoing / auto-revives incoming payloads so
+ *  live values (Promises/Functions) flow through unchanged. When
+ *  `autoBox` is absent/false, the receiver gets the raw MessagePort
+ *  with structured-clone semantics (used for user-owned ports). */
+ | {
+    port: AnyPort<T>;
+    autoBox?: boolean;
+}) & {
+    [UnderlyingType]: TypedMessagePort<T>;
+};
+type StructurableTransferablePort<T> = [T] extends [Capable] ? AnyPort<T> : AnyPort<T> & {
+    [ErrorMessage]: 'Message type must extend Capable';
+    [BadValue]: BadFieldValue<T, Capable>;
+    [Path]: BadFieldPath<T, Capable>;
+    [ParentObject]: BadFieldParent<T, Capable>;
+};
+export declare const init: (context: RevivableContext) => void;
+export declare const isType: (value: unknown) => value is MessagePort | EventPort<StructurableTransferable>;
+export declare const box: <T, T2 extends RevivableContext = RevivableContext>(value: StructurableTransferablePort<T>, context: T2, options?: {
+    autoBox?: boolean;
+}) => BoxedMessagePort<T>;
+export declare const revive: <T extends Capable, T2 extends RevivableContext>(value: BoxedMessagePort<T>, context: T2) => TypedMessagePort<T>;
+/**
+ * Factory for revivable-internal channels. Returns a local port used by the
+ * revivable and a pre-boxed remote port ready to embed in the revivable's
+ * Boxed* structure. The local port auto-boxes/revives on clone transports
+ * (via ProtocolPort over a MessageChannel) and passes by reference on JSON
+ * transports (via EventChannel → portId routing).
+ *
+ * Revivables can post live values (Promises/Functions/…) on `localPort`
+ * without caring about the transport mode.
+ */
+export declare const createRevivableChannel: <T extends Capable>(context: RevivableContext) => {
+    localPort: AnyPort<T>;
+    boxedRemote: BoxedMessagePort<T>;
+};
+export {};

package/build/revivables/promise.d.ts

@@ -0,0 +1,34 @@
+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';
+export declare const type: 'promise';
+export type Context = {
+    type: 'resolve';
+    data: Capable;
+} | {
+    type: 'reject';
+    error: string;
+};
+type CapablePromise<T> = T extends Promise<infer U> ? U extends Capable ? T : T & {
+    [ErrorMessage]: 'Value type must extend a Promise that resolves to a Capable';
+    [BadValue]: BadFieldValue<U, Capable>;
+    [Path]: BadFieldPath<U, Capable>;
+    [ParentObject]: BadFieldParent<U, Capable>;
+} : T & {
+    [ErrorMessage]: 'Value type must extend a Promise that resolves to a Capable';
+    [BadValue]: T;
+    [Path]: '';
+    [ParentObject]: T;
+};
+type ExtractCapable<T> = T extends Promise<infer U> ? U extends Capable ? U : never : never;
+export type BoxedPromise<T extends Capable = Capable> = BoxBaseType<typeof type> & {
+    port: BoxedMessagePort<Context>;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is Promise<any>;
+export declare const box: <T, T2 extends RevivableContext>(value: CapablePromise<T>, context: T2) => BoxedPromise<ExtractCapable<T>>;
+export declare const revive: <T extends BoxedPromise, T2 extends RevivableContext>(value: T, context: T2) => Promise<T[typeof UnderlyingType]>;
+export {};

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

@@ -0,0 +1,18 @@
+import type { RevivableContext, BoxBase as BoxBaseType } from './utils';
+import type { UnderlyingType } from '.';
+import { BoxedMessagePort } from './message-port';
+export declare const type: 'readableStream';
+export type PullContext = {
+    type: 'pull' | 'cancel';
+};
+type ChunkMessage<T = unknown> = Promise<ReadableStreamReadResult<T>>;
+type Msg = PullContext | ChunkMessage;
+export type BoxedReadableStream<T extends ReadableStream = ReadableStream> = BoxBaseType<typeof type> & {
+    port: BoxedMessagePort<Msg>;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is ReadableStream;
+export declare const box: <T extends ReadableStream, T2 extends RevivableContext>(value: T, context: T2) => BoxedReadableStream<T>;
+export declare const revive: <T extends BoxedReadableStream, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+export {};

package/build/revivables/request.d.ts

@@ -0,0 +1,23 @@
+import type { RevivableContext } from './utils';
+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) => {
+    __OSRA_BOX__: 'revivable';
+    type: "request";
+    method: string;
+    url: string;
+    headers: {
+        __OSRA_BOX__: 'revivable';
+        type: "headers";
+        entries: [string, string][];
+    };
+    body: import("./readable-stream").BoxedReadableStream<ReadableStream<Uint8Array<ArrayBuffer>>> | null;
+    credentials: RequestCredentials;
+    cache: RequestCache;
+    redirect: RequestRedirect;
+    referrer: string;
+    referrerPolicy: ReferrerPolicy;
+    integrity: string;
+    keepalive: boolean;
+};
+export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, context: T2) => Request;

package/build/revivables/response.d.ts

@@ -0,0 +1,18 @@
+import type { RevivableContext } from './utils';
+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) => {
+    __OSRA_BOX__: 'revivable';
+    type: "response";
+    status: number;
+    statusText: string;
+    headers: {
+        __OSRA_BOX__: 'revivable';
+        type: "headers";
+        entries: [string, string][];
+    };
+    body: import("./readable-stream").BoxedReadableStream<ReadableStream<Uint8Array<ArrayBuffer>>> | null;
+    url: string;
+    redirected: boolean;
+};
+export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, context: T2) => Response;

package/build/revivables/set.d.ts

@@ -0,0 +1,11 @@
+import type { Capable } from '../types';
+import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils';
+export declare const type: 'set';
+export type BoxedSet<T extends Set<Capable> = Set<Capable>> = BoxBaseType<typeof type> & {
+    values: Array<Capable>;
+} & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is Set<unknown>;
+export declare const box: <T extends Set<Capable>, T2 extends RevivableContext>(value: T, context: T2) => BoxedSet<T>;
+export declare const revive: <T extends BoxedSet, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];

package/build/revivables/transfer.d.ts

@@ -0,0 +1,37 @@
+import type { Capable } from '../types';
+import type { BoxBase as BoxBaseType, RevivableContext, UnderlyingType } from './utils';
+export declare const type: 'transfer';
+declare const TRANSFER_MARKER: unique symbol;
+type TransferWrapper<T = unknown> = {
+    readonly [TRANSFER_MARKER]: true;
+    readonly value: T;
+};
+export type BoxedTransfer<T extends Capable = Capable> = BoxBaseType<typeof type> & {
+    inner: Capable;
+    degraded: boolean;
+    [UnderlyingType]: T;
+};
+/**
+ * Opt into transfer semantics for a transferable value. Without this wrapper
+ * osra sends transferables as structured clones (copies) — the sender-side
+ * reference stays usable after the RPC. Wrapping hands the underlying storage
+ * off to the receiver and neuters the sender-side reference, matching what
+ * you'd get by listing it in the transfer list of `postMessage(msg, [buf])`.
+ *
+ * - Primitives, null, undefined, plain objects, Promises, Dates, etc. are
+ *   returned unchanged.
+ * - Typed array views (`Uint8Array`, `DataView`, …) are accepted as a
+ *   convenience — their underlying `.buffer` is what actually gets moved.
+ * - `transfer(transfer(x))` returns the same wrapper as `transfer(x)`.
+ * - If the current platform cannot transfer the given type, the wrapper
+ *   silently degrades to a copy — nothing throws.
+ *
+ * NOTE: This lies at the type level — the runtime value for transferable
+ * inputs is a TransferWrapper<T>, typed as T so the user's surrounding
+ * code stays unchanged. The box-site unwraps it.
+ */
+export declare const transfer: <T>(value: T) => T;
+export declare const isType: (value: unknown) => value is TransferWrapper;
+export declare const box: <T extends Capable, TContext extends RevivableContext>(wrapper: TransferWrapper<T>, context: TContext) => BoxedTransfer<T>;
+export declare const revive: <T extends BoxedTransfer, TContext extends RevivableContext>(value: T, context: TContext) => T[UnderlyingType];
+export {};

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

@@ -0,0 +1,15 @@
+import type { RevivableContext, UnderlyingType, BoxedBuffer } from './utils';
+import type { TypedArray, TypedArrayType } from '../utils/type-guards';
+import { BoxBase } from './utils';
+export declare const type: 'typedArray';
+type BoxedTypedArray<T extends TypedArray, T2 extends RevivableContext> = typeof BoxBase & {
+    type: typeof type;
+} & {
+    typedArrayType: TypedArrayType;
+} & BoxedBuffer<T2> & {
+    [UnderlyingType]: T;
+};
+export declare const isType: (value: unknown) => value is TypedArray;
+export declare const box: <T extends TypedArray, T2 extends RevivableContext>(value: T, context: T2) => BoxedTypedArray<T, T2>;
+export declare const revive: <T extends BoxedTypedArray<TypedArray, RevivableContext>>(value: T, _context: RevivableContext) => T[UnderlyingType];
+export {};

package/build/revivables/utils.d.ts

@@ -0,0 +1,59 @@
+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';
+export declare const BoxBase: {
+    readonly __OSRA_BOX__: 'revivable';
+};
+export type BoxBase<T extends string = string> = typeof BoxBase & {
+    type: T;
+};
+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`. */
+    sendMessage: (message: MessageFields & Record<string, unknown>) => void;
+    revivableModules: TModules;
+    eventTarget: MessageEventTarget<TModules>;
+};
+export type ExtractType<T> = 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 {
+    type: string;
+} ? 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[]> = ExtractType<TModules[number]>;
+export type InferRevivableBox<TModules extends readonly unknown[]> = ExtractBox<TModules[number]>;
+export declare const isRevivableBox: (value: unknown) => value is BoxBase;
+/** Stable string form for an unknown rejection value. Errors keep their stack;
+ *  everything else gets coerced via `String()`. Used wherever a Promise/Function
+ *  rejection has to cross the wire as a serialisable string. */
+export declare const serializeError: (error: unknown) => string;
+/** Wire shape for an ArrayBuffer carried by a JSON or clone transport. JSON
+ *  paths emit a base64 string (so the buffer survives JSON.stringify); clone
+ *  paths pass the buffer through structured-clone unchanged. */
+export type BoxedBuffer<TCtx extends RevivableContext = RevivableContext> = IsJsonOnlyTransport<TCtx['transport']> extends true ? {
+    base64Buffer: string;
+} : IsJsonOnlyTransport<TCtx['transport']> extends false ? {
+    arrayBuffer: ArrayBuffer;
+} : {
+    base64Buffer: string;
+} | {
+    arrayBuffer: ArrayBuffer;
+};
+export declare const boxBuffer: <TCtx extends RevivableContext>(buffer: ArrayBuffer, context: TCtx) => BoxedBuffer<TCtx>;
+export declare const reviveBuffer: (boxed: {
+    arrayBuffer: ArrayBuffer;
+} | {
+    base64Buffer: string;
+}) => ArrayBuffer;

package/build/types.d.ts

@@ -0,0 +1,45 @@
+import type { ConnectionMessage } from './connections';
+import type { TypedEventTarget } from './utils';
+import type { DefaultRevivableModules, RevivableModule, InferMessages, InferRevivables } from './revivables';
+export declare const OSRA_KEY: '__OSRA_KEY__';
+export declare const OSRA_DEFAULT_KEY: '__OSRA_DEFAULT_KEY__';
+export declare const OSRA_BOX: '__OSRA_BOX__';
+export type Uuid = `${string}-${string}-${string}-${string}-${string}`;
+export type Jsonable = boolean | null | number | string | {
+    [key: string]: Jsonable;
+} | Array<Jsonable>;
+export 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 type StructurableTransferable = Structurable | Transferable | {
+    [key: string]: StructurableTransferable;
+} | Array<StructurableTransferable> | Map<StructurableTransferable, StructurableTransferable> | Set<StructurableTransferable>;
+export type Capable<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = StructurableTransferable | InferRevivables<TModules> | {
+    [key: string]: Capable<TModules>;
+} | Array<Capable<TModules>> | Map<Capable<TModules>, Capable<TModules>> | Set<Capable<TModules>>;
+export type MessageFields = {
+    type: string;
+    remoteUuid: Uuid;
+};
+export type MessageBase = {
+    [OSRA_KEY]: string;
+    /** UUID of the client that sent the message */
+    uuid: Uuid;
+    name?: string;
+};
+export type ProtocolMessage = {
+    type: 'announce';
+    /** Only set when acknowledging a remote announcement */
+    remoteUuid?: Uuid;
+} | {
+    type: 'close';
+    remoteUuid: Uuid;
+};
+export type MessageVariant<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = ProtocolMessage | ConnectionMessage<TModules> | InferMessages<TModules>;
+export type Message<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = MessageBase & MessageVariant<TModules>;
+export type MessageEventMap<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = {
+    message: CustomEvent<Message<TModules>>;
+};
+export type MessageEventTarget<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = TypedEventTarget<MessageEventMap<TModules>>;

package/build/utils/capable-check.d.ts

@@ -0,0 +1,44 @@
+export declare const ErrorMessage: unique symbol;
+export declare const BadValue: unique symbol;
+export declare const Path: unique symbol;
+export declare const ParentObject: unique symbol;
+type IsPlainObject<T> = T extends object ? T extends readonly unknown[] ? false : T extends (...args: any[]) => any ? false : T extends Date | RegExp | Blob | File | FileList | ArrayBuffer | ArrayBufferView | ImageBitmap | ImageData | Map<any, any> | Set<any> | Promise<any> ? false : true : false;
+type FindBadField<T, TConstraint, TPath extends string = '', TParent = T> = T extends TConstraint ? never : T extends readonly unknown[] ? {
+    [K in Extract<keyof T, `${number}`>]: T[K] extends TConstraint ? never : FindBadField<T[K], TConstraint, `${TPath}[${K}]`, T>;
+}[Extract<keyof T, `${number}`>] extends infer R ? [R] extends [never] ? {
+    value: T;
+    path: TPath;
+    parent: TParent;
+} : R : never : IsPlainObject<T> extends true ? {
+    [K in Extract<keyof T, string>]: T[K] extends TConstraint ? never : FindBadField<T[K], TConstraint, TPath extends '' ? K : `${TPath}.${K}`, T>;
+}[Extract<keyof T, string>] extends infer R ? [R] extends [never] ? {
+    value: T;
+    path: TPath;
+    parent: TParent;
+} : R : never : {
+    value: T;
+    path: TPath;
+    parent: TParent;
+};
+/**
+ * The first non-conforming value found by deep traversal of `T` against
+ * `TConstraint`. Falls back to `T` if no traversal is applicable.
+ */
+export type BadFieldValue<T, TConstraint> = FindBadField<T, TConstraint> extends {
+    value: infer V;
+} ? V : T;
+/**
+ * Dotted/bracketed path to the first non-conforming value (e.g. `"a.b[2]"`).
+ * Empty string if the root itself fails the check.
+ */
+export type BadFieldPath<T, TConstraint> = FindBadField<T, TConstraint> extends {
+    path: infer P extends string;
+} ? P : '';
+/**
+ * The immediate parent object/array containing the first non-conforming
+ * value. Equals `T` when the root itself fails.
+ */
+export type BadFieldParent<T, TConstraint> = FindBadField<T, TConstraint> extends {
+    parent: infer P;
+} ? P : T;
+export {};