routie dev init since i didn't adhere to any proper guidance up until now

frontend/node_modules/sync-message-port/dist/lib/index.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'events';
+import { MessageChannel, MessagePort, Transferable } from 'worker_threads';
+/**
+ * Options that can be passed to {@link SyncMessagePort.receiveMessage}.
+ */
+export interface ReceiveMessageOptions {
+    /**
+     * The time (in milliseconds) to wait for a message before returning {@link
+     * timeoutValue} (if set) or throwing a [TimeoutException] otherwise.
+     */
+    timeout?: number;
+    /**
+     * If a message isn't received within {@link timeout} milliseconds, this value
+     * is returned. Ignored if {@link timeout} is not set.
+     */
+    timeoutValue?: unknown;
+    /**
+     * If the underlying channel is closed before calling {@link
+     * SyncMessagePort.receiveMessage} or while a call is pending, return this
+     * value.
+     */
+    closedValue?: unknown;
+}
+/**
+ * An exception thrown by {@link SyncMessagePort.receiveMessage} if a message
+ * isn't received within {@link ReceivedMessageOptions.timeout} milliseconds.
+ */
+export declare class TimeoutException extends Error {
+    constructor(message: string);
+}
+/**
+ * A communication port that can receive messages synchronously from another
+ * `SyncMessagePort`.
+ *
+ * This also emits the same asynchronous events as `MessagePort`. Messages are
+ * preferentially sent to {@link receiveMessage} if a call to it is outstanding,
+ * and only sent to the event handler if they weren't received synchronously.
+ */
+export declare class SyncMessagePort extends EventEmitter {
+    private readonly port;
+    /** Creates a channel whose ports can be passed to `new SyncMessagePort()`. */
+    static createChannel(): MessageChannel;
+    /**
+     * An atomic counter of messages posted yet to be received.
+     */
+    private readonly postCounter;
+    /**
+     * An atomic counter of messages available to be received.
+     */
+    private readonly receiveCounter;
+    /**
+     * Creates a new message port. The `port` must be created by
+     * `SyncMessagePort.createChannel()` and must connect to a port passed to
+     * another `SyncMessagePort` in another worker.
+     */
+    constructor(port: MessagePort);
+    /** See `MessagePort.postMesage()`. */
+    postMessage(value: unknown, transferList?: Transferable[]): void;
+    /**
+     * Returns the message sent by the other port, if one is available. This *does
+     * not* block, and will return `undefined` immediately if no message is
+     * available. In order to distinguish between a message with value `undefined`
+     * and no message, a message is return in an object with a `message` field.
+     *
+     * It does *not* throw an error if the port is closed when this is called;
+     * instead, it just returns `undefined`.
+     */
+    receiveMessageIfAvailable(): {
+        message: unknown;
+    } | undefined;
+    /**
+     * Blocks and returns the next message sent by the other port.
+     *
+     * Throws an error if the channel is closed and all messages are drained,
+     * including if it closes while this is waiting for a message, unless
+     * {@link ReceiveMessageOptions.closedValue} is passed.
+     */
+    receiveMessage(options?: ReceiveMessageOptions): unknown;
+    /** See `MessagePort.close()`. */
+    close(): void;
+}