@kognitivedev/voice-recording 0.2.29

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/.turbo/turbo-test.log

@@ -0,0 +1,11 @@
+$ vitest run
+
+ RUN  v3.2.4 /Users/vserifsaglam/work/memory-experiment/packages/voice-recording
+
+ ✓ src/__tests__/voice-recording.test.ts (1 test) 3ms
+
+ Test Files  1 passed (1)
+      Tests  1 passed (1)
+   Start at  17:29:58
+   Duration  886ms (transform 58ms, setup 0ms, collect 61ms, tests 3ms, environment 0ms, prepare 342ms)
+

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @kognitivedev/voice-recording
+
+## 0.2.29
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/shared@0.2.29

package/dist/backend-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { VoiceRecordingAdapter } from "./types";
+export declare function createVoiceRecordingBackendAdapter(config: {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    endpoints?: {
+        init?: string;
+        complete?: (recordingSessionId: string) => string;
+        createAsset?: (recordingSessionId: string) => string;
+        manifest?: (sessionId: string) => string;
+    };
+}): VoiceRecordingAdapter;

package/dist/backend-adapter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVoiceRecordingBackendAdapter = createVoiceRecordingBackendAdapter;
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function createVoiceRecordingBackendAdapter(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const baseUrl = trimTrailingSlash(config.baseUrl);
+    const fetchImpl = (_a = config.fetch) !== null && _a !== void 0 ? _a : fetch;
+    const endpoint = {
+        init: (_c = (_b = config.endpoints) === null || _b === void 0 ? void 0 : _b.init) !== null && _c !== void 0 ? _c : "/api/kognitive/cognitive/voice/recordings/sessions/init",
+        complete: (_e = (_d = config.endpoints) === null || _d === void 0 ? void 0 : _d.complete) !== null && _e !== void 0 ? _e : ((recordingSessionId) => `/api/kognitive/cognitive/voice/recordings/sessions/${encodeURIComponent(recordingSessionId)}/complete`),
+        createAsset: (_g = (_f = config.endpoints) === null || _f === void 0 ? void 0 : _f.createAsset) !== null && _g !== void 0 ? _g : ((recordingSessionId) => `/api/kognitive/cognitive/voice/recordings/sessions/${encodeURIComponent(recordingSessionId)}/assets`),
+        manifest: (_j = (_h = config.endpoints) === null || _h === void 0 ? void 0 : _h.manifest) !== null && _j !== void 0 ? _j : ((sessionId) => `/api/kognitive/cognitive/voice/recordings/sessions/${encodeURIComponent(sessionId)}`),
+    };
+    const requestJson = async (url, init) => {
+        var _a, _b, _c;
+        const response = await fetchImpl(`${baseUrl}${url}`, Object.assign(Object.assign({}, init), { headers: Object.assign(Object.assign({ "Content-Type": "application/json" }, ((_a = config.headers) !== null && _a !== void 0 ? _a : {})), ((_b = init === null || init === void 0 ? void 0 : init.headers) !== null && _b !== void 0 ? _b : {})) }));
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            throw new Error((_c = payload.error) !== null && _c !== void 0 ? _c : `Voice recording request failed (${response.status})`);
+        }
+        return payload;
+    };
+    return {
+        async initSession(input) {
+            const payload = await requestJson(endpoint.init, {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+            return payload;
+        },
+        async createAssetUpload(input) {
+            return requestJson(endpoint.createAsset(input.recordingSessionId), {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+        },
+        async uploadBinary(target, blob) {
+            const response = await fetchImpl(target.uploadUrl, {
+                method: "PUT",
+                headers: target.uploadHeaders,
+                body: blob,
+            });
+            if (!response.ok) {
+                throw new Error(`Voice recording upload failed (${response.status})`);
+            }
+        },
+        async completeSession(input) {
+            return requestJson(endpoint.complete(input.recordingSessionId), {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+        },
+        async fetchManifest(sessionId) {
+            var _a;
+            const response = await fetchImpl(`${baseUrl}${endpoint.manifest(sessionId)}`, {
+                headers: config.headers,
+            });
+            if (response.status === 404)
+                return null;
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                throw new Error((_a = payload.error) !== null && _a !== void 0 ? _a : `Voice recording manifest request failed (${response.status})`);
+            }
+            return payload;
+        },
+    };
+}

package/dist/controller.d.ts

@@ -0,0 +1,4 @@
+import type { VoiceRecordingAdapter, VoiceRecordingController } from "./types";
+export declare function createVoiceRecordingController(config: {
+    adapter: VoiceRecordingAdapter;
+}): VoiceRecordingController;

package/dist/controller.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVoiceRecordingController = createVoiceRecordingController;
+const wav_1 = require("./wav");
+function detectMixedMimeType() {
+    const candidates = [
+        "audio/webm;codecs=opus",
+        "audio/webm",
+        "audio/ogg;codecs=opus",
+    ];
+    for (const candidate of candidates) {
+        if (typeof MediaRecorder !== "undefined" && MediaRecorder.isTypeSupported(candidate)) {
+            return candidate;
+        }
+    }
+    return "";
+}
+async function computeChecksum(blob) {
+    const buffer = await blob.arrayBuffer();
+    const digest = await crypto.subtle.digest("SHA-256", buffer);
+    return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function buildMixedStream(inputStream, outputStream) {
+    if (!inputStream && !outputStream)
+        return null;
+    const context = new AudioContext();
+    const destination = context.createMediaStreamDestination();
+    if (inputStream) {
+        const source = context.createMediaStreamSource(inputStream);
+        source.connect(destination);
+    }
+    if (outputStream) {
+        const source = context.createMediaStreamSource(outputStream);
+        source.connect(destination);
+    }
+    return {
+        context,
+        stream: destination.stream,
+    };
+}
+function createMixedRecorder(stream, mimeType) {
+    const chunks = [];
+    const recorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined);
+    const done = new Promise((resolve) => {
+        recorder.addEventListener("dataavailable", (event) => {
+            if (event.data && event.data.size > 0) {
+                chunks.push(event.data);
+            }
+        });
+        recorder.addEventListener("stop", () => {
+            resolve(new Blob(chunks, { type: recorder.mimeType || mimeType || "audio/webm" }));
+        });
+    });
+    recorder.start(1000);
+    return {
+        stop: async () => {
+            recorder.stop();
+            return done;
+        },
+    };
+}
+function createPcmCapture(stream) {
+    const context = new AudioContext();
+    const source = context.createMediaStreamSource(stream);
+    const processor = context.createScriptProcessor(4096, 1, 1);
+    const chunks = [];
+    let sampleCount = 0;
+    processor.onaudioprocess = (event) => {
+        const input = event.inputBuffer.getChannelData(0);
+        const copy = new Float32Array(input.length);
+        copy.set(input);
+        chunks.push(copy);
+        sampleCount += copy.length;
+    };
+    source.connect(processor);
+    processor.connect(context.destination);
+    return {
+        stop: async () => {
+            processor.disconnect();
+            source.disconnect();
+            await context.close().catch(() => { });
+            const samples = new Float32Array(sampleCount);
+            let offset = 0;
+            for (const chunk of chunks) {
+                samples.set(chunk, offset);
+                offset += chunk.length;
+            }
+            const bytes = (0, wav_1.encodePcm16Wav)(samples, context.sampleRate, 1);
+            const wavBuffer = new Uint8Array(bytes.byteLength);
+            wavBuffer.set(bytes);
+            return {
+                blob: new Blob([wavBuffer.buffer], { type: "audio/wav" }),
+                sampleRate: context.sampleRate,
+                durationMs: sampleCount > 0 ? Math.round((sampleCount / context.sampleRate) * 1000) : 0,
+                channels: 1,
+            };
+        },
+    };
+}
+function createVoiceRecordingController(config) {
+    let sources = {};
+    let metadata = null;
+    let recordingSessionId = null;
+    let state = { status: "idle", manifest: null, lastError: null };
+    let startedAt = 0;
+    let inputCapture = null;
+    let outputCapture = null;
+    let mixedRecorder = null;
+    let mixedContext = null;
+    const setState = (patch) => {
+        state = Object.assign(Object.assign({}, state), patch);
+    };
+    const uploadAsset = async (kind, blob, extra = {}) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (!recordingSessionId || !metadata || blob.size === 0)
+            return null;
+        const checksum = await computeChecksum(blob);
+        const target = await config.adapter.createAssetUpload({
+            recordingSessionId,
+            sessionId: metadata.sessionId,
+            kind,
+            mimeType: blob.type || (kind === "mixed" ? "audio/webm" : "audio/wav"),
+            byteSize: blob.size,
+            durationMs: (_a = extra.durationMs) !== null && _a !== void 0 ? _a : null,
+            sampleRate: (_b = extra.sampleRate) !== null && _b !== void 0 ? _b : null,
+            channels: (_c = extra.channels) !== null && _c !== void 0 ? _c : null,
+            checksum,
+        });
+        await config.adapter.uploadBinary(target, blob);
+        return {
+            id: target.assetId,
+            kind,
+            mimeType: blob.type || (kind === "mixed" ? "audio/webm" : "audio/wav"),
+            byteSize: blob.size,
+            durationMs: (_d = extra.durationMs) !== null && _d !== void 0 ? _d : null,
+            sampleRate: (_e = extra.sampleRate) !== null && _e !== void 0 ? _e : null,
+            channels: (_f = extra.channels) !== null && _f !== void 0 ? _f : null,
+            checksum,
+            storageKey: target.storageKey,
+        };
+    };
+    return {
+        attachSources(nextSources) {
+            sources = nextSources;
+        },
+        async start(nextMetadata) {
+            var _a;
+            if (state.status === "recording")
+                return;
+            metadata = nextMetadata;
+            setState({ status: "initializing", lastError: null });
+            try {
+                const initialized = await config.adapter.initSession(nextMetadata);
+                recordingSessionId = initialized.recordingSessionId;
+                startedAt = Date.now();
+                inputCapture = sources.inputStream ? createPcmCapture(sources.inputStream) : null;
+                outputCapture = sources.outputStream ? createPcmCapture(sources.outputStream) : null;
+                const mixedStream = (_a = sources.mixedStream) !== null && _a !== void 0 ? _a : (() => {
+                    var _a;
+                    mixedContext = buildMixedStream(sources.inputStream, sources.outputStream);
+                    return (_a = mixedContext === null || mixedContext === void 0 ? void 0 : mixedContext.stream) !== null && _a !== void 0 ? _a : null;
+                })();
+                const mimeType = detectMixedMimeType();
+                mixedRecorder = mixedStream && typeof MediaRecorder !== "undefined"
+                    ? createMixedRecorder(mixedStream, mimeType)
+                    : null;
+                setState({ status: "recording" });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                setState({ status: "failed", lastError: message });
+                throw error;
+            }
+        },
+        async stop(reason) {
+            var _a, _b;
+            if (!metadata || !recordingSessionId)
+                return (_a = state.manifest) !== null && _a !== void 0 ? _a : null;
+            if (state.status !== "recording" && state.status !== "failed")
+                return (_b = state.manifest) !== null && _b !== void 0 ? _b : null;
+            setState({ status: "stopping" });
+            try {
+                const assets = (await Promise.all([
+                    mixedRecorder
+                        ? mixedRecorder.stop().then((blob) => uploadAsset("mixed", blob, {
+                            durationMs: Date.now() - startedAt,
+                            channels: 2,
+                        }))
+                        : Promise.resolve(null),
+                    inputCapture
+                        ? inputCapture.stop().then((result) => uploadAsset("user_input", result.blob, result))
+                        : Promise.resolve(null),
+                    outputCapture
+                        ? outputCapture.stop().then((result) => uploadAsset("assistant_output", result.blob, result))
+                        : Promise.resolve(null),
+                ])).filter(Boolean);
+                await (mixedContext === null || mixedContext === void 0 ? void 0 : mixedContext.context.close().catch(() => { }));
+                mixedContext = null;
+                const manifest = await config.adapter.completeSession({
+                    recordingSessionId,
+                    sessionId: metadata.sessionId,
+                    status: reason === "abort" ? "aborted" : "completed",
+                    totalDurationMs: Date.now() - startedAt,
+                    assets,
+                });
+                setState({
+                    status: manifest.status === "completed" ? "completed" : manifest.status === "aborted" ? "aborted" : "failed",
+                    manifest,
+                });
+                return manifest;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                setState({ status: "failed", lastError: message });
+                await config.adapter.completeSession({
+                    recordingSessionId,
+                    sessionId: metadata.sessionId,
+                    status: "failed",
+                    totalDurationMs: Date.now() - startedAt,
+                    assets: [],
+                    errorMessage: message,
+                }).catch(() => { });
+                throw error;
+            }
+        },
+        async flush() {
+            return this.stop("flush");
+        },
+        async abort() {
+            if (!metadata || !recordingSessionId) {
+                setState({ status: "aborted" });
+                return;
+            }
+            await Promise.allSettled([
+                inputCapture === null || inputCapture === void 0 ? void 0 : inputCapture.stop(),
+                outputCapture === null || outputCapture === void 0 ? void 0 : outputCapture.stop(),
+                mixedRecorder === null || mixedRecorder === void 0 ? void 0 : mixedRecorder.stop(),
+            ]);
+            await (mixedContext === null || mixedContext === void 0 ? void 0 : mixedContext.context.close().catch(() => { }));
+            mixedContext = null;
+            const manifest = await config.adapter.completeSession({
+                recordingSessionId,
+                sessionId: metadata.sessionId,
+                status: "aborted",
+                totalDurationMs: Date.now() - startedAt,
+                assets: [],
+                errorMessage: "aborted",
+            }).catch(() => null);
+            setState({ status: "aborted", manifest });
+        },
+        getState() {
+            return state;
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./tokens";
+export { createVoiceRecordingBackendAdapter } from "./backend-adapter";
+export { createVoiceRecordingController } from "./controller";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVoiceRecordingController = exports.createVoiceRecordingBackendAdapter = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./tokens"), exports);
+var backend_adapter_1 = require("./backend-adapter");
+Object.defineProperty(exports, "createVoiceRecordingBackendAdapter", { enumerable: true, get: function () { return backend_adapter_1.createVoiceRecordingBackendAdapter; } });
+var controller_1 = require("./controller");
+Object.defineProperty(exports, "createVoiceRecordingController", { enumerable: true, get: function () { return controller_1.createVoiceRecordingController; } });

package/dist/tokens.d.ts

@@ -0,0 +1,9 @@
+export interface VoiceRecordingSignedTokenPayload {
+    assetId: string;
+    storageKey: string;
+    projectId: string;
+    operation: "upload" | "download";
+    exp: number;
+}
+export declare function createVoiceRecordingSignedToken(payload: VoiceRecordingSignedTokenPayload, secret?: string): Promise<string>;
+export declare function verifyVoiceRecordingSignedToken(token: string | null | undefined, secret?: string): Promise<VoiceRecordingSignedTokenPayload | null>;

package/dist/tokens.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVoiceRecordingSignedToken = createVoiceRecordingSignedToken;
+exports.verifyVoiceRecordingSignedToken = verifyVoiceRecordingSignedToken;
+function getSecret(secret) {
+    return secret || process.env.VOICE_RECORDING_SIGNING_SECRET || "kognitive-voice-recording-secret";
+}
+function encodeBase64Url(value) {
+    return Buffer.from(value, "utf8").toString("base64url");
+}
+function decodeBase64Url(value) {
+    return Buffer.from(value, "base64url").toString("utf8");
+}
+async function sign(value, secret) {
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(getSecret(secret)), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(value));
+    return Buffer.from(signature).toString("base64url");
+}
+async function createVoiceRecordingSignedToken(payload, secret) {
+    const encodedPayload = encodeBase64Url(JSON.stringify(payload));
+    const signature = await sign(encodedPayload, secret);
+    return `${encodedPayload}.${signature}`;
+}
+async function verifyVoiceRecordingSignedToken(token, secret) {
+    if (!token)
+        return null;
+    const [encodedPayload, signature] = token.split(".");
+    if (!encodedPayload || !signature)
+        return null;
+    const expected = await sign(encodedPayload, secret);
+    if (expected !== signature)
+        return null;
+    try {
+        const parsed = JSON.parse(decodeBase64Url(encodedPayload));
+        if (!parsed.assetId || !parsed.storageKey || !parsed.projectId || !parsed.operation || !parsed.exp) {
+            return null;
+        }
+        if (parsed.exp < Date.now())
+            return null;
+        return parsed;
+    }
+    catch (_a) {
+        return null;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,98 @@
+export type VoiceRecordingAssetKind = "mixed" | "user_input" | "assistant_output" | "manager_input";
+export interface VoiceRecordingSessionMetadata {
+    sessionId: string;
+    userId: string;
+    provider: string;
+    modelId: string;
+    voice?: string | null;
+    transport?: string | null;
+    metadata?: Record<string, unknown>;
+    consent?: {
+        recordingEnabled?: boolean;
+        consentGranted?: boolean;
+    };
+}
+export interface VoiceRecordingAsset {
+    id: string;
+    kind: VoiceRecordingAssetKind;
+    mimeType: string;
+    byteSize: number;
+    durationMs?: number | null;
+    sampleRate?: number | null;
+    channels?: number | null;
+    checksum?: string | null;
+    storageKey: string;
+    playbackUrl?: string | null;
+}
+export interface VoiceRecordingManifest {
+    recordingSessionId: string;
+    sessionId: string;
+    sessionDbId?: string | null;
+    status: "pending" | "recording" | "uploading" | "completed" | "failed" | "aborted";
+    provider: string;
+    modelId: string;
+    voice?: string | null;
+    transport?: string | null;
+    totalDurationMs?: number | null;
+    consent?: {
+        recordingEnabled?: boolean;
+        consentGranted?: boolean;
+    } | null;
+    summary?: {
+        hasAssets: boolean;
+        assetKinds: VoiceRecordingAssetKind[];
+    };
+    assets: VoiceRecordingAsset[];
+}
+export interface VoiceRecordingUploadTarget {
+    assetId: string;
+    storageKey: string;
+    uploadUrl: string;
+    uploadHeaders?: Record<string, string>;
+}
+export interface VoiceRecordingUploadAssetInput {
+    recordingSessionId: string;
+    sessionId: string;
+    kind: VoiceRecordingAssetKind;
+    blob: Blob;
+    mimeType: string;
+    byteSize: number;
+    durationMs?: number | null;
+    sampleRate?: number | null;
+    channels?: number | null;
+    checksum?: string | null;
+}
+export interface VoiceRecordingAdapter {
+    initSession(input: VoiceRecordingSessionMetadata): Promise<{
+        recordingSessionId: string;
+        sessionDbId?: string | null;
+    }>;
+    createAssetUpload(input: Omit<VoiceRecordingUploadAssetInput, "blob">): Promise<VoiceRecordingUploadTarget>;
+    uploadBinary(target: VoiceRecordingUploadTarget, blob: Blob): Promise<void>;
+    completeSession(input: {
+        recordingSessionId: string;
+        sessionId: string;
+        status: "completed" | "failed" | "aborted";
+        totalDurationMs?: number | null;
+        assets: Array<Omit<VoiceRecordingAsset, "playbackUrl">>;
+        errorMessage?: string | null;
+    }): Promise<VoiceRecordingManifest>;
+    fetchManifest(sessionId: string): Promise<VoiceRecordingManifest | null>;
+}
+export interface VoiceRecordingControllerState {
+    status: "idle" | "initializing" | "recording" | "stopping" | "completed" | "failed" | "aborted";
+    manifest?: VoiceRecordingManifest | null;
+    lastError?: string | null;
+}
+export interface VoiceRecordingController {
+    attachSources(sources: {
+        inputStream?: MediaStream | null;
+        outputStream?: MediaStream | null;
+        mixedStream?: MediaStream | null;
+    }): void;
+    start(metadata: VoiceRecordingSessionMetadata): Promise<void>;
+    stop(reason?: string): Promise<VoiceRecordingManifest | null>;
+    flush(): Promise<VoiceRecordingManifest | null>;
+    abort(reason?: string): Promise<void>;
+    getState(): VoiceRecordingControllerState;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wav.d.ts

@@ -0,0 +1 @@
+export declare function encodePcm16Wav(samples: Float32Array, sampleRate: number, channels?: number): Uint8Array;

package/dist/wav.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePcm16Wav = encodePcm16Wav;
+function clamp(sample) {
+    return Math.max(-1, Math.min(1, sample));
+}
+function encodePcm16Wav(samples, sampleRate, channels = 1) {
+    var _a;
+    const bytesPerSample = 2;
+    const blockAlign = channels * bytesPerSample;
+    const byteRate = sampleRate * blockAlign;
+    const dataSize = samples.length * bytesPerSample;
+    const buffer = new ArrayBuffer(44 + dataSize);
+    const view = new DataView(buffer);
+    const writeString = (offset, value) => {
+        for (let index = 0; index < value.length; index += 1) {
+            view.setUint8(offset + index, value.charCodeAt(index));
+        }
+    };
+    writeString(0, "RIFF");
+    view.setUint32(4, 36 + dataSize, true);
+    writeString(8, "WAVE");
+    writeString(12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, channels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, byteRate, true);
+    view.setUint16(32, blockAlign, true);
+    view.setUint16(34, 16, true);
+    writeString(36, "data");
+    view.setUint32(40, dataSize, true);
+    let offset = 44;
+    for (let index = 0; index < samples.length; index += 1) {
+        const value = clamp((_a = samples[index]) !== null && _a !== void 0 ? _a : 0);
+        view.setInt16(offset, value < 0 ? value * 0x8000 : value * 0x7fff, true);
+        offset += 2;
+    }
+    return new Uint8Array(buffer);
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@kognitivedev/voice-recording",
+  "version": "0.2.29",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --noCheck",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@kognitivedev/shared": "^0.2.29"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "description": "Voice session recording controllers and backend adapters for Kognitive",
+  "keywords": [
+    "kognitive",
+    "voice",
+    "recording",
+    "audio"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/voice-recording"
+  },
+  "homepage": "https://kognitive.dev"
+}

package/src/__tests__/voice-recording.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from "vitest";
+import { createVoiceRecordingBackendAdapter } from "../backend-adapter";
+
+describe("@kognitivedev/voice-recording", () => {
+    it("uses the configured backend endpoints", async () => {
+        const fetch = vi.fn()
+            .mockResolvedValueOnce(new Response(JSON.stringify({ recordingSessionId: "rec-1" }), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+                assetId: "asset-1",
+                storageKey: "voice-recordings/project/session/mixed.webm",
+                uploadUrl: "https://upload.example/asset-1",
+            }), { status: 200 }))
+            .mockResolvedValueOnce(new Response(null, { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+                recordingSessionId: "rec-1",
+                sessionId: "call-1",
+                status: "completed",
+                provider: "openai-realtime",
+                modelId: "gpt-realtime-1.5",
+                assets: [],
+            }), { status: 200 }));
+        const adapter = createVoiceRecordingBackendAdapter({
+            baseUrl: "https://example.test",
+            fetch,
+        });
+
+        await adapter.initSession({
+            sessionId: "call-1",
+            userId: "user-1",
+            provider: "openai-realtime",
+            modelId: "gpt-realtime-1.5",
+        });
+        const target = await adapter.createAssetUpload({
+            recordingSessionId: "rec-1",
+            sessionId: "call-1",
+            kind: "mixed",
+            mimeType: "audio/webm",
+            byteSize: 12,
+        });
+        await adapter.uploadBinary(target, new Blob(["hello"], { type: "audio/webm" }));
+        const manifest = await adapter.completeSession({
+            recordingSessionId: "rec-1",
+            sessionId: "call-1",
+            status: "completed",
+            assets: [],
+        });
+
+        expect(fetch).toHaveBeenCalledTimes(4);
+        expect(manifest.status).toBe("completed");
+    });
+});

package/src/backend-adapter.ts

@@ -0,0 +1,93 @@
+import type {
+    VoiceRecordingAdapter,
+    VoiceRecordingManifest,
+    VoiceRecordingSessionMetadata,
+    VoiceRecordingUploadAssetInput,
+    VoiceRecordingUploadTarget,
+} from "./types";
+
+function trimTrailingSlash(value: string) {
+    return value.replace(/\/+$/, "");
+}
+
+export function createVoiceRecordingBackendAdapter(config: {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    endpoints?: {
+        init?: string;
+        complete?: (recordingSessionId: string) => string;
+        createAsset?: (recordingSessionId: string) => string;
+        manifest?: (sessionId: string) => string;
+    };
+}): VoiceRecordingAdapter {
+    const baseUrl = trimTrailingSlash(config.baseUrl);
+    const fetchImpl = config.fetch ?? fetch;
+
+    const endpoint = {
+        init: config.endpoints?.init ?? "/api/kognitive/cognitive/voice/recordings/sessions/init",
+        complete: config.endpoints?.complete ?? ((recordingSessionId: string) => `/api/kognitive/cognitive/voice/recordings/sessions/${encodeURIComponent(recordingSessionId)}/complete`),
+        createAsset: config.endpoints?.createAsset ?? ((recordingSessionId: string) => `/api/kognitive/cognitive/voice/recordings/sessions/${encodeURIComponent(recordingSessionId)}/assets`),
+        manifest: config.endpoints?.manifest ?? ((sessionId: string) => `/api/kognitive/cognitive/voice/recordings/sessions/${encodeURIComponent(sessionId)}`),
+    };
+
+    const requestJson = async <T>(url: string, init?: RequestInit): Promise<T> => {
+        const response = await fetchImpl(`${baseUrl}${url}`, {
+            ...init,
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.headers ?? {}),
+                ...(init?.headers ?? {}),
+            },
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            throw new Error((payload as { error?: string }).error ?? `Voice recording request failed (${response.status})`);
+        }
+        return payload as T;
+    };
+
+    return {
+        async initSession(input: VoiceRecordingSessionMetadata) {
+            const payload = await requestJson<{ recordingSessionId: string; sessionDbId?: string | null }>(endpoint.init, {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+            return payload;
+        },
+        async createAssetUpload(input: Omit<VoiceRecordingUploadAssetInput, "blob">): Promise<VoiceRecordingUploadTarget> {
+            return requestJson<VoiceRecordingUploadTarget>(endpoint.createAsset(input.recordingSessionId), {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+        },
+        async uploadBinary(target: VoiceRecordingUploadTarget, blob: Blob) {
+            const response = await fetchImpl(target.uploadUrl, {
+                method: "PUT",
+                headers: target.uploadHeaders,
+                body: blob,
+            });
+            if (!response.ok) {
+                throw new Error(`Voice recording upload failed (${response.status})`);
+            }
+        },
+        async completeSession(input) {
+            return requestJson<VoiceRecordingManifest>(endpoint.complete(input.recordingSessionId), {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+        },
+        async fetchManifest(sessionId: string) {
+            const response = await fetchImpl(`${baseUrl}${endpoint.manifest(sessionId)}`, {
+                headers: config.headers,
+            });
+            if (response.status === 404) return null;
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                throw new Error((payload as { error?: string }).error ?? `Voice recording manifest request failed (${response.status})`);
+            }
+            return payload as VoiceRecordingManifest;
+        },
+    };
+}
+

package/src/controller.ts

@@ -0,0 +1,277 @@
+import type {
+    VoiceRecordingAdapter,
+    VoiceRecordingAsset,
+    VoiceRecordingAssetKind,
+    VoiceRecordingController,
+    VoiceRecordingControllerState,
+    VoiceRecordingManifest,
+    VoiceRecordingSessionMetadata,
+} from "./types";
+import { encodePcm16Wav } from "./wav";
+
+type AttachedSources = {
+    inputStream?: MediaStream | null;
+    outputStream?: MediaStream | null;
+    mixedStream?: MediaStream | null;
+};
+
+function detectMixedMimeType() {
+    const candidates = [
+        "audio/webm;codecs=opus",
+        "audio/webm",
+        "audio/ogg;codecs=opus",
+    ];
+    for (const candidate of candidates) {
+        if (typeof MediaRecorder !== "undefined" && MediaRecorder.isTypeSupported(candidate)) {
+            return candidate;
+        }
+    }
+    return "";
+}
+
+async function computeChecksum(blob: Blob) {
+    const buffer = await blob.arrayBuffer();
+    const digest = await crypto.subtle.digest("SHA-256", buffer);
+    return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+function buildMixedStream(inputStream?: MediaStream | null, outputStream?: MediaStream | null) {
+    if (!inputStream && !outputStream) return null;
+    const context = new AudioContext();
+    const destination = context.createMediaStreamDestination();
+    if (inputStream) {
+        const source = context.createMediaStreamSource(inputStream);
+        source.connect(destination);
+    }
+    if (outputStream) {
+        const source = context.createMediaStreamSource(outputStream);
+        source.connect(destination);
+    }
+    return {
+        context,
+        stream: destination.stream,
+    };
+}
+
+function createMixedRecorder(stream: MediaStream, mimeType: string) {
+    const chunks: BlobPart[] = [];
+    const recorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined);
+    const done = new Promise<Blob>((resolve) => {
+        recorder.addEventListener("dataavailable", (event) => {
+            if (event.data && event.data.size > 0) {
+                chunks.push(event.data);
+            }
+        });
+        recorder.addEventListener("stop", () => {
+            resolve(new Blob(chunks, { type: recorder.mimeType || mimeType || "audio/webm" }));
+        });
+    });
+    recorder.start(1000);
+    return {
+        stop: async () => {
+            recorder.stop();
+            return done;
+        },
+    };
+}
+
+function createPcmCapture(stream: MediaStream) {
+    const context = new AudioContext();
+    const source = context.createMediaStreamSource(stream);
+    const processor = context.createScriptProcessor(4096, 1, 1);
+    const chunks: Float32Array[] = [];
+    let sampleCount = 0;
+    processor.onaudioprocess = (event) => {
+        const input = event.inputBuffer.getChannelData(0);
+        const copy = new Float32Array(input.length);
+        copy.set(input);
+        chunks.push(copy);
+        sampleCount += copy.length;
+    };
+    source.connect(processor);
+    processor.connect(context.destination);
+    return {
+        stop: async () => {
+            processor.disconnect();
+            source.disconnect();
+            await context.close().catch(() => {});
+            const samples = new Float32Array(sampleCount);
+            let offset = 0;
+            for (const chunk of chunks) {
+                samples.set(chunk, offset);
+                offset += chunk.length;
+            }
+            const bytes = encodePcm16Wav(samples, context.sampleRate, 1);
+            const wavBuffer = new Uint8Array(bytes.byteLength);
+            wavBuffer.set(bytes);
+            return {
+                blob: new Blob([wavBuffer.buffer], { type: "audio/wav" }),
+                sampleRate: context.sampleRate,
+                durationMs: sampleCount > 0 ? Math.round((sampleCount / context.sampleRate) * 1000) : 0,
+                channels: 1,
+            };
+        },
+    };
+}
+
+export function createVoiceRecordingController(config: {
+    adapter: VoiceRecordingAdapter;
+}): VoiceRecordingController {
+    let sources: AttachedSources = {};
+    let metadata: VoiceRecordingSessionMetadata | null = null;
+    let recordingSessionId: string | null = null;
+    let state: VoiceRecordingControllerState = { status: "idle", manifest: null, lastError: null };
+    let startedAt = 0;
+    let inputCapture: ReturnType<typeof createPcmCapture> | null = null;
+    let outputCapture: ReturnType<typeof createPcmCapture> | null = null;
+    let mixedRecorder: ReturnType<typeof createMixedRecorder> | null = null;
+    let mixedContext: { context: AudioContext; stream: MediaStream } | null = null;
+
+    const setState = (patch: Partial<VoiceRecordingControllerState>) => {
+        state = {
+            ...state,
+            ...patch,
+        };
+    };
+
+    const uploadAsset = async (kind: VoiceRecordingAssetKind, blob: Blob, extra: {
+        durationMs?: number | null;
+        sampleRate?: number | null;
+        channels?: number | null;
+    } = {}): Promise<Omit<VoiceRecordingAsset, "playbackUrl"> | null> => {
+        if (!recordingSessionId || !metadata || blob.size === 0) return null;
+        const checksum = await computeChecksum(blob);
+        const target = await config.adapter.createAssetUpload({
+            recordingSessionId,
+            sessionId: metadata.sessionId,
+            kind,
+            mimeType: blob.type || (kind === "mixed" ? "audio/webm" : "audio/wav"),
+            byteSize: blob.size,
+            durationMs: extra.durationMs ?? null,
+            sampleRate: extra.sampleRate ?? null,
+            channels: extra.channels ?? null,
+            checksum,
+        });
+        await config.adapter.uploadBinary(target, blob);
+        return {
+            id: target.assetId,
+            kind,
+            mimeType: blob.type || (kind === "mixed" ? "audio/webm" : "audio/wav"),
+            byteSize: blob.size,
+            durationMs: extra.durationMs ?? null,
+            sampleRate: extra.sampleRate ?? null,
+            channels: extra.channels ?? null,
+            checksum,
+            storageKey: target.storageKey,
+        };
+    };
+
+    return {
+        attachSources(nextSources) {
+            sources = nextSources;
+        },
+        async start(nextMetadata) {
+            if (state.status === "recording") return;
+            metadata = nextMetadata;
+            setState({ status: "initializing", lastError: null });
+            try {
+                const initialized = await config.adapter.initSession(nextMetadata);
+                recordingSessionId = initialized.recordingSessionId;
+                startedAt = Date.now();
+
+                inputCapture = sources.inputStream ? createPcmCapture(sources.inputStream) : null;
+                outputCapture = sources.outputStream ? createPcmCapture(sources.outputStream) : null;
+
+                const mixedStream = sources.mixedStream ?? (() => {
+                    mixedContext = buildMixedStream(sources.inputStream, sources.outputStream);
+                    return mixedContext?.stream ?? null;
+                })();
+                const mimeType = detectMixedMimeType();
+                mixedRecorder = mixedStream && typeof MediaRecorder !== "undefined"
+                    ? createMixedRecorder(mixedStream, mimeType)
+                    : null;
+
+                setState({ status: "recording" });
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                setState({ status: "failed", lastError: message });
+                throw error;
+            }
+        },
+        async stop(reason) {
+            if (!metadata || !recordingSessionId) return state.manifest ?? null;
+            if (state.status !== "recording" && state.status !== "failed") return state.manifest ?? null;
+            setState({ status: "stopping" });
+            try {
+                const assets = (await Promise.all([
+                    mixedRecorder
+                        ? mixedRecorder.stop().then((blob) => uploadAsset("mixed", blob, {
+                            durationMs: Date.now() - startedAt,
+                            channels: 2,
+                        }))
+                        : Promise.resolve(null),
+                    inputCapture
+                        ? inputCapture.stop().then((result) => uploadAsset("user_input", result.blob, result))
+                        : Promise.resolve(null),
+                    outputCapture
+                        ? outputCapture.stop().then((result) => uploadAsset("assistant_output", result.blob, result))
+                        : Promise.resolve(null),
+                ])).filter(Boolean) as Array<Omit<VoiceRecordingAsset, "playbackUrl">>;
+                await mixedContext?.context.close().catch(() => {});
+                mixedContext = null;
+                const manifest = await config.adapter.completeSession({
+                    recordingSessionId,
+                    sessionId: metadata.sessionId,
+                    status: reason === "abort" ? "aborted" : "completed",
+                    totalDurationMs: Date.now() - startedAt,
+                    assets,
+                });
+                setState({
+                    status: manifest.status === "completed" ? "completed" : manifest.status === "aborted" ? "aborted" : "failed",
+                    manifest,
+                });
+                return manifest;
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                setState({ status: "failed", lastError: message });
+                await config.adapter.completeSession({
+                    recordingSessionId,
+                    sessionId: metadata.sessionId,
+                    status: "failed",
+                    totalDurationMs: Date.now() - startedAt,
+                    assets: [],
+                    errorMessage: message,
+                }).catch(() => {});
+                throw error;
+            }
+        },
+        async flush() {
+            return this.stop("flush");
+        },
+        async abort() {
+            if (!metadata || !recordingSessionId) {
+                setState({ status: "aborted" });
+                return;
+            }
+            await Promise.allSettled([
+                inputCapture?.stop(),
+                outputCapture?.stop(),
+                mixedRecorder?.stop(),
+            ]);
+            await mixedContext?.context.close().catch(() => {});
+            mixedContext = null;
+            const manifest = await config.adapter.completeSession({
+                recordingSessionId,
+                sessionId: metadata.sessionId,
+                status: "aborted",
+                totalDurationMs: Date.now() - startedAt,
+                assets: [],
+                errorMessage: "aborted",
+            }).catch(() => null);
+            setState({ status: "aborted", manifest });
+        },
+        getState() {
+            return state;
+        },
+    };
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./tokens";
+export { createVoiceRecordingBackendAdapter } from "./backend-adapter";
+export { createVoiceRecordingController } from "./controller";

package/src/tokens.ts

@@ -0,0 +1,63 @@
+function getSecret(secret?: string) {
+    return secret || process.env.VOICE_RECORDING_SIGNING_SECRET || "kognitive-voice-recording-secret";
+}
+
+function encodeBase64Url(value: string) {
+    return Buffer.from(value, "utf8").toString("base64url");
+}
+
+function decodeBase64Url(value: string) {
+    return Buffer.from(value, "base64url").toString("utf8");
+}
+
+async function sign(value: string, secret?: string) {
+    const key = await crypto.subtle.importKey(
+        "raw",
+        new TextEncoder().encode(getSecret(secret)),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"],
+    );
+    const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(value));
+    return Buffer.from(signature).toString("base64url");
+}
+
+export interface VoiceRecordingSignedTokenPayload {
+    assetId: string;
+    storageKey: string;
+    projectId: string;
+    operation: "upload" | "download";
+    exp: number;
+}
+
+export async function createVoiceRecordingSignedToken(
+    payload: VoiceRecordingSignedTokenPayload,
+    secret?: string,
+) {
+    const encodedPayload = encodeBase64Url(JSON.stringify(payload));
+    const signature = await sign(encodedPayload, secret);
+    return `${encodedPayload}.${signature}`;
+}
+
+export async function verifyVoiceRecordingSignedToken(
+    token: string | null | undefined,
+    secret?: string,
+): Promise<VoiceRecordingSignedTokenPayload | null> {
+    if (!token) return null;
+    const [encodedPayload, signature] = token.split(".");
+    if (!encodedPayload || !signature) return null;
+    const expected = await sign(encodedPayload, secret);
+    if (expected !== signature) return null;
+
+    try {
+        const parsed = JSON.parse(decodeBase64Url(encodedPayload)) as Partial<VoiceRecordingSignedTokenPayload>;
+        if (!parsed.assetId || !parsed.storageKey || !parsed.projectId || !parsed.operation || !parsed.exp) {
+            return null;
+        }
+        if (parsed.exp < Date.now()) return null;
+        return parsed as VoiceRecordingSignedTokenPayload;
+    } catch {
+        return null;
+    }
+}
+

package/src/types.ts

@@ -0,0 +1,106 @@
+export type VoiceRecordingAssetKind = "mixed" | "user_input" | "assistant_output" | "manager_input";
+
+export interface VoiceRecordingSessionMetadata {
+    sessionId: string;
+    userId: string;
+    provider: string;
+    modelId: string;
+    voice?: string | null;
+    transport?: string | null;
+    metadata?: Record<string, unknown>;
+    consent?: {
+        recordingEnabled?: boolean;
+        consentGranted?: boolean;
+    };
+}
+
+export interface VoiceRecordingAsset {
+    id: string;
+    kind: VoiceRecordingAssetKind;
+    mimeType: string;
+    byteSize: number;
+    durationMs?: number | null;
+    sampleRate?: number | null;
+    channels?: number | null;
+    checksum?: string | null;
+    storageKey: string;
+    playbackUrl?: string | null;
+}
+
+export interface VoiceRecordingManifest {
+    recordingSessionId: string;
+    sessionId: string;
+    sessionDbId?: string | null;
+    status: "pending" | "recording" | "uploading" | "completed" | "failed" | "aborted";
+    provider: string;
+    modelId: string;
+    voice?: string | null;
+    transport?: string | null;
+    totalDurationMs?: number | null;
+    consent?: {
+        recordingEnabled?: boolean;
+        consentGranted?: boolean;
+    } | null;
+    summary?: {
+        hasAssets: boolean;
+        assetKinds: VoiceRecordingAssetKind[];
+    };
+    assets: VoiceRecordingAsset[];
+}
+
+export interface VoiceRecordingUploadTarget {
+    assetId: string;
+    storageKey: string;
+    uploadUrl: string;
+    uploadHeaders?: Record<string, string>;
+}
+
+export interface VoiceRecordingUploadAssetInput {
+    recordingSessionId: string;
+    sessionId: string;
+    kind: VoiceRecordingAssetKind;
+    blob: Blob;
+    mimeType: string;
+    byteSize: number;
+    durationMs?: number | null;
+    sampleRate?: number | null;
+    channels?: number | null;
+    checksum?: string | null;
+}
+
+export interface VoiceRecordingAdapter {
+    initSession(input: VoiceRecordingSessionMetadata): Promise<{
+        recordingSessionId: string;
+        sessionDbId?: string | null;
+    }>;
+    createAssetUpload(input: Omit<VoiceRecordingUploadAssetInput, "blob">): Promise<VoiceRecordingUploadTarget>;
+    uploadBinary(target: VoiceRecordingUploadTarget, blob: Blob): Promise<void>;
+    completeSession(input: {
+        recordingSessionId: string;
+        sessionId: string;
+        status: "completed" | "failed" | "aborted";
+        totalDurationMs?: number | null;
+        assets: Array<Omit<VoiceRecordingAsset, "playbackUrl">>;
+        errorMessage?: string | null;
+    }): Promise<VoiceRecordingManifest>;
+    fetchManifest(sessionId: string): Promise<VoiceRecordingManifest | null>;
+}
+
+export interface VoiceRecordingControllerState {
+    status: "idle" | "initializing" | "recording" | "stopping" | "completed" | "failed" | "aborted";
+    manifest?: VoiceRecordingManifest | null;
+    lastError?: string | null;
+}
+
+export interface VoiceRecordingController {
+    attachSources(sources: {
+        inputStream?: MediaStream | null;
+        outputStream?: MediaStream | null;
+        mixedStream?: MediaStream | null;
+    }): void;
+    start(metadata: VoiceRecordingSessionMetadata): Promise<void>;
+    stop(reason?: string): Promise<VoiceRecordingManifest | null>;
+    flush(): Promise<VoiceRecordingManifest | null>;
+    abort(reason?: string): Promise<void>;
+    getState(): VoiceRecordingControllerState;
+}

package/src/wav.ts

@@ -0,0 +1,42 @@
+function clamp(sample: number) {
+    return Math.max(-1, Math.min(1, sample));
+}
+
+export function encodePcm16Wav(samples: Float32Array, sampleRate: number, channels = 1): Uint8Array {
+    const bytesPerSample = 2;
+    const blockAlign = channels * bytesPerSample;
+    const byteRate = sampleRate * blockAlign;
+    const dataSize = samples.length * bytesPerSample;
+    const buffer = new ArrayBuffer(44 + dataSize);
+    const view = new DataView(buffer);
+
+    const writeString = (offset: number, value: string) => {
+        for (let index = 0; index < value.length; index += 1) {
+            view.setUint8(offset + index, value.charCodeAt(index));
+        }
+    };
+
+    writeString(0, "RIFF");
+    view.setUint32(4, 36 + dataSize, true);
+    writeString(8, "WAVE");
+    writeString(12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, channels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, byteRate, true);
+    view.setUint16(32, blockAlign, true);
+    view.setUint16(34, 16, true);
+    writeString(36, "data");
+    view.setUint32(40, dataSize, true);
+
+    let offset = 44;
+    for (let index = 0; index < samples.length; index += 1) {
+        const value = clamp(samples[index] ?? 0);
+        view.setInt16(offset, value < 0 ? value * 0x8000 : value * 0x7fff, true);
+        offset += 2;
+    }
+
+    return new Uint8Array(buffer);
+}
+

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "noEmit": false,
+    "incremental": false
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "src/__tests__"
+  ]
+}