@nonstrict/recordkit 0.1.0 → 0.2.1

package/dist/IpcRecordKit.d.ts

@@ -1,16 +1,9 @@
-/// <reference types="node" resolution-mode="require"/>
-import { EventEmitter } from 'events';
-export declare class IpcRecordKit extends EventEmitter {
+import { NSRPC } from "./NonstrictRPC.js";
+export declare class IpcRecordKit {
     private logMessages;
     private childProcess?;
-    private responseHandler;
-    private methodHandler;
-    initialize(recordKitCliPath: string, logMessages?: boolean): Promise<void>;
+    readonly nsrpc: NSRPC;
+    constructor();
+    initialize(recordKitRpcPath: string, logMessages?: boolean): Promise<void>;
     private write;
-    sendRequest(method: string, params: any): Promise<any>;
-    sendNotification(method: string, params: any): Promise<void>;
-    registerClosure(prefix: string, handler: (payload: any) => any): string;
-    registerMethod(method: string, handler: (payload: any) => any): void;
-    unregisterMethod(method: string): void;
 }
-//# sourceMappingURL=IpcRecordKit.d.ts.map

package/dist/IpcRecordKit.js

@@ -1,120 +1,42 @@
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
 import { spawn } from 'node:child_process';
 import * as readline from 'readline';
-export class IpcRecordKit extends EventEmitter {
+import { NSRPC } from "./NonstrictRPC.js";
+export class IpcRecordKit {
+    logMessages = false;
+    childProcess;
+    nsrpc;
     constructor() {
-        super(...arguments);
-        this.logMessages = false;
-        this.responseHandler = new Map();
-        this.methodHandler = new Map();
+        this.nsrpc = new NSRPC((message) => this.write(message));
     }
-    async initialize(recordKitCliPath, logMessages = false) {
+    async initialize(recordKitRpcPath, logMessages = false) {
         if (this.childProcess !== undefined) {
-            throw new Error('RecordKit CLI: Already initialized.');
+            throw new Error('RecordKit RPC: Already initialized.');
         }
         this.logMessages = logMessages;
         this.childProcess = await new Promise((resolve, reject) => {
-            const childProcess = spawn(recordKitCliPath);
+            const childProcess = spawn(recordKitRpcPath);
             childProcess.on('spawn', () => { resolve(childProcess); });
             childProcess.on('error', (error) => { reject(error); });
         });
         const { stdout } = this.childProcess;
         if (!stdout) {
-            throw new Error('RecordKit CLI: No stdout stream on child process.');
+            throw new Error('RecordKit RPC: No stdout stream on child process.');
         }
         readline.createInterface({ input: stdout }).on('line', (line) => {
             if (logMessages) {
                 console.log("< ", line.trimEnd());
             }
-            const message = JSON.parse(line);
-            if (message.jsonrpc !== '2.0') {
-                console.error("Invalid JSON-RPC message: ", line);
-                return;
-            }
-            if (message.result && message.id) {
-                const responseHandler = this.responseHandler.get(message.id);
-                if (!responseHandler) {
-                    console.error("Received response for unknown request: ", line);
-                    return;
-                }
-                responseHandler?.resolve(message.result);
-                this.responseHandler.delete(message.id);
-            }
-            else if (message.error && message.id) {
-                const responseHandler = this.responseHandler.get(message.id);
-                if (!responseHandler) {
-                    console.error("Received response for unknown request: ", line);
-                    return;
-                }
-                responseHandler?.reject(message.error);
-                this.responseHandler.delete(message.id);
-            }
-            else if (message.method) {
-                const methodHandler = this.methodHandler.get(message.method);
-                if (!methodHandler) {
-                    console.error("No handler installed for method: ", line);
-                    return;
-                }
-                try {
-                    const response = methodHandler(message.params); // TODO: Catch the error and send back over JSONRPC
-                    if (message.id && response) {
-                        this.write({ jsonrpc: '2.0', id: message.id, result: response });
-                    }
-                    else if (message.id) {
-                        // Missing response
-                        this.write({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'Method called, but no response produced.' } });
-                    }
-                    else if (response) {
-                        console.error("No response expected, throwing away result: ", response);
-                    }
-                }
-                catch (error) {
-                    if (message.id) {
-                        this.write({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: 'Method threw error.', data: error } });
-                    }
-                    else {
-                        console.error("Handler for notification with method '\(message.method)' threw an error:", error);
-                    }
-                }
-            }
-            else {
-                console.error("Invalid JSON-RPC message: ", line);
-            }
+            this.nsrpc.receive(line);
         });
     }
     write(message) {
         const stdin = this.childProcess?.stdin;
         if (!stdin) {
-            throw new Error('RecordKit CLI: Missing stdin stream.');
+            throw new Error('RecordKit RPC: Missing stdin stream.');
         }
-        const stringifiedMessage = JSON.stringify(message);
         if (this.logMessages) {
-            console.log("> ", stringifiedMessage);
+            console.log("> ", message);
         }
-        stdin.write(stringifiedMessage + "\n");
-    }
-    async sendRequest(method, params) {
-        const id = 'request_' + randomUUID();
-        const response = new Promise((resolve, reject) => { this.responseHandler.set(id, { resolve, reject }); });
-        this.write({ jsonrpc: '2.0', id, method, params });
-        return response;
-    }
-    async sendNotification(method, params) {
-        this.write({ jsonrpc: '2.0', method, params });
-    }
-    registerClosure(prefix, handler) {
-        const methodName = prefix + '_' + randomUUID();
-        this.registerMethod(methodName, handler);
-        return methodName;
-    }
-    registerMethod(method, handler) {
-        if (this.methodHandler.has(method)) {
-            throw new Error(`Method already registered: ${method}`);
-        }
-        this.methodHandler.set(method, handler);
-    }
-    unregisterMethod(method) {
-        this.methodHandler.delete(method);
+        stdin.write(message + "\n");
     }
 }

package/dist/NonstrictRPC.d.ts

@@ -0,0 +1,39 @@
+export interface NSRPCPerformClosureRequest {
+    nsrpc: number;
+    id?: string;
+    procedure: "perform";
+    target: string;
+    params?: Record<string, unknown>;
+}
+type ClosureTarget = (params: Record<string, unknown>) => Record<string, unknown> | void;
+export declare class NSRPC {
+    private readonly send;
+    private responseHandlers;
+    private closureTargets;
+    constructor(send: (data: string) => void);
+    receive(data: string): void;
+    private sendMessage;
+    private sendResponse;
+    private sendRequest;
+    private handleRequest;
+    private handleClosureRequest;
+    initialize(args: {
+        target: string;
+        type: string;
+        params?: Record<string, unknown>;
+        lifecycle: Object;
+    }): Promise<void>;
+    perform(body: {
+        type?: string;
+        target?: string;
+        action?: string;
+        params?: Record<string, unknown>;
+    }): Promise<unknown>;
+    private release;
+    registerClosure(options: {
+        handler: ClosureTarget;
+        lifecycle: Object;
+        prefix: string;
+    }): string;
+}
+export {};

package/dist/NonstrictRPC.js

@@ -0,0 +1,156 @@
+import { randomUUID } from "crypto";
+import { finalizationRegistry } from "./finalizationRegistry.js";
+export class NSRPC {
+    send;
+    responseHandlers = new Map();
+    closureTargets = new Map();
+    constructor(send) {
+        this.send = send;
+    }
+    receive(data) {
+        // TODO: For now we just assume the message is a valid NSRPC message, but we should:
+        // - Handle invalid JSON comming in
+        // - Check if the nsrpc property is set to a number in the range of 1..<2
+        // - Validate the message against the defined interfaces above
+        const message = JSON.parse(data);
+        if ("status" in message) {
+            // This is a response, dispatch it so it can be handled
+            const responseHandler = this.responseHandlers.get(message.id);
+            this.responseHandlers.delete(message.id);
+            if (responseHandler === undefined) {
+                // TODO: Got a response for a request we don't know about, log this
+                return;
+            }
+            if ("error" in message) {
+                responseHandler.reject(message.error);
+            }
+            else {
+                responseHandler.resolve(message.result);
+            }
+        }
+        else {
+            // This is a request
+            const responseBody = this.handleRequest(message);
+            if (responseBody !== undefined) {
+                this.sendResponse(message.id, responseBody);
+            }
+        }
+    }
+    /* Sending helpers */
+    sendMessage(message) {
+        this.send(JSON.stringify(message));
+    }
+    sendResponse(id, response) {
+        if (id === undefined) {
+            return;
+        }
+        this.sendMessage({ ...response, nsrpc: 1, id });
+    }
+    async sendRequest(request) {
+        const id = "req_" + randomUUID();
+        const response = new Promise((resolve, reject) => {
+            this.responseHandlers.set(id, { resolve, reject });
+        });
+        this.sendMessage({ ...request, nsrpc: 1, id });
+        return response;
+    }
+    /* Request handling */
+    handleRequest(request) {
+        switch (request.procedure) {
+            case "init":
+                return {
+                    status: 501,
+                    error: {
+                        debugDescription: "Init procedure not implemented.",
+                        userMessage: "Failed to communicate with external process. (Procedure not implemented)",
+                    },
+                };
+            case "perform":
+                if ("action" in request) {
+                    return {
+                        status: 501,
+                        error: {
+                            debugDescription: "Perform procedure for (static) methods not implemented.",
+                            userMessage: "Failed to communicate with external process. (Procedure not implemented)",
+                        },
+                    };
+                }
+                else {
+                    return this.handleClosureRequest(request);
+                }
+            case "release":
+                return {
+                    status: 501,
+                    error: {
+                        debugDescription: "Release procedure not implemented.",
+                        userMessage: "Failed to communicate with external process. (Procedure not implemented)",
+                    },
+                };
+        }
+    }
+    handleClosureRequest(request) {
+        const handler = this.closureTargets.get(request.target);
+        if (handler === undefined) {
+            return {
+                status: 404,
+                error: {
+                    debugDescription: `Perform target '${request.target}' not found.`,
+                    userMessage: "Failed to communicate with external process. (Target not found)",
+                },
+            };
+        }
+        try {
+            const rawresult = handler(request.params ?? {});
+            const result = rawresult === undefined ? undefined : rawresult;
+            return {
+                status: 200,
+                result,
+            };
+        }
+        catch (error) {
+            return {
+                status: 202,
+                // TODO: Would be good to have an error type that we can throw that fills these fields more specifically. (But for now it doesn't matter since this is just communicated back the the CLI and not to the user.)
+                error: {
+                    debugDescription: `${error}`,
+                    userMessage: "Handler failed to perform request.",
+                    underlyingError: error,
+                },
+            };
+        }
+    }
+    /* Perform remote procedures */
+    async initialize(args) {
+        const target = args.target;
+        finalizationRegistry.register(args.lifecycle, async () => {
+            await this.release(target);
+        });
+        await this.sendRequest({
+            target: args.target,
+            type: args.type,
+            params: args.params,
+            procedure: "init",
+        });
+    }
+    async perform(body) {
+        return await this.sendRequest({
+            ...body,
+            procedure: "perform",
+        });
+    }
+    async release(target) {
+        await this.sendRequest({
+            procedure: "release",
+            target,
+        });
+    }
+    /* Register locally available targets/actions */
+    registerClosure(options) {
+        const target = `target_${options.prefix}_${randomUUID()}`;
+        this.closureTargets.set(target, options.handler);
+        finalizationRegistry.register(options.lifecycle, () => {
+            this.closureTargets.delete(target);
+        });
+        return target;
+    }
+}

package/dist/RecordKit.d.ts

@@ -1,12 +1,34 @@
-import { IpcRecordKit } from "./IpcRecordKit.js";
-import { RecordingDiscovery } from "./RecordingDiscovery.js";
-import { RecordingSession, RecordingSchema, AbortReason } from "./RecordingSession.js";
+import { RecordingSession, RecordingSchema } from "./RecordingSession.js";
+interface Window {
+    id: number;
+    title?: string;
+    frame: Bounds;
+    level: number;
+    applicationProcessID?: number;
+    applicationName?: string;
+}
+interface Camera {
+    id: string;
+    localizedName: string;
+    modelID: string;
+    manufacturer: string;
+    availability: DeviceAvailability;
+}
+type Microphone = Camera;
+type DeviceAvailability = 'available' | 'lidClosed' | 'unknownSuspended';
+interface Bounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 declare class RecordKit {
-    ipcRecordKitCli: IpcRecordKit;
-    initialize(cliPath: string, logRpcMessages?: boolean): Promise<void>;
-    RecordingSession(schema: RecordingSchema, onAbort: (reason: AbortReason) => void): Promise<RecordingSession>;
-    RecordingDiscovery: typeof RecordingDiscovery;
+    private ipcRecordKit;
+    initialize(rpcBinaryPath: string, logRpcMessages?: boolean): Promise<void>;
+    getWindows(): Promise<Window[]>;
+    getCameras(): Promise<Camera[]>;
+    getMicrophones(): Promise<Microphone[]>;
+    createSession(schema: RecordingSchema): Promise<RecordingSession>;
 }
 export declare let recordkit: RecordKit;
 export {};
-//# sourceMappingURL=RecordKit.d.ts.map

package/dist/RecordKit.js

@@ -1,17 +1,22 @@
 import { IpcRecordKit } from "./IpcRecordKit.js";
-import { RecordingDiscovery } from "./RecordingDiscovery.js";
 import { RecordingSession } from "./RecordingSession.js";
 class RecordKit {
-    constructor() {
-        this.ipcRecordKitCli = new IpcRecordKit();
-        this.RecordingDiscovery = RecordingDiscovery;
+    ipcRecordKit = new IpcRecordKit();
+    async initialize(rpcBinaryPath, logRpcMessages = false) {
+        console.log('Initializing with path:', rpcBinaryPath);
+        return this.ipcRecordKit.initialize(rpcBinaryPath, logRpcMessages);
     }
-    async initialize(cliPath, logRpcMessages = false) {
-        console.log('Initializing with path:', cliPath);
-        return this.ipcRecordKitCli.initialize(cliPath, logRpcMessages);
+    async getWindows() {
+        return await this.ipcRecordKit.nsrpc.perform({ type: 'RecordingSession', action: 'getWindows' });
     }
-    async RecordingSession(schema, onAbort) {
-        return RecordingSession.newInstance(this.ipcRecordKitCli, schema, onAbort);
+    async getCameras() {
+        return await this.ipcRecordKit.nsrpc.perform({ type: 'RecordingSession', action: 'getCameras' });
+    }
+    async getMicrophones() {
+        return await this.ipcRecordKit.nsrpc.perform({ type: 'RecordingSession', action: 'getMicrophones' });
+    }
+    async createSession(schema) {
+        return RecordingSession.newInstance(this.ipcRecordKit.nsrpc, schema);
     }
 }
 export let recordkit = new RecordKit();

package/dist/RecordingSession.d.ts

@@ -1,11 +1,24 @@
-import { IpcRecordKit } from "./IpcRecordKit.js";
-export type RecordingSchema = WindowBasedCropSchema;
-export interface WindowBasedCropSchema {
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { NSRPC } from "./NonstrictRPC.js";
+import { EventEmitter } from "stream";
+export interface RecordingSchema {
+    outputDirectory?: string;
+    recorders: Recorder[];
+}
+export type Recorder = WindowBasedCropRecorder | MovieRecorder;
+export interface MovieRecorder {
+    type: 'movie';
+    filename?: string;
+    microphoneID: string;
+    cameraID: string;
+}
+export interface WindowBasedCropRecorder {
     type: 'windowBasedCrop';
+    filename?: string;
     windowID: number;
     outputDirectory?: string;
     bundleName?: string;
-    filename?: string;
 }
 export type AbortReason = {
     reason: 'userStopped';
@@ -46,13 +59,12 @@ export interface CMTimeRange {
     start: CMTime;
     duration: CMTime;
 }
-export declare class RecordingSession {
-    private readonly ipcRecordKit;
-    private readonly instance;
-    static newInstance(ipcRecordKit: IpcRecordKit, schema: RecordingSchema, onAbort: (reason: AbortReason) => void): Promise<RecordingSession>;
-    constructor(ipcRecordKit: IpcRecordKit, instance: string);
+export declare class RecordingSession extends EventEmitter {
+    private readonly rpc;
+    private readonly target;
+    static newInstance(rpc: NSRPC, schema: RecordingSchema): Promise<RecordingSession>;
+    constructor(rpc: NSRPC, target: string);
     prepare(): Promise<void>;
-    record(): Promise<void>;
-    finish(): Promise<RecordingResult>;
+    start(): Promise<void>;
+    stop(): Promise<RecordingResult>;
 }
-//# sourceMappingURL=RecordingSession.d.ts.map

package/dist/RecordingSession.js

@@ -1,28 +1,37 @@
 import { randomUUID } from "crypto";
-import { finalizationRegistry } from "./finalizationRegistry.js";
-export class RecordingSession {
-    static async newInstance(ipcRecordKit, schema, onAbort) {
-        let instance = 'RecordingSession_' + randomUUID();
-        const onAbortInstance = ipcRecordKit.registerClosure('RecordingSession.onAbort', onAbort);
-        await ipcRecordKit.sendRequest('RecordingSession.newInstance', { instance, schema, onAbortInstance });
-        const object = new RecordingSession(ipcRecordKit, instance);
-        finalizationRegistry.register(object, async () => {
-            await ipcRecordKit.sendRequest('RecordingSession.releaseInstance', { instance });
-            ipcRecordKit.unregisterMethod(onAbortInstance);
+import { EventEmitter } from "stream";
+export class RecordingSession extends EventEmitter {
+    rpc;
+    target;
+    static async newInstance(rpc, schema) {
+        const target = 'RecordingSession_' + randomUUID();
+        const object = new RecordingSession(rpc, target);
+        const weakRefObject = new WeakRef(object);
+        const onAbortInstance = rpc.registerClosure({
+            handler: (params) => { weakRefObject.deref()?.emit('abort', params.reason); },
+            prefix: 'RecordingSession.onAbort',
+            lifecycle: object
+        });
+        await rpc.initialize({
+            target,
+            type: 'RecordingSession',
+            params: { schema, onAbortInstance },
+            lifecycle: object
         });
         return object;
     }
-    constructor(ipcRecordKit, instance) {
-        this.ipcRecordKit = ipcRecordKit;
-        this.instance = instance;
+    constructor(rpc, target) {
+        super();
+        this.rpc = rpc;
+        this.target = target;
     }
     async prepare() {
-        return this.ipcRecordKit.sendRequest('RecordingSession.prepare', { instance: this.instance });
+        await this.rpc.perform({ target: this.target, action: 'prepare' });
     }
-    async record() {
-        return this.ipcRecordKit.sendRequest('RecordingSession.record', { instance: this.instance });
+    async start() {
+        await this.rpc.perform({ target: this.target, action: 'start' });
     }
-    async finish() {
-        return this.ipcRecordKit.sendRequest('RecordingSession.finish', { instance: this.instance });
+    async stop() {
+        return await this.rpc.perform({ target: this.target, action: 'stop' });
     }
 }

package/dist/finalizationRegistry.d.ts

@@ -1,4 +1,3 @@
 type Destructor = () => void;
 export declare const finalizationRegistry: FinalizationRegistry<Destructor>;
 export {};
-//# sourceMappingURL=finalizationRegistry.d.ts.map

package/dist/index.cjs

@@ -0,0 +1,281 @@
+'use strict';
+
+var node_child_process = require('node:child_process');
+var readline = require('readline');
+var crypto = require('crypto');
+var stream = require('stream');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
+
+const finalizationRegistry = new FinalizationRegistry(async (destructor) => { await destructor(); });
+
+class NSRPC {
+    send;
+    responseHandlers = new Map();
+    closureTargets = new Map();
+    constructor(send) {
+        this.send = send;
+    }
+    receive(data) {
+        // TODO: For now we just assume the message is a valid NSRPC message, but we should:
+        // - Handle invalid JSON comming in
+        // - Check if the nsrpc property is set to a number in the range of 1..<2
+        // - Validate the message against the defined interfaces above
+        const message = JSON.parse(data);
+        if ("status" in message) {
+            // This is a response, dispatch it so it can be handled
+            const responseHandler = this.responseHandlers.get(message.id);
+            this.responseHandlers.delete(message.id);
+            if (responseHandler === undefined) {
+                // TODO: Got a response for a request we don't know about, log this
+                return;
+            }
+            if ("error" in message) {
+                responseHandler.reject(message.error);
+            }
+            else {
+                responseHandler.resolve(message.result);
+            }
+        }
+        else {
+            // This is a request
+            const responseBody = this.handleRequest(message);
+            if (responseBody !== undefined) {
+                this.sendResponse(message.id, responseBody);
+            }
+        }
+    }
+    /* Sending helpers */
+    sendMessage(message) {
+        this.send(JSON.stringify(message));
+    }
+    sendResponse(id, response) {
+        if (id === undefined) {
+            return;
+        }
+        this.sendMessage({ ...response, nsrpc: 1, id });
+    }
+    async sendRequest(request) {
+        const id = "req_" + crypto.randomUUID();
+        const response = new Promise((resolve, reject) => {
+            this.responseHandlers.set(id, { resolve, reject });
+        });
+        this.sendMessage({ ...request, nsrpc: 1, id });
+        return response;
+    }
+    /* Request handling */
+    handleRequest(request) {
+        switch (request.procedure) {
+            case "init":
+                return {
+                    status: 501,
+                    error: {
+                        debugDescription: "Init procedure not implemented.",
+                        userMessage: "Failed to communicate with external process. (Procedure not implemented)",
+                    },
+                };
+            case "perform":
+                if ("action" in request) {
+                    return {
+                        status: 501,
+                        error: {
+                            debugDescription: "Perform procedure for (static) methods not implemented.",
+                            userMessage: "Failed to communicate with external process. (Procedure not implemented)",
+                        },
+                    };
+                }
+                else {
+                    return this.handleClosureRequest(request);
+                }
+            case "release":
+                return {
+                    status: 501,
+                    error: {
+                        debugDescription: "Release procedure not implemented.",
+                        userMessage: "Failed to communicate with external process. (Procedure not implemented)",
+                    },
+                };
+        }
+    }
+    handleClosureRequest(request) {
+        const handler = this.closureTargets.get(request.target);
+        if (handler === undefined) {
+            return {
+                status: 404,
+                error: {
+                    debugDescription: `Perform target '${request.target}' not found.`,
+                    userMessage: "Failed to communicate with external process. (Target not found)",
+                },
+            };
+        }
+        try {
+            const rawresult = handler(request.params ?? {});
+            const result = rawresult === undefined ? undefined : rawresult;
+            return {
+                status: 200,
+                result,
+            };
+        }
+        catch (error) {
+            return {
+                status: 202,
+                // TODO: Would be good to have an error type that we can throw that fills these fields more specifically. (But for now it doesn't matter since this is just communicated back the the CLI and not to the user.)
+                error: {
+                    debugDescription: `${error}`,
+                    userMessage: "Handler failed to perform request.",
+                    underlyingError: error,
+                },
+            };
+        }
+    }
+    /* Perform remote procedures */
+    async initialize(args) {
+        const target = args.target;
+        finalizationRegistry.register(args.lifecycle, async () => {
+            await this.release(target);
+        });
+        await this.sendRequest({
+            target: args.target,
+            type: args.type,
+            params: args.params,
+            procedure: "init",
+        });
+    }
+    async perform(body) {
+        return await this.sendRequest({
+            ...body,
+            procedure: "perform",
+        });
+    }
+    async release(target) {
+        await this.sendRequest({
+            procedure: "release",
+            target,
+        });
+    }
+    /* Register locally available targets/actions */
+    registerClosure(options) {
+        const target = `target_${options.prefix}_${crypto.randomUUID()}`;
+        this.closureTargets.set(target, options.handler);
+        finalizationRegistry.register(options.lifecycle, () => {
+            this.closureTargets.delete(target);
+        });
+        return target;
+    }
+}
+
+class IpcRecordKit {
+    logMessages = false;
+    childProcess;
+    nsrpc;
+    constructor() {
+        this.nsrpc = new NSRPC((message) => this.write(message));
+    }
+    async initialize(recordKitRpcPath, logMessages = false) {
+        if (this.childProcess !== undefined) {
+            throw new Error('RecordKit RPC: Already initialized.');
+        }
+        this.logMessages = logMessages;
+        this.childProcess = await new Promise((resolve, reject) => {
+            const childProcess = node_child_process.spawn(recordKitRpcPath);
+            childProcess.on('spawn', () => { resolve(childProcess); });
+            childProcess.on('error', (error) => { reject(error); });
+        });
+        const { stdout } = this.childProcess;
+        if (!stdout) {
+            throw new Error('RecordKit RPC: No stdout stream on child process.');
+        }
+        readline__namespace.createInterface({ input: stdout }).on('line', (line) => {
+            if (logMessages) {
+                console.log("< ", line.trimEnd());
+            }
+            this.nsrpc.receive(line);
+        });
+    }
+    write(message) {
+        const stdin = this.childProcess?.stdin;
+        if (!stdin) {
+            throw new Error('RecordKit RPC: Missing stdin stream.');
+        }
+        if (this.logMessages) {
+            console.log("> ", message);
+        }
+        stdin.write(message + "\n");
+    }
+}
+
+class RecordingSession extends stream.EventEmitter {
+    rpc;
+    target;
+    static async newInstance(rpc, schema) {
+        const target = 'RecordingSession_' + crypto.randomUUID();
+        const object = new RecordingSession(rpc, target);
+        const weakRefObject = new WeakRef(object);
+        const onAbortInstance = rpc.registerClosure({
+            handler: (params) => { weakRefObject.deref()?.emit('abort', params.reason); },
+            prefix: 'RecordingSession.onAbort',
+            lifecycle: object
+        });
+        await rpc.initialize({
+            target,
+            type: 'RecordingSession',
+            params: { schema, onAbortInstance },
+            lifecycle: object
+        });
+        return object;
+    }
+    constructor(rpc, target) {
+        super();
+        this.rpc = rpc;
+        this.target = target;
+    }
+    async prepare() {
+        await this.rpc.perform({ target: this.target, action: 'prepare' });
+    }
+    async start() {
+        await this.rpc.perform({ target: this.target, action: 'start' });
+    }
+    async stop() {
+        return await this.rpc.perform({ target: this.target, action: 'stop' });
+    }
+}
+
+class RecordKit {
+    ipcRecordKit = new IpcRecordKit();
+    async initialize(rpcBinaryPath, logRpcMessages = false) {
+        console.log('Initializing with path:', rpcBinaryPath);
+        return this.ipcRecordKit.initialize(rpcBinaryPath, logRpcMessages);
+    }
+    async getWindows() {
+        return await this.ipcRecordKit.nsrpc.perform({ type: 'RecordingSession', action: 'getWindows' });
+    }
+    async getCameras() {
+        return await this.ipcRecordKit.nsrpc.perform({ type: 'RecordingSession', action: 'getCameras' });
+    }
+    async getMicrophones() {
+        return await this.ipcRecordKit.nsrpc.perform({ type: 'RecordingSession', action: 'getMicrophones' });
+    }
+    async createSession(schema) {
+        return RecordingSession.newInstance(this.ipcRecordKit.nsrpc, schema);
+    }
+}
+let recordkit = new RecordKit();
+
+exports.recordkit = recordkit;

package/dist/index.d.ts

@@ -1,2 +1 @@
 export { recordkit } from './RecordKit.js';
-//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@nonstrict/recordkit",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "RecordKit gives you hassle-free recording in Electron apps on macOS.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
   "files": [
     "dist"
   ],
@@ -12,9 +16,9 @@
     "node": ">=18.16"
   },
   "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
-    "prepublish": "npm run clean && npm run build"
+    "test": "jest",
+    "build": "rm -rf dist && tsc && rollup -c",
+    "prepublish": "npm run build"
   },
   "keywords": [
     "recording",
@@ -34,7 +38,11 @@
   },
   "license": "SEE LICENSE IN License.md",
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "@types/node": "18.19.1",
+    "jest": "^29.7.0",
+    "rollup": "^4.12.0",
+    "ts-jest": "^29.1.2",
     "typescript": "^5.3.3"
   },
   "volta": {

package/dist/IpcRecordKit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IpcRecordKit.d.ts","sourceRoot":"","sources":["../src/IpcRecordKit.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAmBtC,qBAAa,YAAa,SAAQ,YAAY;IAC1C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,OAAO,CAAC,eAAe,CAAyC;IAChE,OAAO,CAAC,aAAa,CAAiD;IAEhE,UAAU,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqEvF,OAAO,CAAC,KAAK;IAYP,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAQtD,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,GAAG,MAAM;IAMvE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAKpE,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGzC"}

package/dist/RecordKit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RecordKit.d.ts","sourceRoot":"","sources":["../src/RecordKit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEvF,cAAM,SAAS;IACX,eAAe,eAAqB;IAE9B,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3E,gBAAgB,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI;IAItF,kBAAkB,4BAAqB;CAC1C;AAED,eAAO,IAAI,SAAS,WAAkB,CAAC"}

package/dist/RecordingDiscovery.d.ts

@@ -1,19 +0,0 @@
-interface Window {
-    windowID: number;
-    title?: string;
-    frame: Bounds;
-    level: number;
-    applicationProcessID?: number;
-    applicationName?: string;
-}
-interface Bounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export declare class RecordingDiscovery {
-    static getWindows(): Promise<Window[]>;
-}
-export {};
-//# sourceMappingURL=RecordingDiscovery.d.ts.map

package/dist/RecordingDiscovery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RecordingDiscovery.d.ts","sourceRoot":"","sources":["../src/RecordingDiscovery.ts"],"names":[],"mappings":"AAEA,UAAU,MAAM;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,UAAU,MAAM;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,kBAAkB;WACd,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAG/C"}

package/dist/RecordingDiscovery.js

@@ -1,6 +0,0 @@
-import { recordkit } from "./RecordKit.js";
-export class RecordingDiscovery {
-    static async getWindows() {
-        return recordkit.ipcRecordKitCli.sendRequest('RecordingDiscovery.getWindows', {});
-    }
-}

package/dist/RecordingSession.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RecordingSession.d.ts","sourceRoot":"","sources":["../src/RecordingSession.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,MAAM,MAAM,eAAe,GACvB,qBAAqB,CAAA;AAEzB,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAEhB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;CAAE,GACnD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;CAAE,GACnE;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;CAAE,CAAA;AAEzC,MAAM,WAAW,eAAe;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,YAAY,CAAA;CACrB;AAED,MAAM,WAAW,OAAO;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC5D,UAAU,EAAE,WAAW,EAAE,CAAA;CAC5B;AAED,MAAM,WAAW,MAAM;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,gBAAgB;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;WAErB,WAAW,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;gBAapI,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM;IAKlD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC;CAG3C"}

package/dist/finalizationRegistry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"finalizationRegistry.d.ts","sourceRoot":"","sources":["../src/finalizationRegistry.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAC5B,eAAO,MAAM,oBAAoB,kCAAqF,CAAA"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}