@libraz/libsonare 1.5.5 → 1.7.0

package/src/public_types.ts

@@ -4,3 +4,71 @@ export * from './public_types_mixing';
 export * from './public_types_music';
 export * from './public_types_realtime';
 export * from './public_types_spectral';
+
+/** Runtime capabilities reported by the loaded libsonare build. */
+export interface SonareCapabilities {
+  version: string;
+  abi: {
+    project: number;
+    engine: number;
+  };
+  platform: string;
+  features: {
+    mastering: boolean;
+    mixing: boolean;
+    fx: boolean;
+    ffmpeg: boolean;
+  };
+  decode: {
+    builtin: string[];
+    ffmpeg: string[];
+  };
+  simd: string;
+  hardwareConcurrency: number;
+}
+
+/** One parameter descriptor in the cross-surface capability catalog. */
+export interface CapabilityCatalogParameter {
+  name: string;
+  id: number;
+  rtSafe: boolean;
+  type: 'boolean' | 'number';
+  min: number | null;
+  max: number | null;
+  default: boolean | number | null;
+  unit: string | null;
+}
+
+/** One named mastering processor and its host-facing capabilities. */
+export interface CapabilityCatalogProcessor {
+  id: string;
+  kind: 'realtime' | 'offline' | 'pair';
+  realtimeInsertable: boolean;
+  stereoOnly: boolean;
+  latencySamples: number;
+  tailSamples: number;
+  /** Coarse realtime work estimate, or null when the processor is not an insert. */
+  realtimeCost: 'low' | 'moderate' | 'high' | null;
+  channelPolicy: 'multichannel' | 'stereoPairOnly' | 'perChannel' | 'passthrough';
+  category: string;
+  params: CapabilityCatalogParameter[];
+}
+
+/** Built-in preset names grouped by feature family. */
+export interface CapabilityCatalogPresets {
+  mastering: string[];
+  synth: string[];
+  mixingScene: string[];
+  voiceChanger: string[];
+}
+
+/** Complete runtime catalog exposed by {@link capabilityCatalog}. */
+export interface CapabilityCatalog {
+  version: string;
+  abi: SonareCapabilities['abi'];
+  processors: CapabilityCatalogProcessor[];
+  presets: CapabilityCatalogPresets;
+}
+
+/** Synchronous progress callback for offline operations. Its return value is ignored. */
+export type ProgressCallback = (progress: number, stage: string) => void;

package/src/public_types_mastering.ts

@@ -394,6 +394,26 @@ export interface StageGainReduction {
   gainReductionDb: number;
 }
 
