@editframe/elements 0.17.6-beta.0 → 0.18.7-beta.0

package/src/elements/EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.ts

@@ -0,0 +1,250 @@
+import { Task } from "@lit/task";
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
+import { LRUCache } from "../../../utils/LRUCache.js";
+import type { EFMedia } from "../../EFMedia.js";
+
+// DECAY_WEIGHT constant - same as original
+const DECAY_WEIGHT = 0.8;
+
+function processFFTData(
+  fftData: Uint8Array,
+  zeroThresholdPercent = 0.1,
+): Uint8Array {
+  // Step 1: Determine the threshold for zeros
+  const totalBins = fftData.length;
+  const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);
+
+  // Step 2: Interrogate the FFT output to find the cutoff point
+  let zeroCount = 0;
+  let cutoffIndex = totalBins; // Default to the end of the array
+
+  for (let i = totalBins - 1; i >= 0; i--) {
+    if (fftData[i] ?? 0 < 10) {
+      zeroCount++;
+    } else {
+      // If we encounter a non-zero value, we can stop
+      if (zeroCount >= zeroThresholdCount) {
+        cutoffIndex = i + 1; // Include this index
+        break;
+      }
+    }
+  }
+
+  if (cutoffIndex < zeroThresholdCount) {
+    return fftData;
+  }
+
+  // Step 3: Resample the "good" portion of the data
+  const goodData = fftData.slice(0, cutoffIndex);
+  const resampledData = interpolateData(goodData, fftData.length);
+
+  // Step 4: Attenuate the top 10% of interpolated samples
+  const attenuationStartIndex = Math.floor(totalBins * 0.9);
+  for (let i = attenuationStartIndex; i < totalBins; i++) {
+    // Calculate attenuation factor that goes from 1 to 0 over the top 10%
+    const attenuationProgress =
+      (i - attenuationStartIndex) / (totalBins - attenuationStartIndex) + 0.2;
+    const attenuationFactor = Math.max(0, 1 - attenuationProgress);
+    resampledData[i] = Math.floor((resampledData[i] ?? 0) * attenuationFactor);
+  }
+
+  return resampledData;
+}
+
+function interpolateData(data: Uint8Array, targetSize: number): Uint8Array {
+  const resampled = new Uint8Array(targetSize);
+  const dataLength = data.length;
+
+  for (let i = 0; i < targetSize; i++) {
+    // Calculate the corresponding index in the original data
+    const ratio = (i / (targetSize - 1)) * (dataLength - 1);
+    const index = Math.floor(ratio);
+    const fraction = ratio - index;
+
+    // Handle edge cases
+    if (index >= dataLength - 1) {
+      resampled[i] = data[dataLength - 1] ?? 0; // Last value
+    } else {
+      // Linear interpolation
+      resampled[i] = Math.round(
+        (data[index] ?? 0) * (1 - fraction) + (data[index + 1] ?? 0) * fraction,
+      );
+    }
+  }
+
+  return resampled;
+}
+
+export function makeAudioFrequencyAnalysisTask(element: EFMedia) {
+  // Internal cache for this task instance (same as original #frequencyDataCache)
+  const cache = new LRUCache<string, Uint8Array>(100);
+
+  return new Task(element, {
+    autoRun: EF_INTERACTIVE,
+    onError: (error) => {
+      console.error("frequencyDataTask error", error);
+    },
+    args: () =>
+      [
+        element.audioBufferTask.status,
+        element.currentSourceTimeMs,
+        element.fftSize,
+        element.fftDecay,
+        element.fftGain,
+        element.shouldInterpolateFrequencies,
+      ] as const,
+    task: async () => {
+      await element.audioBufferTask.taskComplete;
+      if (!element.audioBufferTask.value) return null;
+      if (element.currentSourceTimeMs < 0) return null;
+
+      const currentTimeMs = element.currentSourceTimeMs;
+
+      // ONLY CHANGE: Get real audio data for analysis (same technique as playback)
+      const analysisWindowMs = 5000; // Get 5 seconds for better analysis
+      const fromMs = Math.max(0, currentTimeMs);
+      // Clamp toMs to video duration to prevent requesting segments beyond available content
+      const maxToMs = fromMs + analysisWindowMs;
+      const videoDurationMs = element.intrinsicDurationMs || 0;
+      const toMs =
+        videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;
+
+      // If the clamping results in an invalid range (seeking beyond the end), skip analysis silently
+      if (fromMs >= toMs) {
+        return null;
+      }
+
+      const { fetchAudioSpanningTime: fetchAudioSpan } = await import(
+        "../shared/AudioSpanUtils.ts"
+      );
+      const audioSpan = await fetchAudioSpan(
+        element,
+        fromMs,
+        toMs,
+        new AbortController().signal,
+      );
+
+      if (!audioSpan || !audioSpan.blob) {
+        console.warn("Frequency analysis skipped: no audio data available");
+        return null;
+      }
+
+      // Decode the real audio data
+      const tempAudioContext = new OfflineAudioContext(2, 48000, 48000);
+      const arrayBuffer = await audioSpan.blob.arrayBuffer();
+      const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);
+
+      // Use actual startOffset from audioSpan (relative to requested time)
+      const startOffsetMs = audioSpan.startMs;
+
+      // ORIGINAL ALGORITHM FROM HERE - unchanged customer logic
+      const smoothedKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${startOffsetMs}:${currentTimeMs}`;
+
+      const cachedSmoothedData = cache.get(smoothedKey);
+      if (cachedSmoothedData) {
+        return cachedSmoothedData;
+      }
+
+      const framesData = await Promise.all(
+        Array.from({ length: element.fftDecay }, async (_, i) => {
+          const frameOffset = i * (1000 / 30);
+          const startTime = Math.max(
+            0,
+            (currentTimeMs - frameOffset - startOffsetMs) / 1000,
+          );
+
+          // Cache key for this specific frame
+          const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;
+
+          // Check cache for this specific frame
+          const cachedFrame = cache.get(cacheKey);
+          if (cachedFrame) {
+            return cachedFrame;
+          }
+
+          // Running 48000 * (1 / 30) = 1600 broke something terrible, it came out as 0,
+          // I'm assuming weird floating point nonsense to do with running on rosetta
+          const SIZE = 48000 / 30;
+          let audioContext: OfflineAudioContext;
+          try {
+            audioContext = new OfflineAudioContext(2, SIZE, 48000);
+          } catch (error) {
+            throw new Error(
+              `[EFMedia.frequencyDataTask] Failed to create OfflineAudioContext(2, ${SIZE}, 48000) for frame ${i} at time ${startTime}s: ${error instanceof Error ? error.message : String(error)}. This is for audio frequency analysis.`,
+            );
+          }
+          const analyser = audioContext.createAnalyser();
+          analyser.fftSize = element.fftSize;
+          analyser.minDecibels = -90;
+          analyser.maxDecibels = -10;
+
+          const gainNode = audioContext.createGain();
+          gainNode.gain.value = element.fftGain;
+
+          const filter = audioContext.createBiquadFilter();
+          filter.type = "bandpass";
+          filter.frequency.value = 15000;
+          filter.Q.value = 0.05;
+
+          const audioBufferSource = audioContext.createBufferSource();
+          audioBufferSource.buffer = audioBuffer;
+
+          audioBufferSource.connect(filter);
+          filter.connect(gainNode);
+          gainNode.connect(analyser);
+          analyser.connect(audioContext.destination);
+
+          audioBufferSource.start(0, startTime, 1 / 30);
+
+          try {
+            await audioContext.startRendering();
+            const frameData = new Uint8Array(element.fftSize / 2);
+            analyser.getByteFrequencyData(frameData);
+
+            // Cache this frame's analysis
+            cache.set(cacheKey, frameData);
+            return frameData;
+          } finally {
+            audioBufferSource.disconnect();
+            analyser.disconnect();
+          }
+        }),
+      );
+
+      const frameLength = framesData[0]?.length ?? 0;
+
+      // Combine frames with decay
+      const smoothedData = new Uint8Array(frameLength);
+      for (let i = 0; i < frameLength; i++) {
+        let weightedSum = 0;
+        let weightSum = 0;
+
+        framesData.forEach((frame: Uint8Array, frameIndex: number) => {
+          const decayWeight = DECAY_WEIGHT ** frameIndex;
+          weightedSum += (frame[i] ?? 0) * decayWeight;
+          weightSum += decayWeight;
+        });
+
+        smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
+      }
+
+      // Apply frequency weights using instance FREQ_WEIGHTS
+      smoothedData.forEach((value, i) => {
+        const freqWeight = element.FREQ_WEIGHTS[i] ?? 0;
+        smoothedData[i] = Math.min(255, Math.round(value * freqWeight));
+      });
+
+      // Only return the lower half of the frequency data
+      // The top half is zeroed out, which makes for aesthetically unpleasing waveforms
+      const slicedData = smoothedData.slice(
+        0,
+        Math.floor(smoothedData.length / 2),
+      );
+      const processedData = element.shouldInterpolateFrequencies
+        ? processFFTData(slicedData)
+        : slicedData;
+      cache.set(smoothedKey, processedData);
+      return processedData;
+    },
+  });
+}

package/src/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.browsertest.ts

@@ -0,0 +1,59 @@
+import { TaskStatus } from "@lit/task";
+import { customElement } from "lit/decorators.js";
+import { afterEach, beforeEach, describe, vi } from "vitest";
+import { test as baseTest } from "../../../../test/useMSW.js";
+import { EFAudio } from "../../EFAudio";
+import { makeAudioInitSegmentFetchTask } from "./makeAudioInitSegmentFetchTask";
+
+@customElement("test-media-audio-init-segment-fetch")
+class TestMediaAudioInitSegmentFetch extends EFAudio {}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "test-media-audio-init-segment-fetch": TestMediaAudioInitSegmentFetch;
+  }
+}
+
+const test = baseTest.extend<{
+  element: TestMediaAudioInitSegmentFetch;
+}>({
+  element: async ({}, use) => {
+    const element = document.createElement(
+      "test-media-audio-init-segment-fetch",
+    );
+    await use(element);
+    element.remove();
+  },
+});
+
+describe("makeAudioInitSegmentFetchTask", () => {
+  beforeEach(() => {
+    // MSW setup is now handled by test fixtures
+  });
+
+  afterEach(() => {
+    const elements = document.querySelectorAll(
+      "test-media-audio-init-segment-fetch",
+    );
+    for (const element of elements) {
+      element.remove();
+    }
+    vi.restoreAllMocks();
+  });
+
+  test("creates task with correct initial state", ({ element, expect }) => {
+    const task = makeAudioInitSegmentFetchTask(element);
+
+    expect(task).toBeDefined();
+    expect(task.status).toBe(TaskStatus.INITIAL);
+    expect(task.value).toBeUndefined();
+    expect(task.error).toBeUndefined();
+  });
+
+  test("task integrates with element properties", ({ element, expect }) => {
+    const task = makeAudioInitSegmentFetchTask(element);
+
+    expect(task).toBeDefined();
+    expect(task.status).toBe(TaskStatus.INITIAL);
+  });
+});

package/src/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.ts

@@ -0,0 +1,23 @@
+import { Task } from "@lit/task";
+import type { MediaEngine } from "../../../transcoding/types";
+import type { EFMedia } from "../../EFMedia";
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
+
+export const makeAudioInitSegmentFetchTask = (
+  host: EFMedia,
+): Task<readonly [MediaEngine | undefined], ArrayBuffer> => {
+  return new Task(host, {
+    args: () => [host.mediaEngineTask.value] as const,
+    onError: (error) => {
+      console.error("audioInitSegmentFetchTask error", error);
+    },
+    onComplete: (_value) => {},
+    task: async ([_mediaEngine], { signal }) => {
+      const mediaEngine = await getLatestMediaEngine(host, signal);
+      return mediaEngine.fetchInitSegment(
+        mediaEngine.getAudioRendition(),
+        signal,
+      );
+    },
+  });
+};

package/src/elements/EFMedia/audioTasks/makeAudioInputTask.browsertest.ts

@@ -0,0 +1,55 @@
+import { TaskStatus } from "@lit/task";
+import { customElement } from "lit/decorators.js";
+import { afterEach, beforeEach, describe, vi } from "vitest";
+import { test as baseTest } from "../../../../test/useMSW.js";
+import { EFAudio } from "../../EFAudio";
+import { makeAudioInputTask } from "./makeAudioInputTask";
+
+@customElement("test-media-audio-input")
+class TestMediaAudioInput extends EFAudio {}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "test-media-audio-input": TestMediaAudioInput;
+  }
+}
+
+const test = baseTest.extend<{
+  element: TestMediaAudioInput;
+}>({
+  element: async ({}, use) => {
+    const element = document.createElement("test-media-audio-input");
+    await use(element);
+    element.remove();
+  },
+});
+
+describe("makeAudioInputTask", () => {
+  beforeEach(() => {
+    // MSW setup is now handled by test fixtures
+  });
+
+  afterEach(() => {
+    const elements = document.querySelectorAll("test-media-audio-input");
+    for (const element of elements) {
+      element.remove();
+    }
+    vi.restoreAllMocks();
+  });
+
+  test("creates task with correct initial state", ({ element, expect }) => {
+    const task = makeAudioInputTask(element);
+
+    expect(task).toBeDefined();
+    expect(task.status).toBe(TaskStatus.INITIAL);
+    expect(task.value).toBeUndefined();
+    expect(task.error).toBeUndefined();
+  });
+
+  test("task integrates with element properties", ({ element, expect }) => {
+    const task = makeAudioInputTask(element);
+
+    expect(task).toBeDefined();
+    expect(task.status).toBe(TaskStatus.INITIAL);
+  });
+});

package/src/elements/EFMedia/audioTasks/makeAudioInputTask.ts

@@ -0,0 +1,43 @@
+import { Task } from "@lit/task";
+import { EFMedia } from "../../EFMedia";
+import { BufferedSeekingInput } from "../BufferedSeekingInput";
+import type { InputTask } from "../shared/MediaTaskUtils";
+
+export const makeAudioInputTask = (host: EFMedia): InputTask => {
+  return new Task<
+    readonly [ArrayBuffer | undefined, ArrayBuffer | undefined],
+    BufferedSeekingInput
+  >(host, {
+    args: () =>
+      [
+        host.audioInitSegmentFetchTask.value,
+        host.audioSegmentFetchTask.value,
+      ] as const,
+    onError: (error) => {
+      console.error("audioInputTask error", error);
+    },
+    onComplete: (_value) => {},
+    task: async (_, { signal }) => {
+      const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
+      signal.throwIfAborted(); // Abort if a new seek started
+      const segment = await host.audioSegmentFetchTask.taskComplete;
+      signal.throwIfAborted(); // Abort if a new seek started
+      if (!initSegment || !segment) {
+        throw new Error("Init segment or segment is not available");
+      }
+
+      // Get startTimeOffsetMs from the audio rendition if available
+      const mediaEngine = await host.mediaEngineTask.taskComplete;
+      const audioRendition = mediaEngine?.audioRendition;
+      const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;
+
+      const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
+      signal.throwIfAborted(); // Abort if a new seek started
+      return new BufferedSeekingInput(arrayBuffer, {
+        videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
+        audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
+        startTimeOffsetMs,
+      });
+    },
+  });
+};

package/src/elements/EFMedia/audioTasks/makeAudioSeekTask.chunkboundary.regression.browsertest.ts

@@ -0,0 +1,199 @@
+import { afterEach, beforeEach, describe } from "vitest";
+import { test as baseTest } from "../../../../test/useMSW.js";
+import type { EFConfiguration } from "../../../gui/EFConfiguration.js";
+import "../../../gui/EFPreview.js";
+import "../../EFTimegroup.js";
+import type { EFTimegroup } from "../../EFTimegroup.js";
+import "../../EFVideo.js";
+import type { EFVideo } from "../../EFVideo.js";
+
+const test = baseTest.extend<{
+  timegroup: EFTimegroup;
+  video: EFVideo;
+  configuration: EFConfiguration;
+}>({
+  timegroup: async ({}, use) => {
+    const timegroup = document.createElement("ef-timegroup");
+    timegroup.setAttribute("mode", "sequence");
+    timegroup.setAttribute("id", "test-timegroup"); // Required for localStorage key
+    timegroup.style.cssText =
+      "position: relative; height: 500px; width: 1000px; overflow: hidden; background-color: rgb(100 116 139);";
+    await use(timegroup);
+  },
+  configuration: async ({ expect }, use) => {
+    const configuration = document.createElement("ef-configuration");
+    configuration.innerHTML = `<h1 style="font: 10px monospace">${expect.getState().currentTestName}</h1>`;
+    // Use integrated proxy server (same host/port as test runner)
+    const apiHost = `${window.location.protocol}//${window.location.host}`;
+    configuration.setAttribute("api-host", apiHost);
+    configuration.apiHost = apiHost;
+    document.body.appendChild(configuration);
+    await use(configuration);
+  },
+  video: async ({ configuration, timegroup }, use) => {
+    const video = document.createElement("ef-video");
+    video.id = "bars-n-tone2";
+    video.src = "http://web:3000/head-moov-480p.mp4"; // Real video from working simple-demo
+    video.style.cssText =
+      "width: 100%; height: 100%; object-fit: cover; position: absolute; top: 0; left: 0;";
+
+    // Create the exact structure from simple-demo.html
+    const innerTimegroup = document.createElement("ef-timegroup");
+    innerTimegroup.mode = "contain";
+    innerTimegroup.style.cssText =
+      "position: absolute; width: 100%; height: 100%;";
+    innerTimegroup.append(video);
+    timegroup.append(innerTimegroup);
+    configuration.append(timegroup);
+
+    await use(video);
+  },
+});
+
+/**
+ * Regression test for chunk boundary seeking issue
+ *
+ * Root cause: 32ms coordination gap between PlaybackController and audio track boundaries
+ * - PlaybackController seeks to chunk boundary: 4000ms
+ * - Audio track actually starts at: 4032ms
+ * - Error: "Seek time 4000ms is outside track range [4032ms, 6016ms]"
+ *
+ * This occurs during active playbook and browser reloads at 4s mark.
+ * Fix: Coordinate chunk boundaries or add tolerance for small gaps.
+ */
+describe("Audio Seek Task - Chunk Boundary Regression Test", () => {
+  beforeEach(() => {
+    // Clean up DOM and localStorage
+    while (document.body.children.length) {
+      document.body.children[0]?.remove();
+    }
+    localStorage.clear();
+  });
+
+  afterEach(async () => {
+    // Clean up any remaining elements
+    const videos = document.querySelectorAll("ef-video");
+    for (const video of videos) {
+      video.remove();
+    }
+  });
+
+  test("should not throw RangeError when seeking to exact 4000ms during playback", async ({
+    video,
+    timegroup,
+    expect,
+  }) => {
+    await video.mediaEngineTask.taskComplete;
+    await video.audioInputTask.taskComplete;
+
+    // Simulate active playback - start playing from beginning
+    timegroup.currentTimeMs = 0;
+    await video.audioSeekTask.taskComplete;
+
+    // Now seek to the exact problematic time that causes:
+    // "Seek time 4000ms is outside track range [4032ms, 6016ms]"
+    const exactChunkBoundary = 4000;
+    timegroup.currentTimeMs = exactChunkBoundary;
+
+    // Should not throw RangeError due to track range mismatch
+    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
+  });
+
+  test("should not throw RangeError during progressive playback across segments", async ({
+    video,
+    timegroup,
+    expect,
+  }) => {
+    await video.mediaEngineTask.taskComplete;
+    await video.audioInputTask.taskComplete;
+
+    // Simulate progressive playback that loads segments on demand
+    // Start at 3500ms to be just before the 4-second boundary
+    timegroup.currentTimeMs = 3500;
+    await video.audioSeekTask.taskComplete;
+
+    // Now cross the 4-second chunk boundary where track range issues occur
+    // This should trigger the state where track range is [4032ms, 6016ms]
+    // but we're seeking to 4000ms
+    timegroup.currentTimeMs = 4000.000000000001; // The exact error from logs
+
+    // Should not throw "Seek time 4000.000000000001ms is outside track range [4032ms, 6016ms]"
+    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
+  });
+
+  test("should not throw RangeError when localStorage restoration causes 0ms to 4000ms race condition", async ({
+    video,
+    timegroup,
+    expect,
+  }) => {
+    // REPRODUCE THE RACE CONDITION: Simulate localStorage having "4.0"
+    // This mimics the exact simple-demo.html scenario where:
+    // 1. Media loads with assumption of currentTimeMs = 0
+    // 2. localStorage restores currentTime to 4.0 seconds
+    // 3. Seeking 4000ms in segments loaded for 0ms range triggers RangeError
+
+    // Set localStorage BEFORE media finishes initializing
+    if (timegroup.id) {
+      localStorage.setItem(`ef-timegroup-${timegroup.id}`, "4.0");
+    }
+
+    // Wait for media engine but NOT for full initialization
+    await video.mediaEngineTask.taskComplete;
+
+    // Now trigger the localStorage restoration that happens in waitForMediaDurations().then()
+    // This will load currentTime = 4.0 from localStorage, jumping from 0ms to 4000ms
+    timegroup.currentTime = timegroup.maybeLoadTimeFromLocalStorage();
+
+    // This should trigger: "Seek time 4000ms is outside track range [Yms, Zms]"
+    // because segments were loaded for 0ms but we're now seeking 4000ms
+    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
+  });
+
+  test("should not throw RangeError when forced segment coordination mismatch occurs", async ({
+    video,
+    timegroup,
+    expect,
+  }) => {
+    await video.mediaEngineTask.taskComplete;
+
+    // FORCE SPECIFIC SEGMENT LOADING: Load a segment for 8000ms (segment 5)
+    timegroup.currentTimeMs = 8000;
+    await video.audioSegmentIdTask.taskComplete;
+    await video.audioSegmentFetchTask.taskComplete;
+    await video.audioInputTask.taskComplete;
+
+    // Verify we have segment 5 loaded (8000ms / 15000ms = segment 1, but 1-based = segment 1...
+    // Actually 8000ms maps to segment 5 based on the actual segment calculation)
+    const segmentId = video.audioSegmentIdTask.value;
+    expect(segmentId).toBe(4);
+
+    // Now seek to a time in a different segment to test coordination
+    timegroup.currentTimeMs = 4000;
+
+    // This tests the fundamental segment coordination issue:
+    // - We loaded segment 5 for 8000ms
+    // - Now seeking to 4000ms which should be in a different segment
+    // - Tests that seek doesn't fail due to segment boundary coordination
+    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
+  });
+
+  test("should not throw RangeError when rapidly crossing segment boundaries", async ({
+    video,
+    timegroup,
+    expect,
+  }) => {
+    await video.mediaEngineTask.taskComplete;
+
+    // RAPID BOUNDARY CROSSING: This tests timing-sensitive segment coordination
+    const boundaries = [1000, 4000, 8000, 3000, 7000]; // Jump around within segment 1
+
+    for (const timeMs of boundaries) {
+      timegroup.currentTimeMs = timeMs;
+      // Don't await - test rapid succession to trigger coordination issues
+    }
+
+    // Final seek - this should not throw even after rapid boundary crossing
+    timegroup.currentTimeMs = 4000;
+    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
+  });
+});