EXAMPLE 05 • stepping.ts

Logical Stepping Across Inlined & Outlined Functions

Step Over, Into, and Out of inlined helper functions and outlined transpiled blocks while automatically skipping compiler helpers.

Multi-Statement Inlined Range (calculateCustomsDuty)Outlined Function Range (isStackFrame: true, isHidden: true + OriginalScope)Pure Compiler Helper Ranges (isStackFrame: true, no OriginalScope)Unmapped Compiler Glue Auto-Stepping

OPEN CHROME DEVTOOLS (F12) FIRST, THEN TRIGGER:

Ready. Click "Run & Pause in Debugger" with DevTools open.

How This Example Works

Compilers routinely both inline helper calls (calculateCustomsDuty flattened into dispatchPackage) and outline transpiled language constructs (such as extracting a block into a separate top-level function _outlinedCustomsBlock marked isStackFrame: true, isHidden: true with a definition OriginalScope), while injecting pure runtime helpers like __checkPositive (isStackFrame: true with no OriginalScope).

With scope-aware Logical Stepping, Chrome DevTools follows the authored control flow: Step Over (F10) skips over inlined callees but steps through outlined blocks; Step Out (Shift+F11) exits an inlined function back to its caller or exits an outlined block all the way out of its enclosing authored function; and pure compiler helpers / unmapped glue are skipped automatically.

What to Try & Verify in DevTools

1. Step Over (F10) an Inlined Call & Pure Compiler Helpers Logical Stepping

Try:Click "Run & Pause in Debugger" to pause at debugger; (line 22 of stepping.ts), then press Step Over (F10) three times.

At the debugger;: handlingFee, dutyAmount and totalCost show as <unavailable> (not initialized yet).
1st F10 (Line 23 const handlingFee = 15;): Stops on line 23 (__checkPositive(15) in bundle.js is not entered).
2nd F10 (Line 24 const dutyAmount = calculateCustomsDuty(...)): Stops at the call site before entering the inlined range.
3rd F10 (Skips Inlined Body → Line 28 let totalCost = 0;): DevTools passes the inlined callee range in skipList, skipping all 3 statements of calculateCustomsDuty!

2. Step Into (F11) & Step Out (Shift+F11) of an Inlined Function Logical Stepping

Try:Re-run, press F10 twice to reach line 24 (calculateCustomsDuty(...)), press Step Into (F11), then press Step Out (Shift+F11).

Step Into (F11) Enters Inlined Body: Execution moves to line 11 (const rate = ...) inside calculateCustomsDuty, and the Call Stack adds the virtual calculateCustomsDuty frame.
Pure Helper Skipped on F11: Even though const _inlinedArg = __checkPositive(val) runs first on that line, __checkPositive has no original scope, so F11 lands directly in calculateCustomsDuty.
Step Out (Shift+F11) Returns to Caller: Pressing Shift+F11 inside calculateCustomsDuty skips its remaining lines (rawDuty, roundedDuty) and pauses back in dispatchPackage on line 28 (let totalCost = 0;).

3. Step Over (F10) Seamlessly Through an Outlined Block Logical Stepping

Try:From line 28 (let totalCost = 0;), press Step Over (F10) repeatedly through lines 30–36.

Enters _outlinedCustomsBlock Automatically: Even though { const clearance = ... } is extracted into a separate function _outlinedCustomsBlock in bundle.js, F10 steps *into* line 30 (const clearance = openCustomsClearance(trackingId);) instead of skipping the call!
Merged Call Stack & Live Scopes: While paused inside the outlined block, the Call Stack shows dispatchPackage (hiding _outlinedCustomsBlock), and the Scope pane shows both Block (clearance, subtotalWithDuty) and dispatchPackage variables. totalCost is 0 until the totalCost = ... line ran.
Seamless Exit: Pressing F10 after clearance.commit(totalCost); skips the unmapped return tot; and pauses on line 36 (return { trackingId, dutyAmount, totalCost };).

4. Step Out (Shift+F11) from Inside an Outlined Block Logical Stepping

