@nonstrict/recordkit 0.87.1 → 0.97.0

package/src/Recorder.schema.test.ts

@@ -0,0 +1,167 @@
+import { Recorder } from './Recorder.js';
+import type { AudioStreamBuffer, RecorderSchemaItem } from './Recorder.js';
+import type { Display, Microphone, Window } from './RecordKit.js';
+import type { NSRPC } from './NonstrictRPC.js';
+
+// Pins the TypeScript -> RPC wire mapping done by Recorder.newInstance: device objects are
+// normalized to ids, callbacks are replaced by registered-closure tokens, and optional fields
+// (defaults) are passed through verbatim or omitted — never silently injected. This is the layer
+// where parity with the Swift schema can drift, so it is locked down here without spawning the RPC.
+interface RegisteredClosure {
+  handler: (params: Record<string, unknown>) => Record<string, unknown> | void;
+  prefix: string;
+}
+
+function mockRpc() {
+  const calls: { initialize?: any; closures: RegisteredClosure[] } = { closures: [] };
+  const rpc = {
+    async initialize(args: any) { calls.initialize = args; },
+    registerClosure(options: RegisteredClosure) { calls.closures.push(options); return `closure:${options.prefix}`; },
+    async perform() { return undefined; },
+    async manualRelease() { },
+  } as unknown as NSRPC;
+  return { rpc, calls };
+}
+
+async function wire(items: RecorderSchemaItem[]) {
+  const { rpc, calls } = mockRpc();
+  await Recorder.newInstance(rpc, { items });
+  return { item: calls.initialize.params.schema.items[0], calls };
+}
+
+// Fixtures are fully-typed literals (no casts), so this suite also locks down the public schema
+// types themselves: a field disappearing from the types fails compilation here.
+const MICROPHONE: Microphone = { id: 'mic-7', isVirtual: false, name: 'X', model_id: 'model', manufacturer: 'Acme', availability: 'available' };
+const DISPLAY: Display = { id: 5, symbolName: 'display', frame: { x: 0, y: 0, width: 1920, height: 1080 }, isMain: true, availability: 'available' };
+const WINDOW: Window = { id: 42, frame: { x: 0, y: 0, width: 800, height: 600 }, level: 0 };
+
+describe('Recorder schema serialization (TS -> RPC wire)', () => {
+  it('passes microphone echoCancellation / audioDelay / filename through verbatim', async () => {
+    const { item } = await wire([
+      { type: 'microphone', microphone: 'mic-1', echoCancellation: 'aggressive', audioDelay: 0.3, filename: 'm.m4a' },
+    ]);
+    expect(item).toMatchObject({ type: 'microphone', microphone: 'mic-1', echoCancellation: 'aggressive', audioDelay: 0.3, filename: 'm.m4a' });
+  });
+
+  it('normalizes a Microphone object to its id', async () => {
+    const { item } = await wire([
+      { type: 'microphone', microphone: MICROPHONE },
+    ]);
+    expect(item.microphone).toBe('mic-7');
+  });
+
+  it('keeps applicationAudio backend and applicationID on the wire', async () => {
+    const { item } = await wire([
+      { type: 'applicationAudio', applicationID: 64149, backend: 'screenCaptureKit', filename: 'a.m4a' },
+    ]);
+    expect(item).toMatchObject({ type: 'applicationAudio', applicationID: 64149, backend: 'screenCaptureKit', filename: 'a.m4a' });
+  });
+
+  it('normalizes a Display object and replaces a segment callback with a closure token', async () => {
+    const { item, calls } = await wire([
+      { type: 'display', display: DISPLAY, output: 'segmented', segmentCallback: () => { } },
+    ]);
+    expect(item.display).toBe(5);
+    expect(typeof item.segmentCallback).toBe('string'); // function replaced by a registered-closure token
+    expect(calls.closures.some((c) => c.prefix === 'Display.onSegment')).toBe(true);
+  });
+
+  it('normalizes a desktopIndependentWindow Window object and replaces its segment callback', async () => {
+    const { item, calls } = await wire([
+      { type: 'desktopIndependentWindow', window: WINDOW, output: 'segmented', segmentCallback: () => { } },
+    ]);
+    expect(item.window).toBe(42);
+    expect(typeof item.segmentCallback).toBe('string');
+    expect(calls.closures.some((c) => c.prefix === 'DesktopIndependentWindow.onSegment')).toBe(true);
+  });
+
+  it('does not inject defaults for omitted optional fields (omitted = Swift default)', async () => {
+    const { item } = await wire([{ type: 'microphone', microphone: 'mic-1' }]);
+    expect('echoCancellation' in item).toBe(false);
+    expect('audioDelay' in item).toBe(false);
+  });
+});
+
+describe('Recorder inputEventsOutput wiring (TS -> RPC wire)', () => {
+  async function wireSegmentedInputEvents(item: RecorderSchemaItem, expectedPrefix: string) {
+    const { item: wired, calls } = await wire([item]);
+    expect(typeof wired.inputEventsOutput.segmentCallback).toBe('string'); // function replaced by a registered-closure token
+    const closure = calls.closures.find((c) => c.prefix === expectedPrefix);
+    expect(closure).toBeDefined();
+    return closure!;
+  }
+
+  it('replaces the display inputEventsOutput segment callback and forwards segment paths', async () => {
+    const received: string[] = [];
+    const closure = await wireSegmentedInputEvents(
+      { type: 'display', display: 5, mouse_events: true, inputEventsOutput: { output: 'segmented', segmentCallback: (path) => received.push(path) } },
+      'Display.onInputEventsSegment',
+    );
+    closure.handler({ path: '/tmp/My Recordings/display-events 1.json' });
+    expect(received).toEqual(['/tmp/My Recordings/display-events 1.json']);
+  });
+
+  it('replaces the windowBasedCrop inputEventsOutput segment callback', async () => {
+    await wireSegmentedInputEvents(
+      { type: 'windowBasedCrop', window: 42, mouse_events: true, inputEventsOutput: { output: 'segmented', segmentCallback: () => { } } },
+      'WindowBasedCrop.onInputEventsSegment',
+    );
+  });
+
+  it('replaces the desktopIndependentWindow inputEventsOutput segment callback', async () => {
+    await wireSegmentedInputEvents(
+      { type: 'desktopIndependentWindow', window: 42, mouse_events: true, inputEventsOutput: { output: 'segmented', segmentCallback: () => { } } },
+      'DesktopIndependentWindow.onInputEventsSegment',
+    );
+  });
+
+  it('passes a singleFile inputEventsOutput through verbatim', async () => {
+    const { item } = await wire([
+      { type: 'display', display: 5, mouse_events: true, inputEventsOutput: { filename: 'events.json' } },
+    ]);
+    expect(item.inputEventsOutput).toEqual({ filename: 'events.json' });
+  });
+});
+
+describe('Recorder audio stream decoding (RPC -> AudioStreamBuffer)', () => {
+  function base64Samples(samples: number[]): string {
+    const floats = new Float32Array(samples);
+    return Buffer.from(floats.buffer, floats.byteOffset, floats.byteLength).toString('base64');
+  }
+
+  async function wireMicrophoneStream() {
+    const received: AudioStreamBuffer[] = [];
+    const { calls } = await wire([
+      { type: 'microphone', microphone: 'mic-1', output: 'stream', streamCallback: (buffer) => received.push(buffer) },
+    ]);
+    const closure = calls.closures.find((c) => c.prefix === 'MicrophoneStream.onAudioBuffer');
+    expect(closure).toBeDefined();
+    return { closure: closure!, received };
+  }
+
+  it('decodes base64 channel data into per-channel Float32Arrays', async () => {
+    const { closure, received } = await wireMicrophoneStream();
+    closure.handler({
+      sampleRate: 48000,
+      numberOfChannels: 2,
+      numberOfFrames: 3,
+      channelData: [base64Samples([0, 0.5, -0.5]), base64Samples([1, -1, 0.25])],
+    });
+    expect(received).toHaveLength(1);
+    expect(received[0]).toMatchObject({ sampleRate: 48000, numberOfChannels: 2, numberOfFrames: 3 });
+    expect(Array.from(received[0].channelData[0])).toEqual([0, 0.5, -0.5]);
+    expect(Array.from(received[0].channelData[1])).toEqual([1, -1, 0.25]);
+  });
+
+  it('drops malformed audio buffers instead of invoking the stream callback', async () => {
+    const consoleError = jest.spyOn(console, 'error').mockImplementation(() => { });
+    try {
+      const { closure, received } = await wireMicrophoneStream();
+      closure.handler({ sampleRate: 48000, numberOfChannels: 1, numberOfFrames: 3 }); // missing channelData
+      closure.handler({ sampleRate: 48000, numberOfChannels: 1, numberOfFrames: 3, channelData: [12345] }); // not base64 strings
+      expect(received).toHaveLength(0);
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+});