cursedbelt-core 1.0.0

package/src/core/media/validate.spec.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test';
+import type { ImagePipelineSpec, VideoTrimSpec } from './types';
+import {
+  assertValidImagePipelineSpec,
+  assertValidVideoTrimSpec,
+  validateImagePipelineSpec,
+  validateVideoTrimSpec,
+} from './validate';
+
+const baseImage = (over: Partial<ImagePipelineSpec> = {}): ImagePipelineSpec => ({
+  input: '/tmp/in.jpg',
+  operations: [],
+  output: { format: 'webp', quality: 80 },
+  ...over,
+});
+
+describe('validateImagePipelineSpec', () => {
+  test('accepts a well-formed spec', () => {
+    const r = validateImagePipelineSpec(
+      baseImage({
+        operations: [
+          { type: 'resize', width: 200 },
+          { type: 'crop', left: 0, top: 0, width: 50, height: 50 },
+          { type: 'rotate', angle: 90 },
+          { type: 'flip', direction: 'horizontal' },
+          { type: 'remove-bg', tolerance: 30 },
+          { type: 'format-convert' },
+        ],
+      }),
+    );
+    expect(r.valid).toBe(true);
+    expect(r.errors).toEqual([]);
+  });
+
+  test('accepts a Uint8Array input', () => {
+    expect(validateImagePipelineSpec(baseImage({ input: new Uint8Array([1, 2, 3]) })).valid).toBe(
+      true,
+    );
+  });
+
+  test('rejects a bad output format + out-of-range quality', () => {
+    const r = validateImagePipelineSpec(
+      baseImage({
+        output: { format: 'gif' as unknown as ImagePipelineSpec['output']['format'], quality: 200 },
+      }),
+    );
+    expect(r.valid).toBe(false);
+    expect(r.errors.join(' ')).toContain('output.format');
+    expect(r.errors.join(' ')).toContain('quality');
+  });
+
+  test('flags an empty resize, a non-positive crop, and a non-finite rotate', () => {
+    const r = validateImagePipelineSpec(
+      baseImage({
+        operations: [
+          { type: 'resize' },
+          { type: 'crop', left: -1, top: 0, width: 0, height: 10 },
+          { type: 'rotate', angle: Number.NaN },
+        ],
+      }),
+    );
+    expect(r.valid).toBe(false);
+    expect(r.errors.length).toBeGreaterThanOrEqual(3);
+  });
+
+  test('assert throws with a joined message', () => {
+    expect(() => assertValidImagePipelineSpec(baseImage({ input: '' }))).toThrow(
+      /Invalid ImagePipelineSpec/,
+    );
+  });
+});
+
+const baseTrim = (over: Partial<VideoTrimSpec> = {}): VideoTrimSpec => ({
+  inputPath: '/tmp/in.mp4',
+  outputPath: '/tmp/out.mp4',
+  startSeconds: 2,
+  endSeconds: 8,
+  ...over,
+});
+
+describe('validateVideoTrimSpec', () => {
+  test('accepts a valid trim', () => {
+    expect(validateVideoTrimSpec(baseTrim({ format: 'webm', quality: 'high' })).valid).toBe(true);
+  });
+
+  test('rejects end <= start', () => {
+    const r = validateVideoTrimSpec(baseTrim({ startSeconds: 5, endSeconds: 5 }));
+    expect(r.valid).toBe(false);
+    expect(r.errors.join(' ')).toContain('greater than startSeconds');
+  });
+
+  test('rejects negative bounds, missing paths, bad enums', () => {
+    expect(validateVideoTrimSpec(baseTrim({ startSeconds: -1 })).valid).toBe(false);
+    expect(validateVideoTrimSpec(baseTrim({ inputPath: '' })).valid).toBe(false);
+    expect(
+      validateVideoTrimSpec(baseTrim({ format: 'mov' as unknown as VideoTrimSpec['format'] }))
+        .valid,
+    ).toBe(false);
+  });
+
+  test('assert throws', () => {
+    expect(() => assertValidVideoTrimSpec(baseTrim({ outputPath: '' }))).toThrow(
+      /Invalid VideoTrimSpec/,
+    );
+  });
+});

package/src/core/media/validate.ts

