@libraz/libsonare 1.8.1 → 1.8.2

package/src/vocal_edit_worker_protocol.ts

@@ -0,0 +1,206 @@
+import type {
+  VocalAnalysis,
+  VocalApplyRequest,
+  VocalCapabilities,
+  VocalCreateRequest,
+  VocalEditResult,
+  VocalHistoryState,
+  VocalNotesResult,
+  VocalPitchEvaluation,
+  VocalRenderRequest,
+  VocalRenderResult,
+  VocalRestoreRequest,
+  VocalStateBytes,
+  VocalStateToken,
+  VocalUint64,
+} from './public_types_vocal_edit';
+
+export type VocalWorkerMutation =
+  | { kind: 'beginEdit'; expectedRevision?: VocalUint64 }
+  | { kind: 'apply'; request: VocalApplyRequest }
+  | { kind: 'commit'; expectedRevision: VocalUint64 }
+  | { kind: 'cancel' }
+  | { kind: 'undo'; expectedRevision?: VocalUint64 }
+  | { kind: 'redo'; expectedRevision?: VocalUint64 }
+  | { kind: 'notes' }
+  | { kind: 'analysis' }
+  | { kind: 'capabilities' }
+  | { kind: 'exportState' }
+  | { kind: 'outputLength' }
+  | { kind: 'history' }
+  | { kind: 'draftToken' }
+  | { kind: 'evaluatePitch'; noteId: number; draft?: boolean }
+  | {
+      kind: 'mapCoordinate';
+      noteId: number;
+      sample: number;
+      /** `false` maps source to destination; `true` maps destination to source. */
+      inverse: boolean;
+      draft?: boolean;
+    };
+
+export type VocalWorkerCreateRequest =
+  | { kind: 'create'; request: VocalCreateRequest }
+  | { kind: 'restore'; request: VocalRestoreRequest };
+
+export interface VocalWorkerCreateMessage {
+  type: 'sonare:vocal-create';
+  id: number;
+  sessionId: string;
+  clientIntentSequence: VocalUint64;
+  request: VocalWorkerCreateRequest;
+  cancelBuffer?: SharedArrayBuffer;
+}
+
+export interface VocalWorkerMutateMessage {
+  type: 'sonare:vocal-mutate';
+  id: number;
+  sessionId: string;
+  clientIntentSequence: VocalUint64;
+  baseToken?: VocalStateToken;
+  mutation: VocalWorkerMutation;
+  cancelBuffer?: SharedArrayBuffer;
+}
+
+export interface VocalWorkerPreviewMessage {
+  type: 'sonare:vocal-preview';
+  id: number;
+  sessionId: string;
+  clientIntentSequence: VocalUint64;
+  baseToken?: VocalStateToken;
+  request: VocalRenderRequest;
+  cancelBuffer?: SharedArrayBuffer;
+}
+
+export interface VocalWorkerDisposeMessage {
+  type: 'sonare:vocal-dispose';
+  id: number;
+  sessionId: string;
+  clientIntentSequence: VocalUint64;
+}
+
+export interface VocalWorkerCancelMessage {
+  type: 'sonare:vocal-cancel';
+  id: number;
+  sessionId: string;
+  clientIntentSequence: VocalUint64;
+}
+
+export type VocalWorkerRequestMessage =
+  | VocalWorkerCreateMessage
+  | VocalWorkerMutateMessage
+  | VocalWorkerPreviewMessage
+  | VocalWorkerDisposeMessage
+  | VocalWorkerCancelMessage;
+
+export interface VocalWorkerCreateResult {
+  sessionId: string;
+  token: VocalStateToken;
+  notes: VocalNotesResult;
+  analysis: VocalAnalysis;
+  capabilities: VocalCapabilities;
+}
+
+export interface VocalWorkerResponseBase {
+  id: number;
+  sessionId: string;
+  clientIntentSequence: VocalUint64;
+  token?: VocalStateToken;
+}
+
+export type VocalWorkerResult =
+  | VocalWorkerCreateResult
+  | VocalEditResult
+  | VocalNotesResult
+  | VocalAnalysis
+  | VocalCapabilities
+  | VocalStateBytes
+  | VocalRenderResult
+  | VocalStateToken
+  | VocalHistoryState
+  | VocalPitchEvaluation
+  | number
+  | null;
+
+export interface VocalWorkerResultMessage extends VocalWorkerResponseBase {
+  type: 'sonare:vocal-result';
+  result: VocalWorkerResult;
+}
+
+export interface VocalWorkerProgressMessage extends VocalWorkerResponseBase {
+  type: 'sonare:vocal-progress';
+  complete: boolean;
+}
+
+export interface VocalWorkerErrorMessage extends VocalWorkerResponseBase {
+  type: 'sonare:vocal-error';
+  error: {
+    name: string;
+    message: string;
+    code?: number;
+    codeName?: string;
+    reason?: number;
+    field?: string;
+    expected?: VocalUint64;
+    actual?: VocalUint64;
+    expectedText?: string;
+    actualText?: string;
+  };
+}
+
+export type VocalWorkerResponseMessage =
+  | VocalWorkerResultMessage
+  | VocalWorkerProgressMessage
+  | VocalWorkerErrorMessage;
+
+export function tokenEquals(
+  a: VocalStateToken | undefined,
+  b: VocalStateToken | undefined,
+): boolean {
+  if (!a || !b) {
+    return a === b;
+  }
+  return (
+    a.sessionEpoch === b.sessionEpoch &&
+    a.revision === b.revision &&
+    a.draftId === b.draftId &&
+    a.generation === b.generation &&
+    a.requestId === b.requestId &&
+    a.profileId === b.profileId
+  );
+}
+
+/** Compare the mutable session state portion of a token.
+ *
+ * Render results add request/profile metadata to the state token. That
+ * metadata identifies the render artifact, so it must not make a snapshot's
+ * state appear different from the session state used to create it.
+ */
+export function stateTokenEquals(
+  a: VocalStateToken | undefined,
+  b: VocalStateToken | undefined,
+): boolean {
+  if (!a || !b) {
+    return a === b;
+  }
+  return (
+    a.sessionEpoch === b.sessionEpoch &&
+    a.revision === b.revision &&
+    a.draftId === b.draftId &&
+    a.generation === b.generation &&
+    a.profileId === b.profileId
+  );
+}
+
+/** Decimal sequence comparison without converting a uint64 to Number. */
+export function compareUint64(a: VocalUint64, b: VocalUint64): number {
+  const left = a.replace(/^0+(?=\d)/, '');
+  const right = b.replace(/^0+(?=\d)/, '');
+  if (left.length !== right.length) {
+    return left.length < right.length ? -1 : 1;
+  }
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}