Try:Re-run, step (F10) into line 31 (const subtotalWithDuty = ...) inside the outlined block, and press Step Out (Shift+F11).

Exits the Whole Authored Function (dispatchPackage): Instead of merely returning from _outlinedCustomsBlock back into dispatchPackage, DevTools unwinds both _outlinedCustomsBlock and dispatchPackage, pausing in the caller runSteppingPipeline() (line 41)!

Other things to try

Set breakpoints inside the outlined block and inside the inlined calculateCustomsDuty, then re-run.
Step Into (F11) the dispatchPackage(...) call in runSteppingPipeline.
While paused inside the outlined block, use Restart frame on dispatchPackage.
Select a non-top frame in the Call Stack and press F10.

Not sure if it's a DevTools bug? Tab 4. Decoded Scopes shows what the source map actually encodes.

Try in the Console While Paused

While paused, select a frame and evaluate these in the Console (Esc opens the drawer) using the authored names:

{ trackingId, declaredValue, handlingFee, dutyAmount }

Expected Result: { trackingId: "SHP-9042", declaredValue: 450, handlingFee: 15, dutyAmount: 54 }

Works in dispatchPackage once dutyAmount is initialized (before that, handlingFee/dutyAmount are unavailable) and while paused inside _outlinedCustomsBlock via its dispatchPackage definition scope bindings.

subtotalWithDuty + handlingFee

Expected Result: 519 (when paused inside the outlined block after line 31)

