osra 0.3.3 → 0.4.0

package/build/connections/bidirectional.d.ts

@@ -23,7 +23,24 @@ export type ConnectionRevivableContext<TModules extends readonly RevivableModule
     revivableModules: TModules;
     eventTarget: MessageEventTarget<TModules>;
 };
-export declare const startBidirectionalConnection: <TModules extends readonly RevivableModule[] = readonly [typeof import("../revivables/transfer"), typeof import("../revivables/identity"), typeof import("../revivables/array-buffer"), typeof import("../revivables/date"), typeof import("../revivables/headers"), typeof import("../revivables/error"), typeof import("../revivables/typed-array"), typeof import("../revivables/promise"), typeof import("../revivables/function"), typeof import("../revivables/message-port"), typeof import("../revivables/readable-stream"), typeof import("../revivables/abort-signal"), typeof import("../revivables/response"), typeof import("../revivables/request"), typeof import("../revivables/map"), typeof import("../revivables/set"), typeof import("../revivables/bigint"), typeof import("../revivables/event-target")]>({ transport, value, remoteUuid, eventTarget, send, revivableModules }: {
+export declare const startBidirectionalConnection: <TModules extends readonly RevivableModule[] = readonly [typeof import("../revivables/transfer"), typeof import("../revivables/identity"), typeof import("../revivables/array-buffer"), typeof import("../revivables/date"), typeof import("../revivables/headers"), typeof import("../revivables/error"), typeof import("../revivables/typed-array"), typeof import("../revivables/blob"), typeof import("../revivables/promise"), typeof import("../revivables/function"), typeof import("../revivables/message-port"), typeof import("../revivables/readable-stream"), typeof import("../revivables/abort-signal"), typeof import("../revivables/response"), typeof import("../revivables/request"), typeof import("../revivables/map"), typeof import("../revivables/set"), typeof import("../revivables/bigint"), typeof import("../revivables/symbol"), typeof import("../revivables/event"), typeof import("../revivables/event-target"), {
+    readonly type: 'clonable';
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is import("../revivables/fallbacks").Clonable;
+    readonly box: (value: import("../revivables/fallbacks").Clonable, _context: import("..").RevivableContext<any>) => import("../revivables/fallbacks").Clonable;
+    readonly revive: (value: import("../revivables/fallbacks").BoxedClonable, _context: import("..").RevivableContext<any>) => import("../revivables/fallbacks").Clonable;
+}, {
+    readonly type: 'transferable';
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is import("../revivables/fallbacks").Transferable;
+    readonly box: (value: import("../revivables/fallbacks").Transferable, _context: import("..").RevivableContext<any>) => import("../revivables/fallbacks").Transferable;
+    readonly revive: (value: import("../revivables/fallbacks").BoxedTransferable, _context: import("..").RevivableContext<any>) => import("../revivables/fallbacks").Transferable;
+}, {
+    readonly type: 'unclonable';
+    readonly isType: (value: unknown) => value is never;
+    readonly box: (_value: never, _context: import("..").RevivableContext<any>) => import("../revivables/fallbacks").BoxedUnclonable;
+    readonly revive: (_value: import("../revivables/fallbacks").BoxedUnclonable, _context: import("..").RevivableContext<any>) => Record<string, never>;
+}]>({ transport, value, remoteUuid, eventTarget, send, revivableModules }: {
     transport: Transport;
     value: Capable<TModules>;
     remoteUuid: Uuid;
@@ -44,10 +61,6 @@ export type BidirectionalConnection<TModules extends readonly RevivableModule[]
     revivableContext: ConnectionRevivableContext<TModules>;
     remoteValue: Promise<Capable>;
 };
-/**
- * init() — mounts the bidirectional mode on the shared protocol context.
- * Only activates when the transport can both emit and receive. Owns the
- * announce / close handshake and routes per-connection messages (init /
- * message / message-port-close) to the right connection's eventTarget.
- */
+/** Mounts bidirectional mode on the shared protocol context. Only active
+ *  when the transport can both emit and receive. */
 export declare const init: <TModules extends readonly RevivableModule[]>(ctx: ProtocolContext<TModules>) => void;

package/build/connections/index.d.ts

@@ -17,4 +17,4 @@ export type ConnectionMessage<TModules extends readonly RevivableModule[] = Defa
     Messages: (modules: TModules, value: T) => infer R;
 } ? R : never;
 export type ConnectionContext<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = BidirectionalConnectionContext<TModules>;
-export declare const startConnections: <T = unknown, const TUserModules extends readonly RevivableModule[] = readonly []>(value: Capable<[...DefaultRevivableModules, ...TUserModules]>, { transport: _transport, name, remoteName, key, origin, unregisterSignal, revivableModules: _userRevivableModules, uuid: _uuid, remoteUuid: presetRemoteUuid, }: StartConnectionsOptions<TUserModules>) => Promise<T>;
+export declare const startConnections: <T = unknown, const TModules extends readonly RevivableModule[] = DefaultRevivableModules>(value: Capable<TModules>, { transport: _transport, name, remoteName, key, origin, unregisterSignal, revivableModules: configureRevivableModules, uuid: _uuid, remoteUuid: presetRemoteUuid, }: StartConnectionsOptions<TModules>) => Promise<T>;

package/build/connections/utils.d.ts

@@ -4,7 +4,11 @@ import type { Transport } from '../utils/transport';
 import type { ConnectionContext } from '.';
 import type { TypedEventTarget } from '../utils/typed-event-target';
 export declare const normalizeTransport: (transport: Transport) => Transport;
-export declare const mergeRevivableModules: <TUserModules extends readonly RevivableModule[]>(userModules: TUserModules | undefined) => readonly (typeof import("../revivables/array-buffer") | typeof import("../revivables/date") | typeof import("../revivables/headers") | typeof import("../revivables/error") | typeof import("../revivables/typed-array") | typeof import("../revivables/transfer") | typeof import("../revivables/message-port") | typeof import("../revivables/promise") | typeof import("../revivables/function") | typeof import("../revivables/readable-stream") | typeof import("../revivables/abort-signal") | typeof import("../revivables/response") | typeof import("../revivables/request") | typeof import("../revivables/identity") | typeof import("../revivables/map") | typeof import("../revivables/set") | typeof import("../revivables/bigint") | typeof import("../revivables/event-target"))[] | readonly [...(typeof import("../revivables/array-buffer") | typeof import("../revivables/date") | typeof import("../revivables/headers") | typeof import("../revivables/error") | typeof import("../revivables/typed-array") | typeof import("../revivables/transfer") | typeof import("../revivables/message-port") | typeof import("../revivables/promise") | typeof import("../revivables/function") | typeof import("../revivables/readable-stream") | typeof import("../revivables/abort-signal") | typeof import("../revivables/response") | typeof import("../revivables/request") | typeof import("../revivables/identity") | typeof import("../revivables/map") | typeof import("../revivables/set") | typeof import("../revivables/bigint") | typeof import("../revivables/event-target"))[], ...TUserModules];
+/** Resolves the final revivable module list. The user supplies a function
+ *  that takes the defaults and returns whatever ordering/composition they
+ *  want — add modules, drop defaults, reorder, override per-type. When
+ *  omitted, the defaults are used as-is. */
+export declare const mergeRevivableModules: <TModules extends readonly RevivableModule[] = DefaultRevivableModules>(configure: ((defaults: DefaultRevivableModules) => TModules) | undefined) => TModules;
 export type ProtocolEventMap<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = {
     message: CustomEvent<Message<TModules>>;
 };
@@ -21,14 +25,17 @@ export type ProtocolContext<TModules extends readonly RevivableModule[] = Defaul
     resolveRemoteValue: (value: Capable<TModules>) => void;
     createConnectionEventTarget: () => TypedEventTarget<MessageEventMap<TModules>>;
 };
-export type StartConnectionsOptions<TUserModules extends readonly RevivableModule[] = readonly []> = {
+export type StartConnectionsOptions<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = {
     transport: Transport;
     name?: string;
     remoteName?: string;
     key?: string;
     origin?: string;
     unregisterSignal?: AbortSignal;
-    revivableModules?: TUserModules;
+    /** Configure the revivable module list. Receives the defaults and
+     *  returns the final ordered list — add modules, drop defaults, reorder,
+     *  or override per-type as needed. */
+    revivableModules?: (defaults: DefaultRevivableModules) => TModules;
     uuid?: Uuid;
     remoteUuid?: Uuid;
 };

package/build/index.d.ts

@@ -1,16 +1,25 @@
 import type { Capable } from './types';
-import type { DefaultRevivableModules } from './revivables';
+import type { DefaultRevivableModules, RevivableContext } from './revivables';
 import type { RevivableModule } from './revivables';
 import type { StartConnectionsOptions } from './connections/utils';
+import type { Transport } from './utils/transport';
 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 & {
+/** Synthetic context so `Capable` can narrow on the inferred transport
+ *  without an actual context object at the call site. Only `transport`
+ *  matters; the rest is stubbed with the broadest types. */
+type ContextOf<TTransport extends Transport> = RevivableContext & {
+    transport: TTransport;
+};
+type CapableCheck<T, TModules extends readonly RevivableModule[] = DefaultRevivableModules, Ctx extends RevivableContext = RevivableContext> = T extends Capable<TModules, Ctx> ? 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>>;
+    [BadValue]: BadFieldValue<T, Capable<TModules, Ctx>>;
+    [Path]: BadFieldPath<T, Capable<TModules, Ctx>>;
+    [ParentObject]: BadFieldParent<T, Capable<TModules, Ctx>>;
 };
-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>;
+export declare const expose: <T = unknown, const TModules extends readonly RevivableModule[] = DefaultRevivableModules, const TTransport extends Transport = Transport, const TValue = Capable<TModules, ContextOf<TTransport>>>(value: CapableCheck<TValue, TModules, ContextOf<TTransport>>, options: StartConnectionsOptions<TModules> & {
+    transport: TTransport;
+}) => Promise<T>;