de-shell 0.2.0__tar.gz → 0.2.1__tar.gz

{de_shell-0.2.0 → de_shell-0.2.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: de-shell
-Version: 0.2.0
+Version: 0.2.1
 Summary: The Electron + Python desktop-app shell Direct Electron's apps (SpyDE, Ground Crew, Autopilot) are assembled from
 Author-email: Carter Francis <cartsfrancis@gmail.com>
 License: MIT
-Project-URL: Homepage, https://github.com/CSSFrancis/de-shell
-Project-URL: Repository, https://github.com/CSSFrancis/de-shell
-Project-URL: Issues, https://github.com/CSSFrancis/de-shell/issues
-Project-URL: Changelog, https://github.com/CSSFrancis/de-shell/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/directelectron/de-shell
+Project-URL: Repository, https://github.com/directelectron/de-shell
+Project-URL: Issues, https://github.com/directelectron/de-shell/issues
+Project-URL: Changelog, https://github.com/directelectron/de-shell/blob/main/CHANGELOG.md
 Keywords: electron,desktop,anyplotlib,electron-microscopy,direct-electron
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -26,7 +26,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.20.0
-Requires-Dist: anyplotlib>=0.7.3
+Requires-Dist: anyplotlib>=0.8.0
 Requires-Dist: pyyaml
 Provides-Extra: tests
 Requires-Dist: pytest>=3.6; extra == "tests"
@@ -36,7 +36,7 @@ Dynamic: license-file
 # DE Shell
 
 [![PyPI](https://img.shields.io/pypi/v/de-shell.svg)](https://pypi.org/project/de-shell/)
-[![CI](https://github.com/CSSFrancis/de-shell/actions/workflows/ci.yml/badge.svg)](https://github.com/CSSFrancis/de-shell/actions/workflows/ci.yml)
+[![CI](https://github.com/directelectron/de-shell/actions/workflows/ci.yml/badge.svg)](https://github.com/directelectron/de-shell/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 The substrate Direct Electron's desktop apps are assembled from: **SpyDE**
@@ -122,8 +122,9 @@ peer dependencies — react, electron, electron-updater, @playwright/test —
 are the app's to declare; every app already does. The e2e specs take the
 harness from `shell/testing/harness.cjs`.
 
-Autopilot and SpyDE (on its `chore/de-shell-split` branch) are wired this
-way; Ground Crew still carries a copy under its `packages/` and is next.
+Autopilot and SpyDE ([directelectron/spyde#152](https://github.com/directelectron/spyde/pull/152))
+are wired this way, pinned `de-shell>=0.2,<0.3`; Ground Crew still carries a
+copy under its `packages/` and is next.
 
 ## Developing it
 
@@ -175,9 +176,9 @@ SpyDE commit the app copies were taken from:
   panes on large stills), JSON emit that never writes bare `NaN`, the harness
   hardening, and the unit tests for all of it.
 
-Not yet included: Ground Crew's `dev/instrument-actions` shell deltas
-(`stdoutDemux`, `sizeReporter`, the `frameBytes` transport) — they ride a
-branch that has not merged.
+* Ground Crew `main` @ 0382549 (0.2.1): the chunk-list stdout demuxer, the
+  size reporter and StrictMode-safe registration in `FigureFrame`, the figure
+  document's scroll pin, and the anyplotlib 0.8.0 floor.
 
 ## Rules
 

{de_shell-0.2.0 → de_shell-0.2.1}/README.md

@@ -1,7 +1,7 @@
 # DE Shell
 
 [![PyPI](https://img.shields.io/pypi/v/de-shell.svg)](https://pypi.org/project/de-shell/)
-[![CI](https://github.com/CSSFrancis/de-shell/actions/workflows/ci.yml/badge.svg)](https://github.com/CSSFrancis/de-shell/actions/workflows/ci.yml)
+[![CI](https://github.com/directelectron/de-shell/actions/workflows/ci.yml/badge.svg)](https://github.com/directelectron/de-shell/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 The substrate Direct Electron's desktop apps are assembled from: **SpyDE**
@@ -87,8 +87,9 @@ peer dependencies — react, electron, electron-updater, @playwright/test —
 are the app's to declare; every app already does. The e2e specs take the
 harness from `shell/testing/harness.cjs`.
 
-Autopilot and SpyDE (on its `chore/de-shell-split` branch) are wired this
-way; Ground Crew still carries a copy under its `packages/` and is next.
+Autopilot and SpyDE ([directelectron/spyde#152](https://github.com/directelectron/spyde/pull/152))
+are wired this way, pinned `de-shell>=0.2,<0.3`; Ground Crew still carries a
+copy under its `packages/` and is next.
 
 ## Developing it
 
@@ -140,9 +141,9 @@ SpyDE commit the app copies were taken from:
   panes on large stills), JSON emit that never writes bare `NaN`, the harness
   hardening, and the unit tests for all of it.
 
-Not yet included: Ground Crew's `dev/instrument-actions` shell deltas
-(`stdoutDemux`, `sizeReporter`, the `frameBytes` transport) — they ride a
-branch that has not merged.
+* Ground Crew `main` @ 0382549 (0.2.1): the chunk-list stdout demuxer, the
+  size reporter and StrictMode-safe registration in `FigureFrame`, the figure
+  document's scroll pin, and the anyplotlib 0.8.0 floor.
 
 ## Rules
 

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell/__init__.py

@@ -20,6 +20,6 @@ from __future__ import annotations
 
 #: The package version — the one place it is written. pyproject.toml reads it
 #: (dynamic version) and the release workflow refuses a tag that disagrees.
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = ["ipc", "log_stream", "process_guard", "debug_flags", "compute"]

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell/js/main/backendProcess.ts

@@ -9,6 +9,7 @@ import process from 'process'
 // Extension spelled out so node:test can load this module without a bundler
 // (native type-stripping resolves relative imports literally).
 import { shellConfig } from './config.ts'
+import { createStdoutDemux } from './stdoutDemux.ts'
 
 export interface BackendHandlers {
   onMessage: (msg: Record<string, unknown>) => void
@@ -19,9 +20,6 @@ export interface BackendHandlers {
   onBinary?: (header: Record<string, unknown>, payload: Buffer) => void
 }
 
-const PLOTBIN = Buffer.from('PLOTBIN:')
-const NL = 0x0a
-
 let proc: ChildProcess | null = null
 let tickTimer: ReturnType<typeof setInterval> | null = null
 
@@ -95,60 +93,20 @@ export function startBackend(
     if (!proc && tickTimer) { clearInterval(tickTimer); tickTimer = null }
   }, 2000)
 
-  // Custom stdout demuxer: the stream interleaves text lines (PLOTAPP: JSON and
-  // plain log output, both '\n'-terminated) with raw PLOTBIN binary frames
-  // (PLOTBIN:<hlen>:<plen>\n<header_json><payload>). readline can't carry binary,
-  // so we parse the raw Buffer stream ourselves, accumulating partial reads.
-  let acc: Buffer = Buffer.alloc(0)
-  child.stdout!.on('data', (chunk: Buffer) => {
-    acc = acc.length ? Buffer.concat([acc, chunk]) : chunk
-    // Process as many complete units as are buffered; stop when we need more.
-    for (;;) {
-      if (acc.length === 0) break
-      // A binary frame if the buffer starts with the PLOTBIN marker.
-      if (acc.length >= PLOTBIN.length &&
-          acc.subarray(0, PLOTBIN.length).equals(PLOTBIN)) {
-        const nl = acc.indexOf(NL)
-        if (nl < 0) break                       // prefix line incomplete
-        const prefix = acc.subarray(PLOTBIN.length, nl).toString('ascii')
-        const [hlenS, plenS] = prefix.split(':')
-        const hlen = parseInt(hlenS, 10), plen = parseInt(plenS, 10)
-        if (!(hlen >= 0) || !(plen >= 0)) {     // malformed → drop the line
-          handlers.onStream(`[sidecar protocol] malformed PLOTBIN prefix: ${prefix}\n`, 'stderr')
-          acc = acc.subarray(nl + 1); continue
-        }
-        const bodyStart = nl + 1
-        const end = bodyStart + hlen + plen
-        if (acc.length < end) break             // body not fully arrived yet
-        let header: Record<string, unknown> = {}
-        try {
-          header = JSON.parse(acc.subarray(bodyStart, bodyStart + hlen).toString('utf8'))
-        } catch { /* malformed header — still consume the frame */ }
-        // Copy the payload out so it survives `acc` being sliced/reused.
-        const payload = Buffer.from(acc.subarray(bodyStart + hlen, end))
-        acc = acc.subarray(end)
-        try { handlers.onBinary?.(header, payload) } catch { /* ignore */ }
-        continue
-      }
-      // Otherwise a text line up to the next '\n'.
-      const nl = acc.indexOf(NL)
-      if (nl < 0) break                         // line incomplete
-      const line = acc.subarray(0, nl).toString('utf8')
-      acc = acc.subarray(nl + 1)
-      if (line.startsWith('PLOTAPP:')) {
-        try {
-          handlers.onMessage(JSON.parse(line.slice(8)) as Record<string, unknown>)
-        } catch {
-          // Say so rather than swallow it: a truncated frame is how a backend
-          // bug presents, and silence turns it into "the UI just stopped".
-          handlers.onStream(`[sidecar protocol] malformed JSON message: ${line.slice(0, 200)}\n`, 'stderr')
-        }
-      } else if (line.trim()) {
-        rememberOutput(line)
-        handlers.onStream(line + '\n', 'stdout')
-      }
-    }
+  // Custom stdout demuxer (stdoutDemux.ts): the stream interleaves text lines
+  // (PLOTAPP: JSON and plain log output, both '\n'-terminated) with raw PLOTBIN
+  // binary frames (PLOTBIN:<hlen>:<plen>\n<header_json><payload>). readline
+  // can't carry binary, so the raw Buffer stream is parsed with a chunk-list
+  // accumulator — each byte is copied exactly once, into the emitted unit
+  // (the old whole-prefix Buffer.concat per chunk was O(N²/chunkSize) while a
+  // large frame streamed in: 11.9 s per 64 MB frame at 64 KiB chunks). Plain
+  // output is remembered for a problem report on the way past; the demuxer
+  // itself says so on a malformed message rather than swallowing it.
+  const demux = createStdoutDemux({
+    ...handlers,
+    onStream: (text, kind) => { rememberOutput(text); handlers.onStream(text, kind) },
   })
+  child.stdout!.on('data', (chunk: Buffer) => demux.push(chunk))
 
   child.stderr!.on('data', (d: Buffer) => {
     rememberOutput(d.toString())

de_shell-0.2.1/de_shell/js/main/stdoutDemux.test.ts

@@ -0,0 +1,195 @@
+/**
+ * stdoutDemux.test.ts — node:test unit tests for the backend stdout demuxer.
+ *
+ * The stream interleaves '\n'-terminated text lines (PLOTAPP: JSON + plain
+ * log output) with raw PLOTBIN binary frames
+ * (PLOTBIN:<hlen>:<plen>\n<header_json><payload>). The demuxer must produce
+ * the SAME event trace regardless of how the OS slices the stream into
+ * 'data' chunks — Windows delivers a single large child-stdout write as
+ * uniform 64 KiB chunks (measured 2026-08-15), and chunk boundaries can land
+ * mid-marker, mid-prefix, mid-header or mid-payload.
+ *
+ * Also pins the accumulator's cost shape: a 16 MB frame arriving as 64 KiB
+ * chunks must demux in linear time. The pre-fix Buffer.concat accumulator
+ * recopied the whole prefix per chunk — O(N²/chunk): measured 813 ms at
+ * 16 MB, 11.9 s at 64 MB (notes/runs/2026-08-15-perf-review-measurements.md
+ * §1) — so the 250 ms budget is ~3× under the old cost and ~38× over the
+ * chunk-list cost (6.6 ms measured); generous against CI timer noise on
+ * both sides.
+ *
+ * Run: `node --test src/stdoutDemux.test.ts` (from packages/shell-main/),
+ * or via the `test:unit` npm script.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createStdoutDemux } from './stdoutDemux.ts'
+
+type Event =
+  | { kind: 'message'; msg: Record<string, unknown> }
+  | { kind: 'stream'; text: string }
+  | { kind: 'binary'; header: Record<string, unknown>; payload: string }
+
+function collector() {
+  const events: Event[] = []
+  const demux = createStdoutDemux({
+    onMessage: (msg) => events.push({ kind: 'message', msg }),
+    onStream: (text) => events.push({ kind: 'stream', text }),
+    onBinary: (header, payload) =>
+      events.push({ kind: 'binary', header, payload: payload.toString('hex') }),
+  })
+  return { events, demux }
+}
+
+function frame(header: Record<string, unknown>, payload: Buffer): Buffer {
+  const h = Buffer.from(JSON.stringify(header), 'utf8')
+  return Buffer.concat([
+    Buffer.from(`PLOTBIN:${h.length}:${payload.length}\n`, 'ascii'),
+    h,
+    payload,
+  ])
+}
+
+/** Feed `stream` in slices of `sizes` (cycled); return the event trace. */
+function run(stream: Buffer, sizes: number[]): Event[] {
+  const { events, demux } = collector()
+  let pos = 0
+  let i = 0
+  while (pos < stream.length) {
+    const n = Math.min(sizes[i % sizes.length], stream.length - pos)
+    demux.push(stream.subarray(pos, pos + n))
+    pos += n
+    i++
+  }
+  return events
+}
+
+function patternPayload(n: number): Buffer {
+  const p = Buffer.allocUnsafe(n)
+  for (let i = 0; i < n; i++) p[i] = i & 0xff // includes 0x0a bytes
+  return p
+}
+
+// A representative interleaved stream: log line, PLOTAPP message, a binary
+// frame whose payload contains newline bytes and marker-lookalike bytes,
+// another log line, a second frame back-to-back with a third, final message.
+function interleavedStream(): Buffer {
+  const nasty = Buffer.concat([
+    Buffer.from('\nPLOTBIN:9:9\nPLOTAPP:{}\n', 'ascii'), // lookalikes INSIDE payload
+    patternPayload(3000),
+  ])
+  return Buffer.concat([
+    Buffer.from('starting up\n', 'utf8'),
+    Buffer.from('PLOTAPP:{"type":"state_update","key":"clim"}\n', 'utf8'),
+    frame({ fig_id: 'f1', key: 'image' }, nasty),
+    Buffer.from('mid-run log\n', 'utf8'),
+    frame({ fig_id: 'f2', key: 'image' }, patternPayload(1)),
+    frame({ fig_id: 'f3', key: 'spec' }, Buffer.alloc(0)),
+    Buffer.from('PLOTAPP:{"type":"done"}\n', 'utf8'),
+  ])
+}
+
+test('one whole-stream chunk parses every unit in order', () => {
+  const events = run(interleavedStream(), [1 << 30])
+  assert.deepEqual(events.map((e) => e.kind),
+    ['stream', 'message', 'binary', 'stream', 'binary', 'binary', 'message'])
+  const b1 = events[2] as Extract<Event, { kind: 'binary' }>
+  assert.deepEqual(b1.header, { fig_id: 'f1', key: 'image' })
+  const b3 = events[5] as Extract<Event, { kind: 'binary' }>
+  assert.equal(b3.payload, '')
+  assert.deepEqual((events[6] as Extract<Event, { kind: 'message' }>).msg,
+    { type: 'done' })
+})
+
+test('the event trace is chunking-invariant (64 KiB, tiny, 1-byte, ragged)', () => {
+  const stream = interleavedStream()
+  const reference = run(stream, [1 << 30])
+  for (const sizes of [[65536], [7], [1], [3, 1, 40, 2, 1000, 1]]) {
+    assert.deepEqual(run(stream, sizes), reference,
+      `trace diverged for chunk sizes ${JSON.stringify(sizes)}`)
+  }
+})
+
+test('splits inside the marker, prefix, header and payload all reassemble', () => {
+  const f = frame({ fig_id: 'x' }, patternPayload(64))
+  const reference = run(f, [1 << 30])
+  // Split at every single boundary position of the frame — brute force
+  // covers mid-marker, mid-prefix, mid-header and mid-payload by exhaustion.
+  for (let cut = 1; cut < f.length; cut++) {
+    const { events, demux } = collector()
+    demux.push(f.subarray(0, cut))
+    demux.push(f.subarray(cut))
+    assert.deepEqual(events, reference, `split at byte ${cut} diverged`)
+  }
+})
+
+test('a malformed PLOTBIN prefix line is dropped and parsing resumes', () => {
+  const stream = Buffer.concat([
+    Buffer.from('PLOTBIN:not:numbers\n', 'ascii'),
+    Buffer.from('PLOTAPP:{"type":"after"}\n', 'utf8'),
+  ])
+  for (const sizes of [[1 << 30], [1]]) {
+    const events = run(stream, sizes)
+    assert.deepEqual(events, [
+      { kind: 'message', msg: { type: 'after' } },
+    ])
+  }
+})
+
+test('a malformed header still consumes the frame and delivers the payload', () => {
+  const h = Buffer.from('{broken', 'utf8')
+  const payload = patternPayload(32)
+  const stream = Buffer.concat([
+    Buffer.from(`PLOTBIN:${h.length}:${payload.length}\n`, 'ascii'),
+    h, payload,
+    Buffer.from('PLOTAPP:{"type":"after"}\n', 'utf8'),
+  ])
+  const events = run(stream, [5])
+  assert.deepEqual(events, [
+    { kind: 'binary', header: {}, payload: payload.toString('hex') },
+    { kind: 'message', msg: { type: 'after' } },
+  ])
+})
+
+test('malformed PLOTAPP JSON is reported, not swallowed; blank lines emit nothing', () => {
+  // A truncated frame is how a backend bug presents, and silence turns it
+  // into "the UI just stopped" — so the line is dropped AND said so, on
+  // stderr, and the parse carries on to the next unit.
+  const stream = Buffer.from('PLOTAPP:{nope\n\n   \nreal log\n', 'utf8')
+  const events = run(stream, [2])
+  assert.equal(events.length, 2)
+  assert.match((events[0] as { text?: string }).text ?? '',
+               /^\[sidecar protocol\] malformed JSON message: PLOTAPP:\{nope/)
+  assert.deepEqual(events[1], { kind: 'stream', text: 'real log\n' })
+})
+
+test('a handler that throws does not stop the parse', () => {
+  const seen: string[] = []
+  const demux = createStdoutDemux({
+    onMessage: (m) => { seen.push(`m:${(m as { type?: string }).type}`) },
+    onStream: () => { throw new Error('boom') },
+    onBinary: () => { throw new Error('boom') },
+  })
+  demux.push(Buffer.concat([
+    Buffer.from('log line\n', 'utf8'),
+    frame({ fig_id: 'f' }, patternPayload(8)),
+    Buffer.from('PLOTAPP:{"type":"after"}\n', 'utf8'),
+  ]))
+  assert.deepEqual(seen, ['m:after'])
+})
+
+test('PERF PIN: a 16 MB frame in 64 KiB chunks demuxes in linear time', () => {
+  const payload = Buffer.allocUnsafe(16 * 1024 * 1024).fill(7)
+  const stream = frame({ fig_id: 'big', key: 'image' }, payload)
+  const { events, demux } = collector()
+  const t0 = process.hrtime.bigint()
+  for (let pos = 0; pos < stream.length; pos += 65536) {
+    demux.push(stream.subarray(pos, Math.min(pos + 65536, stream.length)))
+  }
+  const ms = Number(process.hrtime.bigint() - t0) / 1e6
+  assert.equal(events.length, 1)
+  assert.equal((events[0] as Extract<Event, { kind: 'binary' }>).payload.length,
+    payload.length * 2) // hex doubles
+  assert.ok(ms < 250,
+    `16 MB frame took ${ms.toFixed(0)} ms — the quadratic Buffer.concat ` +
+    `accumulator signature (measured 813 ms pre-fix, 6.6 ms chunk-list)`)
+})

de_shell-0.2.1/de_shell/js/main/stdoutDemux.ts

@@ -0,0 +1,167 @@
+/**
+ * stdoutDemux.ts — the backend stdout demuxer.
+ *
+ * The Python sidecar's stdout interleaves '\n'-terminated text lines
+ * (PLOTAPP: JSON and plain log output) with raw PLOTBIN binary frames
+ * (PLOTBIN:<hlen>:<plen>\n<header_json><payload>). readline can't carry
+ * binary, so the raw Buffer stream is parsed here, accumulating partial
+ * reads; the event trace must be invariant to how the OS slices the stream
+ * into 'data' chunks (Windows delivers a large child-stdout write as uniform
+ * 64 KiB chunks).
+ */
+
+export interface DemuxHandlers {
+  onMessage: (msg: Record<string, unknown>) => void
+  onStream: (text: string, kind: 'stdout' | 'stderr') => void
+  onBinary?: (header: Record<string, unknown>, payload: Buffer) => void
+}
+
+export interface StdoutDemux {
+  /** Feed one stdout 'data' chunk; fires handlers for each completed unit. */
+  push(chunk: Buffer): void
+}
+
+const PLOTBIN = Buffer.from('PLOTBIN:')
+const NL = 0x0a
+
+/**
+ * Chunk-list accumulator (perf arc Phase F fix #4). The previous
+ * implementation concatenated every incoming chunk onto one accumulator
+ * (`Buffer.concat([acc, chunk])`), recopying the whole buffered prefix per
+ * chunk — O(N²/chunkSize) while a large PLOTBIN frame streams in: measured
+ * 813 ms per 16 MB frame and 11.9 s / 32.9 GB copied per 64 MB frame at the
+ * OS's 64 KiB chunk size. This version keeps the chunks in a list and copies
+ * each byte exactly once, into the emitted unit (payload/header/line):
+ * 6.6 ms per 16 MB frame, 30 ms per 64 MB. Byte-identical event traces
+ * proven across chunkings in stdoutDemux.test.ts (and previously in the
+ * tools/perf/transport bench, incl. 1-byte splits).
+ */
+export function createStdoutDemux(handlers: DemuxHandlers): StdoutDemux {
+  const chunks: Buffer[] = []   // chunks[0] is valid from `off`
+  let off = 0                   // consumed bytes inside chunks[0]
+  let total = 0                 // unconsumed bytes across the list
+  let noNLBefore = 0            // scan hint: first `noNLBefore` bytes have no NL
+
+  // byte at logical position i (i < total); only used for the tiny marker probe
+  const byteAt = (i: number): number => {
+    let pos = i + off
+    for (const c of chunks) {
+      if (pos < c.length) return c[pos]
+      pos -= c.length
+    }
+    return -1
+  }
+
+  const startsWithMarker = (): boolean => {
+    for (let i = 0; i < PLOTBIN.length; i++) {
+      if (byteAt(i) !== PLOTBIN[i]) return false
+    }
+    return true
+  }
+
+  // logical index of the first NL at/after `from`, else -1 (uses + updates the
+  // hint so an incomplete unit is never rescanned from the start)
+  const findNL = (from: number): number => {
+    const start = Math.max(from, noNLBefore)
+    let logical = 0             // logical index of the start of chunk ci
+    for (let ci = 0; ci < chunks.length; ci++) {
+      const c = chunks[ci]
+      const cOff = ci === 0 ? off : 0
+      const cLen = c.length - cOff
+      if (start < logical + cLen) {
+        const within = cOff + Math.max(0, start - logical)
+        const hit = c.indexOf(NL, within)
+        if (hit >= 0) return logical + (hit - cOff)
+      }
+      logical += cLen
+    }
+    noNLBefore = total
+    return -1
+  }
+
+  // copy `len` bytes starting at logical `start` into a fresh Buffer — the
+  // single copy each emitted byte pays
+  const extract = (start: number, len: number): Buffer => {
+    const out = Buffer.allocUnsafe(len)
+    if (len === 0) return out
+    let pos = start + off
+    let ci = 0
+    while (pos >= chunks[ci].length) { pos -= chunks[ci].length; ci++ }
+    let written = 0
+    while (written < len) {
+      const c = chunks[ci]
+      const n = Math.min(len - written, c.length - pos)
+      c.copy(out, written, pos, pos + n)
+      written += n; pos = 0; ci++
+    }
+    return out
+  }
+
+  const consume = (n: number): void => {
+    total -= n
+    noNLBefore = Math.max(0, noNLBefore - n)
+    let left = n + off
+    while (left > 0 && chunks.length) {
+      const c = chunks[0]
+      if (left >= c.length) { left -= c.length; chunks.shift() }
+      else break
+    }
+    off = left
+  }
+
+  const parse = (): void => {
+    // Process as many complete units as are buffered; stop when we need more.
+    for (;;) {
+      if (total === 0) break
+      // A binary frame if the stream starts with the PLOTBIN marker.
+      if (total >= PLOTBIN.length && startsWithMarker()) {
+        const nl = findNL(0)
+        if (nl < 0) break                       // prefix line incomplete
+        const prefix = extract(PLOTBIN.length, nl - PLOTBIN.length).toString('ascii')
+        const [hlenS, plenS] = prefix.split(':')
+        const hlen = parseInt(hlenS, 10), plen = parseInt(plenS, 10)
+        if (!(hlen >= 0) || !(plen >= 0)) {     // malformed → drop the line
+          consume(nl + 1); continue
+        }
+        const bodyStart = nl + 1
+        const end = bodyStart + hlen + plen
+        if (total < end) break                  // body not fully arrived yet
+        let header: Record<string, unknown> = {}
+        try {
+          header = JSON.parse(extract(bodyStart, hlen).toString('utf8'))
+        } catch { /* malformed header — still consume the frame */ }
+        const payload = extract(bodyStart + hlen, plen)
+        consume(end)
+        try { handlers.onBinary?.(header, payload) } catch { /* ignore */ }
+        continue
+      }
+      // Otherwise a text line up to the next '\n'.
+      const nl = findNL(0)
+      if (nl < 0) break                         // line incomplete
+      const line = extract(0, nl).toString('utf8')
+      consume(nl + 1)
+      if (line.startsWith('PLOTAPP:')) {
+        try {
+          handlers.onMessage(JSON.parse(line.slice(8)) as Record<string, unknown>)
+        } catch {
+          // Say so rather than swallow it: a truncated frame is how a backend
+          // bug presents, and silence turns it into "the UI just stopped".
+          try {
+            handlers.onStream(`[sidecar protocol] malformed JSON message: ${line.slice(0, 200)}\n`, 'stderr')
+          } catch { /* ignore */ }
+        }
+      } else if (line.trim()) {
+        try { handlers.onStream(line + '\n', 'stdout') } catch { /* ignore */ }
+      }
+    }
+  }
+
+  return {
+    push(chunk: Buffer): void {
+      if (chunk.length === 0) return
+      chunks.push(chunk)
+      total += chunk.length
+      parse()
+    },
+  }
+}

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell/js/renderer/FigureFrame.tsx

@@ -5,7 +5,10 @@
  * are easy to omit without any error appearing:
  *
  * * **Register with the bridge**, so state can be routed to this frame — and
- *   deregister on unmount, so a dead element is not held.
+ *   deregister on unmount, so a dead element is not held. In an EFFECT
+ *   (`attachFigure`), not the ref callback alone: StrictMode's double-invoke
+ *   otherwise leaves the figure registered nowhere, and everything pushed to it
+ *   afterwards goes into the void.
  * * **Replay on load**, passing THIS element. State that arrived before the
  *   frame mounted was posted into the void; replay is the only thing that
  *   recovers it, and a figure mounted twice must serve itself rather than
@@ -21,7 +24,8 @@
  * the host page needs `script-src … blob:` for anyplotlib's ESM boot.
  */
 import React, { useEffect, useRef } from 'react'
-import type { FigureBridge } from './figureBridge'
+import { attachFigure, type FigureBridge } from './figureBridge'
+import { createSizeReporter } from './sizeReporter'
 
 export interface FigureFrameProps {
   bridge: FigureBridge
@@ -44,26 +48,33 @@ export function FigureFrame({
 }: FigureFrameProps) {
   const ref = useRef<HTMLIFrameElement | null>(null)
 
-  // Report size to the backend. Fires once on mount and on every resize; the
-  // zero-size guard skips the frame's first layout pass, which would otherwise
-  // tell the backend to lay the figure out at 0×0.
+  // Report size to the backend. Fires once on mount and on every OBSERVED
+  // resize; `createSizeReporter` skips the frame's zero-size first layout
+  // pass and any firing whose rounded size hasn't changed.
+  //
+  // Hardened on both axes the resize burst rode in on: the callback lives in
+  // a ref and the effect deps carry `figId` ONLY, so an inline `onResize`
+  // prop — a new identity on every parent render — no longer re-runs the
+  // effect (which sent unconditionally per re-run; message-driven re-renders
+  // then fed a loop measured at ~1,500 sends/s over constant geometry). The
+  // reporter's skip-on-unchanged covers ResizeObserver refires the same way.
+  const onResizeRef = useRef(onResize)
+  onResizeRef.current = onResize
   useEffect(() => {
     const el = ref.current
-    if (!el || !onResize) return
-    const send = () => {
-      const r = el.getBoundingClientRect()
-      if (r.width > 0 && r.height > 0) {
-        onResize(Math.round(r.width), Math.round(r.height))
-      }
-    }
+    if (!el) return
+    const report = createSizeReporter((w, h) => onResizeRef.current?.(w, h))
+    const send = () => report(el.getBoundingClientRect())
     send()
     const ro = new ResizeObserver(send)
     ro.observe(el)
     return () => ro.disconnect()
-  }, [figId, onResize])
+  }, [figId])
 
-  // Deregister on unmount so the bridge never holds a detached element.
-  useEffect(() => () => bridge.registerIframe(figId, null), [bridge, figId])
+  // REGISTRATION IS OWNED BY AN EFFECT, not by the ref callback alone, and it
+  // re-registers on every run — see `attachFigure`, which holds the reason and
+  // is where the StrictMode double-invoke is pinned by a test.
+  useEffect(() => attachFigure(bridge, figId, ref.current), [bridge, figId])
 
   return (
     <iframe

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell/js/renderer/figureBridge.test.ts

@@ -10,7 +10,7 @@
 import { test, describe } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { createFigureBridge } from './figureBridge.ts'
+import { attachFigure, createFigureBridge } from './figureBridge.ts'
 
 /** A stand-in iframe that records what was posted into it. */
 function fakeIframe(testid = 'frame') {
@@ -182,3 +182,66 @@ describe('registry and eviction', () => {
     assert.equal(row.registeredIn, 'NONE')
   })
 })
+
+describe('attachFigure — the mount lifecycle a figure has to survive', () => {
+  /** React StrictMode, in dev builds: effect, cleanup, effect — same element. */
+  function strictMount(bridge: any, figId: string, el: HTMLIFrameElement) {
+    const detach1 = attachFigure(bridge, figId, el)
+    detach1()
+    return attachFigure(bridge, figId, el)
+  }
+
+  test('a StrictMode double-invoke leaves the figure REGISTERED', () => {
+    // The defect this pins: the cleanup deregistered and nothing put the
+    // element back, because the ref callback does not fire again for the same
+    // DOM node. Everything pushed afterwards was stashed and posted nowhere,
+    // and the pane kept the placeholder its srcdoc was born with — a solid
+    // black FFT pane in a dev build, correct in a production one.
+    const bridge = createFigureBridge()
+    const frame = fakeIframe()
+    strictMount(bridge, 'f1', frame.el)
+
+    assert.equal(bridge.iframes.current.get('f1'), frame.el)
+    frame.posted.length = 0
+    bridge.applyState('f1', 'display_min', -66.4)
+    assert.deepEqual(frame.posted.map(p => p.message),
+      [{ type: 'awi_state', key: 'display_min', value: -66.4 }])
+  })
+
+  test('state that arrived while the slot was empty is replayed on attach', () => {
+    // The other half: a pane whose frame is computed seconds after it mounts
+    // (an FFT, a fit) pushes into an empty slot. Attaching has to deliver it.
+    const bridge = createFigureBridge()
+    const frame = fakeIframe()
+    bridge.applyState('f1', 'title', 'Image FFT')
+    bridge.applyState('f1', 'raw_max', 255)
+    attachFigure(bridge, 'f1', frame.el)
+
+    assert.deepEqual(frame.posted.map(p => p.message.key), ['title', 'raw_max'])
+  })
+
+  test('a real unmount deregisters, and a remount is not evicted by it', () => {
+    const bridge = createFigureBridge()
+    const first = fakeIframe('first')
+    const detach = attachFigure(bridge, 'f1', first.el)
+    detach()
+    assert.equal(bridge.iframes.current.get('f1'), undefined)
+
+    // A remount registers the NEW element before the old one's cleanup runs,
+    // which is the order React uses. The stale cleanup must not evict it.
+    const second = fakeIframe('second')
+    const detachSecond = attachFigure(bridge, 'f1', second.el)
+    detach()
+    assert.equal(bridge.iframes.current.get('f1'), second.el)
+    detachSecond()
+    assert.equal(bridge.iframes.current.get('f1'), undefined)
+  })
+
+  test('attaching nothing is a no-op, and detaching it evicts nobody', () => {
+    const bridge = createFigureBridge()
+    const frame = fakeIframe()
+    bridge.registerIframe('f1', frame.el)
+    attachFigure(bridge, 'f1', null)()
+    assert.equal(bridge.iframes.current.get('f1'), frame.el)
+  })
+})

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell/js/renderer/figureBridge.ts

@@ -58,6 +58,39 @@ export interface FigureBridge {
   dump(classify?: (el: HTMLIFrameElement | undefined) => string): Record<string, unknown>[]
 }
 
+/**
+ * Attach `el` to `figId` for as long as a host component is mounted, and return
+ * the detach. The registration half of `FigureFrame`, exported so the lifecycle
+ * it has to survive can be driven in a test — a `.tsx` cannot be, under this
+ * package's plain `node --test` runner.
+ *
+ * WHY IT IS AN EFFECT BODY AND NOT A REF CALLBACK. React StrictMode (dev builds
+ * only) mounts, runs effects, runs their CLEANUP, and runs them AGAIN — against
+ * the same DOM element, so a ref callback does not fire the second time. A
+ * cleanup that only deregistered therefore left the bridge with no iframe for
+ * the figure and nothing to put one back: every later `applyState`/`applyBinary`
+ * was stashed and posted into the void, and the frame's `onLoad` replay had
+ * already fired. A pane whose state arrives LATER than its mount then keeps
+ * whatever its srcdoc was born with — the zeros placeholder, i.e. solid black
+ * in a dev build and correct in a production one. Re-registering on every run
+ * makes the double-invoke harmless, and the replay re-delivers whatever landed
+ * while the slot was empty.
+ *
+ * The detach checks that the slot is still OURS: a real remount registers the
+ * new element first, and this must not evict it.
+ */
+export function attachFigure(bridge: FigureBridge, figId: string,
+                             el: HTMLIFrameElement | null): () => void {
+  if (el) {
+    bridge.registerIframe(figId, el)
+    bridge.replay(figId, el)
+  }
+  return () => {
+    if (bridge.iframes.current.get(figId) === el) bridge.registerIframe(figId, null)
+  }
+}
+
+
 export function createFigureBridge(
   log: (label: string, detail: Record<string, unknown>) => void = () => {},
 ): FigureBridge {

de_shell-0.2.1/de_shell/js/renderer/sizeReporter.test.ts

@@ -0,0 +1,76 @@
+/**
+ * sizeReporter.test.ts — the dedupe half of FigureFrame's resize hardening.
+ *
+ * The failure it prevents shipped: FigureFrame's size-report effect re-ran on
+ * every parent render (inline `onResize` props make a new identity each
+ * time) and sent unconditionally, so message-driven re-renders fed a resize
+ * loop that sustained ~1,500 sends/s with constant geometry. The reporter is
+ * the testable core: only a CHANGED rounded size goes out.
+ *
+ * The other half — the effect no longer re-running on `onResize` identity —
+ * is wiring node:test cannot see; the e2e resize spec counts the backend's
+ * applied resizes over a Calibrate mount to pin it end-to-end.
+ *
+ * Run by `npm run test:unit` (node:test, native TS type-stripping).
+ */
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { createSizeReporter } from './sizeReporter.ts'
+
+function collector() {
+  const sent: Array<[number, number]> = []
+  return { sent, send: (w: number, h: number) => { sent.push([w, h]) } }
+}
+
+describe('createSizeReporter', () => {
+  test('a real size is reported, rounded', () => {
+    const { sent, send } = collector()
+    const report = createSizeReporter(send)
+    report({ width: 353.4, height: 380.6 })
+    assert.deepEqual(sent, [[353, 381]])
+  })
+
+  test('the frame\'s zero-size first layout pass is skipped', () => {
+    const { sent, send } = collector()
+    const report = createSizeReporter(send)
+    report({ width: 0, height: 0 })
+    report({ width: 0, height: 200 })
+    assert.deepEqual(sent, [])
+  })
+
+  test('an unchanged size is NOT resent — the burst mechanism', () => {
+    const { sent, send } = collector()
+    const report = createSizeReporter(send)
+    for (let i = 0; i < 100; i++) report({ width: 353, height: 381 })
+    assert.equal(sent.length, 1)
+  })
+
+  test('a sub-pixel wobble that rounds to the same size is not resent', () => {
+    const { sent, send } = collector()
+    const report = createSizeReporter(send)
+    report({ width: 353.2, height: 381.1 })
+    report({ width: 353.4, height: 380.8 })
+    assert.equal(sent.length, 1)
+  })
+
+  test('a genuine size change IS sent — the fix\'s own failure mode', () => {
+    // The one dangerous way to over-fix this: a figure that never learns its
+    // new size. Required red-first by the 8-15 review's fix-4 pin.
+    const { sent, send } = collector()
+    const report = createSizeReporter(send)
+    report({ width: 353, height: 381 })
+    report({ width: 353, height: 381 })
+    report({ width: 500, height: 381 })
+    assert.deepEqual(sent, [[353, 381], [500, 381]])
+  })
+
+  test('a size can recur after an intervening change', () => {
+    const { sent, send } = collector()
+    const report = createSizeReporter(send)
+    report({ width: 100, height: 100 })
+    report({ width: 200, height: 100 })
+    report({ width: 100, height: 100 })
+    assert.equal(sent.length, 3)
+  })
+})

de_shell-0.2.1/de_shell/js/renderer/sizeReporter.ts

@@ -0,0 +1,29 @@
+/**
+ * sizeReporter.ts — dedupe for FigureFrame's size reports.
+ *
+ * One reporter per mounted frame. Rounds the observed rect, skips the frame's
+ * zero-size first layout pass, and only lets a CHANGED size through — a
+ * ResizeObserver refires on observe() and on sub-pixel wobble, and an
+ * unconditional send per firing is how the Calibrate resize burst sustained
+ * ~1,500 messages/s over constant geometry.
+ */
+
+export interface SizeLike {
+  width: number
+  height: number
+}
+
+export function createSizeReporter(
+  send: (width: number, height: number) => void,
+): (rect: SizeLike) => void {
+  let last: string | null = null
+  return (rect: SizeLike) => {
+    const w = Math.round(rect.width)
+    const h = Math.round(rect.height)
+    if (w <= 0 || h <= 0) return
+    const key = `${w}x${h}`
+    if (key === last) return
+    last = key
+    send(w, h)
+  }
+}

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell/plotting/figure.py

@@ -109,6 +109,37 @@ def robust_levels(frame: np.ndarray, *,
 #: Figure chrome background. The apps are dark; anyplotlib's template is not.
 FIGURE_BACKGROUND = "#1e1e2e"
 
+#: Injected into every figure frame: the figure document must never SCROLL.
+#:
+#: anyplotlib lays its panel out at the size the app reports and then wraps it
+#: in ~16 px of its own chrome, so the figure document is always a little taller
+#: than the frame it lives in. Nothing shows that — the overflow is clipped —
+#: until something inside gets FOCUS: the first pointer entry focuses the plot
+#: canvas, the browser scrolls that focused element into view, and the whole
+#: picture jumps up by half the overflow. Once. On the first hover of a fresh
+#: pane, which is exactly what an operator reads as "the FFT moved".
+#:
+#: CSS cannot stop it. `overflow: hidden` still leaves a programmatically
+#: scrollable box, and `overflow: clip` on the root propagates to the viewport,
+#: which Chromium scrolls anyway (measured, both).
+#:
+#: So the scroll is UNDONE, on the capture phase, the moment it happens. The
+#: figure's own pan and zoom never touch document scroll — they are canvas
+#: transforms — so a scrolled figure document is always this artefact and never
+#: something a user asked for. Assigning 0 to an already-0 offset does not
+#: re-fire, so this settles rather than loops.
+#: BOTH boxes, deliberately: which one actually scrolls depends on the overflow
+#: cascade — with `html` hidden the viewport cannot scroll and `body` keeps a
+#: scroll box of its own, and the focus scroll lands on whichever it is
+#: (measured: `body` under the style above, `html` when the root is `clip`).
+PIN_SCROLL = (
+    "<script>addEventListener('scroll',function(){"
+    "var d=document,b=[d.documentElement,d.body,d.scrollingElement];"
+    "for(var i=0;i<b.length;i++){var e=b[i];if(!e)continue;"
+    "if(e.scrollTop)e.scrollTop=0;if(e.scrollLeft)e.scrollLeft=0}"
+    "},{capture:true,passive:true})</script>"
+)
+
 
 def fill_iframe_html(html: str, *, background: str = FIGURE_BACKGROUND,
                      extra_head: str = "") -> str:
@@ -130,7 +161,7 @@ def fill_iframe_html(html: str, *, background: str = FIGURE_BACKGROUND,
              f"#widget-root{{background:{background} !important;"
              "width:100% !important;height:100% !important;display:block !important}"
              "</style>")
-    return html.replace("<body>", style + extra_head + "<body>", 1)
+    return html.replace("<body>", style + PIN_SCROLL + extra_head + "<body>", 1)
 
 
 class FigureView:

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: de-shell
-Version: 0.2.0
+Version: 0.2.1
 Summary: The Electron + Python desktop-app shell Direct Electron's apps (SpyDE, Ground Crew, Autopilot) are assembled from
 Author-email: Carter Francis <cartsfrancis@gmail.com>
 License: MIT
-Project-URL: Homepage, https://github.com/CSSFrancis/de-shell
-Project-URL: Repository, https://github.com/CSSFrancis/de-shell
-Project-URL: Issues, https://github.com/CSSFrancis/de-shell/issues
-Project-URL: Changelog, https://github.com/CSSFrancis/de-shell/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/directelectron/de-shell
+Project-URL: Repository, https://github.com/directelectron/de-shell
+Project-URL: Issues, https://github.com/directelectron/de-shell/issues
+Project-URL: Changelog, https://github.com/directelectron/de-shell/blob/main/CHANGELOG.md
 Keywords: electron,desktop,anyplotlib,electron-microscopy,direct-electron
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -26,7 +26,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.20.0
-Requires-Dist: anyplotlib>=0.7.3
+Requires-Dist: anyplotlib>=0.8.0
 Requires-Dist: pyyaml
 Provides-Extra: tests
 Requires-Dist: pytest>=3.6; extra == "tests"
@@ -36,7 +36,7 @@ Dynamic: license-file
 # DE Shell
 
 [![PyPI](https://img.shields.io/pypi/v/de-shell.svg)](https://pypi.org/project/de-shell/)
-[![CI](https://github.com/CSSFrancis/de-shell/actions/workflows/ci.yml/badge.svg)](https://github.com/CSSFrancis/de-shell/actions/workflows/ci.yml)
+[![CI](https://github.com/directelectron/de-shell/actions/workflows/ci.yml/badge.svg)](https://github.com/directelectron/de-shell/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 The substrate Direct Electron's desktop apps are assembled from: **SpyDE**
@@ -122,8 +122,9 @@ peer dependencies — react, electron, electron-updater, @playwright/test —
 are the app's to declare; every app already does. The e2e specs take the
 harness from `shell/testing/harness.cjs`.
 
-Autopilot and SpyDE (on its `chore/de-shell-split` branch) are wired this
-way; Ground Crew still carries a copy under its `packages/` and is next.
+Autopilot and SpyDE ([directelectron/spyde#152](https://github.com/directelectron/spyde/pull/152))
+are wired this way, pinned `de-shell>=0.2,<0.3`; Ground Crew still carries a
+copy under its `packages/` and is next.
 
 ## Developing it
 
@@ -175,9 +176,9 @@ SpyDE commit the app copies were taken from:
   panes on large stills), JSON emit that never writes bare `NaN`, the harness
   hardening, and the unit tests for all of it.
 
-Not yet included: Ground Crew's `dev/instrument-actions` shell deltas
-(`stdoutDemux`, `sizeReporter`, the `frameBytes` transport) — they ride a
-branch that has not merged.
+* Ground Crew `main` @ 0382549 (0.2.1): the chunk-list stdout demuxer, the
+  size reporter and StrictMode-safe registration in `FigureFrame`, the figure
+  document's scroll pin, and the anyplotlib 0.8.0 floor.
 
 ## Rules
 

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell.egg-info/SOURCES.txt

@@ -36,6 +36,8 @@ de_shell/js/main/pythonEnv.test.ts
 de_shell/js/main/pythonEnv.ts
 de_shell/js/main/sentryEnvelope.test.ts
 de_shell/js/main/sentryEnvelope.ts
+de_shell/js/main/stdoutDemux.test.ts
+de_shell/js/main/stdoutDemux.ts
 de_shell/js/main/updater.ts
 de_shell/js/main/updaterErrors.test.ts
 de_shell/js/main/updaterErrors.ts
@@ -49,6 +51,8 @@ de_shell/js/renderer/index.ts
 de_shell/js/renderer/protocol.ts
 de_shell/js/renderer/shellState.test.ts
 de_shell/js/renderer/shellState.ts
+de_shell/js/renderer/sizeReporter.test.ts
+de_shell/js/renderer/sizeReporter.ts
 de_shell/js/testing/harness.cjs
 de_shell/js/testing/harness.test.cjs
 de_shell/plotting/__init__.py

{de_shell-0.2.0 → de_shell-0.2.1}/de_shell.egg-info/requires.txt

@@ -1,5 +1,5 @@
 numpy>=1.20.0
-anyplotlib>=0.7.3
+anyplotlib>=0.8.0
 pyyaml
 
 [tests]

{de_shell-0.2.0 → de_shell-0.2.1}/pyproject.toml

@@ -36,7 +36,13 @@ dependencies = [
     # needs: the centre is the DC term, and enforcing that from Python cannot
     # work — the renderer recomputes the drag from its own grab-time snapshot,
     # so a correction pushed from here is overwritten on the next mousemove.
-    "anyplotlib>=0.7.3",
+    #
+    # 0.8.0 for its PR #62, "a tiled image born on a placeholder rendered solid
+    # black". Every large STILL in Ground Crew is that case: a pane opened at
+    # the frame's shape, given a tile source on its zeros placeholder, then
+    # painted. On 0.7.3 a state push landing between the open and the first
+    # frame could leave the pane showing the placeholder.
+    "anyplotlib>=0.8.0",
     "pyyaml",
 ]
 
@@ -47,10 +53,10 @@ tests = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/CSSFrancis/de-shell"
-Repository = "https://github.com/CSSFrancis/de-shell"
-Issues = "https://github.com/CSSFrancis/de-shell/issues"
-Changelog = "https://github.com/CSSFrancis/de-shell/blob/main/CHANGELOG.md"
+Homepage = "https://github.com/directelectron/de-shell"
+Repository = "https://github.com/directelectron/de-shell"
+Issues = "https://github.com/directelectron/de-shell/issues"
+Changelog = "https://github.com/directelectron/de-shell/blob/main/CHANGELOG.md"
 
 # One version, in one place: de_shell.__version__. The release workflow refuses
 # a tag that does not match it.