package/src/vocal_project.ts

@@ -0,0 +1,327 @@
+import type { VocalStateToken, VocalUint64 } from './public_types_vocal_edit';
+import type {
+  ProjectVocalEditApplyRequest,
+  ProjectVocalEditApplyResult,
+  ProjectVocalEditDependency,
+  ProjectVocalOriginalSource,
+  ProjectVocalReason,
+  ProjectVocalRehydrateItem,
+} from './public_types_vocal_project';
+import { assertSampleRate } from './validation';
+
+/** The embind Project object is deliberately structural here. */
+export interface VocalProjectNative {
+  applyVocalEdit: (request: unknown) => unknown;
+  getVocalEditDependencies: () => unknown;
+  rehydrateVocalEdits: (originals: unknown, cancel?: unknown) => unknown;
+}
+
+const UINT32_MAX = 0xffff_ffff;
+const PROJECT_ID_MAX = UINT32_MAX - 1;
+const UINT64_MAX = '18446744073709551615';
+
+function requireObject(value: unknown, field: string): Record<string, unknown> {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function uint32(value: unknown, field: string, allowZero = true): number {
+  if (
+    typeof value !== 'number' ||
+    !Number.isSafeInteger(value) ||
+    value < (allowZero ? 0 : 1) ||
+    value > PROJECT_ID_MAX
+  ) {
+    throw new RangeError(`${field} must be a uint32 project id`);
+  }
+  return value;
+}
+
+function nativeUint32(value: unknown, field: string): number {
+  if (
+    typeof value !== 'number' ||
+    !Number.isSafeInteger(value) ||
+    value < 0 ||
+    value > UINT32_MAX
+  ) {
+    throw new RangeError(`${field} must be a native uint32`);
+  }
+  return value;
+}
+
+function nativeInt64(value: unknown, field: string): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value)) {
+    throw new RangeError(`${field} must be a safe integer`);
+  }
+  return value;
+}
+
+function positiveSampleCount(value: unknown, field: string): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+    throw new RangeError(`${field} must be a positive safe integer`);
+  }
+  return value;
+}
+
+function finite(value: unknown, field: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new RangeError(`${field} must be finite`);
+  }
+  return value;
+}
+
+function decimalUint64(value: unknown, field: string): VocalUint64 {
+  if (typeof value !== 'string' || !/^(0|[1-9]\d*)$/.test(value)) {
+    throw new RangeError(`${field} must be a canonical decimal uint64 string`);
+  }
+  if (
+    value.length > UINT64_MAX.length ||
+    (value.length === UINT64_MAX.length && value > UINT64_MAX)
+  ) {
+    throw new RangeError(`${field} must fit uint64`);
+  }
+  return value;
+}
+
+function hexSha256(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !/^[0-9a-fA-F]{64}$/.test(value)) {
+    throw new TypeError(`${field} must be 64 hexadecimal characters`);
+  }
+  return value.toLowerCase();
+}
+
+function finiteMono(value: unknown, field: string): Float32Array {
+  if (!(value instanceof Float32Array) || value.length === 0) {
+    throw new TypeError(`${field} must be a non-empty Float32Array`);
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Number.isFinite(value[index])) {
+      throw new RangeError(`${field} must contain only finite samples`);
+    }
+  }
+  return new Float32Array(value);
+}
+
+function sve1(value: unknown): Uint8Array {
+  if (!(value instanceof Uint8Array) || value.length === 0) {
+    throw new TypeError('sve1 must be a non-empty Uint8Array');
+  }
+  return new Uint8Array(value);
+}
+
+function copyToken(value: unknown): VocalStateToken {
+  const source = requireObject(value, 'renderToken');
+  return {
+    sessionEpoch: decimalUint64(source.sessionEpoch, 'renderToken.sessionEpoch'),
+    revision: decimalUint64(source.revision, 'renderToken.revision'),
+    draftId: decimalUint64(source.draftId, 'renderToken.draftId'),
+    generation: decimalUint64(source.generation, 'renderToken.generation'),
+    requestId: decimalUint64(source.requestId, 'renderToken.requestId'),
+    profileId: uint32(source.profileId, 'renderToken.profileId'),
+  };
+}
+
+function copyApplyRequest(request: ProjectVocalEditApplyRequest): ProjectVocalEditApplyRequest {
+  const source = requireObject(request, 'request');
+  const renderedMono = finiteMono(source.renderedMono, 'renderedMono');
+  const expectedSourceSampleCount = positiveSampleCount(
+    source.expectedSourceSampleCount,
+    'expectedSourceSampleCount',
+  );
+  if (renderedMono.length !== expectedSourceSampleCount) {
+    throw new RangeError(
+      `renderedMono length must equal expectedSourceSampleCount (${renderedMono.length} != ${expectedSourceSampleCount})`,
+    );
+  }
+  const expectedSourceSampleRate = finite(
+    source.expectedSourceSampleRate,
+    'expectedSourceSampleRate',
+  );
+  assertSampleRate('Project.applyVocalEdit', expectedSourceSampleRate);
+  const renderedSampleRate = finite(source.renderedSampleRate, 'renderedSampleRate');
+  assertSampleRate('Project.applyVocalEdit', renderedSampleRate, 'renderedSampleRate');
+  if (renderedSampleRate !== expectedSourceSampleRate) {
+    throw new RangeError('renderedSampleRate must equal expectedSourceSampleRate');
+  }
+  const renderedStartSample = source.renderedStartSample ?? 0;
+  if (renderedStartSample !== 0) {
+    throw new RangeError('renderedStartSample must be zero for the v1 Project vocal API');
+  }
+  const renderToken = copyToken(source.renderToken);
+  if (renderToken.draftId !== '0' || renderToken.generation !== '0') {
+    throw new RangeError('renderToken must be a committed session token');
+  }
+  return {
+    clipId: uint32(source.clipId, 'clipId', false),
+    takeId: uint32(source.takeId ?? 0, 'takeId'),
+    expectedSourceId: uint32(source.expectedSourceId, 'expectedSourceId', false),
+    expectedSourceSampleRate,
+    expectedSourceSampleCount,
+    expectedSourceSha256: hexSha256(source.expectedSourceSha256, 'expectedSourceSha256'),
+    expectedClipLengthPpq: finite(source.expectedClipLengthPpq, 'expectedClipLengthPpq'),
+    expectedSourceOffsetPpq: finite(source.expectedSourceOffsetPpq, 'expectedSourceOffsetPpq'),
+    renderedMono,
+    renderedSampleRate,
+    renderedStartSample: 0,
+    renderToken,
+    sve1: sve1(source.sve1),
+  };
+}
+
+function copyApplyResult(value: unknown): ProjectVocalEditApplyResult {
+  const source = requireObject(value, 'applyVocalEdit result');
+  return {
+    clipId: uint32(source.clipId, 'result.clipId', false),
+    takeId: uint32(source.takeId, 'result.takeId'),
+    originalSourceId: uint32(source.originalSourceId, 'result.originalSourceId', false),
+    derivedSourceId: uint32(source.derivedSourceId, 'result.derivedSourceId', false),
+    committedRevision: decimalUint64(source.committedRevision, 'result.committedRevision'),
+    profileId: uint32(source.profileId, 'result.profileId'),
+    derivedSourceSha256: hexSha256(source.derivedSourceSha256, 'result.derivedSourceSha256'),
+    sidecarKey:
+      typeof source.sidecarKey === 'string'
+        ? source.sidecarKey
+        : (() => {
+            throw new TypeError('result.sidecarKey must be a string');
+          })(),
+  };
+}
+
+function copyDependency(value: unknown): ProjectVocalEditDependency {
+  const source = requireObject(value, 'vocal edit dependency');
+  const reason = nativeUint32(source.reason, 'dependency.reason');
+  return {
+    clipId: nativeUint32(source.clipId, 'dependency.clipId'),
+    takeId: nativeUint32(source.takeId, 'dependency.takeId'),
+    originalSourceId: nativeUint32(source.originalSourceId, 'dependency.originalSourceId'),
+    derivedSourceId: nativeUint32(source.derivedSourceId, 'dependency.derivedSourceId'),
+    sourceSampleRate: nativeUint32(source.sourceSampleRate, 'dependency.sourceSampleRate'),
+    profileId: nativeUint32(source.profileId, 'dependency.profileId'),
+    sourceSampleCount: nativeInt64(source.sourceSampleCount, 'dependency.sourceSampleCount'),
+    committedRevision: decimalUint64(source.committedRevision, 'dependency.committedRevision'),
+    originalSourceSha256: hexSha256(source.originalSourceSha256, 'dependency.originalSourceSha256'),
+    derivedSourceSha256: hexSha256(source.derivedSourceSha256, 'dependency.derivedSourceSha256'),
+    originalPcmAvailable: source.originalPcmAvailable === true,
+    derivedPcmAvailable: source.derivedPcmAvailable === true,
+    reason: reason as ProjectVocalReason | number,
+    sidecarKey:
+      typeof source.sidecarKey === 'string'
+        ? source.sidecarKey
+        : (() => {
+            throw new TypeError('dependency.sidecarKey must be a string');
+          })(),
+  };
+}
+
+function copyRehydrateItem(value: unknown): ProjectVocalRehydrateItem {
+  const source = requireObject(value, 'vocal rehydrate item');
+  const status = source.status;
+  if (typeof status !== 'number' || !Number.isSafeInteger(status) || status < 0 || status > 2) {
+    throw new RangeError('rehydrate.status must be one of 0, 1, or 2');
+  }
+  const reason = nativeUint32(source.reason, 'rehydrate.reason');
+  return {
+    clipId: nativeUint32(source.clipId, 'rehydrate.clipId'),
+    takeId: nativeUint32(source.takeId, 'rehydrate.takeId'),
+    derivedSourceId: nativeUint32(source.derivedSourceId, 'rehydrate.derivedSourceId'),
+    status: status as ProjectVocalRehydrateItem['status'],
+    reason: reason as ProjectVocalReason | number,
+  };
+}
+
+function copyOriginalSources(
+  originals: readonly ProjectVocalOriginalSource[],
+): ProjectVocalOriginalSource[] {
+  if (!Array.isArray(originals)) {
+    throw new TypeError('originals must be an array');
+  }
+  const seen = new Set<number>();
+  return originals.map((original, index) => {
+    const source = requireObject(original, `originals[${index}]`);
+    const sourceId = uint32(source.sourceId, `originals[${index}].sourceId`, false);
+    if (seen.has(sourceId)) {
+      throw new RangeError(`originals contains duplicate sourceId ${sourceId}`);
+    }
+    seen.add(sourceId);
+    const sampleRate = finite(source.sampleRate, `originals[${index}].sampleRate`);
+    assertSampleRate('Project.rehydrateVocalEdits', sampleRate, `originals[${index}].sampleRate`);
+    return {
+      sourceId,
+      mono: finiteMono(source.mono, `originals[${index}].mono`),
+      sampleRate,
+    };
+  });
+}
+
+/** Apply a complete committed vocal render to a native Project object. */
+export function projectApplyVocalEdit(
+  native: VocalProjectNative,
+  request: ProjectVocalEditApplyRequest,
+): ProjectVocalEditApplyResult {
+  const normalized = copyApplyRequest(request);
+  return copyApplyResult(native.applyVocalEdit(normalized));
+}
+
+/** Return copied vocal sidecar dependencies in native storage order. */
+export function projectGetVocalEditDependencies(
+  native: VocalProjectNative,
+): ProjectVocalEditDependency[] {
+  const value = native.getVocalEditDependencies();
+  if (!Array.isArray(value)) {
+    throw new TypeError('native vocal dependencies must be an array');
+  }
+  return value.map(copyDependency);
+}
+
+/**
+ * Rehydrate unresolved vocal PCM without creating a Project history entry.
+ * Any truthy return from `cancel` cancels the call.
+ */
+export function projectRehydrateVocalEdits(
+  native: VocalProjectNative,
+  originals: readonly ProjectVocalOriginalSource[],
+  cancel?: () => boolean,
+): ProjectVocalRehydrateItem[] {
+  if (cancel !== undefined && typeof cancel !== 'function') {
+    throw new TypeError('cancel must be a function');
+  }
+  const normalized = copyOriginalSources(originals);
+  let callbackFailed = false;
+  let callbackFailure: unknown;
+  const guardedCancel =
+    cancel === undefined
+      ? undefined
+      : () => {
+          try {
+            return cancel();
+          } catch (error) {
+            callbackFailed = true;
+            callbackFailure = error;
+            // Stop native work without allowing a JS exception to cross the C ABI.
+            return true;
+          }
+        };
+  let value: unknown;
+  try {
+    value = native.rehydrateVocalEdits(normalized, guardedCancel);
+  } catch (error) {
+    if (callbackFailed) {
+      throw callbackFailure;
+    }
+    throw error;
+  }
+  if (callbackFailed) {
+    throw callbackFailure;
+  }
+  // The adapter reports a throwing callback as data instead of throwing
+  // through C++ frames, whose destructors a JS exception would skip.
+  if (value !== null && typeof value === 'object' && 'cancelFailure' in value) {
+    throw (value as { cancelFailure: unknown }).cancelFailure;
+  }
+  if (!Array.isArray(value)) {
+    throw new TypeError('native vocal rehydrate result must be an array');
+  }
+  return value.map(copyRehydrateItem);
+}

