@dxos/pipeline-transcription 0.0.0

package/src/asr/pipeline.ts

@@ -0,0 +1,105 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ContentBlock } from '@dxos/types';
+
+import { type LivePipeline, runLivePipeline } from '../live';
+import { type RunOptions } from '../PipelineRuntime';
+import { type AudioRecorder } from './audio-recorder';
+import { SentenceBuffer } from './sentence-buffer';
+import { type TranscribeConfig, type TranscribeFn, Transcriber } from './transcriber';
+
+export type AsrPipelineOptions = Omit<RunOptions, 'source'> & {
+  /** Audio source — browser `MediaStreamRecorder` or any `AudioRecorder` implementation. */
+  recorder: AudioRecorder;
+  /** Optional ASR transport override (default: `fetch` to the edge transcription service). */
+  transcribe?: TranscribeFn;
+  /** Transcriber chunking configuration. */
+  config: TranscribeConfig;
+  /**
+   * Re-segment the ASR output into complete sentences before it enters the pipeline, merging
+   * fragments that the transcriber cut mid-sentence at chunk boundaries. @default false
+   */
+  segmentSentences?: boolean;
+  /** Optional raw-segment hook invoked before each block enters the pipeline (e.g. live display). */
+  onSegment?: (block: ContentBlock.Transcript) => void;
+  /** Silence (ms) reported on `end` so on-silence stages fire over the final window. */
+  drainSilenceMs?: number;
+};
+
+/** Imperative handle to a running ASR → pipeline session. */
+export type AsrPipeline = {
+  /** Open the recorder + transcriber. */
+  open: () => Promise<void>;
+  /** Begin capturing audio for transcription. */
+  start: () => void;
+  /** Stop capturing (buffered audio is still flushed by `end`). */
+  stop: () => void;
+  /** Abort the in-flight transcription request. */
+  abort: () => void;
+  /** Flush buffered audio, signal silence, and drain the pipeline. */
+  end: () => Promise<void>;
+};
+
+/**
+ * The single end-to-end wiring: an ASR source ({@link Transcriber}) feeding the live orchestration
+ * engine ({@link runLivePipeline}). Every consumer (editor driver, message-list recording, stories)
+ * differs only by recorder, stages, and commit sink — this is the one place audio → text → stages →
+ * sink is assembled.
+ */
+export const runAsrPipeline = ({
+  recorder,
+  transcribe,
+  config,
+  segmentSentences = false,
+  onSegment,
+  drainSilenceMs = 5_000,
+  ...runOptions
+}: AsrPipelineOptions): AsrPipeline => {
+  const live: LivePipeline = runLivePipeline(runOptions);
+  // Optionally merge mid-sentence ASR fragments into complete sentences before the pipeline sees them.
+  const sentences = segmentSentences ? new SentenceBuffer() : undefined;
+  const emit = (block: ContentBlock.Transcript) => {
+    onSegment?.(block);
+    live.block(block);
+  };
+  const handle = (blocks: ContentBlock.Transcript[]) => {
+    for (const block of blocks) {
+      if (sentences) {
+        for (const sentence of sentences.push(block)) {
+          emit(sentence);
+        }
+      } else {
+        emit(block);
+      }
+    }
+  };
+  const transcriber = new Transcriber({
+    config,
+    recorder,
+    transcribe,
+    onSegments: async (blocks: ContentBlock.Transcript[]) => handle(blocks),
+  });
+
+  return {
+    open: async () => {
+      await transcriber.open();
+    },
+    start: () => transcriber.startChunksRecording(),
+    stop: () => transcriber.stopChunksRecording(),
+    abort: () => transcriber.abort(),
+    end: async () => {
+      await transcriber.flush();
+      // Emit any sentence still buffered after the final flush.
+      if (sentences) {
+        for (const sentence of sentences.flush()) {
+          emit(sentence);
+        }
+      }
+      live.silence(drainSilenceMs);
+      await live.end();
+      await transcriber.close();
+    },
+  };
+};

