osra 0.6.8 → 0.6.10

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

@@ -2,6 +2,8 @@ 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';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 type AbortMessage = {
     type: 'abort';
     reason?: Capable;

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

@@ -1,5 +1,7 @@
 import type { RevivableContext } from './utils.js';
 export declare const type: 'arrayBuffer';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 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';

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

@@ -2,6 +2,8 @@ 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';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 type AnyAsyncIterable = {
     [Symbol.asyncIterator]: () => AsyncIterator<unknown>;
 };

package/build/revivables/date.d.ts

@@ -1,5 +1,7 @@
 import type { RevivableContext } from './utils.js';
 export declare const type: 'date';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 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';

package/build/revivables/error.d.ts

@@ -1,6 +1,8 @@
 import type { Capable } from '../types.js';
 import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'error';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type BoxedError = BoxBaseType<typeof type> & {
     name: string;
     message: string;

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

@@ -1,5 +1,7 @@
 import { type RevivableContext } from './utils.js';
 export declare const type: 'eventTarget';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 type ListenerOpts = boolean | {
     capture?: boolean;
     once?: boolean;

package/build/revivables/event.d.ts

@@ -1,6 +1,8 @@
 import type { Capable } from '../types.js';
 import type { RevivableContext, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'event';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 /** Boxes Event/CustomEvent only. Subclass-specific fields (MessageEvent.data,
  *  ErrorEvent.error, ProgressEvent.loaded, etc.) are dropped on the wire. */
 export type BoxedEvent = BoxBaseType<typeof type> & {

package/build/revivables/fallbacks.d.ts

@@ -95,6 +95,7 @@ declare const isClonable: (value: unknown) => value is Clonable;
 export declare const clonable: {
     readonly type: 'clonable';
     readonly capableOnly: true;
+    readonly objectsOnly: true;
     readonly isType: typeof isClonable;
     readonly box: (value: Clonable, _context: RevivableContext<any>) => Clonable;
     readonly revive: (value: BoxedClonable, _context: RevivableContext<any>) => Clonable;
@@ -124,6 +125,7 @@ declare const isTransferable: (value: unknown) => value is Transferable;
 export declare const transferable: {
     readonly type: 'transferable';
     readonly capableOnly: true;
+    readonly objectsOnly: true;
     readonly isType: typeof isTransferable;
     readonly box: (value: Transferable, _context: RevivableContext<any>) => Transferable;
     readonly revive: (value: BoxedTransferable, _context: RevivableContext<any>) => Transferable;
@@ -133,6 +135,7 @@ declare const isBlob: (value: unknown) => value is Blob;
 export declare const blob: {
     readonly type: 'blob';
     readonly capableOnly: true;
+    readonly objectsOnly: true;
     readonly isType: typeof isBlob;
     readonly box: (value: Blob, context: RevivableContext<any>) => Blob;
     readonly revive: (value: BoxedBlob, _context: RevivableContext<any>) => Blob;
@@ -140,6 +143,7 @@ export declare const blob: {
 export type BoxedUnclonable = BoxBaseType<'unclonable'>;
 export declare const unclonable: {
     readonly type: 'unclonable';
+    readonly objectsOnly: true;
     readonly isType: (value: unknown) => value is never;
     readonly box: (_value: never, _context: RevivableContext<any>) => BoxedUnclonable;
     readonly revive: (_value: BoxedUnclonable, _context: RevivableContext<any>) => Record<string, never>;

package/build/revivables/function.d.ts

@@ -3,6 +3,8 @@ import type { UnderlyingType, RevivableContext, BoxBase as BoxBaseType } from '.
 import { type EventPort } from '../utils/event-channel.js';
 import { BoxedMessagePort } from './message-port.js';
 export declare const type: 'function';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 type CallContext = [EventPort<Capable>, Capable[]];
 export type BoxedFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = BoxBaseType<typeof type> & {
     port: BoxedMessagePort<CallContext>;

package/build/revivables/headers.d.ts

@@ -1,5 +1,7 @@
 import type { RevivableContext } from './utils.js';
 export declare const type: 'headers';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 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';

package/build/revivables/identity.d.ts

@@ -2,6 +2,8 @@ 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';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type Messages = {
     type: 'identity-dispose';
     remoteUuid: Uuid;

package/build/revivables/index.d.ts

@@ -29,6 +29,12 @@ 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;
+    /** Declare `true` when `isType` never claims a primitive (string, number, boolean, bigint, symbol,
+     *  undefined, null). The walker then skips the module for primitive leaves, which is most of what a
+     *  large payload is made of. Leaving it off is always safe: the default is to call `isType` for
+     *  every value, exactly as before. `objectsOnlyFlagsAreHonest` in the suite calls every flagged
+     *  module with a set of primitives and fails if one of them says yes. */
+    readonly objectsOnly?: boolean;
     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;
@@ -47,23 +53,27 @@ export declare const defaultRevivableModules: readonly [typeof transfer, typeof
 }, {
     readonly type: 'clonable';
     readonly capableOnly: true;
+    readonly objectsOnly: true;
     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 objectsOnly: true;
     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;
 }, {
     readonly type: 'blob';
     readonly capableOnly: true;
+    readonly objectsOnly: true;
     readonly isType: (value: unknown) => value is Blob;
     readonly box: (value: Blob, context: RevivableContext<any>) => Blob;
     readonly revive: (value: import("./fallbacks.js").BoxedBlob, _context: RevivableContext<any>) => Blob;
 }, typeof eventTarget, {
     readonly type: 'unclonable';
+    readonly objectsOnly: true;
     readonly isType: (value: unknown) => value is 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>;

package/build/revivables/map.d.ts

@@ -1,6 +1,8 @@
 import type { Capable } from '../types.js';
 import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'map';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 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

@@ -5,6 +5,8 @@ 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';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type Messages = {
     type: 'message';
     remoteUuid: Uuid;
@@ -39,6 +41,8 @@ type StructurableTransferablePort<T> = [T] extends [Capable] ? AnyPort<T> : AnyP
 };
 export declare const init: (context: RevivableContext) => void;
 export declare const isType: (value: unknown) => value is MessagePort | EventPort<StructurableTransferable>;
+/** Post a payload that is already boxed. Anything else must go through `postMessage` as usual. */
+export declare const postPreBoxed: (port: MessagePort, boxed: Capable, transferables?: Transferable[]) => void;
 export declare const box: <T, T2 extends RevivableContext = RevivableContext>(value: StructurableTransferablePort<T>, context: T2, options?: {
     autoBox?: boolean;
 }) => BoxedMessagePort<T>;

package/build/revivables/promise.d.ts

@@ -4,6 +4,8 @@ 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';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type Context = {
     type: 'resolve';
     data: Capable;

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

@@ -3,6 +3,8 @@ 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';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type PullContext = {
     type: 'pull';
 } | {

package/build/revivables/request.d.ts

@@ -1,5 +1,7 @@
 import type { RevivableContext } from './utils.js';
 export declare const type: 'request';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 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';

package/build/revivables/response.d.ts

@@ -1,5 +1,7 @@
 import type { RevivableContext } from './utils.js';
 export declare const type: 'response';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 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';

package/build/revivables/set.d.ts

@@ -1,6 +1,8 @@
 import type { Capable } from '../types.js';
 import type { RevivableContext, UnderlyingType, BoxBase as BoxBaseType } from './utils.js';
 export declare const type: 'set';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type BoxedSet<T extends Set<Capable> = Set<Capable>> = BoxBaseType<typeof type> & {
     values: Array<Capable>;
 } & {

package/build/revivables/transfer.d.ts

@@ -1,6 +1,8 @@
 import type { Capable } from '../types.js';
 import type { BoxBase as BoxBaseType, RevivableContext, UnderlyingType } from './utils.js';
 export declare const type: 'transfer';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 declare const TRANSFER_MARKER: unique symbol;
 type TransferWrapper<T = unknown> = {
     readonly [TRANSFER_MARKER]: true;

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

@@ -3,6 +3,8 @@ import type { TypedArray, TypedArrayType } from '../utils/type-guards.js';
 import { BoxBase } from './utils.js';
 import { isTypedArray } from '../utils/type-guards.js';
 export declare const type: 'typedArray';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 type BoxedTypedArray<T extends TypedArray, T2 extends RevivableContext> = typeof BoxBase & {
     type: typeof type;
 } & {

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

@@ -3,6 +3,8 @@ import type { UnderlyingType } from './index.js';
 import type { Capable } from '../types.js';
 import { BoxedMessagePort } from './message-port.js';
 export declare const type: 'writableStream';
+/** Never claims a primitive, so the walker can skip this module for primitive leaves. */
+export declare const objectsOnly = true;
 export type WriteContext = {
     type: 'write';
     chunk: Capable;

package/build/types.d.ts

@@ -32,7 +32,7 @@ export type Capable<TModules extends readonly RevivableModule[] = DefaultRevivab
 /** What a value looks like from the far side of the connection: functions
  *  become async (calls cross the wire), 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 Promise<infer U> ? Promise<Remote<U>> : T extends Map<any, any> | Set<any> | Date | Error | RegExp | ArrayBuffer | ArrayBufferView | Blob | File | FileList | ReadableStream | WritableStream | MessagePort | EventTarget | Request | Response | Headers ? T : T extends AsyncIterable<infer U> ? AsyncIterableIterator<Remote<U>> : T extends ReadonlyArray<unknown> ? {
+export type Remote<T> = T extends (...args: infer P) => infer R ? (...args: P) => Promise<Remote<Awaited<R>>> : T extends Promise<infer U> ? Promise<Remote<U>> : T extends Map<infer K, infer V> ? Map<Remote<K>, Remote<V>> : T extends Set<infer V> ? Set<Remote<V>> : T extends ReadableStream<infer C> ? ReadableStream<Remote<C>> : T extends Date | Error | RegExp | ArrayBuffer | ArrayBufferView | Blob | File | FileList | WritableStream | MessagePort | AbortSignal | Request | Response | Headers ? T : T extends EventTarget ? EventTarget : 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]>;

package/build/utils/index.d.ts

@@ -8,4 +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';
+export { onTeardown, isTornDown } from './teardown.js';

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

@@ -1,6 +1,16 @@
 import type { Message } from '../types.js';
 import type { CustomEmitTransport, CustomReceiveTransport, CustomTransport, EmitJsonPlatformTransport, EmitTransport, JsonPlatformTransport, ReceiveJsonPlatformTransport, ReceiveTransport, Transport } from './transport.js';
 import type { WebExtOnConnect, WebExtOnMessage, WebExtPort, WebExtRuntime } from './webext-types.js';
+/** Structural on purpose, never `typeof Float16Array`. That global type exists only in TypeScript's
+ *  esnext lib, and naming it here lands it in the SHIPPED declarations, where a consumer on an older
+ *  lib gets `Cannot find name 'Float16ArrayConstructor'` inside osra's own .d.ts, and every check
+ *  built on the collapsed types degrades with it. Same shape of break as the webextension-polyfill
+ *  import 0.6.6 and 0.6.7 shipped; `npm run check-consumer-types-legacy-lib` is the guard. */
+type Float16ArrayConstructorLike = (new (buffer: ArrayBufferLike, byteOffset?: number, length?: number) => ArrayBufferView & {
+    readonly length: number;
+}) & {
+    readonly BYTES_PER_ELEMENT: number;
+};
 declare const typedArrayConstructorsByName: {
     readonly Int8Array: Int8ArrayConstructor;
     readonly Uint8Array: Uint8ArrayConstructor;
@@ -9,7 +19,7 @@ declare const typedArrayConstructorsByName: {
     readonly Uint16Array: Uint16ArrayConstructor;
     readonly Int32Array: Int32ArrayConstructor;
     readonly Uint32Array: Uint32ArrayConstructor;
-    readonly Float16Array: Float16ArrayConstructor | undefined;
+    readonly Float16Array: Float16ArrayConstructorLike | undefined;
     readonly Float32Array: Float32ArrayConstructor;
     readonly Float64Array: Float64ArrayConstructor;
     readonly BigInt64Array: BigInt64ArrayConstructor;
@@ -37,9 +47,6 @@ type AnyConstructor = abstract new (...args: any[]) => unknown;
  *  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: typeof isSharedArrayBuffer;
 export declare const isTransferable: (value: unknown) => value is Transferable;
 export type { WebExtRuntime, WebExtPort, WebExtSender, WebExtOnConnect, WebExtOnMessage, WebExtEvent, WebExtGlobal } from './webext-types.js';
 export declare const isWebExtensionRuntime: (value: unknown) => value is WebExtRuntime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osra",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "Easy communication between workers",
   "homepage": "https://github.com/Banou26/osra#readme",
   "bugs": {
@@ -50,11 +50,14 @@
     "print-coverage": "npx nyc report",
     "clean-coverage": "node -e \"for (const dir of ['.nyc_output', 'coverage']) require('node:fs').rmSync(dir, { recursive: true, force: true })\"",
     "type-check": "node ./node_modules/typescript7/bin/tsc --noEmit && node ./node_modules/typescript7/bin/tsc --noEmit -p tsconfig.tests.json",
+    "lint": "vp lint",
+    "format": "vp fmt",
     "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",
     "check-consumer-types": "npm run build && node ./node_modules/typescript7/bin/tsc --noEmit -p tsconfig.consumer.json",
     "check-declaration-imports": "node scripts/check-declaration-imports.mjs",
+    "check-consumer-types-legacy-lib": "npm run build && node ./node_modules/typescript7/bin/tsc --noEmit -p tsconfig.consumer-lib.json",
     "docs-dev": "npm run dev -w docs",
     "docs-build": "npm run build -w docs",
     "docs-preview": "npm run preview -w docs",