bridgebench 3.1.0-alpha.0 → 3.1.0-alpha.2

package/tasks/generation/public/array-rotate-left-normalization.yaml

@@ -0,0 +1,166 @@
+id: array-rotate-left-normalization
+version: 1.0.0
+category: generation
+cluster: algorithmic-correctness
+difficulty: expert
+title: Which rotateLeft Candidate Normalizes Shift and Preserves the Input on Every Case
+summary: A spec defines rotateLeft(a, k) — rotate an array left by k, where k may be zero, negative (rotate right), or larger than the length, and the input must not be mutated. A complete acceptance vector gives exact expected arrays. Five candidates are submitted; some normalize the shift correctly, some fail on k>=length, some rotate the wrong direction, and one produces correct values but mutates the caller's array. Classify each conforms/violates and cite the disproving case.
+prompt: |
+  Answer each deliverable using ONLY the supplied artifacts (spec, acceptance-vector,
+  candidate-a, candidate-b, candidate-c, candidate-d, candidate-e, judging-notes). Cite
+  the artifact id(s) for every claim. Do not execute anything — trace each candidate by
+  hand against the acceptance-vector, which gives the exact expected output array.
+
+  Verdict vocabulary: a candidate CONFORMS if, for every acceptance-vector row, it
+  returns an array equal to the expected array AND it honors every declared property in
+  `spec` (including the no-mutation and new-array requirements); otherwise it VIOLATES.
+
+  1. For EACH candidate (candidate-a … candidate-e), give a verdict: conforms or
+     violates. State the verdict for all five.
+
+  2. For every candidate you mark VIOLATES because it returns the wrong array, name ONE
+     acceptance-vector row (by its `a` and `k`) it fails, and give the array it returns
+     versus the expected array.
+
+  3. Exactly one candidate returns the correct element values on every row yet still
+     VIOLATES. Identify it, quote the exact construct responsible, and state the precise
+     caller-visible consequence.
+
+  4. candidate-a and candidate-e are written differently (slice/concat vs index copy).
+     State whether candidate-e is behaviorally equivalent to `spec` and justify from the
+     code.
+
+  5. State the complete set of conforming candidates.
+artifacts:
+  - id: spec
+    type: spec
+    label: rotateLeft specification (complete contract)
+    content: |
+      FUNCTION rotateLeft(a, k)
+
+      Inputs:
+        a  an array (of numbers). May be empty.
+        k  an integer. May be 0, negative, or larger in magnitude than a.length.
+
+      Return:
+        A NEW array equal to `a` rotated LEFT by k positions. Rotating left by 1 moves
+        a[0] to the end: rotateLeft([1,2,3], 1) === [2,3,4] ... (example continues in the
+        vector). Formally, let n = a.length. If n === 0, return []. Otherwise let the
+        effective shift s = ((k % n) + n) % n (a value in [0, n-1]); the result is
+        a.slice(s) followed by a.slice(0, s).
+
+      Declared properties (part of the contract, not examples):
+        P1  k is normalized: any integer k must behave as its effective shift s above. In
+            particular k === n (or any multiple of n) returns a copy in original order,
+            and k >= n rotates by k mod n, not by an out-of-range amount.
+        P2  Negative k rotates RIGHT: rotateLeft(a, -1) moves the last element to the
+            front.
+        P3  The input array `a` MUST NOT be mutated. The returned array MUST be a
+            distinct object from `a` (a new array), even when the effective shift is 0.
+
+      This is the complete contract.
+  - id: acceptance-vector
+    type: table
+    label: complete acceptance vector (exact expected arrays)
+    content: |
+      This table is the COMPLETE acceptance set. Each row is (a, k) -> expected result
+      array. "a after" restates that the ORIGINAL array must be unchanged after the call
+      (property P3); every row requires `a after` to equal the input `a`.
+
+      row  a            k    expected result   a after (must equal input)
+      R1   [1,2,3,4]    1    [2,3,4,1]         [1,2,3,4]
+      R2   [1,2,3,4]    0    [1,2,3,4]         [1,2,3,4]
+      R3   [1,2,3,4]    4    [1,2,3,4]         [1,2,3,4]   # full rotation -> copy
+      R4   [1,2,3,4]    6    [3,4,1,2]         [1,2,3,4]   # 6 mod 4 = 2
+      R5   [1,2,3,4]    -1   [4,1,2,3]         [1,2,3,4]   # rotate right by 1
+      R6   []           3    []                []
+      R7   [9]          5    [9]               [9]
+
+      Notes for tracing:
+        R3: k equals the length, so the effective shift is 0 -> the elements come back in
+            original order, but the returned array must still be a NEW array (P3).
+        R4: effective shift s = ((6 % 4) + 4) % 4 = 2 -> slice(2)=[3,4], slice(0,2)=[1,2].
+        R5: effective shift s = ((-1 % 4) + 4) % 4 = 3 -> slice(3)=[4], slice(0,3)=[1,2,3].
+  - id: candidate-a
+    type: code
+    label: candidate-a
+    content: |
+      // candidate-a
+      function rotateLeft(a, k) {
+        const n = a.length;
+        if (n === 0) return [];
+        const s = ((k % n) + n) % n;
+        return a.slice(s).concat(a.slice(0, s));
+      }
+  - id: candidate-b
+    type: code
+    label: candidate-b
+    content: |
+      // candidate-b
+      function rotateLeft(a, k) {
+        const n = a.length;
+        if (n === 0) return [];
+        return a.slice(k).concat(a.slice(0, k));   // no modular normalization of k
+      }
+  - id: candidate-c
+    type: code
+    label: candidate-c
+    content: |
+      // candidate-c
+      function rotateLeft(a, k) {
+        const n = a.length;
+        if (n === 0) return [];
+        const s = ((k % n) + n) % n;
+        return a.slice(n - s).concat(a.slice(0, n - s));
+      }
+  - id: candidate-d
+    type: code
+    label: candidate-d
+    content: |
+      // candidate-d
+      function rotateLeft(a, k) {
+        const n = a.length;
+        if (n === 0) return [];
+        const s = ((k % n) + n) % n;
+        for (let i = 0; i < s; i++) a.push(a.shift());   // operates on a
+        return a;
+      }
+  - id: candidate-e
+    type: code
+    label: candidate-e
+    content: |
+      // candidate-e
+      function rotateLeft(a, k) {
+        const n = a.length;
+        if (n === 0) return [];
+        const s = ((k % n) + n) % n;
+        const out = [];
+        for (let i = 0; i < n; i++) out.push(a[(i + s) % n]);
+        return out;
+      }
+  - id: judging-notes
+    type: note
+    label: how to judge (scope and JS slice semantics)
+    content: |
+      Scope for this task:
+        - candidate-a … candidate-e are the COMPLETE set of submissions.
+        - acceptance-vector is the COMPLETE acceptance set. A candidate CONFORMS iff for
+          every row it (1) returns an array equal to the expected result AND (2) leaves
+          `a after` equal to the input AND (3) returns a distinct array object (P3). Any
+          row failing any of these makes the candidate VIOLATE.
+
+      JavaScript slice/concat facts you need to trace exactly (no execution required):
+        - a.slice(start): with start >= a.length yields []. With start negative, it
+          counts from the end: a.slice(-1) is the last element.
+        - a.slice(0, end): with end >= a.length yields the whole array; with end negative
+          it stops that many from the end: [1,2,3,4].slice(0, -1) = [1,2,3].
+        - a.slice(...) and a.concat(...) both return NEW arrays and never mutate `a`.
+        - a.shift() removes and returns a[0], mutating `a` in place; a.push(x) appends to
+          `a` in place. A function built from a.shift()/a.push() therefore rewrites the
+          caller's array and, if it returns `a`, returns the same object it was given.
+        - The normalized shift s = ((k % n) + n) % n always lies in [0, n-1].
+
+      Judge each candidate ONLY against this contract and vector, including P3 (no
+      mutation, new array). A candidate whose element values are correct still VIOLATES
+      if it mutates the input or hands back the same array object.
+tags: [algorithm, array, rotation, immutability, algorithmic-correctness, generation]