package/src/asr/sentence-buffer.test.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { SentenceBuffer, splitSentences } from './sentence-buffer';
+
+const block = (text: string, started = 's') => ({ _tag: 'transcript' as const, started, text });
+
+describe('splitSentences', () => {
+  test('splits on terminal punctuation, keeps the remainder', ({ expect }) => {
+    expect(splitSentences('Hello there. How are')).toEqual({ sentences: ['Hello there.'], rest: 'How are' });
+  });
+
+  test('treats an ellipsis as non-terminal', ({ expect }) => {
+    expect(splitSentences('I was thinking... maybe later')).toEqual({
+      sentences: [],
+      rest: 'I was thinking... maybe later',
+    });
+  });
+
+  test('handles multiple sentences', ({ expect }) => {
+    expect(splitSentences('One. Two! Three?')).toEqual({ sentences: ['One.', 'Two!', 'Three?'], rest: '' });
+  });
+});
+
+describe('SentenceBuffer', () => {
+  test('merges mid-sentence fragments into a single sentence', ({ expect }) => {
+    const buffer = new SentenceBuffer();
+    // Mirrors the file-transcription story's fragmented Whisper output.
+    expect(buffer.push(block("I've been living in London for about..."))).toEqual([]);
+    expect(buffer.push(block('Years,'))).toEqual([]);
+    const emitted = buffer.push(block('maybe a bit longer.'));
+    expect(emitted.map((entry) => entry.text)).toEqual([
+      "I've been living in London for about... Years, maybe a bit longer.",
+    ]);
+  });
+
+  test('emits a completed sentence and buffers the next', ({ expect }) => {
+    const buffer = new SentenceBuffer();
+    const emitted = buffer.push(block('I moved to Camden originally. And now I'));
+    expect(emitted.map((entry) => entry.text)).toEqual(['I moved to Camden originally.']);
+    expect(buffer.flush().map((entry) => entry.text)).toEqual(['And now I']);
+  });
+
+  test('inherits the timestamp of the fragment that began the sentence', ({ expect }) => {
+    const buffer = new SentenceBuffer();
+    buffer.push(block('Hello', '00:00:00'));
+    const [emitted] = buffer.push(block('world.', '00:00:03'));
+    expect(emitted.started).toBe('00:00:00');
+  });
+});

package/src/asr/sentence-buffer.ts

