qubasic 0.11.0__tar.gz → 0.12.0__tar.gz

{qubasic-0.11.0 → qubasic-0.12.0}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.12.0 (2026-06-19)
+
+Correctness and robustness pass on the classic-BASIC layer, from an extended
+adversarial audit. The quantum engine is unchanged.
+
+### Fixed
+- `SHARED` variables in a `SUB` now propagate their modifications back to the caller instead of being discarded when the call's scope is restored (an accumulator across two calls now sums correctly: `8`, not `3`).
+- `RESTORE` resets the `DATA` read pointer inside a program; it was a no-op, so a `READ` after `RESTORE` raised `OUT OF DATA`.
+- Writes to an explicitly `DIM`med array are bounds-checked like reads instead of silently auto-extending past the declared size. Implicit (undimensioned) arrays still grow on first assignment.
+- String arrays work: `LET s$(i) = ...` stores and reads string elements.
+- `SET_DENSITY` followed by inspection without a `MEASURE` no longer raises a raw "unable to translate" error from Aer; the density matrix is captured and shown by `DENSITY`.
+- A script that issues an explicit `RUN` and also contains a `MEASURE` no longer auto-runs (and prints) the program a second time.
+
+### Changed
+- `STATUS` reports the user-variable count only, excluding the internal `_DEPTH`/`_GATES`/`_TIME` set after a run.
+- `DEF FN name(x) = expr` now works at the prompt (immediate mode), matching the in-program form.
+- `HELP` refreshed (`STATUS`, `INT` floors / `FIX` truncates, implicit `LET`, `<>`/`XOR`, corrected `MEAS`); `--help` notes the `-q`/`-v`/`-h` short flags and `python -m qubasic_core`.
+
+## 0.11.1 (2026-06-19)
+
+### Fixed
+- A configuration/session command (`QUBITS`, `SHOTS`, `METHOD`, `LOCC`, ...) placed on a numbered program line now reports a clear error explaining it must run without a line number (before `RUN`), instead of the misleading `UNKNOWN GATE`. Unnumbered config in a script was, and remains, the correct usage.
+
 ## 0.11.0 (2026-06-19)
 
 Convention-conformance and observability pass: make the language behave the way