Combines subtotalWithDuty (sub in customsBlock) with handlingFee (fee in dispatchPackage).

        
        // Authored TypeScript: stepping.ts
      
        export interface CustomsClearance {
      
          id: string;
      
          committed: number;
      
          commit(amount: number): void;
      
        }
      
        declare function openCustomsClearance(trackingId: string): CustomsClearance;
      
        function calculateCustomsDuty(declaredValue: number, category: string): number {
      
          const rate = category === "electronics" ? 0.12 : 0.05;
      
          const rawDuty = declaredValue * rate;
      
          const roundedDuty = Math.round(rawDuty * 100) / 100;
      
          return roundedDuty;
      
        }
      
        function dispatchPackage(
      
          trackingId: string,
      
          declaredValue: number,
      
          category: string,
      
        ) {
      
          debugger; // Pause: Try Step Over (F10), Step Into (F11) & Step Out (Shift+F11)!
      
          const handlingFee = 15;
      
          const dutyAmount = calculateCustomsDuty(declaredValue, category);
      
          // Transpiled `using` block — outlined by the compiler into a separate
      
          // top-level function `_outlinedCustomsBlock` in bundle.js:
      
          let totalCost = 0;
      
          {
      
            const clearance = openCustomsClearance(trackingId);
      
            const subtotalWithDuty = declaredValue + dutyAmount;
      
            totalCost = subtotalWithDuty + handlingFee;
      
            clearance.commit(totalCost);
      
          }
      
          return { trackingId, dutyAmount, totalCost };
      
        }
      
        export function runSteppingPipeline() {
      
          const shipment = dispatchPackage("SHP-9042", 450, "electronics");
      
          const status = `Dispatched ${shipment.trackingId}: $${shipment.totalCost}`;
      
          return { shipment, status };
      
        }

        
        function __checkPositive(v) {
      
          if (v < 0) throw new RangeError("Negative value");
      
          return v;
      
        }
      
        function __openClearance(id) {
      
          return {
      
            id,
      
            committed: 0,
      
            commit(amt) {
      
              this.committed = amt;
      
            }
      
          };
      
        }
      
        function _outlinedCustomsBlock(id, val, cat, fee, duty) {
      
          const cl = __openClearance(id);
      
          const sub = val + duty;
      
          const tot = sub + fee;
      
          cl.commit(tot);
      
          return tot;
      
        }
      
        function dispatchPackage(id, val, cat) {
      
          debugger;
      
          const fee = __checkPositive(15);
      
          const _inlinedArg = __checkPositive(val);
      
          const r = cat === "electronics" ? 0.12 : 0.05;
      
          const raw = _inlinedArg * r;
      
          const duty = Math.round(raw * 100) / 100;
      
          let tot = 0;
      
          tot = _outlinedCustomsBlock(id, val, cat, fee, duty);
      
          return { trackingId: id, dutyAmount: duty, totalCost: tot };
      
        }
      
        function runSteppingPipeline() {
      
          const s = dispatchPackage("SHP-9042", 450, "electronics");
      
          const st = "Dispatched " + s.trackingId + ": $" + s.totalCost;
      
          return { shipment: s, status: st };
      
        }
      
        window.runExample05 = function() {
      
          return runSteppingPipeline();
      
        };
      
        //# sourceMappingURL=bundle.js.map

        
        const builder = new SafeScopeInfoBuilder();
      
        // 1. Original Scopes:
      
        //    - calculateCustomsDuty (inlined into dispatchPackage)
      
        //    - dispatchPackage + inner customsBlock (outlined into _outlinedCustomsBlock)
      
        //    - runSteppingPipeline (outer caller)
      
        builder
      
          .startSource()
      
          .startScope(0, 0, {
      
            kind: "Module",
      
            key: "module",
      
            variables: [
      
              "openCustomsClearance",
      
              "calculateCustomsDuty",
      
              "dispatchPackage",
      
              "runSteppingPipeline",
      
            ],
      
          })
      
          .startScope(dutyStart.line, dutyStart.column, {
      
            name: "calculateCustomsDuty",
      
            kind: "Function",
      
            isStackFrame: true,
      
            key: "calculateCustomsDuty",
      
            variables: ["declaredValue", "category", "rate", "rawDuty", "roundedDuty"],
      
          })
      
          .endScope(dutyEnd.line, dutyEnd.column)
      
          .startScope(dispatchStart.line, dispatchStart.column, {
      
            name: "dispatchPackage",
      
            kind: "Function",
      
            isStackFrame: true,
      
            key: "dispatchPackage",
      
            variables: [
      
              "trackingId",
      
              "declaredValue",
      
              "category",
      
              "handlingFee",
      
              "dutyAmount",
      
              "totalCost",
      
            ],
      
          })
      
          .startScope(blockStart.line, blockStart.column, {
      
            kind: "Block",
      
            key: "customsBlock",
      
            variables: ["clearance", "subtotalWithDuty"],
      
          })
      
          .endScope(blockEnd.line, blockEnd.column)
      
          .endScope(dispatchEnd.line, dispatchEnd.column)
      
          .startScope(pipelineStart.line, pipelineStart.column, {
      
            name: "runSteppingPipeline",
      
            kind: "Function",
      
            isStackFrame: true,
      
            key: "runSteppingPipeline",
      
            variables: ["shipment", "status"],
      
          })
      
          .endScope(pipelineEnd.line, pipelineEnd.column)
      
          .endScope(origModuleEnd.line, origModuleEnd.column)
      
          .endSource();
      
        // 2. Generated Ranges:
      
        //    - __checkPositive & __openClearance: pure compiler helpers (isStackFrame: true, no OriginalScope)
      
        //    - _outlinedCustomsBlock: outlined block function (isStackFrame: true, isHidden: true, scopeKey: "dispatchPackage")
      
        //    - dispatchPackage: contains inlined calculateCustomsDuty range (isStackFrame: false, callSite)
      
        //    - availableFrom(start, from, end, value) = unavailable in [start, from), bound to value in [from, end).
      
        //      Used for generated let/const that are still in their TDZ before their declaration ran.
      
        builder
      
          .startRange(0, 0, {
      
            scopeKey: "module",
      
            values: ["__openClearance", null, "dispatchPackage", "runSteppingPipeline"],
      
          })
      
          // Pure compiler helpers (no OriginalScope -> automatically blackboxed during stepping!)
      
          .startRange(checkPosStart.line, checkPosStart.column, { isStackFrame: true })
      
          .endRange(checkPosEnd.line, checkPosEnd.column)
      
          .startRange(openClrStart.line, openClrStart.column, { isStackFrame: true })
      
          .startRange(commitMethodStart.line, commitMethodStart.column, { isStackFrame: true })
      
          .endRange(commitMethodEnd.line, commitMethodEnd.column)
      
          .endRange(openClrEnd.line, openClrEnd.column)
      
          // Outlined block helper (isStackFrame: true, isHidden: true + definition OriginalScope)
      
          .startRange(outlinedStart.line, outlinedStart.column, {
      
            scopeKey: "dispatchPackage",
      
            isStackFrame: true,
      
            isHidden: true,
      
            values: [
      
              "id", "val", "cat", "fee", "duty",
      
              // totalCost is still 0 until the outlined 'const tot' is assigned
      
              [
      
                { from: outlinedStart, to: afterOutlinedTot, value: "0" },
      
                { from: afterOutlinedTot, to: outlinedEnd, value: "tot" },
      
              ],
      
            ],
      
          })
      
          .startRange(outlinedBodyStart.line, outlinedBodyStart.column, {
      
            scopeKey: "customsBlock",
      
            isStackFrame: false,
      
            values: [
      
              availableFrom(outlinedBodyStart, afterCl, outlinedBodyEnd, "cl"),
      
              availableFrom(outlinedBodyStart, afterSub, outlinedBodyEnd, "sub"),
      
            ],
      
          })
      
          .endRange(outlinedBodyEnd.line, outlinedBodyEnd.column)
      
          .endRange(outlinedEnd.line, outlinedEnd.column)
      
          // Main function with inlined calculateCustomsDuty range
      
          .startRange(genDispatchStart.line, genDispatchStart.column, {
      
            scopeKey: "dispatchPackage",
      
            isStackFrame: true,
      
            values: [
      
              "id", "val", "cat",
      
              availableFrom(genDispatchStart, afterFee, genDispatchEnd, "fee"),
      
              availableFrom(genDispatchStart, afterDuty, genDispatchEnd, "duty"),
      
              availableFrom(genDispatchStart, afterTot, genDispatchEnd, "tot"),
      
            ],
      
          })
      
          .startRange(genInlinedStart.line, genInlinedStart.column, {
      
            scopeKey: "calculateCustomsDuty",
      
            isStackFrame: false,
      
            callSite: callSiteCalculateDuty,
      
            values: [
      
              "_inlinedArg", "cat",
      
              availableFrom(genInlinedStart, afterR, genInlinedEnd, "r"),
      
              availableFrom(genInlinedStart, afterRaw, genInlinedEnd, "raw"),
      
              null, // roundedDuty: 'duty' is only assigned by the very last statement of this range
      
            ],
      
          })
      
          .endRange(genInlinedEnd.line, genInlinedEnd.column)
      
          .endRange(genDispatchEnd.line, genDispatchEnd.column)
      
          .startRange(genPipelineStart.line, genPipelineStart.column, {
      
            scopeKey: "runSteppingPipeline",
      
            isStackFrame: true,
      
            values: [
      
              availableFrom(genPipelineStart, afterS, genPipelineEnd, "s"),
      
              availableFrom(genPipelineStart, afterSt, genPipelineEnd, "st"),
      
            ],
      
          })
      
          .endRange(genPipelineEnd.line, genPipelineEnd.column)
      
          .startRange(genRunStart.line, genRunStart.column, { isStackFrame: true })
      
          .endRange(genRunEnd.line, genRunEnd.column)
      
          .endRange(genModuleEnd.line, genModuleEnd.column);

