# Trace a runtime bug from a stack trace in Deno with Atlas in 2026 > Atlas enables Deno developers to trace runtime bugs from production stack traces directly to a fix, integrating direct with `deno test` and `deno fmt`. Atlas helps Deno developers trace runtime bugs from production stack traces to a fix without a debugger attached, by reading each frame, using `grep` for error messages, and leveraging `lsp` to find callers, then applying `edit` and adding a regression test with `deno test`. ## Key takeaways - Atlas traces Deno runtime bugs from stack traces using `read`, `grep`, and `lsp` tools. - Atlas integrates with Deno's `deno.json` and `deno.jsonc` for project context and permissions. - Fix Deno bugs with Atlas's `edit` tool and validate with `deno test` regression tests. - Atlas ensures Deno code safety by tightening `--allow-all` to specific `--allow-net` and `--allow-read` scopes. - Review and approve all Deno code changes via Atlas's unified diff before writing. ## How Atlas traces Deno runtime bugs from stack traces Atlas reads stack trace frames, validating offsets, to trace Deno runtime bugs. In 2026, this process ensures that a trace from an older build, which might point to the wrong code, fails loudly instead of silently misdirecting the developer. Tracing a Deno runtime bug begins by pasting the production stack trace into Atlas. Atlas uses its `read` tool to consume each `file:line` pair from the trace. A critical step is Atlas's validation of these offsets against the current Deno file. If the `read` tool reports an "Offset is out of range for this file" error, it immediately signals that the stack trace originated from a different build, preventing you from debugging outdated code. Once valid, Atlas can then `grep` for the specific error message string, often revealing where the error is constructed, which is typically more informative than just the top frame. For deeper analysis, the `lsp` tool's `findReferences` operation can be used on the failing Deno function to identify all callers that might supply the bad input, helping to reconstruct the full path to the bug. ## Ensuring Deno code accuracy and safety with Atlas Atlas ensures Deno code accuracy and safety by integrating directly with `deno.json` or `deno.jsonc` configurations, allowing it to read import maps and JSR specifiers. This setup, crucial in 2026, ensures Atlas understands your project's dependencies and tasks before any action. Atlas operates within your Deno project by first reading your `deno.json` or `deno.jsonc` configuration. This allows Atlas to understand your project's import maps, JSR and npm specifiers, and any defined tasks. This deep integration means Atlas can add dependencies using `deno add jsr:@std/...` rather than requiring manual `import_map.json` edits. Furthermore, Atlas enhances Deno's inherent security model by helping to tighten broad `--allow-all` tasks down to the specific `--allow-net` and `--allow-read` scopes your code truly needs. Every Atlas tool call is permission-gated, and any proposed changes are presented as a unified diff for your approval, ensuring you maintain full control over your Deno codebase. ## Fixing Deno bugs and preventing recurrence with Atlas Fixing Deno bugs with Atlas involves using the `edit` tool to apply changes and then immediately adding a regression test to prevent recurrence. This ensures that once a bug is identified and fixed, it cannot silently reappear in future builds, a critical practice for robust Deno applications in 2026. Once the responsible line in your Deno code is identified, Atlas's `edit` tool allows you to apply the necessary fix. A key part of the workflow is to then add a regression test using `deno test`. This ensures that the specific bug cannot recur silently in the future, providing a robust safety net for your Deno application. Atlas can run `deno test` and `deno check` behind a permission prompt to validate your changes. Before writing any changes to disk, Atlas computes a unified diff for every file edit and surfaces it for your approval. Atlas also integrates with `git`, allowing it to read branches, status, and diffs, and can stage and create commits on your behalf, making the entire fix and commit process streamlined and auditable. ## Steps 1. Paste the Deno stack trace into Atlas and have Atlas `read` each frame's file at the reported offset. 2. If Atlas `read` reports "Offset is out of range for this file", re-read the Deno file from the top before trusting any line number, as the trace came from a different build. 3. `grep` for the Deno error message string to find where it is constructed, which is usually more informative than the top frame. 4. Use the Atlas `lsp` tool's `findReferences` operation on the failing Deno function to see which callers can reach it with the bad input. 5. `edit` the Deno code to apply the fix, then add a regression test using `deno test` so the trace cannot recur silently. 6. Review the unified diff computed by Atlas for your Deno project and approve the changes before writing them to disk. ## FAQ ### How does Atlas handle Deno stack traces from old builds? Atlas validates offsets against the current Deno file. If an offset is out of range, it loudly reports that the trace came from an older build, preventing misdirection to incorrect code. ### Can Atlas manage Deno project dependencies like JSR packages? Yes, Atlas reads your Deno project's `deno.json` or `deno.jsonc` to understand import maps and JSR/npm specifiers, and can add dependencies using `deno add jsr:@std/...`. ### How does Atlas ensure Deno code changes are safe? Atlas drafts a plan, asks for approval, computes a unified diff for every file edit, and surfaces it for approval before writing. It also gates every tool call with permission rules. ### Does Atlas run Deno tests automatically after a fix? Yes, Atlas can run `deno test` behind a permission prompt to validate fixes and ensure new regression tests prevent the bug from recurring. ### How does Atlas help tighten Deno runtime permissions? Atlas can analyze your Deno code and suggest tightening broad `--allow-all` tasks in `deno.json` to specific scopes like `--allow-net` and `--allow-read` based on actual code needs. ### What Deno configuration files does Atlas understand? Atlas reads `deno.json` and `deno.jsonc` to understand your Deno project's import maps, JSR and npm specifiers, and defined tasks. ### Can Atlas help me format my Deno code? Yes, Atlas can run `deno fmt` and `deno lint` on the diff of your changes, ensuring your Deno code adheres to formatting standards. --- Canonical HTML: https://runatlas.sh/resources/stacks/trace-a-runtime-bug-from-a-stack-trace-in-deno Source of truth: aeo_pages row `/resources/stacks/trace-a-runtime-bug-from-a-stack-trace-in-deno` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.