@@ -0,0 +1,131 @@
+// Pure spec validation — catches a malformed pipeline/trim spec BEFORE it reaches
+// sharp or ffmpeg (where the failure mode is an opaque native error). No deps;
+// `validate*` returns a collected error list, `assert*` throws on the first problem.
+
+import { IMAGE_OUTPUT_FORMATS } from './format';
+import type { ImageOperation, ImagePipelineSpec, VideoTrimSpec } from './types';
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+function ok(errors: string[]): ValidationResult {
+  return { valid: errors.length === 0, errors };
+}
+
+const isPositive = (n: unknown): n is number =>
+  typeof n === 'number' && Number.isFinite(n) && n > 0;
+const isNonNeg = (n: unknown): n is number => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+
+function validateOperation(op: ImageOperation, i: number, errors: string[]): void {
+  const at = `operations[${i}]`;
+  switch (op.type) {
+    case 'resize':
+      if (op.width === undefined && op.height === undefined) {
+        errors.push(`${at} (resize) needs at least one of width/height`);
+      }
+      if (op.width !== undefined && !isPositive(op.width))
+        errors.push(`${at} resize.width must be > 0`);
+      if (op.height !== undefined && !isPositive(op.height)) {
+        errors.push(`${at} resize.height must be > 0`);
+      }
+      break;
+    case 'crop':
+      if (!isNonNeg(op.left) || !isNonNeg(op.top)) errors.push(`${at} crop.left/top must be >= 0`);
+      if (!isPositive(op.width) || !isPositive(op.height)) {
+        errors.push(`${at} crop.width/height must be > 0`);
+      }
+      break;
+    case 'rotate':
+      if (typeof op.angle !== 'number' || !Number.isFinite(op.angle)) {
+        errors.push(`${at} rotate.angle must be a finite number`);
+      }
+      break;
+    case 'flip':
+      if (op.direction !== 'horizontal' && op.direction !== 'vertical') {
+        errors.push(`${at} flip.direction must be 'horizontal' | 'vertical'`);
+      }
+      break;
+    case 'compress':
+      if (!isPositive(op.quality) || op.quality > 100) {
+        errors.push(`${at} compress.quality must be in 1..100`);
+      }
+      break;
+    case 'remove-bg':
+      if (op.tolerance !== undefined && (!isNonNeg(op.tolerance) || op.tolerance > 441)) {
+        errors.push(`${at} remove-bg.tolerance must be in 0..441`);
+      }
+      break;
+    case 'format-convert':
+      break;
+  }
+}
+
+export function validateImagePipelineSpec(spec: ImagePipelineSpec): ValidationResult {
+  const errors: string[] = [];
+  if (spec == null || typeof spec !== 'object') return ok(['spec must be an object']);
+  if (typeof spec.input !== 'string' && !(spec.input instanceof Uint8Array)) {
+    errors.push('input must be a file path (string) or Uint8Array');
+  } else if (typeof spec.input === 'string' && spec.input.length === 0) {
+    errors.push('input path must be non-empty');
+  }
+  if (!Array.isArray(spec.operations)) {
+    errors.push('operations must be an array');
+  } else {
+    spec.operations.forEach((op, i) => {
+      validateOperation(op, i, errors);
+    });
+  }
+  if (!spec.output || !IMAGE_OUTPUT_FORMATS.includes(spec.output.format)) {
+    errors.push(`output.format must be one of ${IMAGE_OUTPUT_FORMATS.join(', ')}`);
+  }
+  if (spec.output && spec.output.quality !== undefined) {
+    if (!isPositive(spec.output.quality) || spec.output.quality > 100) {
+      errors.push('output.quality must be in 1..100');
+    }
+  }
+  return ok(errors);
+}
+
+export function assertValidImagePipelineSpec(spec: ImagePipelineSpec): void {
+  const { valid, errors } = validateImagePipelineSpec(spec);
+  if (!valid) throw new Error(`Invalid ImagePipelineSpec: ${errors.join('; ')}`);
+}
+
+export function validateVideoTrimSpec(spec: VideoTrimSpec): ValidationResult {
+  const errors: string[] = [];
+  if (spec == null || typeof spec !== 'object') return ok(['spec must be an object']);
+  if (typeof spec.inputPath !== 'string' || spec.inputPath.length === 0) {
+    errors.push('inputPath must be a non-empty string');
+  }
+  if (typeof spec.outputPath !== 'string' || spec.outputPath.length === 0) {
+    errors.push('outputPath must be a non-empty string');
+  }
+  if (!isNonNeg(spec.startSeconds)) errors.push('startSeconds must be >= 0');
+  if (!isNonNeg(spec.endSeconds)) errors.push('endSeconds must be >= 0');
+  if (
+    isNonNeg(spec.startSeconds) &&
+    isNonNeg(spec.endSeconds) &&
+    spec.endSeconds <= spec.startSeconds
+  ) {
+    errors.push('endSeconds must be greater than startSeconds');
+  }
+  if (spec.format !== undefined && spec.format !== 'mp4' && spec.format !== 'webm') {
+    errors.push("format must be 'mp4' | 'webm'");
+  }
+  if (
+    spec.quality !== undefined &&
+    spec.quality !== 'high' &&
+    spec.quality !== 'medium' &&
+    spec.quality !== 'low'
+  ) {
+    errors.push("quality must be 'high' | 'medium' | 'low'");
+  }
+  return ok(errors);
+}
+
+export function assertValidVideoTrimSpec(spec: VideoTrimSpec): void {
+  const { valid, errors } = validateVideoTrimSpec(spec);
+  if (!valid) throw new Error(`Invalid VideoTrimSpec: ${errors.join('; ')}`);
+}