Decoded OriginalScope Tree (stepping.ts)
      Module
      (anonymous)
      [0:0 → 43:0)
      
    
variables: [openCustomsClearance, calculateCustomsDuty, dispatchPackage, runSteppingPipeline]

      Function
      calculateCustomsDuty
      [9:29 → 14:1)
      isStackFrame
    
variables: [declaredValue, category, rate, rawDuty, roundedDuty]

      Function
      dispatchPackage
      [16:24 → 36:1)
      isStackFrame
    
variables: [trackingId, declaredValue, category, handlingFee, dutyAmount, totalCost]

      Block
      (anonymous)
      [28:2 → 33:3)
      
    
variables: [clearance, subtotalWithDuty]

      Function
      runSteppingPipeline
      [38:35 → 42:1)
      isStackFrame
    
variables: [shipment, status]
Decoded GeneratedRange & Binding Tree (bundle.js)
      Range [0:0 → 40:0)
      → Module
      isStackFrame: false
      
      
    

          bindings: openCustomsClearance → __openClearance, calculateCustomsDuty → <unavailable>, dispatchPackage → dispatchPackage, runSteppingPipeline → runSteppingPipeline
        

      Range [0:24 → 3:1)
      → unmapped range
      isStackFrame
      
      
    

      Range [4:24 → 12:1)
      → unmapped range
      isStackFrame
      
      
    

      Range [8:10 → 10:5)
      → unmapped range
      isStackFrame
      
      
    

      Range [13:30 → 19:1)
      → Function(dispatchPackage)
      isStackFrame
      isHidden: true
      
    

          bindings: trackingId → id, declaredValue → val, category → cat, handlingFee → fee, dutyAmount → duty, totalCost → SubRanges([13:30-16:24]: 0 | [16:24-19:1]: tot)
        

      Range [14:2 → 17:17)
      → Block
      isStackFrame: false
      
      
    

          bindings: clearance → SubRanges([14:2-14:33]: unavailable | [14:33-17:17]: cl), subtotalWithDuty → SubRanges([14:2-15:25]: unavailable | [15:25-17:17]: sub)
        

      Range [20:24 → 30:1)
      → Function(dispatchPackage)
      isStackFrame
      
      
    

          bindings: trackingId → id, declaredValue → val, category → cat, handlingFee → SubRanges([20:24-22:34]: unavailable | [22:34-30:1]: fee), dutyAmount → SubRanges([20:24-26:43]: unavailable | [26:43-30:1]: duty), totalCost → SubRanges([20:24-27:14]: unavailable | [27:14-30:1]: tot)
        

      Range [24:2 → 26:43)
      → Function(calculateCustomsDuty)
      isStackFrame: false
      
      callSite @ 24:22
    

          bindings: declaredValue → _inlinedArg, category → cat, rate → SubRanges([24:2-24:48]: unavailable | [24:48-26:43]: r), rawDuty → SubRanges([24:2-25:30]: unavailable | [25:30-26:43]: raw), roundedDuty → <unavailable>
        

      Range [31:28 → 35:1)
      → Function(runSteppingPipeline)
      isStackFrame
      
      
    

          bindings: shipment → SubRanges([31:28-32:60]: unavailable | [32:60-35:1]: s), status → SubRanges([31:28-33:64]: unavailable | [33:64-35:1]: st)
        

      Range [36:30 → 38:1)
      → unmapped range
      isStackFrame
      
      
    

              Raw Source Map JSON (bundle.js.map)
              {
  "version": 3,
  "file": "bundle.js",
  "sources": [
    "stepping.ts"
  ],
  "sourcesContent": [
    "// Authored TypeScript: stepping.ts\nexport interface CustomsClearance {\n  id: string;\n  committed: number;\n  commit(amount: number): void;\n}\n\ndeclare function openCustomsClearance(trackingId: string): CustomsClearance;\n\nfunction calculateCustomsDuty(declaredValue: number, category: string): number {\n  const rate = category === \"electronics\" ? 0.12 : 0.05;\n  const rawDuty = declaredValue * rate;\n  const roundedDuty = Math.round(rawDuty * 100) / 100;\n  return roundedDuty;\n}\n\nfunction dispatchPackage(\n  trackingId: string,\n  declaredValue: number,\n  category: string,\n) {\n  debugger; // Pause: Try Step Over (F10), Step Into (F11) & Step Out (Shift+F11)!\n  const handlingFee = 15;\n  const dutyAmount = calculateCustomsDuty(declaredValue, category);\n\n  // Transpiled `using` block — outlined by the compiler into a separate\n  // top-level function `_outlinedCustomsBlock` in bundle.js:\n  let totalCost = 0;\n  {\n    const clearance = openCustomsClearance(trackingId);\n    const subtotalWithDuty = declaredValue + dutyAmount;\n    totalCost = subtotalWithDuty + handlingFee;\n    clearance.commit(totalCost);\n  }\n\n  return { trackingId, dutyAmount, totalCost };\n}\n\nexport function runSteppingPipeline() {\n  const shipment = dispatchPackage(\"SHP-9042\", 450, \"electronics\");\n  const status = `Dispatched ${shipment.trackingId}: $${shipment.totalCost}`;\n  return { shipment, status };\n}\n"
  ],
  "names": [
    "clearance",
    "subtotalWithDuty",
    "dispatchPackage",
    "handlingFee",
    "dutyAmount",
    "rate",
    "rawDuty",
    "roundedDuty",
    "totalCost",
    "runSteppingPipeline",
    "shipment",
    "status",
    "Module",
    "openCustomsClearance",
    "calculateCustomsDuty",
    "Function",
    "declaredValue",
    "category",
    "trackingId",
    "Block",
    "__openClearance",
    "id",
    "val",
    "cat",
    "fee",
    "duty",
    "0",
    "tot",
    "cl",
    "sub",
    "_inlinedArg",
    "r",
    "raw",
    "s",
    "st"
  ],
  "mappings": ";;;;;;;;;;;;;;EA6BIA;EACAC;EACA;EACA;;;AAhBJC;EAKE;EACAC;EACAC;EAbAC;EACAC;EACAC;EAeAC;;EAQA;;AAGFC;EACEC;EACAC;EACA;;;;;;",
  "scopes": [
    "BCAAY,DaCZO,BHJdcG,DOCZCC,CFB,BHCYZA,DWFCdCI,BCMCI,DRC,CFD,CDB,BHCjBOJ,DSC,CEB,CBA"
  ],
  "ranges": [
    "ECAAA,GVADK,EEY,FDB,EFBY,EFEK,FCF,FCB,EPBeAE,GWXYZab,HFDYc,EDBCAC,GAA,HAAfd,HBBZe,FDR,FCB,EHBYAD,GWXYAAA,HDCiBZ,HEGrBa,HFHOc,EDECAD,GfYAAA,HCAuBgB,HDBehB,IAXV,FCrB,FEB,EHBcAG,GAA,HAB8BiB,HBCgCjB,FEB,EFBe,FCB,FCA"
  ]
}
            