package/tasks/generation/public/cache-interface-dropin.yaml

@@ -0,0 +1,178 @@
+id: cache-interface-dropin
+version: 1.0.0
+category: generation
+cluster: interface-compatibility
+difficulty: expert
+title: Which Cache Implementation Is a Drop-In Replacement for the Declared Cache Interface
+summary: A frozen Cache<V> interface and its existing call sites are declared complete. Five candidate implementations are proposed as drop-in replacements. Some match exactly; decoys break compatibility subtly — one renames delete to remove, one narrows get to V | null, one makes the ttlMs argument required. One conformer adds an extra method beyond the interface. Classify each conforms/violates against the interface and name the exact call site each violator breaks.
+prompt: |
+  Answer each deliverable using ONLY the supplied artifacts (interface, call-sites,
+  candidate-a, candidate-b, candidate-c, candidate-d, candidate-e, judging-notes). Cite
+  the artifact id(s) for every claim. Do not execute anything — compare each candidate's
+  member signatures against the `interface` using the structural-typing rules in
+  `judging-notes`.
+
+  A candidate is judged as a DROP-IN replacement: an instance must be assignable to a
+  variable typed `Cache<V>` and every existing call site in `call-sites` must keep
+  type-checking and behaving as the interface specifies. Verdict vocabulary: CONFORMS if
+  it is a valid drop-in; VIOLATES otherwise.
+
+  1. For EACH candidate (candidate-a … candidate-e), give a verdict: conforms or
+     violates against the Cache<V> drop-in contract.
+
+  2. For every candidate you mark VIOLATES, name the exact incompatibility (which member,
+     and whether it is a name, nullability, optionality/arity, return-type, or
+     property-vs-method mismatch) and the exact call-site id (CS1–CS5) it breaks.
+
+  3. State the complete set of candidates that are valid drop-in replacements.
+
+  4. candidate-e declares a member that does not appear in Cache<V>. Does that extra
+     member break drop-in compatibility? Justify strictly from the rules in
+     `judging-notes`.
+
+  5. A reviewer approves candidate-c, reasoning "null and undefined are both falsy, so it
+     makes no difference." Rebut this using CS1 and the interface's declared nullability
+     of get.
+artifacts:
+  - id: interface
+    type: spec
+    label: Cache<V> interface (frozen, complete)
+    content: |
+      // The frozen cache contract. Every drop-in replacement must satisfy exactly this.
+      interface Cache<V> {
+        get(key: string): V | undefined;              // MISS is undefined (never null)
+        set(key: string, value: V, ttlMs?: number): void;  // ttlMs is OPTIONAL
+        has(key: string): boolean;
+        delete(key: string): boolean;                 // returns true iff a value was removed
+        readonly size: number;                        // a property, not a method
+      }
+
+      This interface is COMPLETE: it has exactly these five members (get, set, has,
+      delete, and the size property) and no others. The names, parameter lists, optionality
+      markers, return types, and the property-vs-method shape shown here are all part of
+      the contract.
+  - id: call-sites
+    type: code
+    label: existing call sites a drop-in must keep working
+    content: |
+      // These are the ONLY places the codebase touches a cache. `cache` is typed Cache<Profile>.
+      // A valid drop-in must keep every one of these compiling and behaving as written.
+
+      // CS1 — get followed by a STRICT undefined check:
+      const hit = cache.get(userId);
+      if (hit === undefined) return loadAndCache(userId);   // miss path keyed on `=== undefined`
+      return hit;                                            // hit path returns the value
+
+      // CS2 — set with NO ttl argument:
+      cache.set(userId, profile);                           // relies on ttlMs being optional
+
+      // CS3 — delete used for its boolean result, by the name `delete`:
+      if (cache.delete(userId)) metrics.evictions += 1;
+
+      // CS4 — has:
+      if (!cache.has(userId)) warm(userId);
+
+      // CS5 — size read as a PROPERTY (no call parentheses):
+      gauge.set('cache.size', cache.size);
+  - id: candidate-a
+    type: code
+    label: candidate-a
+    content: |
+      // candidate-a
+      class CandidateA<V> {
+        private m = new Map<string, V>();
+        get(key: string): V | undefined { return this.m.get(key); }
+        set(key: string, value: V, ttlMs?: number): void { this.m.set(key, value); }
+        has(key: string): boolean { return this.m.has(key); }
+        delete(key: string): boolean { return this.m.delete(key); }
+        get size(): number { return this.m.size; }
+      }
+  - id: candidate-b
+    type: code
+    label: candidate-b
+    content: |
+      // candidate-b
+      class CandidateB<V> {
+        private m = new Map<string, V>();
+        get(key: string): V | undefined { return this.m.get(key); }
+        set(key: string, value: V, ttlMs?: number): void { this.m.set(key, value); }
+        has(key: string): boolean { return this.m.has(key); }
+        remove(key: string): boolean { return this.m.delete(key); }
+        get size(): number { return this.m.size; }
+      }
+  - id: candidate-c
+    type: code
+    label: candidate-c
+    content: |
+      // candidate-c
+      class CandidateC<V> {
+        private m = new Map<string, V>();
+        get(key: string): V | null {
+          const v = this.m.get(key);
+          return v === undefined ? null : v;
+        }
+        set(key: string, value: V, ttlMs?: number): void { this.m.set(key, value); }
+        has(key: string): boolean { return this.m.has(key); }
+        delete(key: string): boolean { return this.m.delete(key); }
+        get size(): number { return this.m.size; }
+      }
+  - id: candidate-d
+    type: code
+    label: candidate-d
+    content: |
+      // candidate-d
+      class CandidateD<V> {
+        private m = new Map<string, V>();
+        get(key: string): V | undefined { return this.m.get(key); }
+        set(key: string, value: V, ttlMs: number): void { this.m.set(key, value); }
+        has(key: string): boolean { return this.m.has(key); }
+        delete(key: string): boolean { return this.m.delete(key); }
+        get size(): number { return this.m.size; }
+      }
+  - id: candidate-e
+    type: code
+    label: candidate-e
+    content: |
+      // candidate-e
+      class CandidateE<V> {
+        private m = new Map<string, V>();
+        get(key: string): V | undefined { return this.m.get(key); }
+        set(key: string, value: V, ttlMs?: number): void { this.m.set(key, value); }
+        has(key: string): boolean { return this.m.has(key); }
+        delete(key: string): boolean { return this.m.delete(key); }
+        clear(): void { this.m.clear(); }
+        get size(): number { return this.m.size; }
+      }
+  - id: judging-notes
+    type: note
+    label: structural-typing rules for a drop-in (scope)
+    content: |
+      Scope: candidate-a … candidate-e are the COMPLETE set of proposals. Judge each ONLY
+      against the frozen `interface` and the `call-sites`.
+
+      Rules for deciding whether a class is a valid drop-in for Cache<V>:
+        R1 MEMBER NAMES: every member named in Cache<V> (get, set, has, delete, size) must
+           be present under that EXACT name. A member under a different name (e.g. remove
+           instead of delete) does not satisfy the interface member and breaks any call
+           site that uses the interface name.
+        R2 RETURN TYPES / NULLABILITY: a member's return type must be assignable to the
+           interface's. get must return `V | undefined`. `V | null` is NOT assignable to
+           `V | undefined` (null and undefined are distinct types), so a get returning
+           `V | null` is incompatible.
+        R3 PARAMETER OPTIONALITY / ARITY: a parameter the interface marks optional (ttlMs?)
+           may be OMITTED by callers. A candidate that makes that parameter REQUIRED
+           (ttlMs: number) cannot be called with the argument omitted, so it is not
+           assignable to the interface and breaks any call site that omits it.
+        R4 PROPERTY VS METHOD: `readonly size: number` is a property, read as `cache.size`.
+           A candidate exposing `size()` as a method would break `cache.size` property
+           access. (Check whether each candidate exposes size as a getter/property or a
+           method.)
+        R5 EXTRA MEMBERS: a class MAY declare members BEYOND the five in Cache<V>. Under
+           structural typing a type with additional members is still assignable to the
+           interface, and the existing call sites never touch the extra member, so extra
+           members do NOT break drop-in compatibility.
+
+      The `interface` is complete (exactly five members) and the `call-sites` are the only
+      usages. A candidate CONFORMS iff it is assignable to Cache<V> and keeps CS1–CS5
+      compiling and behaving as specified; otherwise it VIOLATES.
+tags: [typescript, interface, drop-in, structural-typing, interface-compatibility, generation]

