osra 0.4.4 → 0.4.5

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';

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/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,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: 'error';
 export type BoxedError = BoxBaseType<typeof type> & {
     name: string;

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,8 +10,8 @@ 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<(type: string, listener: EventListener, options?: ListenerOpts) => void>;
+    removeListener: import("./function.js").BoxedFunction<(type: string, listener: EventListener, options?: ListenerOpts) => void>;
 };
 export type BoxedEventTarget = ReturnType<typeof box>;
 export declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, context: T2) => EventTarget;

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,31 @@
-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, ReplaceWithBox, ReplaceWithRevive } 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';
+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;
@@ -37,20 +37,20 @@ export type RevivableModule<T extends string = string, T2 = any, T3 extends BoxB
 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, {
     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];

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

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,7 +11,7 @@ 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;
     redirect: RequestRedirect;

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,11 @@
-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>;
+} | import("./identity.js").BoxedIdentity<import("../types.js").Capable>;
 export declare const revive: <T extends {
     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';
 };

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/index.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__';

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,12 @@
-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 '../revivables/index.js';
+export * from './replace.js';
+export * from '../connections/index.js';
+export * from './transferable.js';
+export * from './type-guards.js';
+export * from './typed-event-target.js';
+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';

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:

package/build/utils/transport.d.ts

@@ -1,5 +1,5 @@
-import type { Message } from '../types';
-import type { WebExtOnConnect, WebExtOnMessage, WebExtPort, WebExtRuntime, WebExtSender } from './type-guards';
+import type { Message } from '../types.js';
+import type { WebExtOnConnect, WebExtOnMessage, WebExtPort, WebExtRuntime, WebExtSender } from './type-guards.js';
 export type MessageContext = {
     port?: MessagePort | WebExtPort;
     sender?: WebExtSender;

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

@@ -1,6 +1,6 @@
 import type { Runtime } from 'webextension-polyfill';
-import type { Message } from '../types';
-import type { CustomEmitTransport, CustomReceiveTransport, CustomTransport, EmitJsonPlatformTransport, EmitTransport, JsonPlatformTransport, ReceiveJsonPlatformTransport, ReceiveTransport, Transport } from './transport';
+import type { Message } from '../types.js';
+import type { CustomEmitTransport, CustomReceiveTransport, CustomTransport, EmitJsonPlatformTransport, EmitTransport, JsonPlatformTransport, ReceiveJsonPlatformTransport, ReceiveTransport, Transport } from './transport.js';
 declare const typedArrayConstructorsByName: {
     readonly Int8Array: Int8ArrayConstructor;
     readonly Uint8Array: Uint8ArrayConstructor;

package/build/utils/typed-event-target.d.ts

@@ -1,4 +1,4 @@
-import type { UnderlyingType } from './type';
+import type { UnderlyingType } from './type.js';
 export type EventMap = Record<string, Event>;
 export interface TypedEventTarget<T extends EventMap> extends EventTarget {
     [UnderlyingType]?: T;

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

@@ -1,5 +1,5 @@
-import type { UnderlyingType } from './type';
-import type { TypedEventTarget } from './typed-event-target';
+import type { UnderlyingType } from './type.js';
+import type { TypedEventTarget } from './typed-event-target.js';
 export type TypedMessagePortEventMap<T = unknown> = {
     'message': MessageEvent<T>;
     'messageerror': MessageEvent;

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "osra",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "Easy communication between workers",
   "files": [
     "build"
   ],
   "main": "build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
   "type": "module",
   "scripts": {
     "build": "vite build && tsgo --declaration --emitDeclarationOnly",
@@ -38,6 +45,9 @@
     "url": "https://github.com/Banou26/osra/issues"
   },
   "homepage": "https://github.com/Banou26/osra#readme",
+  "dependencies": {
+    "@types/webextension-polyfill": "^0.12.4"
+  },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@playwright/test": "^1.58.2",
@@ -46,8 +56,7 @@
     "@types/chrome": "^0.1.27",
     "@types/firefox-webext-browser": "^143.0.0",
     "@types/node": "^25.0.2",
-    "@types/webextension-polyfill": "^0.12.4",
-    "@typescript/native-preview": "^7.0.0-dev.20260404.1",
+    "@typescript/native-preview": "7.0.0-dev.20260404.1",
     "chai": "^5.3.3",
     "chai-as-promised": "^8.0.1",
     "concurrently": "^9.1.0",