1	// Authored TypeScript: stepping.ts
2	export interface CustomsClearance {
3	id: string;
4	committed: number;
5	commit(amount: number): void;
6	}
7
8	declare function openCustomsClearance(trackingId: string): CustomsClearance;
9
10	function calculateCustomsDuty(declaredValue: number, category: string): number {
11	const rate = category === "electronics" ? 0.12 : 0.05;
12	const rawDuty = declaredValue * rate;
13	const roundedDuty = Math.round(rawDuty * 100) / 100;
14	return roundedDuty;
15	}
16
17	function dispatchPackage(
18	trackingId: string,
19	declaredValue: number,
20	category: string,
21	) {
22	debugger; // Pause: Try Step Over (F10), Step Into (F11) & Step Out (Shift+F11)!
23	const handlingFee = 15;
24	const dutyAmount = calculateCustomsDuty(declaredValue, category);
25
26	// Transpiled `using` block — outlined by the compiler into a separate
27	// top-level function `_outlinedCustomsBlock` in bundle.js:
28	let totalCost = 0;
29	{
30	const clearance = openCustomsClearance(trackingId);
31	const subtotalWithDuty = declaredValue + dutyAmount;
32	totalCost = subtotalWithDuty + handlingFee;
33	clearance.commit(totalCost);
34	}
35
36	return { trackingId, dutyAmount, totalCost };
37	}
38
39	export function runSteppingPipeline() {
40	const shipment = dispatchPackage("SHP-9042", 450, "electronics");
41	const status = `Dispatched ${shipment.trackingId}: $${shipment.totalCost}`;
42	return { shipment, status };
43	}