@@ -0,0 +1,88 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ContentBlock } from '@dxos/types';
+
+/**
+ * Splits text into complete sentences plus a trailing incomplete remainder.
+ *
+ * A run of `.`/`!`/`?` followed by whitespace or end-of-string terminates a sentence; an ellipsis
+ * (`..`+) is treated as non-terminal so mid-thought pauses keep accumulating. Abbreviations are not
+ * special-cased — this is a deterministic heuristic, not a full sentence tokenizer.
+ */
+export const splitSentences = (text: string): { sentences: string[]; rest: string } => {
+  const sentences: string[] = [];
+  let start = 0;
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (char !== '.' && char !== '!' && char !== '?') {
+      continue;
+    }
+    // Collapse a run of terminators (e.g. "?!" or "...").
+    let end = index;
+    while (end + 1 < text.length && (text[end + 1] === '.' || text[end + 1] === '!' || text[end + 1] === '?')) {
+      end++;
+    }
+    const isEllipsis = text.slice(index, end + 1).startsWith('..');
+    const next = text[end + 1];
+    const atBoundary = next === undefined || /\s/.test(next);
+    if (!isEllipsis && atBoundary) {
+      const sentence = text.slice(start, end + 1).trim();
+      if (sentence.length > 0) {
+        sentences.push(sentence);
+      }
+      start = end + 1;
+    }
+    index = end;
+  }
+  return { sentences, rest: text.slice(start).trim() };
+};
+
+/**
+ * Accumulates ASR fragments (which cut mid-sentence at chunk boundaries) and re-emits complete,
+ * sentence-aligned transcript blocks. Each emitted block inherits the `started` timestamp of the
+ * fragment that began the sentence. `flush` emits whatever remains (e.g. on stop).
+ */
+export class SentenceBuffer {
+  #text = '';
+  #started?: string;
+
+  /** Append a fragment; returns any complete sentences it produced. */
+  push(block: ContentBlock.Transcript): ContentBlock.Transcript[] {
+    const fragment = block.text.trim();
+    if (fragment.length === 0) {
+      return [];
+    }
+    if (this.#text.length === 0) {
+      this.#started = block.started;
+    }
+    this.#text = this.#text.length === 0 ? fragment : `${this.#text} ${fragment}`;
+
+    const { sentences, rest } = splitSentences(this.#text);
+    if (sentences.length === 0) {
+      return [];
+    }
+    const startedForSentences = this.#started;
+    this.#text = rest;
+    // The remainder starts a new sentence whose timestamp we don't know yet; cleared until the next push.
+    this.#started = rest.length > 0 ? this.#started : undefined;
+    return sentences.map((text, index) => ({
+      _tag: 'transcript' as const,
+      started: index === 0 ? (startedForSentences ?? block.started) : block.started,
+      text,
+    }));
+  }
+
+  /** Emit any buffered text as a final sentence. */
+  flush(): ContentBlock.Transcript[] {
+    const remaining = this.#text.trim();
+    this.#text = '';
+    const started = this.#started;
+    this.#started = undefined;
+    if (remaining.length === 0) {
+      return [];
+    }
+    return [{ _tag: 'transcript', started: started ?? new Date(0).toISOString(), text: remaining }];
+  }
+}

package/src/asr/transcriber.test.ts

@@ -0,0 +1,104 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { type AudioChunk } from './audio-recorder';
+import { type WhisperSegment, alignWhisperSegments } from './transcriber';
+
+const T0 = Date.parse('2026-01-01T00:00:00.000Z');
+
+const chunk = (offsetMs = 0, samples = 16): AudioChunk => ({
+  timestamp: T0 + offsetMs,
+  data: new Float64Array(samples),
+});
+
+const segment = (overrides: Partial<WhisperSegment>): WhisperSegment => ({
+  text: '',
+  start: 0,
+  end: 0,
+  no_speech_prob: 0,
+  words: [],
+  ...overrides,
+});
+
+describe('alignWhisperSegments', () => {
+  test('returns empty when no chunks were transcribed', ({ expect }) => {
+    const result = alignWhisperSegments(
+      [segment({ text: 'x', end: 1, words: [{ word: 'x', start: 0, end: 1 }] })],
+      [],
+      0,
+    );
+    expect(result.transcripts).toEqual([]);
+    expect(result.lastTimestamp).toBeUndefined();
+  });
+
+  test('absolute-timestamps and deduplicates segments against lastTimestamp', ({ expect }) => {
+    const segments: WhisperSegment[] = [
+      segment({
+        text: 'hello world',
+        start: 0,
+        end: 1,
+        words: [
+          { word: 'hello ', start: 0, end: 0.5 },
+          { word: 'world', start: 0.5, end: 1 },
+        ],
+      }),
+    ];
+
+    const first = alignWhisperSegments(segments, [chunk(0)], 0);
+    expect(first.transcripts).toHaveLength(1);
+    expect(first.transcripts[0]._tag).toBe('transcript');
+    expect(first.transcripts[0].text).toBe('hello world');
+    expect(new Date(first.transcripts[0].started).getTime()).toBe(T0);
+    expect(first.lastTimestamp).toBe(T0 + 1_000);
+
+    // Same segments, same chunk start: every word's absolute start is < lastTimestamp -> filtered out.
+    const second = alignWhisperSegments(segments, [chunk(0)], first.lastTimestamp!);
+    expect(second.transcripts).toEqual([]);
+    expect(second.lastTimestamp).toBeUndefined();
+  });
+
+  test('keeps later words when earlier words fall before lastTimestamp', ({ expect }) => {
+    const segments: WhisperSegment[] = [
+      segment({
+        text: 'old new',
+        start: 0,
+        end: 2,
+        words: [
+          { word: 'old ', start: 0, end: 1 },
+          { word: 'new', start: 1.5, end: 2 },
+        ],
+      }),
+    ];
+
+    // First word starts at T0, second at T0+1500 — only the second survives a cursor at T0+1000.
+    const result = alignWhisperSegments(segments, [chunk(0)], T0 + 1_000);
+    expect(result.transcripts).toHaveLength(1);
+    expect(result.transcripts[0].text).toBe('new');
+    expect(new Date(result.transcripts[0].started).getTime()).toBe(T0 + 1_500);
+    expect(result.lastTimestamp).toBe(T0 + 2_000);
+  });
+
+  test('drops segments that end before lastTimestamp', ({ expect }) => {
+    const segments: WhisperSegment[] = [
+      segment({
+        text: 'stale',
+        start: 0,
+        end: 0.5,
+        words: [{ word: 'stale', start: 0, end: 0.5 }],
+      }),
+      segment({
+        text: 'fresh',
+        start: 1,
+        end: 2,
+        words: [{ word: 'fresh', start: 1.5, end: 2 }],
+      }),
+    ];
+
+    const result = alignWhisperSegments(segments, [chunk(0)], T0 + 1_000);
+    expect(result.transcripts).toHaveLength(1);
+    expect(result.transcripts[0].text).toBe('fresh');
+  });
+});

package/src/asr/transcriber.ts

@@ -0,0 +1,337 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { WaveFile } from 'wavefile';
+
+import { DeferredTask, Trigger, synchronized } from '@dxos/async';
+import { EDGE_SERVICE_DEFAULTS, EdgeServiceName } from '@dxos/config';
+import { type Context, LifecycleState, Resource } from '@dxos/context';
+import { log } from '@dxos/log';
+import { trace } from '@dxos/tracing';
+import { type ContentBlock } from '@dxos/types';
+
+import { type AudioChunk, type AudioRecorder } from './audio-recorder';
+import { mergeFloat64Arrays } from './util';
+
+export type WhisperWord = {
+  word: string;
+
+  /**
+   * Time in seconds from the start of the audio.
+   */
+  start: number;
+
+  /**
+   * Time in seconds from the start of the audio.
+   */
+  end: number;
+};
+
+export type WhisperSegment = {
+  text: string;
+
+  /**
+   * Time in seconds from the start of the audio.
+   */
+  start: number;
+
+  /**
+   * Time in seconds from the start of the audio.
+   */
+  end: number;
+
+  /**
+   * Probability of no speech in the segment.
+   */
+  no_speech_prob: number;
+
+  words: WhisperWord[];
+};
+
+export type TranscribeConfig = {
+  /**
+   * Number of chunks to transcribe automatically after.
+   */
+  transcribeAfterChunksAmount: number;
+
+  /**
+   * Number of chunks to save before the user starts speaking.
+   * This is needed to catch the beginning of the user's speech.
+   */
+  prefixBufferChunksAmount: number;
+
+  /**
+   * Override the transcription endpoint base URL.
+   * Defaults to the DXOS calls service.
+   */
+  endpoint?: string;
+};
+
+/**
+ * Function that converts a base64-encoded WAV payload into Whisper segments.
+ * Allows callers to swap in alternative providers or mock the transport.
+ */
+export type TranscribeFn = (audio: string) => Promise<WhisperSegment[]>;
+
+export type TranscriberProps = {
+  config: TranscribeConfig;
+  recorder: AudioRecorder;
+  /**
+   * Optional override of the transcription transport. When provided, supersedes `config.endpoint`.
+   */
+  transcribe?: TranscribeFn;
+  /**
+   * Callback to handle the transcribed segments, after all segment transformers are applied.
+   * @param segments - The transcribed segments.
+   */
+  onSegments: (segments: ContentBlock.Transcript[]) => Promise<void>;
+};
+
+/**
+ * Handles transcription of audio chunks.
+ * If user is not speaking, the last `minChunksAmount` chunks are saved and transcribed.
+ * If user is speaking, the chunks are added to the buffer until the user is done talking.
+ */
+export class Transcriber extends Resource {
+  private _audioChunks: AudioChunk[] = [];
+  private _lastTimestamp = 0;
+
+  private readonly _openTrigger = new Trigger({ autoReset: true });
+
+  private readonly _config: TranscribeConfig;
+  private readonly _recorder: AudioRecorder;
+  private readonly _onSegments: TranscriberProps['onSegments'];
+  private readonly _transcribeFn?: TranscribeFn;
+
+  private _recording = false;
+  private _transcribeTask?: DeferredTask = undefined;
+  /** Aborts the in-flight transcription request (e.g. when the user cancels the drain). */
+  private _transcribeAbort?: AbortController = undefined;
+
+  constructor({ config, recorder, onSegments, transcribe }: TranscriberProps) {
+    super();
+    this._config = config;
+    this._recorder = recorder;
+    this._onSegments = onSegments;
+    this._transcribeFn = transcribe;
+  }
+
+  protected override async _open(ctx: Context): Promise<void> {
+    log.info('opening');
+    this._recorder.setOnChunk((chunk) => this._saveAudioChunk(chunk));
+    await this._recorder.start();
+    this._transcribeTask = new DeferredTask(ctx, async () => this._transcribe());
+    this._openTrigger.wake();
+  }
+
+  protected override async _close(): Promise<void> {
+    log.info('closing');
+    this._recording = false;
+    this._transcribeTask = undefined;
+    this._transcribeAbort?.abort();
+    await this._recorder.stop();
+  }
+
+  /** Abort the in-flight transcription request (e.g. user cancelled the drain). */
+  abort(): void {
+    this._transcribeAbort?.abort();
+  }
+
+  startChunksRecording(): void {
+    log.info('starting');
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+
+    this._recording = true;
+  }
+
+  stopChunksRecording(): void {
+    if (this._lifecycleState !== LifecycleState.OPEN || !this._recording) {
+      return;
+    }
+
+    this._recording = false;
+    this._transcribeTask?.schedule();
+    log.info('stopped');
+  }
+
+  /**
+   * Stop recording and transcribe any buffered audio, resolving once the final segments have been
+   * delivered via `onSegments`. Used to drain the pipeline when recording stops so the tail of speech
+   * (and its downstream enrichment) is not lost.
+   */
+  async flush(): Promise<void> {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+
+    this._recording = false;
+    await this._transcribe();
+  }
+
+  private _saveAudioChunk(chunk: AudioChunk): void {
+    log('saving audio chunk', { chunk });
+    this._audioChunks.push(chunk);
+
+    // Clean the buffer if the user is not speaking and the transcription task is not scheduled.
+    if (
+      !this._recording &&
+      (!this._transcribeTask || !this._transcribeTask.scheduled) &&
+      this._audioChunks.length >= this._config.prefixBufferChunksAmount
+    ) {
+      this._audioChunks = this._dropOldChunks();
+    } else if (this._audioChunks.length >= this._config.transcribeAfterChunksAmount && this._recording) {
+      this._transcribeTask?.schedule();
+    }
+  }
+
+  // Serialized so a threshold-scheduled run and a flush()/deferred run cannot read the same buffer
+  // concurrently and duplicate or drop tail segments.
+  @synchronized
+  private async _transcribe(): Promise<void> {
+    log('transcribing', { chunks: this._audioChunks.length });
+    const chunks = this._audioChunks;
+    this._audioChunks = this._dropOldChunks();
+    if (chunks.length === 0) {
+      return;
+    }
+
+    const audio = await this._mergeAudioChunks(chunks);
+    const segments = await this._fetchTranscription(audio);
+    if (!Array.isArray(segments) || segments.length === 0) {
+      return;
+    }
+
+    const alignedSegments = this._alignSegments(segments, chunks);
+    if (alignedSegments.length > 0) {
+      await this._onSegments(alignedSegments);
+    }
+  }
+
+  private _dropOldChunks(): AudioChunk[] {
+    return this._config.prefixBufferChunksAmount > 0
+      ? this._audioChunks.slice(-this._config.prefixBufferChunksAmount)
+      : [];
+  }
+
+  @trace.span({ showInBrowserTimeline: true })
+  private async _mergeAudioChunks(chunks: AudioChunk[]): Promise<string> {
+    const file = new WaveFile();
+    const wavConfig = this._recorder.wavConfig;
+
+    file.fromScratch(
+      wavConfig.channels,
+      wavConfig.sampleRate,
+      wavConfig.bitDepthCode,
+      mergeFloat64Arrays(chunks.map(({ data }) => data)),
+    );
+
+    return file.toBase64();
+  }
+
+  @trace.span({ showInBrowserTimeline: true })
+  private async _fetchTranscription(audio: string): Promise<WhisperSegment[]> {
+    if (audio.length === 0) {
+      throw new Error('No audio to send for transcribing');
+    }
+
+    let segments: unknown;
+    if (this._transcribeFn) {
+      segments = await this._transcribeFn(audio);
+    } else {
+      // TODO(burdon): Create separate endpoint?
+      const endpoint = this._config.endpoint ?? EDGE_SERVICE_DEFAULTS[EdgeServiceName.Transcription];
+      this._transcribeAbort = new AbortController();
+      let response: Response;
+      try {
+        response = await fetch(`${endpoint}/transcribe`, {
+          method: 'POST',
+          body: JSON.stringify({ audio }),
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          signal: this._transcribeAbort.signal,
+        });
+      } catch (err) {
+        // Aborting (user cancelled the drain) is a clean stop, not a failed transcription cycle.
+        if (err instanceof DOMException && err.name === 'AbortError') {
+          return [];
+        }
+        throw err;
+      } finally {
+        this._transcribeAbort = undefined;
+      }
+
+      if (!response.ok) {
+        throw new Error(`Transcription failed: ${response.statusText}`);
+      }
+
+      ({ segments } = (await response.json()) as { segments?: unknown });
+    }
+
+    if (!Array.isArray(segments)) {
+      throw new Error('Transcription response payload is invalid');
+    }
+
+    log.info('transcription response', { segments: segments.length });
+    return segments as WhisperSegment[];
+  }
+
+  private _alignSegments(segments: WhisperSegment[], originalChunks: AudioChunk[]): ContentBlock.Transcript[] {
+    const result = alignWhisperSegments(segments, originalChunks, this._lastTimestamp);
+    if (result.lastTimestamp !== undefined) {
+      this._lastTimestamp = result.lastTimestamp;
+    }
+
+    return result.transcripts;
+  }
+}
+
+/**
+ * Pure helper that filters and absolute-timestamps Whisper segments against a chunk timeline.
+ * Exported for testing.
+ *
+ * @param segments - Raw segments returned by the Whisper service for `originalChunks`.
+ * @param originalChunks - Chunks fed into the transcription request (used for the zero timestamp).
+ * @param lastTimestamp - Most recent absolute timestamp already emitted; segments whose end
+ *   falls strictly before this point are deduped out, as are individual words whose start does.
+ */
+export const alignWhisperSegments = (
+  segments: WhisperSegment[],
+  originalChunks: AudioChunk[],
+  lastTimestamp: number,
+): { transcripts: ContentBlock.Transcript[]; lastTimestamp?: number } => {
+  if (originalChunks.length === 0) {
+    return { transcripts: [] };
+  }
+
+  const zeroTimestamp = originalChunks[0].timestamp;
+
+  const filteredSegments = segments
+    .filter((segment) => zeroTimestamp + segment.end * 1_000 >= lastTimestamp)
+    .map((segment) => {
+      const words = segment.words.filter((word) => zeroTimestamp + word.start * 1_000 >= lastTimestamp);
+      return {
+        ...segment,
+        words,
+        text: words.map((word) => word.word).join(''),
+        start: words.at(0)?.start ?? segment.end,
+      };
+    })
+    .filter((segment) => segment.words.length > 0);
+
+  if (filteredSegments.length === 0) {
+    return { transcripts: [] };
+  }
+
+  return {
+    lastTimestamp: zeroTimestamp + filteredSegments.at(-1)!.end * 1_000,
+    transcripts: filteredSegments.map((segment) => ({
+      _tag: 'transcript',
+      started: new Date(zeroTimestamp + segment.start * 1_000).toISOString(),
+      text: segment.text.trim(),
+    })),
+  };
+};

package/src/asr/util.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const mergeFloat64Arrays = (arrays: Float64Array[]) => {
+  const newArray = new Float64Array(arrays.reduce((acc, array) => array.length + acc, 0));
+  let offset = 0;
+  for (const array of arrays) {
+    newArray.set(array, offset);
+    offset += array.length;
+  }
+
+  return newArray;
+};