package/src/web_midi.ts

@@ -31,6 +31,21 @@ export interface WebMidiEngine {
     value: number,
     time?: number,
   ): void;
+  pushMidiInputPitchBend?(group: number, channel: number, bend14: number, time?: number): void;
+  pushMidiInputChannelPressure?(
+    group: number,
+    channel: number,
+    pressure: number,
+    time?: number,
+  ): void;
+  pushMidiInputPolyPressure?(
+    group: number,
+    channel: number,
+    note: number,
+    pressure: number,
+    time?: number,
+  ): void;
+  pushMidiInputUmp?(words: Uint32Array | readonly number[], time?: number): void;
 }
 
 type MidiInputState = 'connected' | 'disconnected';
@@ -285,8 +300,8 @@ function dispatchMidiMessage(
     return 0;
   }
   const first = data[0];
-  if (first > 0xff) {
-    dispatchUmpMessage(
+  if (first > 0xff || data instanceof Uint32Array) {
+    dispatchUmpMessages(
       engine,
       data,
       timestampToSamples?.(event.receivedTime ?? event.timeStamp ?? 0) ?? 0,
@@ -312,8 +327,12 @@ function dispatchMidiMessage(
   }
 
   const a = readU7(data, offset);
-  const b = readU7(data, offset + 1);
-  if (a < 0 || b < 0) {
+  if (a < 0) {
+    return status;
+  }
+  const oneDataByteMessage = message === 0xc0 || message === 0xd0;
+  const b = oneDataByteMessage ? -1 : readU7(data, offset + 1);
+  if (!oneDataByteMessage && b < 0) {
     return status;
   }
 
@@ -331,20 +350,56 @@ function dispatchMidiMessage(
     }
   } else if (message === 0xb0 && b >= 0) {
     engine.pushMidiInputCc(group, channel, a, b, portTimeSamples);
+  } else if (message === 0xa0 && b >= 0) {
+    engine.pushMidiInputPolyPressure?.(group, channel, a, b, portTimeSamples);
+  } else if (message === 0xd0) {
+    engine.pushMidiInputChannelPressure?.(group, channel, a, portTimeSamples);
+  } else if (message === 0xe0 && b >= 0) {
+    engine.pushMidiInputPitchBend?.(group, channel, a | (b << 7), portTimeSamples);
   }
 
   return status;
 }
 
-function dispatchUmpMessage(
+function dispatchUmpMessages(
   engine: WebMidiEngine,
   words: ArrayLike<number>,
   portTimeSamples: number,
+): void {
+  let offset = 0;
+  while (offset < words.length) {
+    const word0 = words[offset] >>> 0;
+    const wordCount = umpWordCount(word0 >>> 28);
+    if (words.length - offset < wordCount) {
+      return;
+    }
+    const packet = new Uint32Array(wordCount);
+    for (let index = 0; index < wordCount; index++) {
+      packet[index] = words[offset + index] >>> 0;
+    }
+    dispatchUmpMessage(engine, packet, portTimeSamples);
+    offset += wordCount;
+  }
+}
+
+function dispatchUmpMessage(
+  engine: WebMidiEngine,
+  words: Uint32Array,
+  portTimeSamples: number,
 ): void {
   const word0 = words[0] >>> 0;
   const messageType = word0 >>> 28;
   const group = (word0 >>> 24) & 0x0f;
 
+  // Data packets (MT 0x3/0x5) need the owned SysEx path; raw input refuses them.
+  if (messageType === 0x3 || messageType === 0x5) {
+    return;
+  }
+  if (engine.pushMidiInputUmp) {
+    engine.pushMidiInputUmp(words, portTimeSamples);
+    return;
+  }
+
   if (messageType === 0x2) {
     const status = (word0 >>> 16) & 0xff;
     const message = status & 0xf0;
@@ -361,6 +416,12 @@ function dispatchUmpMessage(
       }
     } else if (message === 0xb0) {
       engine.pushMidiInputCc(group, channel, a, b, portTimeSamples);
+    } else if (message === 0xa0) {
+      engine.pushMidiInputPolyPressure?.(group, channel, a, b, portTimeSamples);
+    } else if (message === 0xd0) {
+      engine.pushMidiInputChannelPressure?.(group, channel, a, portTimeSamples);
+    } else if (message === 0xe0) {
+      engine.pushMidiInputPitchBend?.(group, channel, a | (b << 7), portTimeSamples);
     }
     return;
   }
@@ -380,10 +441,44 @@ function dispatchUmpMessage(
       engine.pushMidiInputNoteOn(group, channel, data1, velocity, portTimeSamples);
     } else if (status === 0xb) {
       engine.pushMidiInputCc(group, channel, data1, (word1 >>> 25) & 0x7f, portTimeSamples);
+    } else if (status === 0xa) {
+      engine.pushMidiInputPolyPressure?.(
+        group,
+        channel,
+        data1,
+        (word1 >>> 25) & 0x7f,
+        portTimeSamples,
+      );
+    } else if (status === 0xd) {
+      engine.pushMidiInputChannelPressure?.(group, channel, (word1 >>> 25) & 0x7f, portTimeSamples);
+    } else if (status === 0xe) {
+      engine.pushMidiInputPitchBend?.(group, channel, word1 >>> 18, portTimeSamples);
     }
   }
 }
 
+function umpWordCount(messageType: number): number {
+  switch (messageType & 0x0f) {
+    case 0x0:
+    case 0x1:
+    case 0x2:
+    case 0x6:
+    case 0x7:
+      return 1;
+    case 0x3:
+    case 0x4:
+    case 0x8:
+    case 0x9:
+    case 0xa:
+      return 2;
+    case 0xb:
+    case 0xc:
+      return 3;
+    default:
+      return 4;
+  }
+}
+
 function readU7(data: ArrayLike<number>, index: number): number {
   if (index >= data.length) {
     return -1;

package/src/worklet/engine-mixer-facade.ts

@@ -727,7 +727,8 @@ export function setTrackOutputBus(
 /**
  * Keys one insert of a lane strip from another lane's post-strip pre-fader
  * audio (ducking/sidechainRouter inserts). sourceTarget null removes the
- * binding.
+ * binding. The binding is cached for resync only once the engine has accepted
+ * it, so a refused (self-keyed or cyclic) binding throws and is never replayed.
  */
 export function setLaneSidechain(
   ctx: EngineMixerContext,