1	function __checkPositive(v) {
2	if (v < 0) throw new RangeError("Negative value");
3	return v;
4	}
5	function __openClearance(id) {
6	return {
7	id,
8	committed: 0,
9	commit(amt) {
10	this.committed = amt;
11	}
12	};
13	}
14	function _outlinedCustomsBlock(id, val, cat, fee, duty) {
15	const cl = __openClearance(id);
16	const sub = val + duty;
17	const tot = sub + fee;
18	cl.commit(tot);
19	return tot;
20	}
21	function dispatchPackage(id, val, cat) {
22	debugger;
23	const fee = __checkPositive(15);
24	const _inlinedArg = __checkPositive(val);
25	const r = cat === "electronics" ? 0.12 : 0.05;
26	const raw = _inlinedArg * r;
27	const duty = Math.round(raw * 100) / 100;
28	let tot = 0;
29	tot = _outlinedCustomsBlock(id, val, cat, fee, duty);
30	return { trackingId: id, dutyAmount: duty, totalCost: tot };
31	}
32	function runSteppingPipeline() {
33	const s = dispatchPackage("SHP-9042", 450, "electronics");
34	const st = "Dispatched " + s.trackingId + ": $" + s.totalCost;
35	return { shipment: s, status: st };
36	}
37	window.runExample05 = function() {
38	return runSteppingPipeline();
39	};
40	//# sourceMappingURL=bundle.js.map