package/src/core/media/videoCuts.spec.ts

@@ -0,0 +1,327 @@
+/**
+ * The cut-list algebra. Pure, so every rule the editor and the encoder both depend on is
+ * asserted once here rather than twice, differently, in two repos.
+ */
+import { describe, expect, test } from 'bun:test';
+import {
+  addSplit,
+  type CutPlan,
+  cutListProblem,
+  cutSeconds,
+  cutTimecode,
+  keptSeconds,
+  keptSegments,
+  MIN_CUT_SECONDS,
+  normalizeCuts,
+  planCuts,
+  planProblem,
+  planSegments,
+  removeSplit,
+  toggleSegment,
+  type VideoCut,
+} from './videoCuts';
+
+const cut = (start: number, end: number): VideoCut => ({ start, end });
+const shape = (cuts: readonly VideoCut[]): string =>
+  cuts.map((c) => `${c.start}-${c.end}`).join(' ');
+
+describe('normalizeCuts', () => {
+  test('orders marks by where they are, not by when they were made', () => {
+    expect(shape(normalizeCuts([cut(30, 40), cut(5, 10)], 60))).toBe('5-10 30-40');
+  });
+
+  test('a mark dragged backwards is still a mark', () => {
+    // Scrubbing right-to-left is how half of these get made.
+    expect(shape(normalizeCuts([cut(40, 30)], 60))).toBe('30-40');
+  });
+
+  test('🔴 overlapping marks MERGE rather than being refused', () => {
+    // Not a mistake to report: cutting a passage, watching it back and cutting a span that
+    // includes part of what you already removed is the ordinary way this gets used.
+    expect(shape(normalizeCuts([cut(5, 20), cut(15, 30)], 60))).toBe('5-30');
+  });
+
+  test('🔴 marks that TOUCH are one mark — the spans are half-open', () => {
+    // `[5,10)` then `[10,20)` leaves no frame between them, so two rows here would be a list
+    // that cannot be acted on differently from one row.
+    expect(shape(normalizeCuts([cut(5, 10), cut(10, 20)], 60))).toBe('5-20');
+  });
+
+  test('a mark inside another disappears into it', () => {
+    expect(shape(normalizeCuts([cut(5, 40), cut(10, 20)], 60))).toBe('5-40');
+  });
+
+  test('marks are clamped into the clip', () => {
+    expect(shape(normalizeCuts([cut(-10, 5), cut(55, 900)], 60))).toBe('0-5 55-60');
+  });
+
+  test('a span too short to hold a frame is dropped', () => {
+    expect(normalizeCuts([cut(5, 5 + MIN_CUT_SECONDS / 2)], 60)).toEqual([]);
+    expect(normalizeCuts([cut(5, 5 + MIN_CUT_SECONDS)], 60)).toHaveLength(1);
+  });
+
+  test('🔴 a NaN bound drops its mark instead of poisoning the sort', () => {
+    /*
+     * The usual source is a `<video>` whose metadata has not loaded, which reports NaN for
+     * duration and therefore for anything derived from the playhead. Every comparison against
+     * NaN is false, so leaving it in produces an array `sort` calls sorted and is not —
+     * and the merge pass below then leaves real overlaps in, silently.
+     */
+    expect(shape(normalizeCuts([cut(30, 40), cut(Number.NaN, 10), cut(5, 8)], 60))).toBe(
+      '5-8 30-40',
+    );
+  });
+
+  test('an unknown duration means no cuts can be placed', () => {
+    expect(normalizeCuts([cut(5, 10)], Number.NaN)).toEqual([]);
+    expect(normalizeCuts([cut(5, 10)], 0)).toEqual([]);
+  });
+});
+
+describe('keptSegments — what the encoder actually concatenates', () => {
+  test('one cut in the middle leaves the head and the tail', () => {
+    expect(shape(keptSegments([cut(10, 20)], 60))).toBe('0-10 20-60');
+  });
+
+  test('a cut at the very start leaves only the tail', () => {
+    expect(shape(keptSegments([cut(0, 10)], 60))).toBe('10-60');
+  });
+
+  test('a cut running to the end leaves only the head', () => {
+    expect(shape(keptSegments([cut(50, 60)], 60))).toBe('0-50');
+  });
+
+  test('two cuts leave three pieces', () => {
+    expect(shape(keptSegments([cut(10, 20), cut(30, 40)], 60))).toBe('0-10 20-30 40-60');
+  });
+
+  test('cutting everything keeps nothing', () => {
+    expect(keptSegments([cut(0, 60)], 60)).toEqual([]);
+  });
+
+  test('a sliver of footage between two cuts is not kept', () => {
+    // A gap shorter than a frame is not a piece of video; concatenating it would ask the
+    // encoder for a segment with nothing in it.
+    expect(shape(keptSegments([cut(0, 10), cut(10 + MIN_CUT_SECONDS / 2, 60)], 60))).toBe('');
+  });
+
+  test('the two halves add up to the whole clip', () => {
+    const cuts = [cut(10, 20), cut(35, 41)];
+    expect(cutSeconds(cuts, 60) + keptSeconds(cuts, 60)).toBeCloseTo(60, 6);
+  });
+});
+
+describe('🔴 cutListProblem — the same refusal in the editor and on the server', () => {
+  test('an empty list is refused, because it would re-encode a file to no purpose', () => {
+    // Sending it queues a full pass over a multi-gigabyte master to produce a second copy
+    // that differs from the first in nothing, and then asks the owner to choose between them.
+    expect(cutListProblem([], 60)).toContain('Nothing is marked');
+  });
+
+  test('🔴 cutting the whole clip is refused, because ffmpeg does NOT refuse it', () => {
+    /*
+     * `concat` with zero segments writes a valid container with no frames in it and exits 0.
+     * So there is no error anywhere: the job succeeds, the file arrives, the review screen
+     * offers a choice between the original and a video that plays nothing. The refusal has
+     * to be here, before it is queued.
+     */
+    expect(cutListProblem([cut(0, 60)], 60)).toContain('whole video');
+  });
+
+  test('an unknown duration is refused with the reason, not with a crash', () => {
+    expect(cutListProblem([cut(1, 2)], Number.NaN)).toContain('length is not known');
+  });
+
+  test('an ordinary list has no problem', () => {
+    expect(cutListProblem([cut(10, 20)], 60)).toBeNull();
+  });
+});
+
+describe('cutTimecode', () => {
+  test('tenths, because whole seconds make two nearby marks look identical', () => {
+    expect(cutTimecode(0)).toBe('0:00.0');
+    expect(cutTimecode(9.44)).toBe('0:09.4');
+    expect(cutTimecode(9.46)).toBe('0:09.4');
+    expect(cutTimecode(75.5)).toBe('1:15.5');
+  });
+
+  test('hours appear only when there are hours, and the minutes pad when they do', () => {
+    expect(cutTimecode(3725.2)).toBe('1:02:05.2');
+    expect(cutTimecode(600)).toBe('10:00.0');
+  });
+
+  test('a bad number reads as zero rather than as NaN:NaN', () => {
+    expect(cutTimecode(Number.NaN)).toBe('0:00.0');
+    expect(cutTimecode(-5)).toBe('0:00.0');
+  });
+});
+
+
+/*
+ * ── The MARKING model ─────────────────────────────────────────────────────────────────
+ *
+ * Owner, 2026-08-26: *"There are always start and end points needed for mid section removals
+ * to be valid. I think there could be ambiguity about which side to cut in some cases if the
+ * same type of marker is used for every cut marker. You can make it allow clicking 'x' on a
+ * section to indicate remove it."*
+ *
+ * So: a cut is a SPLIT, splits make SEGMENTS, and a segment is in or out. Every assertion
+ * below is about the property that buys — there is no pairing to get wrong, and every point
+ * in the clip belongs to exactly one segment whose fate is stated rather than inferred.
+ */
+const plan = (splits: number[], removed: VideoCut[] = []): CutPlan => ({ splits, removed });
+const shapeOf = (p: CutPlan, duration: number): string =>
+  planSegments(p, duration)
+    .map((segment) => `${segment.removed ? 'X' : '='}${segment.start}-${segment.end}`)
+    .join(' ');
+
+describe('splitting the clip', () => {
+  test('no splits is one segment, the whole thing, kept', () => {
+    expect(shapeOf(plan([]), 60)).toBe('=0-60');
+  });
+
+  test('a cut in the middle makes two segments', () => {
+    expect(shapeOf(addSplit(plan([]), 30, 60), 60)).toBe('=0-30 =30-60');
+  });
+
+  test('the segments always cover the whole clip with no gaps', () => {
+    // The property that removes the ambiguity: there is nowhere in the video that is not in
+    // exactly one segment, so "which side" is never a question anybody has to answer.
+    const segments = planSegments(plan([10, 20, 45]), 60);
+    expect(segments[0]?.start).toBe(0);
+    expect(segments[segments.length - 1]?.end).toBe(60);
+    for (let i = 1; i < segments.length; i++)
+      expect(segments[i]?.start).toBe(segments[i - 1]?.end as number);
+  });
+
+  test('cuts are sorted however they were made, and a repeat is a no-op', () => {
+    expect(shapeOf(plan([45, 10, 10]), 60)).toBe('=0-10 =10-45 =45-60');
+  });
+
+  test('a cut at the very start or end is refused — it would make a segment with no frames', () => {
+    expect(planSegments(plan([0, 60]), 60)).toHaveLength(1);
+  });
+
+  test('two cuts a frame apart are one cut', () => {
+    // A sliver no frame can live in is also a target nobody can click.
+    expect(shapeOf(plan([30, 30.01]), 60)).toBe('=0-30 =30-60');
+  });
+});
+
+describe("🔴 clicking ✗ on a piece — the owner's example, both halves", () => {
+  test('one cut in the middle, remove the LEFT', () => {
+    const one = addSplit(plan([]), 30, 60);
+    const after = toggleSegment(one, { start: 0, end: 30 }, 60);
+    expect(shapeOf(after, 60)).toBe('X0-30 =30-60');
+    expect(planCuts(after, 60)).toEqual([{ start: 0, end: 30 }]);
+  });
+
+  test('one cut in the middle, remove the RIGHT — the same gesture, no new concept', () => {
+    const one = addSplit(plan([]), 30, 60);
+    const after = toggleSegment(one, { start: 30, end: 60 }, 60);
+    expect(planCuts(after, 60)).toEqual([{ start: 30, end: 60 }]);
+  });
+
+  test('many sections out of the middle, which is not a special case either', () => {
+    let p = plan([]);
+    for (const at of [10, 20, 30, 40]) p = addSplit(p, at, 60);
+    p = toggleSegment(p, { start: 10, end: 20 }, 60);
+    p = toggleSegment(p, { start: 30, end: 40 }, 60);
+    expect(shapeOf(p, 60)).toBe('=0-10 X10-20 =20-30 X30-40 =40-60');
+    expect(planCuts(p, 60)).toEqual([
+      { start: 10, end: 20 },
+      { start: 30, end: 40 },
+    ]);
+  });
+
+  test('marking two pieces in a row produces ONE cut, not two', () => {
+    // The encoder should not be handed a join it would immediately have to close up.
+    let p = plan([20, 30]);
+    p = toggleSegment(p, { start: 20, end: 30 }, 60);
+    p = toggleSegment(p, { start: 30, end: 60 }, 60);
+    expect(planCuts(p, 60)).toEqual([{ start: 20, end: 60 }]);
+  });
+
+  test('✗ again puts it back', () => {
+    const p = toggleSegment(addSplit(plan([]), 30, 60), { start: 0, end: 30 }, 60);
+    expect(planCuts(toggleSegment(p, { start: 0, end: 30 }, 60), 60)).toEqual([]);
+  });
+});
+
+describe('🔴 cutting again after marking keeps the decision', () => {
+  test('splitting a removed piece leaves BOTH halves removed', () => {
+    /*
+     * The gesture people actually use: mark a section out, watch it back, and cut again to
+     * take a little more. If the new split dropped the mark, the footage somebody had already
+     * decided against would silently come back — and the strip would look like the cut had
+     * been undone by an action that says nothing about it.
+     */
+    const marked = toggleSegment(addSplit(plan([]), 30, 60), { start: 0, end: 30 }, 60);
+    const again = addSplit(marked, 15, 60);
+    expect(shapeOf(again, 60)).toBe('X0-15 X15-30 =30-60');
+  });
+
+  test('and un-marking one half does not resurrect the other', () => {
+    const marked = toggleSegment(addSplit(plan([]), 30, 60), { start: 0, end: 30 }, 60);
+    const again = addSplit(marked, 15, 60);
+    const restored = toggleSegment(again, { start: 0, end: 15 }, 60);
+    expect(shapeOf(restored, 60)).toBe('=0-15 X15-30 =30-60');
+  });
+});
+
+describe('🔴 undoing a cut merges, and only agreement survives', () => {
+  test('two kept pieces merge into a kept piece', () => {
+    expect(shapeOf(removeSplit(plan([30]), 30, 60), 60)).toBe('=0-60');
+  });
+
+  test('two removed pieces merge into a removed piece', () => {
+    let p = plan([30]);
+    p = toggleSegment(p, { start: 0, end: 30 }, 60);
+    p = toggleSegment(p, { start: 30, end: 60 }, 60);
+    expect(shapeOf(removeSplit(p, 30, 60), 60)).toBe('X0-60');
+  });
+
+  test('🔴 one of each merges to KEPT — the safe reading of a contradiction', () => {
+    /*
+     * Anything else invents an intention. Promoting it to removed deletes footage nobody
+     * marked; that is unrecoverable from the strip, because the piece it belonged to no longer
+     * exists to un-mark. Demoting costs one more click and can be seen.
+     */
+    const p = toggleSegment(plan([30]), { start: 0, end: 30 }, 60);
+    expect(shapeOf(removeSplit(p, 30, 60), 60)).toBe('=0-60');
+  });
+
+  test('undoing a cut that is not there changes nothing', () => {
+    const p = plan([30]);
+    expect(removeSplit(p, 45, 60)).toBe(p);
+  });
+});
+
+describe('a plan is refused for the same two reasons a cut list is', () => {
+  test('nothing marked', () => {
+    expect(planProblem(plan([30]), 60)).toContain('Nothing is marked');
+  });
+
+  test('everything marked', () => {
+    const p = toggleSegment(plan([]), { start: 0, end: 60 }, 60);
+    expect(planProblem(p, 60)).toContain('whole video');
+  });
+
+  test('an ordinary plan is fine', () => {
+    expect(planProblem(toggleSegment(plan([30]), { start: 0, end: 30 }, 60), 60)).toBeNull();
+  });
+});
+
+describe('segment keys', () => {
+  test('🔴 a key is its BOUNDS, so it cannot drift when a cut lands to its left', () => {
+    /*
+     * Stored as an index, `removed: [2]` comes to mean a different piece of footage the moment
+     * anything is split before it — during the one gesture people use most. This is also the
+     * React key, so a wrong one re-renders the wrong row.
+     */
+    const before = planSegments(plan([20, 40]), 60);
+    const after = planSegments(addSplit(plan([20, 40]), 10, 60), 60);
+    const survivor = before.find((segment) => segment.start === 40);
+    expect(after.some((segment) => segment.key === survivor?.key)).toBe(true);
+  });
+});