osra is a zero-runtime-dependency TypeScript RPC library that connects two JavaScript contexts over any message channel. This page installs the package and wires a page to a Web Worker; the same expose() call works over every other transport.
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(newError('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
constname='Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
constout=getStreamSomehow();
consterr=getStreamSomehow();
constmyConsole=new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(newError('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
Both sides call expose(); the returned promise resolves with the remote side’s value once the handshake completes. A side that only serves (like the worker above) can ignore the returned promise, and a side that only consumes passes {}. Functions returned across the boundary stay callable (makeCounter hands back a live counter), and async generators stream with for await.
Namespacing tag that lets multiple independent osra connections share one channel. Not authentication.
origin
'*'
On window transports: sets the outbound postMessage target origin and filters inbound messages by event.origin
name / remoteName
-
Label your endpoint / only accept envelopes from a matching peer name
unregisterSignal
-
AbortSignal that tears the connection down (see Lifecycle)
uuid / remoteUuid
random / -
Pin instance uuids (remoteUuid is otherwise learned from the peer’s announce); when both sides preset each other’s remoteUuid, the announce handshake is skipped
revivableModules
-
defaults => modules function to add, drop, reorder, or override revivable modules (see Custom revivables)
If multiple peers connect over the same transport, the returned promise resolves with the first peer’s value; later peers still connect and can call your exposed value. See multi-peer.
See transports for every channel osra runs over — windows and iframes, SharedWorkers, WebSockets, service workers, web extensions, and custom { emit, receive } pairs. Supported types lists everything that crosses the boundary, on both structured-clone and JSON transports. For the full expose() signature, handshake sequence, and error behavior, read the expose() reference.