1	const builder = new SafeScopeInfoBuilder();
2
3	// 1. Original Scopes:
4	// - calculateCustomsDuty (inlined into dispatchPackage)
5	// - dispatchPackage + inner customsBlock (outlined into _outlinedCustomsBlock)
6	// - runSteppingPipeline (outer caller)
7	builder
8	.startSource()
9	.startScope(0, 0, {
10	kind: "Module",
11	key: "module",
12	variables: [
13	"openCustomsClearance",
14	"calculateCustomsDuty",
15	"dispatchPackage",
16	"runSteppingPipeline",
17	],
18	})
19	.startScope(dutyStart.line, dutyStart.column, {
20	name: "calculateCustomsDuty",
21	kind: "Function",
22	isStackFrame: true,
23	key: "calculateCustomsDuty",
24	variables: ["declaredValue", "category", "rate", "rawDuty", "roundedDuty"],
25	})
26	.endScope(dutyEnd.line, dutyEnd.column)
27	.startScope(dispatchStart.line, dispatchStart.column, {
28	name: "dispatchPackage",
29	kind: "Function",
30	isStackFrame: true,
31	key: "dispatchPackage",
32	variables: [
33	"trackingId",
34	"declaredValue",
35	"category",
36	"handlingFee",
37	"dutyAmount",
38	"totalCost",
39	],
40	})
41	.startScope(blockStart.line, blockStart.column, {
42	kind: "Block",
43	key: "customsBlock",
44	variables: ["clearance", "subtotalWithDuty"],
45	})
46	.endScope(blockEnd.line, blockEnd.column)
47	.endScope(dispatchEnd.line, dispatchEnd.column)
48	.startScope(pipelineStart.line, pipelineStart.column, {
49	name: "runSteppingPipeline",
50	kind: "Function",
51	isStackFrame: true,
52	key: "runSteppingPipeline",
53	variables: ["shipment", "status"],
54	})
55	.endScope(pipelineEnd.line, pipelineEnd.column)
56	.endScope(origModuleEnd.line, origModuleEnd.column)
57	.endSource();
58
59	// 2. Generated Ranges:
60	// - __checkPositive & __openClearance: pure compiler helpers (isStackFrame: true, no OriginalScope)
61	// - _outlinedCustomsBlock: outlined block function (isStackFrame: true, isHidden: true, scopeKey: "dispatchPackage")
62	// - dispatchPackage: contains inlined calculateCustomsDuty range (isStackFrame: false, callSite)
63	// - availableFrom(start, from, end, value) = unavailable in [start, from), bound to value in [from, end).
64	// Used for generated let/const that are still in their TDZ before their declaration ran.
65	builder
66	.startRange(0, 0, {
67	scopeKey: "module",
68	values: ["__openClearance", null, "dispatchPackage", "runSteppingPipeline"],
69	})
70	// Pure compiler helpers (no OriginalScope -> automatically blackboxed during stepping!)
71	.startRange(checkPosStart.line, checkPosStart.column, { isStackFrame: true })
72	.endRange(checkPosEnd.line, checkPosEnd.column)
73	.startRange(openClrStart.line, openClrStart.column, { isStackFrame: true })
74	.startRange(commitMethodStart.line, commitMethodStart.column, { isStackFrame: true })
75	.endRange(commitMethodEnd.line, commitMethodEnd.column)
76	.endRange(openClrEnd.line, openClrEnd.column)
77	// Outlined block helper (isStackFrame: true, isHidden: true + definition OriginalScope)
78	.startRange(outlinedStart.line, outlinedStart.column, {
79	scopeKey: "dispatchPackage",
80	isStackFrame: true,
81	isHidden: true,
82	values: [
83	"id", "val", "cat", "fee", "duty",
84	// totalCost is still 0 until the outlined 'const tot' is assigned
85	[
86	{ from: outlinedStart, to: afterOutlinedTot, value: "0" },
87	{ from: afterOutlinedTot, to: outlinedEnd, value: "tot" },
88	],
89	],
90	})
91	.startRange(outlinedBodyStart.line, outlinedBodyStart.column, {
92	scopeKey: "customsBlock",
93	isStackFrame: false,
94	values: [
95	availableFrom(outlinedBodyStart, afterCl, outlinedBodyEnd, "cl"),
96	availableFrom(outlinedBodyStart, afterSub, outlinedBodyEnd, "sub"),
97	],
98	})
99	.endRange(outlinedBodyEnd.line, outlinedBodyEnd.column)
100	.endRange(outlinedEnd.line, outlinedEnd.column)
101	// Main function with inlined calculateCustomsDuty range
102	.startRange(genDispatchStart.line, genDispatchStart.column, {
103	scopeKey: "dispatchPackage",
104	isStackFrame: true,
105	values: [
106	"id", "val", "cat",
107	availableFrom(genDispatchStart, afterFee, genDispatchEnd, "fee"),
108	availableFrom(genDispatchStart, afterDuty, genDispatchEnd, "duty"),
109	availableFrom(genDispatchStart, afterTot, genDispatchEnd, "tot"),
110	],
111	})
112	.startRange(genInlinedStart.line, genInlinedStart.column, {
113	scopeKey: "calculateCustomsDuty",
114	isStackFrame: false,
115	callSite: callSiteCalculateDuty,
116	values: [
117	"_inlinedArg", "cat",
118	availableFrom(genInlinedStart, afterR, genInlinedEnd, "r"),
119	availableFrom(genInlinedStart, afterRaw, genInlinedEnd, "raw"),
120	null, // roundedDuty: 'duty' is only assigned by the very last statement of this range
121	],
122	})
123	.endRange(genInlinedEnd.line, genInlinedEnd.column)
124	.endRange(genDispatchEnd.line, genDispatchEnd.column)
125	.startRange(genPipelineStart.line, genPipelineStart.column, {
126	scopeKey: "runSteppingPipeline",
127	isStackFrame: true,
128	values: [
129	availableFrom(genPipelineStart, afterS, genPipelineEnd, "s"),
130	availableFrom(genPipelineStart, afterSt, genPipelineEnd, "st"),
131	],
132	})
133	.endRange(genPipelineEnd.line, genPipelineEnd.column)
134	.startRange(genRunStart.line, genRunStart.column, { isStackFrame: true })
135	.endRange(genRunEnd.line, genRunEnd.column)
136	.endRange(genModuleEnd.line, genModuleEnd.column);