+/** Existing EBU R128 measurements captured before or after mastering. */
+export interface MasteringLoudnessSummary {
+  integratedLufs: number;
+  maxMomentaryLufs: number;
+  maxShortTermLufs: number;
+  truePeakDbtp: number;
+  loudnessRange: number;
+}
+
+/** Compact explanation of how an offline mastering chain changed a program. */
+export interface MasteringReport {
+  before: MasteringLoudnessSummary;
+  after: MasteringLoudnessSummary;
+  appliedGainDb: number;
+  maxGainReductionDb: number;
+  loudnessTargetLimited: boolean;
+  /** 32 logarithmically-spaced after-minus-before spectral energy deltas (dB). */
+  bandEnergyDeltaDb: Float32Array;
+}
+
 export interface MasteringChainResult {
   /** Latency-compensated offline output; no separate latency field is reported. */
   samples: Float32Array;
@@ -414,6 +434,7 @@ export interface MasteringChainResult {
   loudnessTargetLimited: boolean;
   /** Per-stage gain reductions for the dynamics/maximizer stages (a subset of `stages`). */
   stageGainReductions: StageGainReduction[];
+  report: MasteringReport;
 }
 
 export interface MasteringChainStereoResult {
@@ -429,6 +450,7 @@ export interface MasteringChainStereoResult {
   outputLra: number;
   loudnessTargetLimited: boolean;
   stageGainReductions: StageGainReduction[];
+  report: MasteringReport;
 }
 
 /**

package/src/public_types_mixing.ts

@@ -1,4 +1,11 @@
-export type PanMode = 'balance' | 'stereoPan' | 'stereo-pan' | 'dualPan' | 'dual-pan' | number;
+export type PanMode =
+  | 'balance'
+  | 'pan'
+  | 'stereoPan'
+  | 'stereo-pan'
+  | 'dualPan'
+  | 'dual-pan'
+  | number;
 
 /**
  * Surround pan position for a strip feeding a >2-channel bus. Phase 1 honors
@@ -77,10 +84,28 @@ export type AutomationCurve = 'linear' | 'exponential' | 'hold' | 's-curve';
 
 /**
  * Pan law applied when computing left/right gains from a pan position
- * (see {@link Mixer.setPanLaw}). Maps to the underlying integer code.
+ * (see {@link Mixer.setPanLaw}). On mono strips it changes the centre gain;
+ * on stereo Balance strips it changes only the far-channel taper, while centre
+ * remains unity. Maps to the underlying integer code.
  */
 export type PanLaw = 'const3dB' | 'const4.5dB' | 'const6dB' | 'linear0dB';
 
+/** Accepted pan-law name aliases for mixer and realtime-engine inputs. */
+export type PanLawName =
+  | PanLaw
+  | 'const-3db'
+  | '-3db'
+  | 'const-4.5db'
+  | '-4.5db'
+  | 'const-6db'
+  | '-6db'
+  | 'linear-0db'
+  | 'linear'
+  | '0db';
+
+/** Pan-law name or raw C ABI ordinal. */
+export type PanLawInput = PanLawName | number;
+
 /**
  * Meter tap point for reading a strip's meter snapshot
  * (see {@link Mixer.meterTap} and {@link Mixer.stripMeter}).

package/src/public_types_music.ts

@@ -315,6 +315,13 @@ export interface TimeSignature {
   confidence: number;
 }
 
+/** Existing tempo-estimator hypothesis retained by unified analysis. */
+export interface BpmHypothesis {
+  value: number;
+  confidence: number;
+  relation: 'primary' | 'half' | 'double' | 'other';
+}
+
 /**
  * Rhythm features
  */
@@ -343,8 +350,10 @@ export interface MelodyContour {
 export interface AnalysisResult {
   bpm: number;
   bpmConfidence: number;
+  bpmCandidates: BpmHypothesis[];
   key: Key;
   timeSignature: TimeSignature;
+  timeSignatureCandidates: TimeSignature[];
   beatTimes: Float32Array;
   beats: Beat[];
   chords: Chord[];

package/src/public_types_realtime.ts

@@ -105,15 +105,33 @@ export type VoicePresetId =
   | 'robot-mascot'
   | 'dark-villain';
 
-export interface RealtimeVoiceChangerPreset {
+export type VoicePresetCategory =
+  | 'monitor'
+  | 'bright'
+  | 'soft'
+  | 'deep'
+  | 'robot'
+  | 'dark'
+  | 'custom';
+
+export interface RealtimeVoiceChangerPresetMetadata {
   schemaVersion: 1;
-  id?: string;
-  name?: string;
+  id: string;
+  name: string;
   description?: string;
-  macros?: Record<string, number>;
-  dsp?: Record<string, unknown>;
+  category: VoicePresetCategory;
 }
 
+export type RealtimeVoiceChangerPreset =
+  | (RealtimeVoiceChangerPresetMetadata & {
+      dsp: Record<string, unknown>;
+      macros?: never;
+    })
+  | (RealtimeVoiceChangerPresetMetadata & {
+      macros: Record<string, number>;
+      dsp?: never;
+    });
+
 export type RealtimeVoiceChangerConfigInput = VoicePresetId | RealtimeVoiceChangerPreset;
 
 /**

package/src/public_types_spectral.ts

@@ -182,6 +182,39 @@ export interface PitchResult {
   meanF0: number;
 }
 
+/** Per-bin pitch candidates and peak magnitudes from spectral piptrack. */
+export interface PiptrackResult {
+  nBins: number;
+  nFrames: number;
+  pitches: Float32Array;
+  magnitudes: Float32Array;
+}
+
+/** Magnitude and reassigned time/frequency coordinates for every STFT bin. */
+export interface ReassignedSpectrogramResult {
+  nBins: number;
+  nFrames: number;
+  magnitude: Float32Array;
+  times: Float32Array;
+  frequencies: Float32Array;
+}
+
+/** Row-major matrix returned by librosa.segment-compatible APIs. */
+export interface SegmentMatrix {
+  rows: number;
+  cols: number;
+  values: Float32Array;
+}
+
+/** One stable monophonic note region segmented from an F0 track. */
+export interface NoteSegment {
+  frameStart: number;
+  frameEnd: number;
+  startSeconds: number;
+  endSeconds: number;
+  medianCents: number;
+}
+
 /**
  * Loudness measurement result (EBU R128 / ITU-R BS.1770)
  */

package/src/quick_analysis.ts

@@ -29,7 +29,12 @@ import type {
 import { Mode, PitchClass } from './public_types';
 import type { ProgressCallback, WasmAcousticResult } from './sonare.js';
 import type { ValidateOptions } from './validation';
-import { assertNonNegativeInteger, assertSampleRate, assertSamples } from './validation';
+import {
+  assertFiniteScalar,
+  assertNonNegativeInteger,
+  assertSampleRate,
+  assertSamples,
+} from './validation';
 
 function requireModule() {
   return getSonareModule();
@@ -43,12 +48,29 @@ export interface SamplesRequest extends GuardedOptions {
   sampleRate?: number;
 }
 
+/** Peak-picking configuration for {@link detectOnsets}. */
+export interface OnsetDetectOptions {
+  nFft?: number;
+  hopLength?: number;
+  threshold?: number;
+  preMax?: number;
+  postMax?: number;
+  preAvg?: number;
+  postAvg?: number;
+  delta?: number;
+  wait?: number;
+  backtrack?: boolean;
+  backtrackRange?: number;
+}
+export interface DetectOnsetsRequest extends SamplesRequest, OnsetDetectOptions {}
+
 /** Canonical request form for key detection functions. */
 export interface DetectKeyRequest extends KeyDetectionOptions, SamplesRequest {}
 
 /** Canonical request form for analysis with synchronous progress reporting. */
 export interface AnalyzeWithProgressRequest extends SamplesRequest {
-  onProgress: ProgressCallback;
+  onProgress?: ProgressCallback;
+  cancel?: () => boolean;
 }
 
 /** Canonical request form for chord detection. */
@@ -64,6 +86,7 @@ export interface ChordFunctionalAnalysisRequest extends DetectChordsRequest {
 /** Canonical request form for impulse-response analysis. */
 export interface AnalyzeImpulseResponseRequest extends SamplesRequest {
   nOctaveBands?: number;
+  minDecayDb?: number;
 }
 
 /** Canonical request form for acoustic analysis. */
@@ -207,20 +230,20 @@ export function detectKeyCandidates(
  * @param sampleRate - Sample rate in Hz (default: 22050)
  * @returns Array of onset times in seconds
  */
-export function detectOnsets(request: SamplesRequest): Float32Array;
+export function detectOnsets(request: DetectOnsetsRequest): Float32Array;
 export function detectOnsets(
   samples: Float32Array,
   sampleRate?: number,
-  options?: GuardedOptions,
+  options?: OnsetDetectOptions & GuardedOptions,
 ): Float32Array;
 export function detectOnsets(
-  samples: Float32Array | SamplesRequest,
+  samples: Float32Array | DetectOnsetsRequest,
   sampleRate = 22050,
-  options: GuardedOptions = {},
+  options: OnsetDetectOptions & GuardedOptions = {},
 ): Float32Array {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput('detectOnsets', request.samples, request.sampleRate ?? 22050, request);
-  return requireModule().detectOnsets(request.samples, request.sampleRate ?? 22050);
+  return requireModule().detectOnsets(request.samples, request.sampleRate ?? 22050, request);
 }
 
 /**
@@ -418,23 +441,35 @@ export function analyzeImpulseResponse(
   samples: Float32Array,
   sampleRate?: number,
   nOctaveBands?: number,
+  minDecayDb?: number,
 ): AcousticResult;
 export function analyzeImpulseResponse(
   samples: Float32Array | AnalyzeImpulseResponseRequest,
   sampleRate = 48000,
   nOctaveBands = 6,
+  minDecayDb?: number,
 ): AcousticResult {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, nOctaveBands } : samples;
+  const request =
+    samples instanceof Float32Array ? { samples, sampleRate, nOctaveBands, minDecayDb } : samples;
+  if (request.minDecayDb === null) {
+    throw new TypeError('analyzeImpulseResponse: minDecayDb must be a finite number');
+  }
+  const resolvedMinDecayDb = request.minDecayDb === undefined ? 30.0 : request.minDecayDb;
+  assertFiniteScalar('analyzeImpulseResponse', resolvedMinDecayDb, 'minDecayDb');
+  if (resolvedMinDecayDb <= 0) {
+    throw new RangeError('analyzeImpulseResponse: minDecayDb must be greater than zero');
+  }
   validateAnalysisInput(
     'analyzeImpulseResponse',
     request.samples,
     request.sampleRate ?? 48000,
     request,
   );
-  const result: WasmAcousticResult = requireModule().analyzeImpulseResponse(
+  const result: WasmAcousticResult = requireModule().analyzeImpulseResponseEx(
     request.samples,
     request.sampleRate ?? 48000,
     request.nOctaveBands ?? 6,
+    resolvedMinDecayDb,
   );
   return result;
 }
@@ -559,7 +594,8 @@ export function analyzeWithProgress(
   const result = requireModule().analyzeWithProgress(
     request.samples,
     request.sampleRate ?? 22050,
-    request.onProgress,
+    request.onProgress ?? (() => {}),
+    request.cancel ?? (() => false),
   );
   return convertAnalysisResult(result);
 }

package/src/realtime_engine.ts

@@ -1,8 +1,8 @@
-import { panLawCode, panModeCode, sendTimingCode } from './codes';
+import { panLawCode, panModeCode, sendTimingCode, trackMonitorModeCode } from './codes';
 import { ErrorCode, SonareError } from './errors';
 import { getSonareModule } from './module_state';
 import type { ProjectMidiCcBinding, SynthPatch } from './project';
-import type { EqBand, PanLaw, PanMode, SendTiming } from './public_types';
+import type { EqBand, PanLawInput, PanMode, SendTiming } from './public_types';
 import type {
   WasmClipPageRequest,
   WasmEngineAutomationPoint,
@@ -38,6 +38,7 @@ export type EngineMarker = WasmEngineMarker;
 export type EngineMetronomeConfig = WasmEngineMetronomeConfig;
 export type EngineGraphSpec = WasmEngineGraphSpec;
 export type EngineCaptureStatus = WasmEngineCaptureStatus;
+export type EngineCaptureSource = EngineCaptureStatus['source'] | number;
 export type EngineBounceOptions = WasmEngineBounceOptions;
 export type EngineBounceResult = WasmEngineBounceResult;
 export type EngineFreezeOptions = WasmEngineFreezeOptions;
@@ -77,6 +78,12 @@ export interface EngineTrackLane {
   sourceChannelLayout?: number;
 }
 
+/** Per-track cue/monitor tap mode: off, pre-fader listen, or after-fader listen. */
+export type EngineTrackMonitorMode = 'off' | 'pfl' | 'afl' | 0 | 1 | 2;
+
+/** Short alias for {@link EngineTrackMonitorMode}. */
+export type TrackMonitorMode = EngineTrackMonitorMode;
+
 export interface EngineBus {
   busId: number;
   gainDb?: number;
@@ -161,6 +168,7 @@ export class RealtimeEngine {
     maxBlockSize = 128,
     commandCapacity = 1024,
     telemetryCapacity = 1024,
+    maxChannels = 64,
   ) {
     const module = getSonareModule();
     const capabilities = engineCapabilities();
@@ -174,6 +182,7 @@ export class RealtimeEngine {
       maxBlockSize,
       commandCapacity,
       telemetryCapacity,
+      maxChannels,
     );
   }
 
@@ -182,8 +191,15 @@ export class RealtimeEngine {
     maxBlockSize: number,
     commandCapacity = 1024,
     telemetryCapacity = 1024,
+    maxChannels = 64,
   ): void {
-    this.native.prepare(sampleRate, maxBlockSize, commandCapacity, telemetryCapacity);
+    this.native.prepareWithChannels(
+      sampleRate,
+      maxBlockSize,
+      commandCapacity,
+      telemetryCapacity,
+      maxChannels,
+    );
   }
 
   /** Queue a sample-accurate parameter change (engine kSetParam). */
@@ -209,6 +225,11 @@ export class RealtimeEngine {
     this.native.setSoloMute(laneIndex, solo, mute, renderFrame);
   }
 
+  /** Queue a per-track PFL/AFL monitor tap mode change. */
+  setTrackMonitorMode(laneIndex: number, mode: EngineTrackMonitorMode, renderFrame = -1): void {
+    this.native.setTrackMonitorMode(laneIndex, trackMonitorModeCode(mode), renderFrame);
+  }
+
   setMidiClips(clips: readonly EngineMidiClipSchedule[]): void {
     this.native.setMidiClips(clips);
   }
@@ -256,7 +277,12 @@ export class RealtimeEngine {
    * synthesizer GM fallback bank (the data-free floor).
    */
   setSf2Instrument(
-    config: { destinationId?: number; gain?: number; polyphony?: number } = {},
+    config: {
+      destinationId?: number;
+      gain?: number;
+      polyphony?: number;
+      preferModelForModeledFamilies?: boolean;
+    } = {},
     destinationId = config.destinationId ?? 0,
   ): void {
     this.native.setSf2Instrument(destinationId, config);
@@ -347,6 +373,10 @@ export class RealtimeEngine {
     return this.native.externalMidiDroppedCount();
   }
 
+  externalMidiPendingCount(): number {
+    return this.native.externalMidiPendingCount();
+  }
+
   /**
    * Drain queued external-MIDI events, already lowered to MIDI 1.0 byte
    * messages ready to write to a Web MIDI output port. Call once per audio
@@ -358,6 +388,31 @@ export class RealtimeEngine {
     return this.native.drainExternalMidi(maxRecords);
   }
 
+  /** Scalar, allocation-free external-MIDI drain for AudioWorklet SAB output. */
+  popExternalMidiToScratch(): boolean {
+    return this.native.popExternalMidiToScratch();
+  }
+
+  externalMidiScratchDestinationId(): number {
+    return this.native.externalMidiScratchDestinationId();
+  }
+
+  externalMidiScratchRenderFrame(): number {
+    return this.native.externalMidiScratchRenderFrame();
+  }
+
+  externalMidiScratchByteWord(): number {
+    return this.native.externalMidiScratchByteWord();
+  }
+
+  externalMidiScratchByteCount(): number {
+    return this.native.externalMidiScratchByteCount();
+  }
+
+  consumeExternalMidiScratch(): void {
+    this.native.consumeExternalMidiScratch();
+  }
+
   pushMidiInputNoteOn(
     group: number,
     channel: number,
@@ -427,6 +482,11 @@ export class RealtimeEngine {
     this.native.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
   }
 
+  /** Queue one immediate MIDI 1.0 channel-voice UMP word for a destination. */
+  pushMidiUmp(destinationId: number, word0: number, renderFrame = -1): void {
+    this.native.pushMidiUmp(destinationId, word0, renderFrame);
+  }
+
   /**
    * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
    * the full message including the leading 0xF0 and trailing 0xF7 (1..512
@@ -480,6 +540,11 @@ export class RealtimeEngine {
     this.native.settleParameters();
   }
 
+  /** Drains queued commands on an offline/control-only engine immediately. */
+  flushControlCommands(): void {
+    this.native.flushControlCommands();
+  }
+
   seekPpq(ppq: number, renderFrame = -1): void {
     this.native.seekPpq(ppq, renderFrame);
   }
@@ -777,7 +842,7 @@ export class RealtimeEngine {
   }
 
   /** Sets a track lane strip's pan law in realtime. */
-  setTrackStripPanLaw(trackId: number, panLaw: PanLaw | number): void {
+  setTrackStripPanLaw(trackId: number, panLaw: PanLawInput): void {
     this.native.setTrackStripPanLaw(trackId, panLawCode(panLaw));
   }
 
@@ -824,6 +889,27 @@ export class RealtimeEngine {
     return this.native.popClipPageRequest();
   }
 
+  /**
+   * Moves one native request into the binding's persistent scalar scratch.
+   * This avoids creating an embind JS object in AudioWorklet process().
+   */
+  popClipPageRequestToScratch(): boolean {
+    return this.native.popClipPageRequestToScratch();
+  }
+
+  clipPageRequestScratchClipId(): number {
+    return this.native.clipPageRequestScratchClipId();
+  }
+
+  clipPageRequestScratchSample(): number {
+    return this.native.clipPageRequestScratchSample();
+  }
+
+  /** Cumulative page misses dropped because the native bounded request queue was full. */
+  clipPageRequestOverflowCount(): number {
+    return this.native.clipPageRequestOverflowCount();
+  }
+
   setCaptureBuffer(numChannels: number, capacityFrames: number): void {
     this.native.setCaptureBuffer(numChannels, capacityFrames);
   }
@@ -836,7 +922,7 @@ export class RealtimeEngine {
     this.native.setCapturePunch(startSample, endSample, enabled);
   }
 
-  setCaptureSource(source: EngineCaptureStatus['source']): void {
+  setCaptureSource(source: EngineCaptureSource): void {
     this.native.setCaptureSource(source);
   }
 
@@ -861,6 +947,10 @@ export class RealtimeEngine {
     return this.native.capturedAudio();
   }
 
+  /**
+   * Renders in place, adding engine output to `channels`. Zero each plane first
+   * when it contains no upstream input.
+   */
   process(channels: Float32Array[]): Float32Array[] {
     return this.native.process(channels);
   }
@@ -886,6 +976,7 @@ export class RealtimeEngine {
 
   /**
    * Runs the engine in place over the prepared per-channel scratch buffers.
+   * Zero each active span first when it contains no upstream input.
    * Allocation-free: safe to call on the AudioWorklet render thread after
    * `prepareChannels`.
    */
@@ -913,6 +1004,51 @@ export class RealtimeEngine {
     return this.native.drainTelemetry(maxRecords);
   }
 
+  popTelemetryToScratch(): boolean {
+    return this.native.popTelemetryToScratch();
+  }
+
+  telemetryScratchType(): number {
+    return this.native.telemetryScratchType();
+  }
+
+  telemetryScratchError(): number {
+    return this.native.telemetryScratchError();
+  }
+
+  telemetryScratchRenderFrame(): number {
+    return Number(this.native.telemetryScratchRenderFrame());
+  }
+
+  telemetryScratchTimelineSample(): number {
+    return Number(this.native.telemetryScratchTimelineSample());
+  }
+
+  telemetryScratchAudibleTimelineSample(): number {
+    return Number(this.native.telemetryScratchAudibleTimelineSample());
+  }
+
+  telemetryScratchGraphLatencySamplesQ8(): number {
+    return this.native.telemetryScratchGraphLatencySamplesQ8();
+  }
+
+  telemetryScratchValue(): number {
+    return this.native.telemetryScratchValue();
+  }
+
+  popMeterTelemetryToScratch(): boolean {
+    return this.native.popMeterTelemetryToScratch();
+  }
+  meterScratchTargetId(): number {
+    return this.native.meterScratchTargetId();
+  }
+  meterScratchRenderFrame(): number {
+    return Number(this.native.meterScratchRenderFrame());
+  }
+  meterScratchValue(field: number): number {
+    return this.native.meterScratchValue(field);
+  }
+
   drainMeterTelemetry(maxRecords = 1024): EngineMeterTelemetry[] {
     return this.native.drainMeterTelemetry(maxRecords);
   }
@@ -944,6 +1080,31 @@ export class RealtimeEngine {
     return this.native.drainScopeTelemetry(maxRecords);
   }
 
+  popScopeTelemetryToScratch(): boolean {
+    return this.native.popScopeTelemetryToScratch();
+  }
+  scopeScratchTargetId(): number {
+    return this.native.scopeScratchTargetId();
+  }
+  scopeScratchRenderFrame(): number {
+    return Number(this.native.scopeScratchRenderFrame());
+  }
+  scopeScratchBandCount(): number {
+    return this.native.scopeScratchBandCount();
+  }
+  scopeScratchBand(index: number): number {
+    return this.native.scopeScratchBand(index);
+  }
+  scopeScratchPointCount(): number {
+    return this.native.scopeScratchPointCount();
+  }
+  scopeScratchPointLeft(index: number): number {
+    return this.native.scopeScratchPointLeft(index);
+  }
+  scopeScratchPointRight(index: number): number {
+    return this.native.scopeScratchPointRight(index);
+  }
+
   destroy(): void {
     this.native.delete();
   }