@hussmartinez/audio-sdk 0.0.0-stage → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js ADDED
@@ -0,0 +1,1453 @@
1
+ import { SdkError, applyCommands, checkFile, coreLimits, createErrorHelpers, createHistory, createStore, createWorkerClient, defineLimits, defineMessages, isSdkError, locate, plural, resolveAssetsBase, sdkCoreMessages, sequenceOffsets, withProcessingTime } from "@hussmartinez/sdk-core";
2
+ // src/core/errors/audio-error.ts
3
+ var AudioError = class extends SdkError {
4
+ name = "AudioError";
5
+ };
6
+ function isAudioError(value, code) {
7
+ return isSdkError(value, code) && value.name === "AudioError";
8
+ }
9
+ // src/core/errors/abort.ts
10
+ var { adapt: asAudioError, abortError, throwIfAborted } = /* @__PURE__ */ createErrorHelpers(AudioError, {
11
+ fallbackCode: "UNKNOWN",
12
+ fallbackMessage: "Audio processing failed."
13
+ });
14
+ var LEVEL_FACTOR = 4;
15
+ function buildPyramid(finest, bucket = 256) {
16
+ const levels = [];
17
+ let current = finest;
18
+ let framesPerBucket = bucket;
19
+ for (;;) {
20
+ levels.push({
21
+ framesPerBucket,
22
+ channels: current.min.map((min, c) => ({
23
+ min,
24
+ max: current.max[c]
25
+ }))
26
+ });
27
+ if ((current.min[0]?.length ?? 0) <= 1) break;
28
+ current = {
29
+ min: current.min.map((values) => combine(values, Math.min)),
30
+ max: current.max.map((values) => combine(values, Math.max))
31
+ };
32
+ framesPerBucket *= LEVEL_FACTOR;
33
+ }
34
+ return { levels };
35
+ }
36
+ function combine(values, pick) {
37
+ const out = new Float32Array(Math.ceil(values.length / LEVEL_FACTOR));
38
+ for (let i = 0; i < out.length; i += 1) {
39
+ let value = values[i * LEVEL_FACTOR];
40
+ const end = Math.min(values.length, (i + 1) * LEVEL_FACTOR);
41
+ for (let j = i * LEVEL_FACTOR + 1; j < end; j += 1) value = pick(value, values[j]);
42
+ out[i] = value;
43
+ }
44
+ return out;
45
+ }
46
+ // src/adapters/web-audio/platform-decode.ts
47
+ var webAudioDecoder = (bytes, { sampleRate, channels }) => {
48
+ const Offline = globalThis.OfflineAudioContext;
49
+ if (typeof Offline !== "function") throw new AudioError("UNSUPPORTED_ENVIRONMENT", "Web Audio isn't available.", { details: { feature: "OfflineAudioContext" } });
50
+ let context;
51
+ try {
52
+ context = new Offline({
53
+ numberOfChannels: channels,
54
+ length: 1,
55
+ sampleRate
56
+ });
57
+ } catch (error) {
58
+ throw new AudioError("UNSUPPORTED_FORMAT", "This browser can't decode at this rate.", {
59
+ details: { sampleRate },
60
+ cause: error
61
+ });
62
+ }
63
+ return context.decodeAudioData(bytes);
64
+ };
65
+ function untilAborted(work, signal) {
66
+ work.catch(() => {});
67
+ if (!signal) return work;
68
+ return new Promise((resolve, reject) => {
69
+ const onAbort = () => reject(abortError(signal));
70
+ if (signal.aborted) {
71
+ onAbort();
72
+ return;
73
+ }
74
+ signal.addEventListener("abort", onAbort, { once: true });
75
+ work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
76
+ });
77
+ }
78
+ async function decodeOnPage(file, probe, decoder, createBuffer, signal) {
79
+ const { container, codec, sampleRate, channels, frameBound, frameTolerance } = probe;
80
+ throwIfAborted(signal);
81
+ const bytes = await untilAborted(file.arrayBuffer(), signal);
82
+ let decoded;
83
+ try {
84
+ decoded = await untilAborted(Promise.resolve().then(() => decoder(bytes, {
85
+ sampleRate,
86
+ channels
87
+ })), signal);
88
+ } catch (error) {
89
+ if (isAudioError(error)) throw error;
90
+ throw new AudioError("DECODE_FAILED", "The browser couldn't decode this file.", {
91
+ details: {
92
+ container,
93
+ codec
94
+ },
95
+ cause: error
96
+ });
97
+ }
98
+ if (decoded.length === 0) throw new AudioError("DECODE_FAILED", "The browser decoded no audio from this file.", { details: {
99
+ container,
100
+ codec,
101
+ reason: "no audio decoded"
102
+ } });
103
+ const invalid = (reason) => new AudioError("INVALID_AUDIO", `The decoded audio ${reason}.`, { details: {
104
+ container,
105
+ codec,
106
+ reason: `decoded ${reason}`
107
+ } });
108
+ if (decoded.sampleRate !== sampleRate) throw invalid("rate differs from the probe");
109
+ if (decoded.numberOfChannels > channels) throw invalid("channel count exceeds the probe");
110
+ if (decoded.length > frameBound + frameTolerance) throw invalid("length exceeds the bound");
111
+ if (decoded.length <= frameBound) return decoded;
112
+ const capped = createBuffer({
113
+ numberOfChannels: decoded.numberOfChannels,
114
+ length: frameBound,
115
+ sampleRate
116
+ });
117
+ for (let c = 0; c < decoded.numberOfChannels; c += 1) capped.copyToChannel(decoded.getChannelData(c).subarray(0, frameBound), c, 0);
118
+ return capped;
119
+ }
120
+ // src/adapters/audio-engine.ts
121
+ var BLOCK_FRAMES = 65536;
122
+ function createAudioEngine(options = {}) {
123
+ const selfHosted = options.assetsUrl === void 0 ? void 0 : new URL("audio/audio.worker.js", resolveAssetsBase(options.assetsUrl)).href;
124
+ return createEngine({
125
+ loadWorker: selfHosted ? async () => () => new Worker(selfHosted, {
126
+ type: "module",
127
+ name: "hm-audio"
128
+ }) : async () => (await import("./lazy/inline-worker-CkUV_wKW.js")).createInlineWorker,
129
+ version: "0.2.0",
130
+ ...selfHosted ? { asset: selfHosted } : {},
131
+ createBuffer: (bufferOptions) => new AudioBuffer(bufferOptions),
132
+ decodePlatform: webAudioDecoder,
133
+ ...options.idleTimeout === void 0 ? {} : { idleTimeout: options.idleTimeout }
134
+ });
135
+ }
136
+ function createEngine(environment) {
137
+ let startWorker;
138
+ let destroyed = false;
139
+ const layouts = /* @__PURE__ */ new WeakMap();
140
+ const compressedProbes = /* @__PURE__ */ new WeakSet();
141
+ const finestPeaks = /* @__PURE__ */ new WeakMap();
142
+ const newClient = () => createWorkerClient({
143
+ createWorker: () => {
144
+ if (!startWorker) throw new AudioError("WORKER_START_FAILED", "The audio worker hasn't loaded.");
145
+ return startWorker();
146
+ },
147
+ errorClasses: { AudioError },
148
+ packageVersion: environment.version,
149
+ ...environment.asset === void 0 ? {} : { workerAsset: environment.asset },
150
+ ...environment.idleTimeout === void 0 ? {} : { idleTimeout: environment.idleTimeout }
151
+ });
152
+ let main;
153
+ let analysis;
154
+ async function ready() {
155
+ if (destroyed) throw new Error("The audio engine has been destroyed.");
156
+ startWorker ??= await environment.loadWorker();
157
+ }
158
+ async function run(work) {
159
+ try {
160
+ return await work();
161
+ } catch (error) {
162
+ throw error instanceof RangeError || error instanceof TypeError ? error : asAudioError(error);
163
+ }
164
+ }
165
+ async function reprobe(file, probe, signal) {
166
+ main ??= newClient();
167
+ const fresh = await main.call("probe", { file }, signal ? { signal } : {});
168
+ if (!(fresh.probe.codec === probe.codec && fresh.probe.sampleRate === probe.sampleRate && fresh.probe.channels === probe.channels && fresh.probe.frameBound === probe.frameBound)) throw new AudioError("INVALID_AUDIO", "The probe doesn't describe this file.", { details: { container: probe.container } });
169
+ return fresh.probe;
170
+ }
171
+ async function layoutOf(file, probe, signal) {
172
+ const known = layouts.get(probe);
173
+ if (known) return known;
174
+ main ??= newClient();
175
+ const fresh = await main.call("probe", { file }, signal ? { signal } : {});
176
+ if (!(fresh.probe.sampleRate === probe.sampleRate && fresh.probe.channels === probe.channels && fresh.probe.frameBound === probe.frameBound)) throw new AudioError("INVALID_AUDIO", "The probe doesn't describe this file.", { details: { container: probe.container } });
177
+ if (!fresh.layout) throw new AudioError("UNSUPPORTED_FORMAT", "Compressed formats aren't supported yet.", { details: {
178
+ container: probe.container,
179
+ codec: probe.codec
180
+ } });
181
+ return fresh.layout;
182
+ }
183
+ return {
184
+ probe(file, options = {}) {
185
+ return run(async () => {
186
+ throwIfAborted(options.signal);
187
+ await ready();
188
+ main ??= newClient();
189
+ const result = await main.call("probe", { file }, options.signal ? { signal: options.signal } : {});
190
+ if (result.layout) layouts.set(result.probe, result.layout);
191
+ else compressedProbes.add(result.probe);
192
+ return result.probe;
193
+ });
194
+ },
195
+ decode(file, probe, options = {}) {
196
+ return run(async () => {
197
+ throwIfAborted(options.signal);
198
+ await ready();
199
+ if (probe.codec !== "pcm") {
200
+ const audio = await decodeOnPage(file, compressedProbes.has(probe) ? probe : await reprobe(file, probe, options.signal), environment.decodePlatform, environment.createBuffer, options.signal);
201
+ options.onProgress?.(1);
202
+ return audio;
203
+ }
204
+ const layout = await layoutOf(file, probe, options.signal);
205
+ const { frames, channels, sampleRate } = layout;
206
+ let buffer;
207
+ try {
208
+ buffer = environment.createBuffer({
209
+ numberOfChannels: channels,
210
+ length: frames,
211
+ sampleRate
212
+ });
213
+ } catch (error) {
214
+ throw new AudioError("UNSUPPORTED_FORMAT", "This browser can't hold audio at this rate.", {
215
+ details: {
216
+ container: layout.container,
217
+ sampleRate
218
+ },
219
+ cause: error
220
+ });
221
+ }
222
+ const buckets = Math.ceil(frames / 256);
223
+ const peaks = {
224
+ min: Array.from({ length: channels }, () => new Float32Array(buckets)),
225
+ max: Array.from({ length: channels }, () => new Float32Array(buckets))
226
+ };
227
+ main ??= newClient();
228
+ for (let start = 0; start < frames; start += BLOCK_FRAMES) {
229
+ const block = await main.call("readBlock", {
230
+ file,
231
+ layout,
232
+ start,
233
+ frames: Math.min(BLOCK_FRAMES, frames - start),
234
+ bucket: 256
235
+ }, options.signal ? { signal: options.signal } : {});
236
+ const at = start / 256;
237
+ for (let c = 0; c < channels; c += 1) {
238
+ buffer.copyToChannel(block.channels[c], c, start);
239
+ peaks.min[c]?.set(block.min[c], at);
240
+ peaks.max[c]?.set(block.max[c], at);
241
+ }
242
+ options.onProgress?.(Math.min(start + BLOCK_FRAMES, frames) / frames);
243
+ }
244
+ if (frames === 0) options.onProgress?.(1);
245
+ finestPeaks.set(buffer, peaks);
246
+ return buffer;
247
+ });
248
+ },
249
+ peaks(audio, options = {}) {
250
+ return run(async () => {
251
+ throwIfAborted(options.signal);
252
+ const known = finestPeaks.get(audio);
253
+ if (known) return buildPyramid(known, 256);
254
+ await ready();
255
+ analysis ??= newClient();
256
+ const buckets = Math.ceil(audio.length / 256);
257
+ const peaks = {
258
+ min: Array.from({ length: audio.numberOfChannels }, () => new Float32Array(buckets)),
259
+ max: Array.from({ length: audio.numberOfChannels }, () => new Float32Array(buckets))
260
+ };
261
+ for (let start = 0; start < audio.length; start += BLOCK_FRAMES) {
262
+ const end = Math.min(audio.length, start + BLOCK_FRAMES);
263
+ const channels = Array.from({ length: audio.numberOfChannels }, (_, c) => audio.getChannelData(c).slice(start, end));
264
+ const block = await analysis.call("peaks", {
265
+ channels,
266
+ bucket: 256
267
+ }, {
268
+ transfer: true,
269
+ ...options.signal ? { signal: options.signal } : {}
270
+ });
271
+ const at = start / 256;
272
+ for (let c = 0; c < audio.numberOfChannels; c += 1) {
273
+ peaks.min[c]?.set(block.min[c], at);
274
+ peaks.max[c]?.set(block.max[c], at);
275
+ }
276
+ }
277
+ finestPeaks.set(audio, peaks);
278
+ return buildPyramid(peaks, 256);
279
+ });
280
+ },
281
+ async destroy() {
282
+ destroyed = true;
283
+ main?.destroy();
284
+ analysis?.destroy();
285
+ }
286
+ };
287
+ }
288
+ // src/core/errors/audio-limits.ts
289
+ var audioLimitDefinitions = {
290
+ ...coreLimits,
291
+ maxFileSize: {
292
+ ...coreLimits.maxFileSize,
293
+ default: 1e9,
294
+ warning: 25e7
295
+ },
296
+ maxDecodedSize: {
297
+ ...coreLimits.maxDecodedSize,
298
+ default: 1e9,
299
+ warning: 4e8
300
+ },
301
+ maxDuration: {
302
+ code: "DURATION_TOO_LONG",
303
+ unit: "milliseconds",
304
+ default: 108e5,
305
+ warning: 36e5
306
+ },
307
+ maxChannels: {
308
+ code: "TOO_MANY_CHANNELS",
309
+ unit: "count",
310
+ default: 8
311
+ },
312
+ maxSampleRate: {
313
+ code: "SAMPLE_RATE_TOO_HIGH",
314
+ unit: "hertz",
315
+ default: 192e3
316
+ },
317
+ maxSessionSize: {
318
+ code: "SESSION_TOO_LARGE",
319
+ unit: "bytes",
320
+ default: 15e8,
321
+ warning: 75e7
322
+ },
323
+ maxClips: {
324
+ code: "TOO_MANY_CLIPS",
325
+ unit: "count",
326
+ default: 2e3
327
+ }
328
+ };
329
+ var audioLimits = /* @__PURE__ */ defineLimits(audioLimitDefinitions, { errorClass: AudioError });
330
+ // src/core/model/plan.ts
331
+ var EMPTY_METADATA = Object.freeze({
332
+ title: "",
333
+ artist: "",
334
+ album: "",
335
+ year: "",
336
+ comment: ""
337
+ });
338
+ var NO_FADE = Object.freeze({
339
+ frames: 0,
340
+ curve: "linear"
341
+ });
342
+ function clipLength(clip) {
343
+ return clip.end - clip.start;
344
+ }
345
+ function planLength(plan) {
346
+ let total = 0;
347
+ for (const clip of plan.clips) total += clipLength(clip);
348
+ return total;
349
+ }
350
+ function clipOffsets(plan) {
351
+ return clipBoundaries(plan).slice(0, -1);
352
+ }
353
+ function clipBoundaries(plan) {
354
+ return sequenceOffsets(plan.clips.map(clipLength));
355
+ }
356
+ var MIN_GAIN_DB = -120;
357
+ var MAX_GAIN_DB = 120;
358
+ var isFrames = (value) => Number.isSafeInteger(value) && value >= 0;
359
+ function clipProblem(clip, sourceFrames) {
360
+ if (![
361
+ clip.start,
362
+ clip.end,
363
+ clip.fadeIn.frames,
364
+ clip.fadeOut.frames
365
+ ].every(isFrames)) return "invalid-frames";
366
+ if (clip.end <= clip.start) return "clip-too-short";
367
+ if (clip.end > sourceFrames) return "clip-outside-source";
368
+ if (typeof clip.gainDb !== "number" || !(clip.gainDb >= -120 && clip.gainDb <= 120)) return "gain-out-of-range";
369
+ if (clip.fadeIn.frames + clip.fadeOut.frames > clipLength(clip)) return "fades-too-long";
370
+ }
371
+ // src/core/operations/commands.ts
372
+ var MAX_METADATA_LENGTH = 1e3;
373
+ var CURVES = /* @__PURE__ */ new Set(["linear", "equalPower"]);
374
+ var Invalid = class extends Error {
375
+ reason;
376
+ constructor(reason, message) {
377
+ super(message);
378
+ this.reason = reason;
379
+ }
380
+ };
381
+ function invalid(reason, message) {
382
+ throw new Invalid(reason, message);
383
+ }
384
+ function isRecord(value) {
385
+ return typeof value === "object" && value !== null;
386
+ }
387
+ function isKey(value) {
388
+ return typeof value === "string" && value.length > 0;
389
+ }
390
+ function isIndex(value, max) {
391
+ return Number.isSafeInteger(value) && value >= 0 && value <= max;
392
+ }
393
+ function fade(value, name) {
394
+ if (!isRecord(value)) invalid("malformed-command", `${name} isn't a fade`);
395
+ onlyFields(value, FADE_FIELDS, name);
396
+ if (typeof value.curve !== "string" || !CURVES.has(value.curve)) invalid("invalid-fade-curve", `${name}'s curve isn't linear or equalPower`);
397
+ return {
398
+ frames: value.frames,
399
+ curve: value.curve
400
+ };
401
+ }
402
+ var COMMAND_FIELDS = {
403
+ "audio.insertClips": [
404
+ "at",
405
+ "clips",
406
+ "splitKey"
407
+ ],
408
+ "audio.removeClips": ["keys"],
409
+ "audio.restoreClips": ["entries"],
410
+ "audio.replaceClips": [
411
+ "index",
412
+ "count",
413
+ "clips"
414
+ ],
415
+ "audio.updateClips": ["clips"],
416
+ "audio.deleteRange": [
417
+ "start",
418
+ "end",
419
+ "newKey"
420
+ ],
421
+ "audio.trimClip": [
422
+ "key",
423
+ "start",
424
+ "end"
425
+ ],
426
+ "audio.splitClip": [
427
+ "key",
428
+ "at",
429
+ "newKey"
430
+ ],
431
+ "audio.moveClips": ["keys", "to"],
432
+ "audio.reorderClips": ["order"],
433
+ "audio.setGain": ["keys", "gainDb"],
434
+ "audio.setFade": [
435
+ "key",
436
+ "edge",
437
+ "frames",
438
+ "curve"
439
+ ],
440
+ "audio.setMetadata": ["field", "value"]
441
+ };
442
+ var CLIP_FIELDS = [
443
+ "key",
444
+ "source",
445
+ "start",
446
+ "end",
447
+ "gainDb",
448
+ "fadeIn",
449
+ "fadeOut"
450
+ ];
451
+ var FADE_FIELDS = ["frames", "curve"];
452
+ var ENTRY_FIELDS = ["index", "clip"];
453
+ function onlyFields(value, allowed, what) {
454
+ for (const [field, content] of Object.entries(value)) if (content !== void 0 && !allowed.includes(field)) invalid("malformed-command", `${what} has no field ${field}`);
455
+ }
456
+ function optionalKey(value, name) {
457
+ if (value !== void 0 && !isKey(value)) invalid("malformed-command", `${name} must be a non-empty string`);
458
+ return value;
459
+ }
460
+ function checkClip(value, sourceFrames) {
461
+ if (!isRecord(value) || !isKey(value.key) || !isKey(value.source)) invalid("malformed-command", "a clip needs a key and a source");
462
+ onlyFields(value, CLIP_FIELDS, "a clip");
463
+ const clip = {
464
+ key: value.key,
465
+ source: value.source,
466
+ start: value.start,
467
+ end: value.end,
468
+ gainDb: value.gainDb,
469
+ fadeIn: fade(value.fadeIn, "fadeIn"),
470
+ fadeOut: fade(value.fadeOut, "fadeOut")
471
+ };
472
+ const frames = sourceFrames(clip.source);
473
+ if (frames === void 0) invalid("unknown-source", `the session has no source ${clip.source}`);
474
+ const problem = clipProblem(clip, frames);
475
+ if (problem) invalid(problem, `clip ${clip.key} isn't valid within its source`);
476
+ return clip;
477
+ }
478
+ function checkClips(values, sourceFrames) {
479
+ if (!Array.isArray(values)) invalid("malformed-command", "clips must be a list");
480
+ return values.map((value) => checkClip(value, sourceFrames));
481
+ }
482
+ function checkNewKeys(keys, existing) {
483
+ const taken = new Set(existing);
484
+ const seen = /* @__PURE__ */ new Set();
485
+ for (const key of keys) {
486
+ if (!isKey(key)) invalid("malformed-command", "a key must be a non-empty string");
487
+ if (taken.has(key)) invalid("key-taken", `the key ${key} is taken`);
488
+ if (seen.has(key)) invalid("duplicate-key", `the key ${key} appears twice`);
489
+ seen.add(key);
490
+ }
491
+ }
492
+ function positions(plan, keys) {
493
+ if (!Array.isArray(keys)) invalid("malformed-command", "keys must be a list");
494
+ if (keys.length === 0) invalid("no-clips", "it needs at least one clip");
495
+ const wanted = new Set(keys);
496
+ if (wanted.size !== keys.length) invalid("duplicate-key", "a clip appears twice");
497
+ const found = [];
498
+ plan.clips.forEach((clip, index) => {
499
+ if (wanted.has(clip.key)) found.push(index);
500
+ });
501
+ if (found.length !== wanted.size) invalid("unknown-clip", "the plan doesn't have every clip");
502
+ return found;
503
+ }
504
+ function position(plan, key) {
505
+ return positions(plan, [key])[0];
506
+ }
507
+ function fitFades(clip) {
508
+ const length = clipLength(clip);
509
+ const total = clip.fadeIn.frames + clip.fadeOut.frames;
510
+ if (total <= length || !(length > 0)) return clip;
511
+ return {
512
+ ...clip,
513
+ fadeIn: {
514
+ ...clip.fadeIn,
515
+ frames: Math.floor(clip.fadeIn.frames * length / total)
516
+ },
517
+ fadeOut: {
518
+ ...clip.fadeOut,
519
+ frames: Math.floor(clip.fadeOut.frames * length / total)
520
+ }
521
+ };
522
+ }
523
+ function part(clip, from, to, key) {
524
+ const length = clipLength(clip);
525
+ return fitFades({
526
+ ...clip,
527
+ key,
528
+ start: clip.start + from,
529
+ end: clip.start + to,
530
+ fadeIn: from === 0 ? clip.fadeIn : NO_FADE,
531
+ fadeOut: to === length ? clip.fadeOut : NO_FADE
532
+ });
533
+ }
534
+ function locate$1(plan, frame) {
535
+ if (!isIndex(frame, planLength(plan))) invalid("frame-outside-plan", "the frame is outside the plan");
536
+ const found = locate(clipBoundaries(plan), frame);
537
+ return found ? {
538
+ index: found.index,
539
+ offset: found.within
540
+ } : {
541
+ index: plan.clips.length,
542
+ offset: 0
543
+ };
544
+ }
545
+ function withClips(plan, clips) {
546
+ return {
547
+ ...plan,
548
+ clips
549
+ };
550
+ }
551
+ function splice(plan, index, count, clips) {
552
+ return withClips(plan, [
553
+ ...plan.clips.slice(0, index),
554
+ ...clips,
555
+ ...plan.clips.slice(index + count)
556
+ ]);
557
+ }
558
+ function updateByKey(plan, clips) {
559
+ const byKey = new Map(clips.map((clip) => [clip.key, clip]));
560
+ return withClips(plan, plan.clips.map((clip) => byKey.get(clip.key) ?? clip));
561
+ }
562
+ function apply(plan, command, sourceFrames) {
563
+ if (!isRecord(command)) invalid("malformed-command", "a command is an object");
564
+ const fields = Object.hasOwn(COMMAND_FIELDS, command.type) ? COMMAND_FIELDS[command.type] : void 0;
565
+ if (!fields) invalid("unknown-command", "unknown command");
566
+ onlyFields(command, ["type", ...fields], command.type);
567
+ switch (command.type) {
568
+ case "audio.insertClips": {
569
+ const clips = checkClips(command.clips, sourceFrames);
570
+ if (clips.length === 0) invalid("no-clips", "it needs at least one clip");
571
+ const keys = clips.map((clip) => clip.key);
572
+ checkNewKeys(keys, plan.clips.map((clip) => clip.key));
573
+ const splitKey = optionalKey(command.splitKey, "splitKey");
574
+ const { index, offset } = locate$1(plan, command.at);
575
+ if (offset === 0) return {
576
+ state: splice(plan, index, 0, clips),
577
+ inverse: {
578
+ type: "audio.replaceClips",
579
+ index,
580
+ count: clips.length,
581
+ clips: []
582
+ }
583
+ };
584
+ if (splitKey === void 0) invalid("new-key-required", "inserting inside a clip needs a splitKey");
585
+ checkNewKeys([splitKey], [...plan.clips.map((clip) => clip.key), ...keys]);
586
+ const split = plan.clips[index];
587
+ const parts = [
588
+ part(split, 0, offset, split.key),
589
+ ...clips,
590
+ part(split, offset, clipLength(split), splitKey)
591
+ ];
592
+ return {
593
+ state: splice(plan, index, 1, parts),
594
+ inverse: {
595
+ type: "audio.replaceClips",
596
+ index,
597
+ count: parts.length,
598
+ clips: [split]
599
+ }
600
+ };
601
+ }
602
+ case "audio.removeClips": {
603
+ const at = positions(plan, command.keys);
604
+ const removed = new Set(at);
605
+ return {
606
+ state: withClips(plan, plan.clips.filter((_, index) => !removed.has(index))),
607
+ inverse: {
608
+ type: "audio.restoreClips",
609
+ entries: at.map((index) => ({
610
+ index,
611
+ clip: plan.clips[index]
612
+ }))
613
+ }
614
+ };
615
+ }
616
+ case "audio.restoreClips": {
617
+ if (!Array.isArray(command.entries)) invalid("malformed-command", "entries must be a list");
618
+ if (command.entries.length === 0) invalid("no-clips", "it needs at least one clip");
619
+ const entries = command.entries.map((entry) => {
620
+ if (!isRecord(entry)) invalid("malformed-command", "an entry needs an index and a clip");
621
+ onlyFields(entry, ENTRY_FIELDS, "an entry");
622
+ return {
623
+ index: entry.index,
624
+ clip: checkClip(entry.clip, sourceFrames)
625
+ };
626
+ });
627
+ checkNewKeys(entries.map(({ clip }) => clip.key), plan.clips.map((clip) => clip.key));
628
+ const clips = [...plan.clips];
629
+ let previous = -1;
630
+ for (const { index, clip } of entries) {
631
+ if (!isIndex(index, clips.length) || index <= previous) invalid("invalid-index", `clip ${clip.key} can't be restored at index ${String(index)}`);
632
+ clips.splice(index, 0, clip);
633
+ previous = index;
634
+ }
635
+ return {
636
+ state: withClips(plan, clips),
637
+ inverse: {
638
+ type: "audio.removeClips",
639
+ keys: entries.map(({ clip }) => clip.key)
640
+ }
641
+ };
642
+ }
643
+ case "audio.replaceClips": {
644
+ const { index, count } = command;
645
+ if (!isIndex(index, plan.clips.length) || !isIndex(count, plan.clips.length - index)) invalid("invalid-index", "the run of clips is outside the plan");
646
+ const clips = checkClips(command.clips, sourceFrames);
647
+ if (count === 0 && clips.length === 0) invalid("empty-change", "it changes nothing");
648
+ const removed = plan.clips.slice(index, index + count);
649
+ checkNewKeys(clips.map((clip) => clip.key), [...plan.clips.slice(0, index), ...plan.clips.slice(index + count)].map((clip) => clip.key));
650
+ return {
651
+ state: splice(plan, index, count, clips),
652
+ inverse: {
653
+ type: "audio.replaceClips",
654
+ index,
655
+ count: clips.length,
656
+ clips: removed
657
+ }
658
+ };
659
+ }
660
+ case "audio.updateClips": {
661
+ const clips = checkClips(command.clips, sourceFrames);
662
+ const at = positions(plan, clips.map((clip) => clip.key));
663
+ return {
664
+ state: updateByKey(plan, clips),
665
+ inverse: {
666
+ type: "audio.updateClips",
667
+ clips: at.map((index) => plan.clips[index])
668
+ }
669
+ };
670
+ }
671
+ case "audio.deleteRange": {
672
+ const { start, end } = command;
673
+ const newKey = optionalKey(command.newKey, "newKey");
674
+ if (!isIndex(start, planLength(plan)) || !isIndex(end, planLength(plan))) invalid("frame-outside-plan", "the range must be inside the plan");
675
+ if (end <= start) invalid("empty-range", "the range must be at least one frame long");
676
+ const first = locate$1(plan, start);
677
+ const last = locate$1(plan, end - 1);
678
+ const firstClip = plan.clips[first.index];
679
+ const lastClip = plan.clips[last.index];
680
+ const kept = [];
681
+ if (first.offset > 0) kept.push(part(firstClip, 0, first.offset, firstClip.key));
682
+ if (last.offset + 1 < clipLength(lastClip)) {
683
+ let key = lastClip.key;
684
+ if (first.index === last.index && first.offset > 0) {
685
+ if (newKey === void 0) invalid("new-key-required", "deleting inside a clip needs a newKey");
686
+ checkNewKeys([newKey], plan.clips.map((clip) => clip.key));
687
+ key = newKey;
688
+ }
689
+ kept.push(part(lastClip, last.offset + 1, clipLength(lastClip), key));
690
+ }
691
+ const count = last.index - first.index + 1;
692
+ return {
693
+ state: splice(plan, first.index, count, kept),
694
+ inverse: {
695
+ type: "audio.replaceClips",
696
+ index: first.index,
697
+ count: kept.length,
698
+ clips: plan.clips.slice(first.index, first.index + count)
699
+ }
700
+ };
701
+ }
702
+ case "audio.trimClip": {
703
+ const index = position(plan, command.key);
704
+ const clip = plan.clips[index];
705
+ return {
706
+ state: updateByKey(plan, [checkClip(fitFades({
707
+ ...clip,
708
+ start: command.start,
709
+ end: command.end
710
+ }), sourceFrames)]),
711
+ inverse: {
712
+ type: "audio.updateClips",
713
+ clips: [clip]
714
+ }
715
+ };
716
+ }
717
+ case "audio.splitClip": {
718
+ const index = position(plan, command.key);
719
+ const clip = plan.clips[index];
720
+ const { index: within, offset } = locate$1(plan, command.at);
721
+ if (within !== index || offset === 0) invalid("not-inside-clip", "the frame must be strictly inside the clip");
722
+ checkNewKeys([command.newKey], plan.clips.map((entry) => entry.key));
723
+ return {
724
+ state: splice(plan, index, 1, [part(clip, 0, offset, clip.key), part(clip, offset, clipLength(clip), command.newKey)]),
725
+ inverse: {
726
+ type: "audio.replaceClips",
727
+ index,
728
+ count: 2,
729
+ clips: [clip]
730
+ }
731
+ };
732
+ }
733
+ case "audio.moveClips": {
734
+ const moved = new Set(positions(plan, command.keys));
735
+ const block = plan.clips.filter((_, index) => moved.has(index));
736
+ const rest = plan.clips.filter((_, index) => !moved.has(index));
737
+ if (!isIndex(command.to, rest.length)) invalid("invalid-index", "the clips can't move there");
738
+ return {
739
+ state: withClips(plan, [
740
+ ...rest.slice(0, command.to),
741
+ ...block,
742
+ ...rest.slice(command.to)
743
+ ]),
744
+ inverse: {
745
+ type: "audio.reorderClips",
746
+ order: plan.clips.map((clip) => clip.key)
747
+ }
748
+ };
749
+ }
750
+ case "audio.reorderClips": {
751
+ const { order } = command;
752
+ const byKey = new Map(plan.clips.map((clip) => [clip.key, clip]));
753
+ if (!Array.isArray(order) || order.length !== plan.clips.length || new Set(order).size !== order.length || order.some((key) => !byKey.has(key))) invalid("invalid-order", "the order must list every clip exactly once");
754
+ return {
755
+ state: withClips(plan, order.map((key) => byKey.get(key))),
756
+ inverse: {
757
+ type: "audio.reorderClips",
758
+ order: plan.clips.map((clip) => clip.key)
759
+ }
760
+ };
761
+ }
762
+ case "audio.setGain": {
763
+ const at = positions(plan, command.keys);
764
+ const gainDb = command.gainDb;
765
+ if (typeof gainDb !== "number" || !(gainDb >= -120 && gainDb <= 120)) invalid("gain-out-of-range", `gain must be from ${MIN_GAIN_DB} to 120 dB`);
766
+ const before = at.map((index) => plan.clips[index]);
767
+ return {
768
+ state: updateByKey(plan, before.map((clip) => ({
769
+ ...clip,
770
+ gainDb
771
+ }))),
772
+ inverse: {
773
+ type: "audio.updateClips",
774
+ clips: before
775
+ }
776
+ };
777
+ }
778
+ case "audio.setFade": {
779
+ const clip = plan.clips[position(plan, command.key)];
780
+ const { edge, frames } = command;
781
+ if (edge !== "in" && edge !== "out") invalid("invalid-edge", "the edge must be in or out");
782
+ const next = {
783
+ frames,
784
+ curve: fade({
785
+ frames,
786
+ curve: command.curve
787
+ }, "the fade").curve
788
+ };
789
+ return {
790
+ state: updateByKey(plan, [checkClip(edge === "in" ? {
791
+ ...clip,
792
+ fadeIn: next
793
+ } : {
794
+ ...clip,
795
+ fadeOut: next
796
+ }, sourceFrames)]),
797
+ inverse: {
798
+ type: "audio.updateClips",
799
+ clips: [clip]
800
+ }
801
+ };
802
+ }
803
+ case "audio.setMetadata": {
804
+ const { field, value } = command;
805
+ if (typeof field !== "string" || !Object.hasOwn(EMPTY_METADATA, field)) invalid("unknown-metadata-field", "there's no such metadata field");
806
+ if (typeof value !== "string") invalid("malformed-command", "a metadata value must be text");
807
+ if (value.length > 1e3) invalid("metadata-too-long", `a metadata value can have at most ${MAX_METADATA_LENGTH} characters`);
808
+ return {
809
+ state: {
810
+ ...plan,
811
+ metadata: {
812
+ ...plan.metadata,
813
+ [field]: value
814
+ }
815
+ },
816
+ inverse: {
817
+ type: "audio.setMetadata",
818
+ field,
819
+ value: plan.metadata[field]
820
+ }
821
+ };
822
+ }
823
+ default: return invalid("unknown-command", "unknown command");
824
+ }
825
+ }
826
+ function createPlanReducer(sourceFrames) {
827
+ return (plan, command) => {
828
+ try {
829
+ return apply(plan, command, sourceFrames);
830
+ } catch (error) {
831
+ if (!(error instanceof Invalid)) throw error;
832
+ const type = isRecord(command) && typeof command.type === "string" ? command.type : "";
833
+ const known = type.startsWith("audio.") && type.length <= 64;
834
+ throw new AudioError("INVALID_COMMAND", `Invalid ${known ? type : "command"}: ${error.message}.`, { details: known ? {
835
+ command: type,
836
+ reason: error.reason
837
+ } : { reason: error.reason } });
838
+ }
839
+ };
840
+ }
841
+ // src/core/format/plan-document.ts
842
+ var AUDIO_PLAN_FORMAT = "hm-audio-plan";
843
+ var AUDIO_PLAN_VERSION = 1;
844
+ var DOCUMENT_FIELDS = [
845
+ "format",
846
+ "version",
847
+ "sampleRate",
848
+ "channels",
849
+ "sources",
850
+ "clips",
851
+ "metadata"
852
+ ];
853
+ var SOURCE_FIELDS = ["frames", "asset"];
854
+ var ASSET_FIELDS = [
855
+ "asset",
856
+ "mediaType",
857
+ "size"
858
+ ];
859
+ var METADATA_FIELDS = [
860
+ "title",
861
+ "artist",
862
+ "album",
863
+ "year",
864
+ "comment"
865
+ ];
866
+ var ASSET_ID = /^sha256:[0-9a-f]{64}$/;
867
+ var MEDIA_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/;
868
+ function malformed(message) {
869
+ return invalid("malformed-command", message);
870
+ }
871
+ var isCount = (value, min) => Number.isSafeInteger(value) && value >= min;
872
+ function readAsset(value) {
873
+ if (!isRecord(value)) malformed("an asset is an object");
874
+ onlyFields(value, ASSET_FIELDS, "an asset");
875
+ const { asset, mediaType, size } = value;
876
+ if (typeof asset !== "string" || !ASSET_ID.test(asset)) malformed("an asset id is sha256:<hex>");
877
+ if (typeof mediaType !== "string" || mediaType.length > 255 || !MEDIA_TYPE.test(mediaType)) malformed("a media type is type/subtype, in lowercase");
878
+ if (!isCount(size, 0)) malformed("an asset's size is a whole number of bytes");
879
+ return {
880
+ asset,
881
+ mediaType,
882
+ size
883
+ };
884
+ }
885
+ function readSources(value) {
886
+ if (!isRecord(value) || Array.isArray(value)) malformed("sources is an object");
887
+ return Object.fromEntries(Object.entries(value).map(([id, source]) => {
888
+ if (!isKey(id)) malformed("a source id is a non-empty string");
889
+ if (!isRecord(source)) malformed("a source is an object");
890
+ onlyFields(source, SOURCE_FIELDS, "a source");
891
+ if (!isCount(source.frames, 1)) malformed("a source's frames are a whole number above 0");
892
+ return [id, source.asset === void 0 ? { frames: source.frames } : {
893
+ frames: source.frames,
894
+ asset: readAsset(source.asset)
895
+ }];
896
+ }));
897
+ }
898
+ function readMetadata(value) {
899
+ if (!isRecord(value)) malformed("metadata is an object");
900
+ onlyFields(value, METADATA_FIELDS, "metadata");
901
+ const fields = METADATA_FIELDS.map((field) => {
902
+ const text = value[field];
903
+ if (typeof text !== "string") malformed(`metadata.${field} is text`);
904
+ if (text.length > 1e3) invalid("metadata-too-long", `metadata.${field} is over ${MAX_METADATA_LENGTH} characters`);
905
+ return [field, text];
906
+ });
907
+ return Object.fromEntries(fields);
908
+ }
909
+ function read(value) {
910
+ if (!isRecord(value) || Array.isArray(value)) malformed("a document is an object");
911
+ const { format, version } = value;
912
+ if (typeof format !== "string") malformed("format is text");
913
+ if (format !== "hm-audio-plan") throw new AudioError("UNSUPPORTED_FORMAT", `This isn't an ${AUDIO_PLAN_FORMAT} document.`, { details: {
914
+ format: AUDIO_PLAN_FORMAT,
915
+ reason: "unknown-format"
916
+ } });
917
+ if (Number.isSafeInteger(version) && version > 1) throw new AudioError("UNSUPPORTED_FORMAT", `This ${AUDIO_PLAN_FORMAT} document is a later version than this release reads.`, { details: {
918
+ format: AUDIO_PLAN_FORMAT,
919
+ reason: "unknown-format-version"
920
+ } });
921
+ if (version !== 1) malformed("version is 1");
922
+ onlyFields(value, DOCUMENT_FIELDS, "a document");
923
+ if (!isCount(value.sampleRate, 1)) malformed("sampleRate is a whole number above 0");
924
+ if (!isCount(value.channels, 1)) malformed("channels is a whole number above 0");
925
+ const sources = readSources(value.sources);
926
+ if (!Array.isArray(value.clips)) malformed("clips is a list");
927
+ const lookup = (id) => Object.hasOwn(sources, id) ? sources[id]?.frames : void 0;
928
+ const clips = value.clips.map((clip) => checkClip(clip, lookup));
929
+ const keys = /* @__PURE__ */ new Set();
930
+ for (const { key } of clips) {
931
+ if (keys.has(key)) invalid("duplicate-key", `two clips have the key ${key}`);
932
+ keys.add(key);
933
+ }
934
+ return {
935
+ plan: {
936
+ sampleRate: value.sampleRate,
937
+ channels: value.channels,
938
+ clips,
939
+ metadata: readMetadata(value.metadata)
940
+ },
941
+ sources
942
+ };
943
+ }
944
+ function readAudioPlanDocument(value) {
945
+ try {
946
+ return read(value);
947
+ } catch (error) {
948
+ if (!(error instanceof Invalid)) throw error;
949
+ const reason = error.reason === "malformed-command" ? "malformed-document" : error.reason;
950
+ throw new AudioError("INVALID_DOCUMENT", `Invalid ${AUDIO_PLAN_FORMAT} document: ${error.message}.`, { details: {
951
+ format: AUDIO_PLAN_FORMAT,
952
+ reason
953
+ } });
954
+ }
955
+ }
956
+ function toAudioPlanDocument(plan, sources) {
957
+ for (const clip of plan.clips) if (!Object.hasOwn(sources, clip.source)) throw new TypeError(`The sources don't include ${clip.source}, which clip ${clip.key} uses.`);
958
+ return {
959
+ format: AUDIO_PLAN_FORMAT,
960
+ version: 1,
961
+ sampleRate: plan.sampleRate,
962
+ channels: plan.channels,
963
+ sources: Object.fromEntries(Object.entries(sources).map(([id, { frames, asset }]) => [id, asset === void 0 ? { frames } : {
964
+ frames,
965
+ asset: { ...asset }
966
+ }])),
967
+ clips: plan.clips.map(({ key, source, start, end, gainDb, fadeIn, fadeOut }) => ({
968
+ key,
969
+ source,
970
+ start,
971
+ end,
972
+ gainDb,
973
+ fadeIn: {
974
+ frames: fadeIn.frames,
975
+ curve: fadeIn.curve
976
+ },
977
+ fadeOut: {
978
+ frames: fadeOut.frames,
979
+ curve: fadeOut.curve
980
+ }
981
+ })),
982
+ metadata: { ...plan.metadata }
983
+ };
984
+ }
985
+ // src/core/model/envelope.ts
986
+ function dbToGain(db) {
987
+ return 10 ** (db / 20);
988
+ }
989
+ function fadeShape(curve, position) {
990
+ return curve === "equalPower" ? Math.sin(position * Math.PI / 2) : position;
991
+ }
992
+ function gainAt(clip, frame) {
993
+ const length = clip.end - clip.start;
994
+ let gain = dbToGain(clip.gainDb);
995
+ const { fadeIn, fadeOut } = clip;
996
+ if (fadeIn.frames > 0 && frame < fadeIn.frames) gain *= fadeShape(fadeIn.curve, frame / fadeIn.frames);
997
+ const fromEnd = length - 1 - frame;
998
+ if (fadeOut.frames > 0 && fromEnd < fadeOut.frames) gain *= fadeShape(fadeOut.curve, Math.max(0, fromEnd) / fadeOut.frames);
999
+ return gain;
1000
+ }
1001
+ // src/core/model/time.ts
1002
+ function framesToSeconds(frames, sampleRate) {
1003
+ return frames / sampleRate;
1004
+ }
1005
+ function secondsToFrames(seconds, sampleRate) {
1006
+ return Math.round(seconds * sampleRate);
1007
+ }
1008
+ // src/core/session/session.ts
1009
+ var BYTES_PER_SAMPLE = 4;
1010
+ function clipsOf(command) {
1011
+ switch (command.type) {
1012
+ case "audio.insertClips":
1013
+ case "audio.replaceClips":
1014
+ case "audio.updateClips": return command.clips;
1015
+ case "audio.restoreClips": return command.entries.map((entry) => entry.clip);
1016
+ default: return [];
1017
+ }
1018
+ }
1019
+ function keysOf(command) {
1020
+ const keys = clipsOf(command).map((clip) => clip.key);
1021
+ if ("newKey" in command && typeof command.newKey === "string") keys.push(command.newKey);
1022
+ if ("splitKey" in command && typeof command.splitKey === "string") keys.push(command.splitKey);
1023
+ return keys;
1024
+ }
1025
+ function createAudioSession(options) {
1026
+ const { engine } = options;
1027
+ const policy = audioLimits.resolve(options.filePolicy);
1028
+ const history = createHistory();
1029
+ const sources = /* @__PURE__ */ new Map();
1030
+ const reducer = createPlanReducer((id) => sources.get(id)?.info.frames);
1031
+ let plan;
1032
+ let status = "empty";
1033
+ let error;
1034
+ let busy = 0;
1035
+ let selection;
1036
+ let nextKey = 0;
1037
+ let nextSource = 0;
1038
+ const loading = /* @__PURE__ */ new Set();
1039
+ const cancelLoads = (message) => {
1040
+ for (const controller of loading) controller.abort(new AudioError("ABORTED", message));
1041
+ };
1042
+ let generation = 0;
1043
+ const superseded = (since) => since !== generation ? new AudioError("ABORTED", "The recording was closed or replaced.") : void 0;
1044
+ const heldBytes = () => {
1045
+ let total = 0;
1046
+ for (const source of sources.values()) total += source.bytes;
1047
+ return total;
1048
+ };
1049
+ function referenced(steps) {
1050
+ const ids = new Set(plan?.clips.map((clip) => clip.source));
1051
+ for (const { commands, inverses } of steps) for (const command of [...commands, ...inverses]) for (const clip of clipsOf(command)) ids.add(clip.source);
1052
+ return ids;
1053
+ }
1054
+ function collect() {
1055
+ const keep = referenced(history.steps);
1056
+ for (const id of sources.keys()) if (!keep.has(id)) sources.delete(id);
1057
+ }
1058
+ function stepsToDrop(extra) {
1059
+ const { maximum } = policy.limits.maxSessionSize;
1060
+ const order = history.dropOrder;
1061
+ for (let count = 0; count <= order.length; count += 1) {
1062
+ const kept = new Set(order.slice(count));
1063
+ const ids = referenced(history.steps.filter((entry) => kept.has(entry)));
1064
+ let total = extra;
1065
+ for (const id of ids) total += sources.get(id)?.bytes ?? 0;
1066
+ if (total <= maximum) return count;
1067
+ }
1068
+ }
1069
+ function sessionWarnings() {
1070
+ const found = [...sources.values()].flatMap((source) => source.warnings);
1071
+ const bytes = heldBytes();
1072
+ if (bytes > 0 && bytes >= policy.limits.maxSessionSize.warning) found.push({
1073
+ type: "limit",
1074
+ limit: "maxSessionSize",
1075
+ actual: bytes
1076
+ });
1077
+ const clips = plan?.clips.length ?? 0;
1078
+ if (clips > 0 && clips >= policy.limits.maxClips.warning) found.push({
1079
+ type: "limit",
1080
+ limit: "maxClips",
1081
+ actual: clips
1082
+ });
1083
+ return found;
1084
+ }
1085
+ function makeSnapshot() {
1086
+ return Object.freeze({
1087
+ status,
1088
+ plan,
1089
+ sources: Object.freeze([...sources.values()].map((source) => source.info)),
1090
+ canUndo: history.canUndo,
1091
+ canRedo: history.canRedo,
1092
+ historyTrimmed: history.trimmed,
1093
+ busy: busy > 0,
1094
+ error,
1095
+ warnings: Object.freeze(sessionWarnings()),
1096
+ sessionBytes: heldBytes(),
1097
+ selection
1098
+ });
1099
+ }
1100
+ const store = createStore(makeSnapshot());
1101
+ function changed() {
1102
+ if (selection) {
1103
+ const end = Math.min(selection.end, plan ? planLength(plan) : 0);
1104
+ selection = selection.start < end ? {
1105
+ start: selection.start,
1106
+ end
1107
+ } : void 0;
1108
+ }
1109
+ store.set(makeSnapshot());
1110
+ }
1111
+ function emit(event) {
1112
+ try {
1113
+ options.onEvent?.(event);
1114
+ } catch {}
1115
+ }
1116
+ function facts(source) {
1117
+ const { info } = source;
1118
+ return {
1119
+ durationSeconds: framesToSeconds(info.frames, info.sampleRate),
1120
+ sampleRate: info.sampleRate,
1121
+ channels: info.channels,
1122
+ container: info.container,
1123
+ codec: info.codec,
1124
+ truncated: source.warnings.some((warning) => warning.type === "truncated")
1125
+ };
1126
+ }
1127
+ async function load(file, signal, onProgress, beforeDecode) {
1128
+ if (!(file instanceof Blob)) throw new TypeError("A recording must be a Blob or a File.");
1129
+ nextSource += 1;
1130
+ const id = `s${nextSource}`;
1131
+ const warnings = [];
1132
+ const warnAt = (limit, actual) => {
1133
+ if (policy.check(limit, actual) === "warning") warnings.push({
1134
+ type: "limit",
1135
+ limit,
1136
+ actual,
1137
+ source: id
1138
+ });
1139
+ };
1140
+ if (checkFile(policy, file) === "warning") warnings.push({
1141
+ type: "limit",
1142
+ limit: "maxFileSize",
1143
+ actual: file.size,
1144
+ source: id
1145
+ });
1146
+ const probe = await withProcessingTime(policy, (limited) => engine.probe(file, { signal: limited }), { signal });
1147
+ warnAt("maxChannels", probe.channels);
1148
+ warnAt("maxSampleRate", probe.sampleRate);
1149
+ warnAt("maxDuration", Math.ceil(probe.frameBound * 1e3 / probe.sampleRate));
1150
+ warnAt("maxDecodedSize", probe.frameBound * probe.channels * BYTES_PER_SAMPLE);
1151
+ beforeDecode(probe);
1152
+ const audio = await withProcessingTime(policy, (limited) => engine.decode(file, probe, {
1153
+ signal: limited,
1154
+ ...onProgress ? { onProgress } : {}
1155
+ }), { signal });
1156
+ const frames = Math.min(audio.length, probe.frameBound);
1157
+ const channels = audio.numberOfChannels;
1158
+ if (audio.sampleRate !== probe.sampleRate || channels < 1 || channels > probe.channels) throw new AudioError("INVALID_AUDIO", "The decoder's output doesn't match the probe.", { details: {
1159
+ container: probe.container,
1160
+ codec: probe.codec
1161
+ } });
1162
+ if (frames < 1) throw new AudioError("DECODE_FAILED", "The recording decoded to no audio.", { details: { codec: probe.codec } });
1163
+ const peaks = await withProcessingTime(policy, (limited) => engine.peaks(audio, { signal: limited }), { signal });
1164
+ throwIfAborted(signal);
1165
+ if (probe.declaredFrames !== void 0 && probe.declaredFrames > frames) warnings.push({
1166
+ type: "truncated",
1167
+ source: id,
1168
+ frames,
1169
+ declaredFrames: probe.declaredFrames
1170
+ });
1171
+ return {
1172
+ info: Object.freeze({
1173
+ id,
1174
+ sampleRate: audio.sampleRate,
1175
+ channels,
1176
+ frames,
1177
+ container: probe.container,
1178
+ codec: probe.codec
1179
+ }),
1180
+ audio,
1181
+ peaks,
1182
+ bytes: frames * channels * BYTES_PER_SAMPLE,
1183
+ warnings: Object.freeze(warnings)
1184
+ };
1185
+ }
1186
+ async function track(signal, replaces, run) {
1187
+ if (replaces) cancelLoads("A newer recording replaced this one.");
1188
+ const controller = new AbortController();
1189
+ loading.add(controller);
1190
+ const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
1191
+ busy += 1;
1192
+ changed();
1193
+ try {
1194
+ return await run(combined);
1195
+ } finally {
1196
+ busy -= 1;
1197
+ loading.delete(controller);
1198
+ changed();
1199
+ }
1200
+ }
1201
+ function applyChecked(current, commands) {
1202
+ const result = applyCommands(reducer, current, commands);
1203
+ if (result.state.clips.length > current.clips.length) policy.check("maxClips", result.state.clips.length);
1204
+ return result;
1205
+ }
1206
+ function commit(result, commands) {
1207
+ plan = result.state;
1208
+ history.push({
1209
+ commands,
1210
+ inverses: result.inverses
1211
+ });
1212
+ collect();
1213
+ }
1214
+ function newKey() {
1215
+ const used = new Set(plan?.clips.map((clip) => clip.key));
1216
+ for (const { commands, inverses } of history.steps) for (const command of [...commands, ...inverses]) for (const key of keysOf(command)) used.add(key);
1217
+ let key;
1218
+ do {
1219
+ nextKey += 1;
1220
+ key = `c${nextKey}`;
1221
+ } while (used.has(key));
1222
+ return key;
1223
+ }
1224
+ return {
1225
+ getSnapshot: store.getSnapshot,
1226
+ subscribe: store.subscribe,
1227
+ async open(file, callOptions = {}) {
1228
+ generation += 1;
1229
+ const started = generation;
1230
+ status = "opening";
1231
+ error = void 0;
1232
+ try {
1233
+ const source = await track(callOptions.signal, true, (signal) => load(file, signal, callOptions.onProgress, () => {}));
1234
+ const replaced = superseded(started);
1235
+ if (replaced) throw replaced;
1236
+ policy.check("maxSessionSize", source.bytes);
1237
+ sources.clear();
1238
+ history.clear();
1239
+ sources.set(source.info.id, source);
1240
+ plan = {
1241
+ sampleRate: source.info.sampleRate,
1242
+ channels: source.info.channels,
1243
+ clips: [{
1244
+ key: newKey(),
1245
+ source: source.info.id,
1246
+ start: 0,
1247
+ end: source.info.frames,
1248
+ gainDb: 0,
1249
+ fadeIn: NO_FADE,
1250
+ fadeOut: NO_FADE
1251
+ }],
1252
+ metadata: EMPTY_METADATA
1253
+ };
1254
+ selection = void 0;
1255
+ status = "ready";
1256
+ changed();
1257
+ emit({
1258
+ type: "recording_opened",
1259
+ ...facts(source)
1260
+ });
1261
+ } catch (reason) {
1262
+ const failure = asAudioError(reason, "The recording couldn't be opened.");
1263
+ if (started !== generation) throw failure;
1264
+ status = plan ? "ready" : "error";
1265
+ error = failure;
1266
+ changed();
1267
+ emit({
1268
+ type: "failed",
1269
+ operation: "open",
1270
+ code: failure.code
1271
+ });
1272
+ throw failure;
1273
+ }
1274
+ },
1275
+ async insert(file, insertOptions = {}) {
1276
+ if (!plan || status !== "ready") throw new AudioError("INVALID_COMMAND", "Open a recording before inserting another.", { details: { reason: "no-recording" } });
1277
+ const started = generation;
1278
+ error = void 0;
1279
+ try {
1280
+ const source = await track(insertOptions.signal, false, (signal) => {
1281
+ policy.check("maxFiles", sources.size + 1);
1282
+ return load(file, signal, insertOptions.onProgress, (probe) => {
1283
+ const rate = plan?.sampleRate;
1284
+ if (probe.sampleRate !== rate) throw new AudioError("UNSUPPORTED_FORMAT", `Recordings at ${probe.sampleRate} Hz can't be inserted into a ${rate} Hz session yet.`, { details: { sampleRate: probe.sampleRate } });
1285
+ });
1286
+ });
1287
+ const replaced = superseded(started);
1288
+ if (replaced) throw replaced;
1289
+ const current = plan;
1290
+ const drop = stepsToDrop(source.bytes);
1291
+ if (drop === void 0) throw policy.error("maxSessionSize", heldBytes() + source.bytes);
1292
+ const commands = [{
1293
+ type: "audio.insertClips",
1294
+ at: insertOptions.at ?? planLength(current),
1295
+ clips: [{
1296
+ key: newKey(),
1297
+ source: source.info.id,
1298
+ start: 0,
1299
+ end: source.info.frames,
1300
+ gainDb: 0,
1301
+ fadeIn: NO_FADE,
1302
+ fadeOut: NO_FADE
1303
+ }],
1304
+ splitKey: newKey()
1305
+ }];
1306
+ sources.set(source.info.id, source);
1307
+ let result;
1308
+ try {
1309
+ result = applyChecked(current, commands);
1310
+ } catch (reason) {
1311
+ sources.delete(source.info.id);
1312
+ throw reason;
1313
+ }
1314
+ history.drop(drop);
1315
+ commit(result, commands);
1316
+ changed();
1317
+ emit({
1318
+ type: "recording_inserted",
1319
+ ...facts(source)
1320
+ });
1321
+ } catch (reason) {
1322
+ const failure = asAudioError(reason, "The recording couldn't be inserted.");
1323
+ if (started !== generation) throw failure;
1324
+ error = failure;
1325
+ changed();
1326
+ emit({
1327
+ type: "failed",
1328
+ operation: "insert",
1329
+ code: failure.code
1330
+ });
1331
+ throw failure;
1332
+ }
1333
+ },
1334
+ execute(commands) {
1335
+ const list = Array.isArray(commands) ? [...commands] : [commands];
1336
+ if (list.length === 0) return;
1337
+ try {
1338
+ if (!plan) throw new AudioError("INVALID_COMMAND", "Open a recording before editing it.", { details: { reason: "no-recording" } });
1339
+ let copies;
1340
+ try {
1341
+ copies = structuredClone(list);
1342
+ } catch (reason) {
1343
+ throw new AudioError("INVALID_COMMAND", "Commands must be plain data.", {
1344
+ cause: reason,
1345
+ details: { reason: "not-plain-data" }
1346
+ });
1347
+ }
1348
+ commit(applyChecked(plan, copies), copies);
1349
+ } catch (reason) {
1350
+ const failure = asAudioError(reason);
1351
+ emit({
1352
+ type: "failed",
1353
+ operation: "command",
1354
+ code: failure.code
1355
+ });
1356
+ throw failure;
1357
+ }
1358
+ changed();
1359
+ emit({
1360
+ type: "command",
1361
+ commands: list.map((command) => command.type)
1362
+ });
1363
+ },
1364
+ group: (fn) => history.group(fn),
1365
+ createKey: newKey,
1366
+ undo() {
1367
+ const current = plan;
1368
+ const entry = current && history.undo();
1369
+ if (!current || !entry) return;
1370
+ try {
1371
+ plan = applyCommands(reducer, current, entry.inverses).state;
1372
+ } catch (reason) {
1373
+ history.restore("undo");
1374
+ throw reason;
1375
+ }
1376
+ changed();
1377
+ emit({ type: "undo" });
1378
+ },
1379
+ redo() {
1380
+ const current = plan;
1381
+ const entry = current && history.redo();
1382
+ if (!current || !entry) return;
1383
+ try {
1384
+ plan = applyCommands(reducer, current, entry.commands).state;
1385
+ } catch (reason) {
1386
+ history.restore("redo");
1387
+ throw reason;
1388
+ }
1389
+ changed();
1390
+ emit({ type: "redo" });
1391
+ },
1392
+ select(range) {
1393
+ let next;
1394
+ if (range) {
1395
+ const { start, end } = range;
1396
+ if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end)) throw new RangeError("A selection is a range of whole frames.");
1397
+ const length = plan ? planLength(plan) : 0;
1398
+ const from = Math.max(0, Math.min(start, end, length));
1399
+ const to = Math.min(length, Math.max(start, end, 0));
1400
+ next = from < to ? {
1401
+ start: from,
1402
+ end: to
1403
+ } : void 0;
1404
+ }
1405
+ if (next?.start === selection?.start && next?.end === selection?.end) return;
1406
+ selection = next;
1407
+ changed();
1408
+ },
1409
+ getPeaks: (id) => sources.get(id)?.peaks,
1410
+ async close() {
1411
+ generation += 1;
1412
+ cancelLoads("The recording was closed.");
1413
+ const hadRecording = plan !== void 0;
1414
+ sources.clear();
1415
+ history.clear();
1416
+ plan = void 0;
1417
+ selection = void 0;
1418
+ error = void 0;
1419
+ status = "empty";
1420
+ changed();
1421
+ if (hadRecording) emit({ type: "recording_closed" });
1422
+ }
1423
+ };
1424
+ }
1425
+ // src/messages/en.ts
1426
+ var audioMessages = /* @__PURE__ */ defineMessages({
1427
+ ...sdkCoreMessages,
1428
+ "errors.INVALID_AUDIO": "This file isn't valid audio, or it's too damaged to open.",
1429
+ "errors.UNSUPPORTED_FORMAT": "This audio format isn't supported. Try converting the file to WAV, then open it again.",
1430
+ "errors.DECODE_FAILED": "This browser can't play this kind of audio. Try another browser, or convert the file to WAV.",
1431
+ "errors.INVALID_COMMAND": "This edit couldn't be made. Please try again.",
1432
+ "errors.INVALID_DOCUMENT": "This project is damaged, or it isn't an audio project.",
1433
+ "errors.DURATION_TOO_LONG": "This recording is {actual, duration} long, which is over the {maximum, duration} limit.",
1434
+ "errors.TOO_MANY_CHANNELS": "This recording has {actual, number} channels, which is over the {maximum, number}-channel limit.",
1435
+ "errors.SAMPLE_RATE_TOO_HIGH": "This recording's sample rate is {actual, number} Hz, which is over the {maximum, number} Hz limit.",
1436
+ "errors.SESSION_TOO_LARGE": "The open recordings would use {actual, fileSize} of memory, which is over the {maximum, fileSize} limit. Remove a recording, or clear the undo history, and try again.",
1437
+ "errors.TOO_MANY_CLIPS": /* @__PURE__ */ plural("maximum", {
1438
+ one: "A recording can have {maximum} clip. Join or delete clips, and try again.",
1439
+ other: "A recording can have up to {maximum} clips. Join or delete clips, and try again."
1440
+ }),
1441
+ "warnings.maxDuration": "This recording is {actual, duration} long, and may be slow to open and edit.",
1442
+ "warnings.maxChannels": "This recording has {actual, number} channels, and may be slow to edit.",
1443
+ "warnings.maxSampleRate": "This recording's sample rate is {actual, number} Hz, and it may be slow to edit.",
1444
+ "warnings.maxSessionSize": "The open recordings use {actual, fileSize} of memory. Clearing the undo history frees memory.",
1445
+ "warnings.maxClips": /* @__PURE__ */ plural("actual", {
1446
+ one: "This recording has {actual} clip. Many clips may be slow to play and export.",
1447
+ other: "This recording has {actual} clips. Many clips may be slow to play and export."
1448
+ }),
1449
+ "warnings.truncated": "This recording looks incomplete, perhaps from an interrupted recording or download. It opened with the audio it holds."
1450
+ });
1451
+ export { AUDIO_PLAN_FORMAT, AUDIO_PLAN_VERSION, AudioError, EMPTY_METADATA, MAX_GAIN_DB, MAX_METADATA_LENGTH, MIN_GAIN_DB, NO_FADE, audioLimitDefinitions, audioLimits, audioMessages, clipLength, clipOffsets, createAudioEngine, createAudioSession, dbToGain, framesToSeconds, gainAt, isAudioError, planLength, readAudioPlanDocument, secondsToFrames, toAudioPlanDocument };
1452
+
1453
+ //# sourceMappingURL=index.js.map