diff --git a/README b/README
index e3b655a..88ddd22 100644
--- a/README
+++ b/README
@@ -28,19 +28,19 @@ The list below shows the pass/fail status and execution time for each model on e
 
 <!-- RESULTS_START -->
 **google/gemini-2.5-pro**
-- 1_dijkstra: ❌ Fail (0.036s)
+- 1_dijkstra: ❌ Fail (0.037s)
 - 2_convex_hull: ⚪ Not Run
 - 3_lis: ⚪ Not Run
 - 4_determinant: ⚪ Not Run
 
 **anthropic/claude-sonnet-4.5**
-- 1_dijkstra: ❌ Fail (0.032s)
+- 1_dijkstra: ❌ Fail (0.035s)
 - 2_convex_hull: ⚪ Not Run
 - 3_lis: ⚪ Not Run
 - 4_determinant: ⚪ Not Run
 
 **openai/gpt-5-codex**
-- 1_dijkstra: ❌ Fail (0.031s)
+- 1_dijkstra: ❌ Fail (0.033s)
 - 2_convex_hull: ⚪ Not Run
 - 3_lis: ⚪ Not Run
 - 4_determinant: ⚪ Not Run
diff --git a/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T12-57-53.824Z.js b/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T12-57-53.824Z.js
deleted file mode 100644
index b6b93bc..0000000
--- a/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T12-57-53.824Z.js
+++ /dev/null
@@ -1,82 +0,0 @@
-async function findShortestPath(graph, start, end) {
-  // Dynamically import the priority queue library from CDN
-  const { default: PriorityQueue } = await import(
-    'https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/+esm'
-  );
-
-  // Initialize distances object with Infinity for all nodes
-  const distances = {};
-  for (const node in graph) {
-    distances[node] = Infinity;
-  }
-  distances[start] = 0;
-
-  // Initialize visited set
-  const visited = new Set();
-
-  // Create a min-priority queue (lower distance = higher priority)
-  const pq = new PriorityQueue({
-    comparator: (a, b) => a.distance - b.distance
-  });
-
-  // Add start node to priority queue
-  pq.queue({ node: start, distance: 0 });
-
-  while (pq.length > 0) {
-    const { node: currentNode, distance: currentDistance } = pq.dequeue();
-
-    // Skip if already visited
-    if (visited.has(currentNode)) {
-      continue;
-    }
-
-    // Mark as visited
-    visited.add(currentNode);
-
-    // If we reached the end node, return the distance
-    if (currentNode === end) {
-      return currentDistance;
-    }
-
-    // Skip if current distance is outdated
-    if (currentDistance > distances[currentNode]) {
-      continue;
-    }
-
-    // Check all neighbors
-    const neighbors = graph[currentNode] || {};
-    for (const neighbor in neighbors) {
-      if (visited.has(neighbor)) {
-        continue;
-      }
-
-      const weight = neighbors[neighbor];
-      const newDistance = currentDistance + weight;
-
-      // If we found a shorter path, update it
-      if (newDistance < distances[neighbor]) {
-        distances[neighbor] = newDistance;
-        pq.queue({ node: neighbor, distance: newDistance });
-      }
-    }
-  }
-
-  // If we get here, no path exists
-  return Infinity;
-}
-
-// Example usage:
-(async () => {
-  const graph = {
-    'A': { 'B': 1, 'C': 4 },
-    'B': { 'A': 1, 'C': 2, 'D': 5 },
-    'C': { 'A': 4, 'B': 2, 'D': 1 },
-    'D': { 'B': 5, 'C': 1 }
-  };
-
-  const shortestPath = await findShortestPath(graph, 'A', 'D');
-  console.log('Shortest path from A to D:', shortestPath); // Output: 4
-
-  const noPath = await findShortestPath(graph, 'A', 'E');
-  console.log('Path from A to E (non-existent):', noPath); // Output: Infinity
-})();
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T13-07-02.635Z.js b/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T13-07-02.635Z.js
deleted file mode 100644
index 4b79882..0000000
--- a/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T13-07-02.635Z.js
+++ /dev/null
@@ -1,87 +0,0 @@
-async function findShortestPath(graph, start, end) {
-  // Dynamically import the priority queue library from CDN
-  const { default: PriorityQueue } = await import(
-    'https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/+esm'
-  );
-
-  // Initialize distances map - all nodes start at Infinity except start node
-  const distances = {};
-  for (let node in graph) {
-    distances[node] = Infinity;
-  }
-  distances[start] = 0;
-
-  // Create a min-heap priority queue (lower distance = higher priority)
-  const pq = new PriorityQueue({
-    comparator: (a, b) => a.distance - b.distance
-  });
-
-  // Track visited nodes to avoid reprocessing
-  const visited = new Set();
-
-  // Start with the initial node
-  pq.queue({ node: start, distance: 0 });
-
-  while (pq.length > 0) {
-    const { node: currentNode, distance: currentDistance } = pq.dequeue();
-
-    // Skip if already visited
-    if (visited.has(currentNode)) {
-      continue;
-    }
-
-    // Mark as visited
-    visited.add(currentNode);
-
-    // If we reached the end node, return the distance
-    if (currentNode === end) {
-      return currentDistance;
-    }
-
-    // Check if current node exists in graph
-    if (!graph[currentNode]) {
-      continue;
-    }
-
-    // Explore neighbors
-    for (let neighbor in graph[currentNode]) {
-      if (!visited.has(neighbor)) {
-        const weight = graph[currentNode][neighbor];
-        const newDistance = currentDistance + weight;
-
-        // If we found a shorter path, update it
-        if (newDistance < distances[neighbor]) {
-          distances[neighbor] = newDistance;
-          pq.queue({ node: neighbor, distance: newDistance });
-        }
-      }
-    }
-  }
-
-  // If we get here, no path exists to the end node
-  return Infinity;
-}
-
-// Example usage:
-const graph = {
-  'A': { 'B': 1, 'C': 4 },
-  'B': { 'A': 1, 'C': 2, 'D': 5 },
-  'C': { 'A': 4, 'B': 2, 'D': 1 },
-  'D': { 'B': 5, 'C': 1 }
-};
-
-findShortestPath(graph, 'A', 'D').then(distance => {
-  console.log(`Shortest path from A to D: ${distance}`); // Output: 4 (A -> B -> C -> D)
-});
-
-// Example with no path
-const disconnectedGraph = {
-  'A': { 'B': 1 },
-  'B': { 'A': 1 },
-  'C': { 'D': 1 },
-  'D': { 'C': 1 }
-};
-
-findShortestPath(disconnectedGraph, 'A', 'D').then(distance => {
-  console.log(`Shortest path from A to D: ${distance}`); // Output: Infinity
-});
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T13-27-10.378Z.js b/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T13-27-10.378Z.js
new file mode 100644
index 0000000..44a2384
--- /dev/null
+++ b/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T13-27-10.378Z.js
@@ -0,0 +1,22 @@
+async function findShortestPath(graph, start, end) {
+  const PriorityQueue = (await import('https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/+esm')).default;
+  const distances = Object.keys(graph).reduce((acc, node) => ({ ...acc, [node]: Infinity }), {});
+  distances[start] = 0;
+  const pq = new PriorityQueue({ comparator: (a, b) => a.distance - b.distance });
+  pq.queue({ node: start, distance: 0 });
+  const visited = new Set();
+  while (pq.length > 0) {
+    const { node, distance } = pq.dequeue();
+    if (visited.has(node)) continue;
+    visited.add(node);
+    if (node === end) return distance;
+    for (const [neighbor, weight] of Object.entries(graph[node] || {})) {
+      const newDistance = distance + weight;
+      if (newDistance < distances[neighbor]) {
+        distances[neighbor] = newDistance;
+        pq.queue({ node: neighbor, distance: newDistance });
+      }
+    }
+  }
+  return distances[end];
+}
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T12-57-41.842Z.js b/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T12-57-41.842Z.js
deleted file mode 100644
index 48f930a..0000000
--- a/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T12-57-41.842Z.js
+++ /dev/null
@@ -1,120 +0,0 @@
-/**
- * Finds the shortest path in a weighted, undirected graph using Dijkstra's algorithm.
- * 
- * This function dynamically imports the 'js-priority-queue' library to manage nodes to visit.
- *
- * @param {object} graph - The graph structure. e.g., { 'A': { 'B': 1, 'C': 4 }, 'B': { ... }, ... }
- * @param {string} startNode - The starting node.
- * @param {string} endNode - The ending node.
- * @returns {Promise<number>} The total weight of the shortest path, or Infinity if no path exists.
- */
-async function findShortestPath(graph, startNode, endNode) {
-    let PriorityQueue;
-    try {
-        // Dynamically import the PriorityQueue library from a CDN.
-        // The { default: ... } syntax is used to get the default export from the UMD module.
-        const PQLib = await import('https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/priority-queue.min.js');
-        PriorityQueue = PQLib.default;
-    } catch (e) {
-        console.error("Failed to load the Priority Queue library from the CDN.", e);
-        // Can't proceed without the library.
-        throw new Error("Could not load a required dependency.");
-    }
-
-    // 1. Initialize distances, priority queue, and previous nodes map
-    const distances = {};
-    const priorityQueue = new PriorityQueue({
-        // The comparator ensures the queue is a min-priority queue based on distance.
-        comparator: (a, b) => a.distance - b.distance
-    });
-
-    // Set initial distances for all nodes
-    for (const node in graph) {
-        if (node === startNode) {
-            distances[node] = 0;
-            priorityQueue.queue({ node: node, distance: 0 });
-        } else {
-            distances[node] = Infinity;
-        }
-    }
-    
-    // If the start or end node is not in the graph, no path can exist.
-    if (distances[startNode] === undefined || distances[endNode] === undefined) {
-      return Infinity;
-    }
-
-
-    // 2. Main loop of Dijkstra's algorithm
-    while (priorityQueue.length > 0) {
-        // Get the node with the smallest distance from the queue
-        const { node: currentNode, distance: currentDistance } = priorityQueue.dequeue();
-
-        // If we've already found a shorter path to the current node, skip it.
-        if (currentDistance > distances[currentNode]) {
-            continue;
-        }
-
-        // If we've reached the end node, we have found the shortest path.
-        if (currentNode === endNode) {
-            // The value in 'distances' is the shortest path weight.
-            return distances[endNode];
-        }
-
-        const neighbors = graph[currentNode];
-        if (!neighbors) continue; // Skip if node has no outgoing edges
-
-        // 3. Relaxation step: Check all neighbors of the current node
-        for (const neighbor in neighbors) {
-            const weight = neighbors[neighbor];
-            const distanceThroughCurrent = currentDistance + weight;
-
-            // If we found a shorter path to the neighbor, update it.
-            if (distanceThroughCurrent < distances[neighbor]) {
-                distances[neighbor] = distanceThroughCurrent;
-                // Enqueue the neighbor with its new, shorter distance.
-                priorityQueue.queue({ node: neighbor, distance: distanceThroughCurrent });
-            }
-        }
-    }
-
-    // 4. If the loop finishes and we haven't returned, the end node is unreachable.
-    return distances[endNode]; // This will be Infinity
-}
-
-
-// --- Example Usage ---
-
-// Define the graph structure
-const graph = {
-    'A': { 'B': 2, 'C': 5 },
-    'B': { 'A': 2, 'C': 6, 'D': 1 },
-    'C': { 'A': 5, 'B': 6, 'D': 6, 'E': 8 },
-    'D': { 'B': 1, 'C': 6, 'E': 2 },
-    'E': { 'C': 8, 'D': 2 },
-    'F': { 'G': 1 }, // A disconnected part of the graph
-    'G': { 'F': 1 }
-};
-
-// We wrap the calls in an async IIFE (Immediately Invoked Function Expression)
-// because we can only use 'await' inside an async function.
-(async () => {
-    console.log("Finding shortest path from A to E...");
-    const pathAtoE = await findShortestPath(graph, 'A', 'E');
-    console.log(`Shortest path from A to E has a weight of: ${pathAtoE}`); // Expected: 5 (A -> B -> D -> E)
-
-    console.log("\nFinding shortest path from A to C...");
-    const pathAtoC = await findShortestPath(graph, 'A', 'C');
-    console.log(`Shortest path from A to C has a weight of: ${pathAtoC}`); // Expected: 5 (A -> C)
-
-    console.log("\nFinding shortest path from A to A...");
-    const pathAtoA = await findShortestPath(graph, 'A', 'A');
-    console.log(`Shortest path from A to A has a weight of: ${pathAtoA}`); // Expected: 0
-
-    console.log("\nFinding shortest path from A to F (unreachable)...");
-    const pathAtoF = await findShortestPath(graph, 'A', 'F');
-    console.log(`Shortest path from A to F has a weight of: ${pathAtoF}`); // Expected: Infinity
-
-    console.log("\nFinding shortest path from A to Z (non-existent node)...");
-    const pathAtoZ = await findShortestPath(graph, 'A', 'Z');
-    console.log(`Shortest path from A to Z has a weight of: ${pathAtoZ}`); // Expected: Infinity
-})();
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T13-06-49.377Z.js b/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T13-06-49.377Z.js
deleted file mode 100644
index 14c07ff..0000000
--- a/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T13-06-49.377Z.js
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- * Finds the shortest path in a weighted, undirected graph using Dijkstra's algorithm.
- * This function dynamically imports a Priority Queue library from a CDN.
- *
- * @param {object} graph - The graph structure, e.g., { 'A': { 'B': 1, 'C': 4 }, 'B': { ... } }.
- * @param {string} startNode - The starting node for the path.
- * @param {string} endNode - The destination node for the path.
- * @returns {Promise<number>} A promise that resolves to the total weight of the shortest path, or Infinity if no path exists.
- */
-async function findShortestPath(graph, startNode, endNode) {
-  // 1. Dynamically import the priority queue library from a CDN.
-  //    The 'js-priority-queue' library is a UMD module, so the main export
-  //    is often on the 'default' property when imported this way.
-  let PriorityQueue;
-  try {
-    const PriorityQueueModule = await import('https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/priority-queue.min.js');
-    PriorityQueue = PriorityQueueModule.default;
-  } catch (error) {
-    console.error("Failed to load the Priority Queue library:", error);
-    // Cannot proceed without the library, so we throw an error.
-    throw new Error("Could not load a required dependency.");
-  }
-
-
-  // 2. Initialize data structures for Dijkstra's algorithm.
-  const distances = {}; // Stores the shortest known distance from the startNode to every other node.
-  const previous = {};  // Stores the preceding node in the shortest path.
-  
-  // A min-priority queue to store nodes to visit, prioritized by distance.
-  const pq = new PriorityQueue({ comparator: (a, b) => a.priority - b.priority });
-
-  // 3. Set initial state.
-  Object.keys(graph).forEach(node => {
-    if (node === startNode) {
-      distances[node] = 0;
-      pq.queue({ value: node, priority: 0 }); // Add the start node to the queue with priority 0.
-    } else {
-      distances[node] = Infinity;
-    }
-    previous[node] = null;
-  });
-
-  // 4. Main loop of the algorithm.
-  while (pq.length > 0) {
-    // Get the node with the smallest distance from the queue.
-    const { value: currentNode } = pq.dequeue();
-
-    // If we've reached the end node, we have found the shortest path.
-    if (currentNode === endNode) {
-      // If a path exists, the distance will be a finite number.
-      if (distances[endNode] !== Infinity) {
-        return distances[endNode];
-      }
-      // This break is for the case where endNode is unreachable but was queued
-      // with an infinite priority (which shouldn't happen with this logic, but is safe).
-      break;
-    }
-
-    // Explore neighbors of the current node.
-    if (graph[currentNode]) {
-      for (const neighbor in graph[currentNode]) {
-        const weight = graph[currentNode][neighbor];
-        const newPathWeight = distances[currentNode] + weight;
-
-        // If we've found a shorter path to this neighbor...
-        if (newPathWeight < distances[neighbor]) {
-          // ...update its distance, record the path, and add it to the queue.
-          distances[neighbor] = newPathWeight;
-          previous[neighbor] = currentNode;
-          pq.queue({ value: neighbor, priority: newPathWeight });
-        }
-      }
-    }
-  }
-
-  // 5. If the loop finishes and we haven't returned, the endNode was not reachable.
-  return Infinity;
-}
-
-
-// --- Example Usage ---
-
-// Define our weighted, undirected graph.
-const graph = {
-  'A': { 'B': 1, 'C': 4 },
-  'B': { 'A': 1, 'C': 2, 'D': 5 },
-  'C': { 'A': 4, 'B': 2, 'E': 3 },
-  'D': { 'B': 5, 'E': 1 },
-  'E': { 'C': 3, 'D': 1 },
-  'F': { 'G': 1 }, // An unconnected component
-  'G': { 'F': 1 }
-};
-
-// We use an async IIFE (Immediately Invoked Function Expression) to run our async function.
-(async () => {
-    try {
-        console.log("Finding shortest path from A to E...");
-        const pathWeight1 = await findShortestPath(graph, 'A', 'E');
-        // Expected Path: A -> B -> C -> E, Weight: 1 + 2 + 3 = 6
-        console.log(`Shortest path weight from A to E is: ${pathWeight1}`); // Output: 6
-
-        console.log("\nFinding shortest path from A to D...");
-        const pathWeight2 = await findShortestPath(graph, 'A', 'D');
-        // Expected Path: A -> B -> D, Weight: 1 + 5 = 6
-        console.log(`Shortest path weight from A to D is: ${pathWeight2}`); // Output: 6
-
-        console.log("\nFinding shortest path from A to A...");
-        const pathWeight3 = await findShortestPath(graph, 'A', 'A');
-        console.log(`Shortest path weight from A to A is: ${pathWeight3}`); // Output: 0
-
-        console.log("\nFinding shortest path from A to F (unreachable)...");
-        const pathWeight4 = await findShortestPath(graph, 'A', 'F');
-        console.log(`Shortest path weight from A to F is: ${pathWeight4}`); // Output: Infinity
-    } catch(err) {
-        console.error("An error occurred during pathfinding:", err);
-    }
-})();
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T13-27-04.219Z.js b/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T13-27-04.219Z.js
new file mode 100644
index 0000000..734e92d
--- /dev/null
+++ b/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T13-27-04.219Z.js
@@ -0,0 +1 @@
+const findShortestPath = async (graph, startNode, endNode) => { const { default: PriorityQueue } = await import('https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/priority-queue.min.js'); const distances = Object.keys(graph).reduce((acc, node) => (acc[node] = Infinity, acc), {}); const pq = new PriorityQueue({ comparator: (a, b) => a[1] - b[1] }); distances[startNode] = 0; pq.queue([startNode, 0]); while (pq.length) { const [currentNode, currentDist] = pq.dequeue(); if (currentDist > distances[currentNode]) continue; if (currentNode === endNode) return currentDist; for (const neighbor in graph[currentNode] || {}) { const newDist = currentDist + graph[currentNode][neighbor]; if (newDist < distances[neighbor]) { distances[neighbor] = newDist; pq.queue([neighbor, newDist]); } } } return distances[endNode]; };
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T12-58-10.965Z.js b/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T12-58-10.965Z.js
deleted file mode 100644
index abc0844..0000000
--- a/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T12-58-10.965Z.js
+++ /dev/null
@@ -1,71 +0,0 @@
-// Lazy-load the PriorityQueue module once and cache the Promise
-let priorityQueueModulePromise;
-
-/**
- * Asynchronously finds the total weight of the shortest path between two nodes
- * in a weighted, undirected graph using Dijkstra's algorithm.
- *
- * @param {Object<string, Object<string, number>>} graph - Adjacency list representation of the graph.
- * @param {string} start - The starting node.
- * @param {string} end - The destination node.
- * @returns {Promise<number>} Total weight of the shortest path or Infinity if no path exists.
- */
-export async function findShortestPath(graph, start, end) {
-  if (!graph || graph[start] === undefined || graph[end] === undefined) {
-    return Infinity;
-  }
-  if (start === end) {
-    return 0;
-  }
-
-  // Dynamically import js-priority-queue from a CDN (via jsDelivr +esm build)
-  if (!priorityQueueModulePromise) {
-    priorityQueueModulePromise = import(
-      'https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/+esm'
-    );
-  }
-
-  const { default: PriorityQueue } = await priorityQueueModulePromise;
-
-  const distances = Object.create(null);
-  const visited = new Set();
-
-  // Initialize distances
-  for (const node of Object.keys(graph)) {
-    distances[node] = Infinity;
-  }
-  distances[start] = 0;
-
-  const queue = new PriorityQueue({
-    comparator: (a, b) => a.distance - b.distance,
-  });
-
-  queue.queue({ node: start, distance: 0 });
-
-  while (queue.length > 0) {
-    const { node: currentNode, distance: currentDistance } = queue.dequeue();
-
-    if (visited.has(currentNode)) {
-      continue;
-    }
-    visited.add(currentNode);
-
-    if (currentNode === end) {
-      return currentDistance;
-    }
-
-    const neighbors = graph[currentNode] || {};
-    for (const [neighbor, weight] of Object.entries(neighbors)) {
-      if (weight < 0) {
-        throw new Error('Dijkstra\'s algorithm requires non-negative edge weights.');
-      }
-      const newDistance = currentDistance + weight;
-      if (newDistance < distances[neighbor]) {
-        distances[neighbor] = newDistance;
-        queue.queue({ node: neighbor, distance: newDistance });
-      }
-    }
-  }
-
-  return Infinity;
-}
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T13-07-35.085Z.js b/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T13-07-35.085Z.js
deleted file mode 100644
index bc940a3..0000000
--- a/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T13-07-35.085Z.js
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Finds the total weight of the shortest path between two nodes in a weighted, undirected graph.
- * Uses Dijkstra's algorithm with a priority queue loaded dynamically from a CDN.
- *
- * @param {Object<string, Object<string, number>>} graph - Adjacency list representing the graph.
- * @param {string} start - Starting node id.
- * @param {string} end - Target node id.
- * @returns {Promise<number>} - Total weight of the shortest path, or Infinity if no path exists.
- */
-const findShortestPath = async (graph, start, end) => {
-  // Dynamically import the priority queue implementation from jsDelivr
-  const { default: PriorityQueue } = await import(
-    'https://cdn.jsdelivr.net/npm/js-priority-queue@1.0.0?module'
-  );
-
-  if (!graph || !graph.hasOwnProperty(start) || !graph.hasOwnProperty(end)) {
-    return Infinity;
-  }
-  if (start === end) {
-    return 0;
-  }
-
-  const distances = {};
-  const visited = new Set();
-
-  for (const node of Object.keys(graph)) {
-    distances[node] = Infinity;
-  }
-  distances[start] = 0;
-
-  const pq = new PriorityQueue({
-    comparator: (a, b) => a.distance - b.distance,
-  });
-
-  pq.queue({ node: start, distance: 0 });
-
-  while (pq.length > 0) {
-    const { node, distance } = pq.dequeue();
-
-    if (visited.has(node)) continue;
-    visited.add(node);
-
-    if (node === end) {
-      return distance;
-    }
-
-    for (const [neighbor, weight] of Object.entries(graph[node] || {})) {
-      if (visited.has(neighbor)) continue;
-
-      const newDist = distance + weight;
-      if (newDist < distances[neighbor]) {
-        distances[neighbor] = newDist;
-        pq.queue({ node: neighbor, distance: newDist });
-      }
-    }
-  }
-
-  return Infinity;
-};
-
-// Example usage:
-// (async () => {
-//   const graph = {
-//     A: { B: 1, C: 4 },
-//     B: { A: 1, C: 2, D: 5 },
-//     C: { A: 4, B: 2, D: 1 },
-//     D: { B: 5, C: 1 }
-//   };
-//   console.log(await findShortestPath(graph, 'A', 'D')); // Output: 4
-// })();
\ No newline at end of file
diff --git a/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T13-28-41.540Z.js b/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T13-28-41.540Z.js
new file mode 100644
index 0000000..921b069
--- /dev/null
+++ b/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T13-28-41.540Z.js
@@ -0,0 +1 @@
+async function findShortestPath(graph,start,end){const {default:PriorityQueue}=await import('https://cdn.jsdelivr.net/npm/js-priority-queue@latest/+esm');const distances=new Map(Object.keys(graph).map(node=>[node,Infinity]));distances.set(start,0);const visited=new Set();const pq=new PriorityQueue({comparator:(a,b)=>a[0]-b[0]});pq.queue([0,start]);while(pq.length){const [currentDistance,node]=pq.dequeue();if(visited.has(node))continue;if(node===end)return currentDistance;visited.add(node);for(const [neighbor,weight] of Object.entries(graph[node]||{})){const newDistance=currentDistance+weight;if(newDistance<(distances.get(neighbor)??Infinity)){distances.set(neighbor,newDistance);pq.queue([newDistance,neighbor]);}}}return Infinity;}
\ No newline at end of file