{qubasic-0.11.0/qubasic.egg-info → qubasic-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.11.0
+Version: 0.12.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -255,11 +255,14 @@ Hex/binary literals: `&HFF`, `&B10110`
 DIM data(10)            1D array
 DIM matrix(3, 3)        Multi-dimensional (flat storage)
 LET data(0) = PI
+LET names$(0) = "alice" String array (name$ elements hold strings)
 REDIM data(20)          Resize (preserves existing data)
 ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
+A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
+
 ## Control flow
 
 ```

{qubasic-0.11.0 → qubasic-0.12.0}/README.md

@@ -222,11 +222,14 @@ Hex/binary literals: `&HFF`, `&B10110`
 DIM data(10)            1D array
 DIM matrix(3, 3)        Multi-dimensional (flat storage)
 LET data(0) = PI
+LET names$(0) = "alice" String array (name$ elements hold strings)
 REDIM data(20)          Resize (preserves existing data)
 ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
+A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
+
 ## Control flow
 
 ```

{qubasic-0.11.0 → qubasic-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.11.0"
+version = "0.12.0"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"

{qubasic-0.11.0 → qubasic-0.12.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.11.0
+Version: 0.12.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -255,11 +255,14 @@ Hex/binary literals: `&HFF`, `&B10110`
 DIM data(10)            1D array
 DIM matrix(3, 3)        Multi-dimensional (flat storage)
 LET data(0) = PI
+LET names$(0) = "alice" String array (name$ elements hold strings)
 REDIM data(20)          Resize (preserves existing data)
 ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
+A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
+
 ## Control flow
 
 ```

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/__init__.py

@@ -28,7 +28,7 @@ __all__ = [
     'GATE_TABLE', 'GATE_ALIASES',
 ]
 
-__version__ = '0.11.0'
+__version__ = '0.12.0'
 
 def __getattr__(name):
     """Lazy import heavy modules on first access."""

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/analysis.py

@@ -109,6 +109,28 @@ class AnalysisMixin:
 
     def cmd_density(self, rest: str = '') -> None:
         """Show density matrix (DENSITY [reg]); summarizes for large systems."""
+        # A mixed state set via SET_DENSITY has a stored density matrix and no
+        # statevector; display it directly.
+        dm = getattr(self, '_last_density', None)
+        if dm is not None and not rest.strip():
+            rho = np.ascontiguousarray(dm)
+            dim = rho.shape[0]
+            self.io.writeln(f"\n  Density matrix ({dim}x{dim}):\n")
+            if dim <= 16:
+                for i in range(dim):
+                    row = []
+                    for j in range(dim):
+                        v = complex(rho[i, j])
+                        if abs(v.imag) < 1e-6:
+                            row.append(f"{v.real:7.3f}")
+                        else:
+                            row.append(f"{v.real:+.2f}{v.imag:+.2f}j")
+                    self.io.writeln(f"    {'  '.join(row)}")
+            else:
+                self.io.writeln(f"    ({dim}x{dim}, too large to display)")
+            self.io.writeln(f"\n  Purity: {float(np.real(np.trace(rho @ rho))):.6f}")
+            self.io.writeln('')
+            return
         sv, n, rest = self._resolve_analysis_target(rest)
         if sv is None:
             if self.locc_mode and self.locc and not self.locc.joint:

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/cli.py

@@ -38,8 +38,12 @@ def run_script(path: str, terminal: 'QBasicTerminal') -> None:
     ProgramMgmtMixin._load_lines_with_defs(
         lines, lambda line: terminal.process(line, track_undo=False))
 
-    # Auto-run if the program has a reachable MEASURE (incl. in subs / IF clauses)
-    if terminal.program and terminal._program_has_measure(sorted(terminal.program)):
+    # Auto-run if the program has a reachable MEASURE (incl. in subs / IF
+    # clauses), unless the script already issued an explicit RUN (which would
+    # otherwise execute and print the program twice).
+    explicit_run = any(l.strip().upper() == 'RUN' for l in lines)
+    if (terminal.program and not explicit_run
+            and terminal._program_has_measure(sorted(terminal.program))):
         terminal.cmd_run()
 
 
@@ -78,12 +82,13 @@ def main():
         print("Usage:")
         print("  qubasic                  Interactive REPL")
         print("  qubasic script.qb        Run a script file")
-        print("  qubasic --quiet script    Suppress banner and progress")
+        print("  qubasic --quiet script    Suppress banner and progress (also -q)")
         print("  qubasic --json script     Output results as JSON")
         print("  qubasic --agent script    Confine file writes to the working dir")
         print("  qubasic --seed N script   Set random seed for reproducibility")
-        print("  qubasic --version         Show version")
-        print("  qubasic --help            Show this help")
+        print("  qubasic --version         Show version (also -v)")
+        print("  qubasic --help            Show this help (also -h)")
+        print("  python -m qubasic_core    Run without the installed console script")
         print()
         print("Type HELP inside the REPL for full command reference.")
         sys.exit(0)

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/control_flow.py

@@ -75,7 +75,11 @@ class ControlFlowMixin:
         name, idx_expr, val_expr = parsed.name, parsed.index_expr, parsed.value_expr
         self._assert_assignable(name)
         base = getattr(self, '_option_base', 0)
-        val = self._eval_with_vars(val_expr, run_vars)
+        # String arrays (name$) hold string values; numeric arrays hold floats.
+        if name.endswith('$'):
+            val = self._eval_string_expr(val_expr, run_vars)
+        else:
+            val = self._eval_with_vars(val_expr, run_vars)
         parts = self._split_arg_list(idx_expr)
         if len(parts) > 1:
             # Multi-dimensional write: flatten with the same stride convention
@@ -97,10 +101,19 @@ class ControlFlowMixin:
         idx = int(self._eval_with_vars(idx_expr, run_vars)) - base
         if idx < 0:
             raise RuntimeError(f"ARRAY INDEX OUT OF RANGE: {name}({idx + base})")
+        dimmed = getattr(self, '_dimmed_arrays', set())
         if name not in self.arrays:
+            # Implicit array: created (and allowed to grow) on first assignment.
             self.arrays[name] = [0.0] * (idx + 1)
-        while idx >= len(self.arrays[name]):
-            self.arrays[name].append(0.0)
+        elif idx >= len(self.arrays[name]):
+            if name in dimmed:
+                # Explicitly DIMmed: writes are bounds-checked like reads,
+                # instead of silently auto-extending past the declared size.
+                raise RuntimeError(
+                    f"ARRAY INDEX OUT OF RANGE: {name}({idx + base}), "
+                    f"size {len(self.arrays[name])}")
+            while idx >= len(self.arrays[name]):
+                self.arrays[name].append(0.0)
         self.arrays[name][idx] = val
         return True, ExecResult.ADVANCE
 

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/engine_state.py

@@ -54,6 +54,11 @@ class Engine:
         self.variables: dict[str, Any] = {}
         self.arrays: dict[str, Any] = {}
         self._array_dims: dict[str, list[int]] = {}
+        # Arrays declared with DIM/REDIM enforce their bounds on write;
+        # arrays created implicitly by first assignment keep auto-growing.
+        self._dimmed_arrays: set[str] = set()
+        # Density matrix captured by a no-MEASURE run with SET_DENSITY.
+        self._last_density: Any = None
 
         # Subroutines and registers
         self.subroutines: dict[str, Any] = {}
@@ -112,6 +117,8 @@ class Engine:
         self.variables.clear()
         self.arrays.clear()
         self._array_dims.clear()
+        self._dimmed_arrays.clear()
+        self._last_density = None
         self.last_counts = None
         self.last_sv = None
         self.last_circuit = None

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/executor.py

@@ -113,6 +113,8 @@ class ExecutorMixin:
         self._classical_bits = {}
         # Partial-measurement subset (None = measure all at the end).
         self._measure_subset = None
+        # Density matrix captured by a no-MEASURE run (None unless set).
+        self._last_density = None
         # Apply any qubit state preparation requested via POKE to $0100.
         if getattr(self, '_poke_state_prep', None):
             self._emit_poke_state_prep(qc)
@@ -289,6 +291,7 @@ class ExecutorMixin:
         # 3. Remaining statement handlers (not in control-flow dispatch)
         from qubasic_core.statements import RestoreStmt
         if isinstance(parsed, RestoreStmt):
+            self._data_ptr = 0   # reset the DATA read pointer (was a no-op)
             return ExecResult.ADVANCE
 
         # Multi-line IF block markers — no-ops during execution
@@ -333,6 +336,19 @@ class ExecutorMixin:
                 return ExecResult.ADVANCE
             # Fall through to _apply_gate_str for custom gates not in GATE_TABLE
 
+        # A REPL/config command (QUBITS, SHOTS, METHOD, LOCC, ...) used as a
+        # numbered program line reaches here only because it is neither a gate
+        # nor a statement. Explain it instead of failing with "UNKNOWN GATE".
+        # SEND/SHARE are LOCC statements (handled on the LOCC path), so leave
+        # them to their own error.
+        _first = stmt.split(None, 1)[0].upper() if stmt.split() else ''
+        if ((_first in self._CMD_WITH_ARG or _first in self._CMD_NO_ARG)
+                and _first not in ('SEND', 'SHARE')):
+            raise QBasicBuildError(
+                f"{_first} is a configuration/session command, not a program "
+                f"statement; run it without a line number (before RUN), e.g. "
+                f"QUBITS 3 / SHOTS 1024 / METHOD statevector / LOCC 2 2")
+
         # Slow path: subroutine expansion + gate dispatch
         expanded = self._expand_statement(stmt)
         for gate_str in expanded:

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/help_text.py

@@ -42,7 +42,7 @@ REGISTERS & SUBROUTINES
   DEFS                List subroutines
 
 VARIABLES & LOOPS
-  LET angle = PI/4    Set a variable
+  LET angle = PI/4    Set a variable (LET optional: x = 5 also works)
   10 RX angle, 0      Use in gate parameters
   10 FOR I = 0 TO 3   Loop (variable substitution in body)
   20   H I
@@ -62,6 +62,7 @@ CONFIGURATION
   SHOTS n             Set number of shots (default: 1024)
   METHOD name         Set simulation method (automatic, statevector,
                       matrix_product_state, stabilizer, ...)
+  STATUS [JSON]       Show every active mode (qubits, method, LOCC, noise, ...)
 
 DEMOS
   DEMO LIST           List available demos
@@ -141,7 +142,7 @@ INLINE CIRCUIT INSTRUCTIONS (in programs, results available after RUN)
   SAVE_EXPECT ZZ 0,1 -> v   Expectation value -> variable
   SAVE_PROBS 0,1 -> p       Probability snapshot -> array
   SAVE_AMPS 0,3 -> a        Specific amplitudes -> array
-  MEAS qubit -> var          Mid-circuit measurement (LOCC mode)
+  MEAS qubit -> var          Mid-circuit measurement + IF feedforward (any mode)
   MEASURE_X/Y/Z qubit       Basis measurement
 
 FLOW CONTROL (in programs)
@@ -162,8 +163,8 @@ FLOW CONTROL (in programs)
   LET arr[i] = val        Array assignment
 
 EXPRESSIONS
-  PI, TAU, E, SQRT2, sin(), cos(), sqrt(), log(), etc.
-  Comparisons: ==, !=, <, >, <=, >=, AND, OR, NOT
+  PI, TAU, E, SQRT2, sin(), cos(), sqrt(), log(), int() floors, fix() truncates
+  Comparisons: ==, !=, <>, <, >, <=, >=    Logical/bitwise: AND, OR, NOT, XOR
   Arrays: arr(i) or arr[i]
   Example: LET theta = PI/4 + asin(0.5)
 """

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/patterns.py

@@ -24,7 +24,7 @@ RE_GET = re.compile(r'GET\s+(\w+\$?)', re.IGNORECASE)
 RE_INPUT = re.compile(r'INPUT\s+(?:"([^"]*)"\s*,\s*)?(\w+)', re.IGNORECASE)
 RE_CTRL = re.compile(r'CTRL\s+(\w+)\s+(.*)', re.IGNORECASE)
 RE_INV = re.compile(r'INV\s+(\w+)\s+(.*)', re.IGNORECASE)
-RE_LET_ARRAY = re.compile(r'LET\s+(\w+)\((.+?)\)\s*=\s*(.*)', re.IGNORECASE)
+RE_LET_ARRAY = re.compile(r'LET\s+(\w+\$?)\((.+?)\)\s*=\s*(.*)', re.IGNORECASE)
 RE_LET_VAR = re.compile(r'LET\s+(\w+(?:\.\w+)?)\s*=\s*(.*)', re.IGNORECASE)
 RE_PRINT = re.compile(r'PRINT\s+(.*)', re.IGNORECASE)
 RE_GOTO = re.compile(r'GOTO\s+(\d+)\s*$', re.IGNORECASE)

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/subs.py

@@ -27,6 +27,9 @@ class SubroutineMixin:
         self._static_vars: dict[str, dict[str, Any]] = {'_GLOBAL': {}}
         self._call_stack: list[dict[str, Any]] = []
         self._func_call_depth: int = 0
+        # Names declared SHARED in the current scope level, so their
+        # modifications survive _pop_scope instead of being discarded.
+        self._shared_stack: list[set[str]] = []
 
     def _scan_subs(self, sorted_lines: list[int]) -> None:
         """Scan program for SUB/FUNCTION blocks and build jump table."""
@@ -284,12 +287,15 @@ class SubroutineMixin:
             if vname in self._scope_stack[-1]:
                 run_vars[vname] = self._scope_stack[-1].get(vname, 0)
                 self.variables[vname] = run_vars[vname]
+                if self._shared_stack:
+                    self._shared_stack[-1].add(vname)
         return True, ExecResult.ADVANCE
 
     # ── Scope management ───────────────────────────────────────────────
 
     def _push_scope(self) -> None:
         self._scope_stack.append(dict(self.variables))
+        self._shared_stack.append(set())
 
     def _pop_scope(self, frame: dict[str, Any] | None = None) -> None:
         # Save STATIC vars for the current frame before restoring outer scope.
@@ -303,5 +309,13 @@ class SubroutineMixin:
                 for vname in list(self._static_vars[sub_name]):
                     self._static_vars[sub_name][vname] = self.variables.get(vname, 0)
         if self._scope_stack:
+            # SHARED variables must keep the modifications made inside the
+            # call; capture them before restoring the caller snapshot and
+            # write them back, instead of discarding them with the snapshot.
+            shared = self._shared_stack.pop() if self._shared_stack else set()
+            shared_vals = {v: self.variables.get(v) for v in shared}
             self.variables.clear()
             self.variables.update(self._scope_stack.pop())
+            for v, val in shared_vals.items():
+                if val is not None:
+                    self.variables[v] = val

{qubasic-0.11.0 → qubasic-0.12.0}/qubasic_core/terminal.py

@@ -915,6 +915,18 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         if upper.startswith('BEGIN'):
             return self._def_multiline(rest[5:].strip())
 
+        # DEF FN name(params) = expr — a user expression function, same as the
+        # in-program form, so it works at the prompt too.
+        if upper.startswith('FN'):
+            from qubasic_core.patterns import RE_DEF_FN
+            fm = RE_DEF_FN.match(f"DEF {rest}")
+            if fm:
+                fparams = [p.strip() for p in fm.group(2).split(',') if p.strip()]
+                self._user_fns['FN' + fm.group(1).upper()] = {
+                    'params': fparams, 'body': fm.group(3).strip()}
+                self.io.writeln(f"DEF FN {fm.group(1).upper()}({', '.join(fparams)})")
+                return
+
         m = RE_DEF_SINGLE.match(rest)
         if not m:
             self.io.writeln("?USAGE: DEF NAME[(params)] = GATE : GATE : ...")
@@ -1067,7 +1079,11 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             parsed = LetArrayStmt(raw=f"LET {rest}", name=name,
                                   index_expr=idx_expr, value_expr=val_expr)
             self._cf_let_array(f"LET {rest}", self.variables, parsed)
-            self.io.writeln(f"{name}({idx_expr.strip()}) = {self.eval_expr(val_expr)}")
+            shown = (self._eval_string_expr(val_expr) if name.endswith('$')
+                     else self.eval_expr(val_expr))
+            self.io.writeln(f"{name}({idx_expr.strip()}) = {shown!r}"
+                            if isinstance(shown, str)
+                            else f"{name}({idx_expr.strip()}) = {shown}")
             return
         sm = RE_LET_STR.match(f"LET {rest}")
         if sm:
@@ -1122,7 +1138,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             'trace_mode': bool(getattr(self, '_trace_mode', False)),
             'bank': getattr(self, '_current_slot', 0),
             'program_lines': len(self.program),
-            'variables': len(self.variables),
+            'variables': sum(1 for k in self.variables if not k.startswith('_')),
             'arrays': len(self.arrays),
             'subroutines': len(self.subroutines),
             'custom_gates': sorted(self._custom_gates.keys()),
@@ -1281,9 +1297,24 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         }
 
     def _run_no_measure(self, qc, qc_sv, t0: float) -> None:
-        """Execute the no-MEASURE path: statevector only, no shots."""
+        """Execute the no-MEASURE path: statevector (or density matrix), no shots."""
         too_large = self.num_qubits > self._SV_EXTRACT_MAX_QUBITS
-        if too_large:
+        if getattr(self, '_pending_set_density', None) is not None and not too_large:
+            # A mixed state has no statevector, so capture the density matrix
+            # for DENSITY instead. Saving a statevector here used to raise an
+            # untranslatable-circuit error from Aer.
+            self.last_sv = None
+            try:
+                qc_sv.save_density_matrix()
+                dm_backend = self._make_backend('density_matrix', include_noise=True)
+                dm_result = dm_backend.run(
+                    transpile(qc_sv, dm_backend, optimization_level=self._transpile_opt_level)).result()
+                data = dm_result.data(0)
+                dm = data.get('density_matrix') if hasattr(data, 'get') else None
+                self._last_density = np.array(dm) if dm is not None else None
+            except Exception:
+                self._last_density = None
+        elif too_large:
             self.last_sv = None
         else:
             try:
@@ -1919,6 +1950,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         self.arrays[name] = [0.0] * total
         if len(dims) > 1:
             self._array_dims[name] = dims
+        self._dimmed_arrays.add(name)
         return True
 
     def _try_exec_dim_type(self, stmt: str) -> bool:
@@ -1957,6 +1989,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
                 self.arrays[name] = old[:new_size]
         else:
             self.arrays[name] = [0.0] * new_size
+        self._dimmed_arrays.add(name)
         return True
 
     def _try_exec_erase(self, stmt: str) -> bool:
@@ -1967,6 +2000,8 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         name = m.group(1)
         if name in self.arrays:
             del self.arrays[name]
+        self._array_dims.pop(name, None)
+        self._dimmed_arrays.discard(name)
         return True
 
     def _try_exec_get(self, stmt: str, run_vars: dict) -> bool:

{qubasic-0.11.0 → qubasic-0.12.0}/tests/test_qubasic.py

@@ -2078,6 +2078,79 @@ class TestConventionAndStateRegressions(unittest.TestCase):
         self.assertIn('rightmost', note)
         self.assertIn('bit_order', t.result())
 
+    def test_config_command_as_program_line_errors_clearly(self):
+        # A config/REPL command used as a numbered program line explains itself
+        # instead of failing with the misleading "UNKNOWN GATE".
+        for cmd in ('QUBITS 3', 'SHOTS 256', 'METHOD stabilizer', 'LOCC 2 2'):
+            t = QBasicTerminal(); t.num_qubits = 2
+            t.program = {10: cmd, 20: 'H 0', 30: 'MEASURE'}
+            _, out = capture(t.cmd_run)
+            self.assertIn('configuration', out.lower())
+            self.assertNotIn('UNKNOWN GATE', out)
+
+    def test_subroutine_call_not_treated_as_config_command(self):
+        t = QBasicTerminal(); t.num_qubits = 2
+        t.process('DEF BELL = H 0 : CX 0,1', track_undo=False)
+        t.program = {10: 'BELL', 20: 'MEASURE'}
+        capture(t.cmd_run)
+        self.assertIsNotNone(t.last_counts)  # ran; not blocked as a "command"
+
+
+class TestDeepFixRegressions(unittest.TestCase):
+    """SHARED writeback, RESTORE, array write bounds, string arrays,
+    SET_DENSITY inspection, STATUS var count, immediate DEF FN."""
+
+    def _runp(self, lines, nq=1):
+        t = QBasicTerminal(); t.num_qubits = nq
+        for l in lines:
+            t.process(l, track_undo=False)
+        capture(t.cmd_run)
+        return t
+
+    def test_shared_writeback(self):
+        t = self._runp(['10 LET acc=0', '20 SUB ADD(n)', '30 SHARED acc',
+                        '40 LET acc=acc+n', '50 END SUB', '60 CALL ADD(5)',
+                        '70 CALL ADD(3)'])
+        self.assertEqual(t.variables.get('acc'), 8.0)
+
+    def test_restore_resets_data_pointer(self):
+        t = self._runp(['10 DATA 5', '20 READ a', '30 RESTORE', '40 READ b',
+                        '50 LET s=a+b'])
+        self.assertEqual(t.variables.get('s'), 10.0)
+
+    def test_dimmed_array_write_is_bounds_checked(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        for l in ['10 DIM a(3)', '20 LET a(99)=1']:
+            t.process(l, track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('OUT OF RANGE', out)
+        # An implicit (undimensioned) array still auto-grows on write.
+        t2 = self._runp(['10 LET b(50)=7', '20 LET v=b(50)'])
+        self.assertEqual(t2.variables.get('v'), 7.0)
+
+    def test_string_array(self):
+        t = self._runp(['10 LET s$(0)="he"+"llo"', '20 LET t$=s$(0)'])
+        self.assertEqual(t.variables.get('t$'), 'hello')
+
+    def test_set_density_no_measure_does_not_crash(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.process('SET_DENSITY [[0.5,0],[0,0.5]]', track_undo=False)
+        t.process('10 ID 0', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertNotIn('Unable to translate', out)
+        self.assertIsNotNone(getattr(t, '_last_density', None))
+        _, dout = capture(t.cmd_density, '')
+        self.assertIn('Density matrix', dout)
+
+    def test_status_excludes_internal_vars(self):
+        t = self._runp(['10 H 0', '20 MEASURE'])
+        self.assertEqual(t._status_dict()['variables'], 0)
+
+    def test_immediate_def_fn(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        capture(t.cmd_def, 'FN sq(x) = x*x')
+        self.assertEqual(t.eval_expr('sq(5)'), 25.0)
+
 
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):