package/tasks/generation/public/edge-case-coverage-cache-loader.yaml

@@ -0,0 +1,264 @@
+id: edge-case-coverage-cache-loader
+version: 1.0.0
+category: generation
+cluster: edge-case-coverage
+difficulty: expert
+title: getOrLoad — Single-Flight Cache Meeting Every Concurrency And Error Edge
+summary: An async cache spec enumerates five mandatory edges (single-flight concurrency, negative caching, non-caching of loader errors, key normalization, empty-key rejection). Six submissions are under review; exactly one satisfies all five while each of five decoys misses exactly one. Classify all six by reading the code against the behavior scenarios.
+prompt: |
+  Answer each deliverable using ONLY the supplied artifacts (cache-spec, behavior-vectors,
+  candidates-a, candidates-b, reviewer-thread, submission-manifest). Cite artifact id(s) for every
+  claim. Do not invent edges the spec omits and do not overlook one it requires. The verdict
+  vocabulary is exactly: conforms / violates. A submission `conforms` only if it satisfies EVERY
+  required edge E1..E5 in cache-spec.
+
+  submission-manifest declares candidate-1..candidate-6 the complete set with exactly one that
+  satisfies all five edges. No code is executed; reason about behavior by reading each candidate
+  against the behavior-vectors scenarios.
+
+  1. Classify each of candidate-1..candidate-6 as `conforms` or `violates`.
+
+  2. For every candidate you mark `violates`, name the single required edge (one of E1..E5) it
+     fails and cite the behavior-vectors scenario that exposes it. Describe the conforming behavior
+     and the candidate's differing behavior in that scenario.
+
+  3. Exactly one candidate `conforms` (satisfies all five edges). Identify it.
+
+  4. In reviewer-thread, reviewer @kai says candidate-2 "is correct because once the first load
+     finishes, the value is cached and later callers hit the cache." State candidate-2's verdict
+     and cite the edge and behavior-vectors scenario that refutes @kai.
+
+  5. For candidate-4, describe exactly what happens on the SECOND call for a key whose loader
+     REJECTED on the first call, and name the required edge this behavior breaks.
+artifacts:
+  - id: cache-spec
+    type: spec
+    label: getOrLoad cache specification with required edge set (complete)
+    content: |
+      class Cache { getOrLoad(rawKey: string, loader: (key: string) => Promise<unknown>): Promise<unknown> }
+
+      Supporting declarations (shared by all submissions):
+        const TTL_MS = 30_000;
+        class InvalidKeyError extends Error {}
+
+      getOrLoad returns a cached value when present and unexpired, otherwise loads it via `loader`.
+      A conforming implementation MUST satisfy every required edge below. This list is COMPLETE; an
+      implementation that mishandles any single one does NOT conform.
+
+      E1  SINGLE-FLIGHT (concurrency). If N calls arrive for the SAME (normalized) key while no
+          cached value exists and a load is in progress, `loader` is invoked EXACTLY ONCE; the
+          other callers await the in-flight promise and resolve to the same result. (This requires
+          registering the in-flight promise BEFORE awaiting the loader.)
+
+      E2  NEGATIVE CACHING. If `loader` RESOLVES with null (the key is genuinely absent), that null
+          is cached for TTL_MS as a negative result. A subsequent call within the TTL returns the
+          cached null WITHOUT invoking `loader` again.
+
+      E3  ERROR NON-CACHING. If `loader` REJECTS, the rejection is NOT cached and the in-flight
+          entry is evicted, so the very next call re-invokes `loader` (a transient failure must be
+          retryable, not permanently stuck).
+
+      E4  KEY NORMALIZATION. The key is trimmed of leading/trailing whitespace before it is used
+          for lookup, storage, and single-flight. Thus " user:7 " and "user:7" address the SAME
+          cache slot and coalesce.
+
+      E5  EMPTY-KEY REJECTION. If the key is empty or whitespace-only, getOrLoad throws
+          InvalidKeyError SYNCHRONOUSLY before touching the cache or invoking `loader`.
+
+      This is the entire required edge set.
+  - id: behavior-vectors
+    type: note
+    label: authoritative behavior scenarios (one per required edge)
+    content: |
+      One authoritative scenario per required edge. A conforming implementation exhibits the stated
+      conforming behavior.
+
+      BV-E1 (single-flight): three tasks call getOrLoad("user:7", loader) at the same tick; no
+        cached value exists; `loader` takes 50 ms and resolves to U.
+        Conforming: `loader` is invoked EXACTLY ONCE; all three calls resolve to U.
+
+      BV-E2 (negative caching): getOrLoad("user:9", loader) where `loader` RESOLVES with null; then
+        a second getOrLoad("user:9", loader) 1 ms later (well within TTL_MS).
+        Conforming: `loader` is invoked once total; the second call returns null from cache without
+        invoking `loader`.
+
+      BV-E3 (error non-caching): getOrLoad("user:5", loader) where `loader` REJECTS with LoadError;
+        after that call settles, a second getOrLoad("user:5", loader) is made.
+        Conforming: the first call rejects; the second call RE-INVOKES `loader` (the rejection was
+        not cached).
+
+      BV-E4 (key normalization): getOrLoad(" user:7 ", loader) and getOrLoad("user:7", loader) for
+        an uncached key.
+        Conforming: both address the same slot — across the two coalesced calls `loader` is invoked
+        once and both resolve to the same value; the stored key is the trimmed "user:7".
+
+      BV-E5 (empty key): getOrLoad("   ", loader) (whitespace only) and getOrLoad("", loader).
+        Conforming: each throws InvalidKeyError synchronously; `loader` is NOT invoked and the cache
+        is left untouched.
+  - id: candidates-a
+    type: code
+    label: submissions candidate-1, candidate-2, candidate-3
+    content: |
+      const TTL_MS = 30_000;
+      class InvalidKeyError extends Error {}
+      type Loader = (key: string) => Promise<unknown>;
+
+      // ---- candidate-1 ----
+      class Cache1 {
+        private values = new Map<string, { value: unknown; expiresAt: number }>();
+        private inflight = new Map<string, Promise<unknown>>();
+        async getOrLoad(rawKey: string, loader: Loader): Promise<unknown> {
+          const key = rawKey.trim();                                   // E4
+          if (key === '') throw new InvalidKeyError('empty key');      // E5
+          const c = this.values.get(key);
+          if (c && c.expiresAt > Date.now()) return c.value;           // hit (incl. cached null, E2)
+          const existing = this.inflight.get(key);
+          if (existing) return existing;                              // E1: await in-flight load
+          const p = loader(key)
+            .then((value) => {
+              this.values.set(key, { value, expiresAt: Date.now() + TTL_MS });   // caches null too (E2)
+              this.inflight.delete(key);
+              return value;
+            })
+            .catch((err) => { this.inflight.delete(key); throw err; }); // E3: evict, do not cache
+          this.inflight.set(key, p);                                   // registered BEFORE await (E1)
+          return p;
+        }
+      }
+
+      // ---- candidate-2 ----
+      class Cache2 {
+        private values = new Map<string, { value: unknown; expiresAt: number }>();
+        async getOrLoad(rawKey: string, loader: Loader): Promise<unknown> {
+          const key = rawKey.trim();
+          if (key === '') throw new InvalidKeyError('empty key');
+          const c = this.values.get(key);
+          if (c && c.expiresAt > Date.now()) return c.value;
+          const value = await loader(key);                            // no in-flight registration
+          this.values.set(key, { value, expiresAt: Date.now() + TTL_MS });
+          return value;
+        }
+      }
+
+      // ---- candidate-3 ----
+      class Cache3 {
+        private values = new Map<string, { value: unknown; expiresAt: number }>();
+        private inflight = new Map<string, Promise<unknown>>();
+        async getOrLoad(rawKey: string, loader: Loader): Promise<unknown> {
+          const key = rawKey.trim();
+          if (key === '') throw new InvalidKeyError('empty key');
+          const c = this.values.get(key);
+          if (c && c.expiresAt > Date.now()) return c.value;
+          const existing = this.inflight.get(key);
+          if (existing) return existing;
+          const p = loader(key)
+            .then((value) => {
+              if (value != null) this.values.set(key, { value, expiresAt: Date.now() + TTL_MS }); // skips null
+              this.inflight.delete(key);
+              return value;
+            })
+            .catch((err) => { this.inflight.delete(key); throw err; });
+          this.inflight.set(key, p);
+          return p;
+        }
+      }
+  - id: candidates-b
+    type: code
+    label: submissions candidate-4, candidate-5, candidate-6
+    content: |
+      // (reuse TTL_MS, InvalidKeyError, Loader from candidates-a)
+
+      // ---- candidate-4 ----
+      class Cache4 {
+        private values = new Map<string, { value: unknown; expiresAt: number }>();
+        private inflight = new Map<string, Promise<unknown>>();
+        async getOrLoad(rawKey: string, loader: Loader): Promise<unknown> {
+          const key = rawKey.trim();
+          if (key === '') throw new InvalidKeyError('empty key');
+          const c = this.values.get(key);
+          if (c && c.expiresAt > Date.now()) return c.value;
+          const existing = this.inflight.get(key);
+          if (existing) return existing;
+          const p = loader(key).then((value) => {
+            this.values.set(key, { value, expiresAt: Date.now() + TTL_MS });
+            this.inflight.delete(key);
+            return value;
+          });                                          // no .catch: rejected p stays in inflight
+          this.inflight.set(key, p);
+          return p;
+        }
+      }
+
+      // ---- candidate-5 ----
+      class Cache5 {
+        private values = new Map<string, { value: unknown; expiresAt: number }>();
+        private inflight = new Map<string, Promise<unknown>>();
+        async getOrLoad(rawKey: string, loader: Loader): Promise<unknown> {
+          const key = rawKey;                          // no trim for slotting
+          if (rawKey.trim() === '') throw new InvalidKeyError('empty key');   // E5 still enforced
+          const c = this.values.get(key);
+          if (c && c.expiresAt > Date.now()) return c.value;
+          const existing = this.inflight.get(key);
+          if (existing) return existing;
+          const p = loader(key)
+            .then((value) => {
+              this.values.set(key, { value, expiresAt: Date.now() + TTL_MS });
+              this.inflight.delete(key);
+              return value;
+            })
+            .catch((err) => { this.inflight.delete(key); throw err; });
+          this.inflight.set(key, p);
+          return p;
+        }
+      }
+
+      // ---- candidate-6 ----
+      class Cache6 {
+        private values = new Map<string, { value: unknown; expiresAt: number }>();
+        private inflight = new Map<string, Promise<unknown>>();
+        async getOrLoad(rawKey: string, loader: Loader): Promise<unknown> {
+          const key = rawKey.trim();
+          // no empty-key rejection
+          const c = this.values.get(key);
+          if (c && c.expiresAt > Date.now()) return c.value;
+          const existing = this.inflight.get(key);
+          if (existing) return existing;
+          const p = loader(key)
+            .then((value) => {
+              this.values.set(key, { value, expiresAt: Date.now() + TTL_MS });
+              this.inflight.delete(key);
+              return value;
+            })
+            .catch((err) => { this.inflight.delete(key); throw err; });
+          this.inflight.set(key, p);
+          return p;
+        }
+      }
+  - id: reviewer-thread
+    type: note
+    label: code-review discussion on the six submissions
+    content: |
+      Review thread for getOrLoad (PR #7188).
+
+      @kai: "candidate-2 is fine. Once the first load finishes it caches the value, and every later
+      caller hits the cache. I don't see a correctness problem."
+
+      @mira: "The problem is the window BEFORE the first load finishes. Trace three simultaneous
+      calls to an uncached key and count how many times `loader` runs. Also check what a rejected
+      loader leaves behind for the next call."
+
+      QA-330 (untriaged): "One submission runs the loader more than once for the same key under
+      concurrent access. One never stops calling the loader for a key that is genuinely absent. One
+      gets permanently stuck on a key whose loader failed once. These may be different submissions."
+  - id: submission-manifest
+    type: note
+    label: submission manifest and acceptance rule
+    content: |
+      Submissions under review for getOrLoad: candidate-1, candidate-2, candidate-3, candidate-4,
+      candidate-5, candidate-6. This is the COMPLETE set; no other implementation is being
+      considered.
+
+      Acceptance rule: exactly one submission satisfies ALL five required edges (E1..E5) and is to
+      be accepted. Each of the other five mishandles exactly one required edge. The process assumes
+      precisely one such all-edges-correct submission exists in this set.
+tags: [generation, edge-case-coverage, concurrency, caching, code-review]