Five Default Assumptions of a Qt Desktop Workbench: From file:// to app://

🇨🇳 中文版

Project context: how Lume and lume-qt relate

Worth settling the name first, because otherwise the run of lume-prefixed symbols later makes it look as though the whole project were written in Lume.

Lume is a single-binary C11 backend framework: business logic lives in .lume scripts, and the artifact is a roughly 1.7 MB executable that serves static sites, JSON APIs, SSE, and native SQLite at once; no Node runtime, no separate frontend service process. It owns only the DSL layer — HTTP, sessions, and MCP come from a statically linked agent-httpd.

Writing it means a server declaration plus a route, with data going straight to SQLite:

server {
  port = medmon_port;
  workers = medmon_workers;
  bind = medmon_bind;
};

get "/api/medmon/health", (req) => {
  let r = try(() => sql_write(db, "DELETE FROM events WHERE id = -1"));
  if (r.err != null) {
    return { status: 503, body: { ok: false, err: r.err } };
  }
  return { body: { ok: true, write: true } };
};

Source: tools/lume-medmon/app.lume:33 through tools/lume-medmon/app.lume:37, and tools/lume-medmon/app.lume:169 through tools/lume-medmon/app.lume:175. That route is a "zero-row write" probe of the write path: it modifies no business data, yet it genuinely opens a SQLite write transaction, so it catches the "reads are fine, POST is stuck" state that a process-alive check misses.

In lume-qt, Lume plays exactly one role: the desktop shell hands audit uploads, alarm-threshold delivery, and the health probe to this reference service, and the shell needs a single environment variable, QTRS_LUME_URL=http://127.0.0.1:8090. The local JSONL ledger stays authoritative; the Lume mirror is optional and non-blocking, and it also exposes three read-only tools (medmon_summary, medmon_events, medmon_review) for engineering review. This reference implementation does not carry what production needs — per-case indexes, retention cleanup, write-side authentication — and the service itself has neither authentication nor TLS by default, so it belongs on loopback only.

So all five default assumptions in this article live on the Qt side: Lume is neither a runtime dependency of the C++ host nor a target of these replacements. lumesink.cpp, isAllowedLumeKey, and digestForLume name "the path that uploads to the Lume service"; that code is C++ from beginning to end and unrelated to DSL syntax.

Here is that boundary laid out, so the five replacements have somewhere to land:

React / TypeScript         workbench UI · 3D volume rendering · live dashboard · state
        ↕  QWebChannel (properties + signals; the JS side initiates, the host answers)
Qt / C++ host              window lifecycle · device I/O · DICOM parsing · scheme responses · index writes
        ↕  local files / local processes
local services             Lume reference service (audit upload, optional) · JSONL authoritative ledger

Each of the three edges has its own protocol: app:// governs how pages and assets are loaded, QWebChannel governs how host and page talk, and QTRS_LUME_URL governs how the shell uploads audit records to the mirror. The five replacements each touch one edge, not the architecture as a whole.

TL;DR

  • The default path — file:// loading static artifacts, QWebChannel injected into the page — holds for a single page with no routing and low-frequency bridging; once history routing, real-time data, and dirty data stack up, the failure points are not in the UI.
  • The page is served through a custom app:// scheme: host-answered means a fallback rule finally has a place to live, and the extension-less deep-link fallback now sits in resolveRequestPath; with no router dependency today it will not fire. The bridge is unaffected, since the official bridge only requires send and onmessage.
  • Frontend artifacts hook into the C++ build chain: make cpp syncs the frontend itself, turning "remember to run them in the right order" from discipline into an edge in the build graph.
  • Link health cannot be inferred from a single frame's age: SignalState / ChannelHealth / BatchSeries separate interruption, slowness, and batch queueing; DICOM marks missing values with hasZ instead of using 0 as a sentinel.
  • De-identification is not one regex: path rules must run before UID rules (the other order leaves half a path behind), and the outbound payload keeps only allowlisted fields, dropping unknown ones by default.

Source: https://github.com/erishen/lume-qt

The default path: the starter shape and the intersection where it holds

Most Qt WebEngine desktop projects start in the same shape: the frontend uses Vite or webpack to produce a build that lands in resources/web; the C++ side loads a file:// entry point with QWebEngineView; two-way communication injects a QObject through QWebChannel; and the build order is "frontend first, then C++, then package it all together".

Why it is popular is plain: it mostly decouples build from runtime. What runs in a browser will largely run inside QWebEngineView; a frontend engineer does not need to understand CMake, and a host engineer does not need to understand Vite; static artifacts drop into any resource system. For a tool-like app of one page, a few buttons, and a handful of bridge calls, it costs almost nothing. The four comment lines at Makefile:7 through Makefile:10 are that idea in miniature: targets reachable on their own, frontend artifacts directed into resources/web, the C++ build consuming them.

The communication half is designed as "inject it and it works". The repository ships Qt's official qwebchannel.js as-is:

var QWebChannel = function(transport, initCallback, converters)
{
    if (typeof transport !== "object" || typeof transport.send !== "function") {
        console.error("The QWebChannel expects a transport object with a send function and onmessage callback property." +
                      " Given is: transport: " + typeof(transport) + ", transport.send: " + typeof(transport.send));
        return;
    }

Source: frontend/public/qwebchannel.js:20 through frontend/public/qwebchannel.js:27. The constructor checks only that transport has send and onmessage; the message-type table QWebChannelMessageTypes (frontend/public/qwebchannel.js:8) defines nothing but protocol semantics — signal, propertyUpdate, init, invokeMethod — and makes no assumption about which URL the page was loaded from. So "file:// + static artifacts + QWebChannel" becomes a self-consistent minimal loop.

The intersection where it holds is narrower than it looks: a single page, no history routing, packaged assets that do not depend on an absolute root path, a frontend built once at release time, low-frequency links, clean data, and a single instance held by agreement. Inside that intersection — tool-like shells, internal demos, read-only panels — the simplicity is a real advantage, and there is no reason to replace it just to look better architecturally.

What the approach does wave through, though, are two omissions treated as always true: "how the page loads has nothing to do with business logic", and "when the frontend is rebuilt is decided by a human, in the right order". Against real-time data, dirty data, and data egress, those two omissions produce five concrete failure points; each is paired with its replacement below.

The five replacements

Replacement one: the page no longer loads from file://

Failure: As soon as the page uses history routing, or packaged assets are referenced by an absolute root path, file:// has no server-side fallback, and a deep-link refresh lands on an empty path. That is not "inelegant" — it is "not working".

Replacement: Give the page its own scheme, answered by the host. But be precise about what that buys: a place where a fallback rule can be written, not the fallback itself. The file:// problem is not "a missing handler"; it is that there is nowhere to put a fallback at all. app:// creates that place; whether a rule goes into it, and which rule, stays the host's decision.

Evidence: This is not an announcement but a hard registration in the startup path, and it carries an ordering constraint:

    // 注册自定义 scheme 必须在 QApplication 构造之前,
    // 否则 Qt WebEngine 会拒绝使用未注册的 scheme。
    QWebEngineUrlScheme scheme("app");
    scheme.setSyntax(QWebEngineUrlScheme::Syntax::Host);

Source: src/main.cpp:123 through src/main.cpp:126. Registration only stands the scheme up; the flags are what draw the security boundary, and all five are set together:

    scheme.setFlags(
        QWebEngineUrlScheme::Flag::SecureScheme
        | QWebEngineUrlScheme::Flag::LocalScheme
        | QWebEngineUrlScheme::Flag::LocalAccessAllowed
        | QWebEngineUrlScheme::Flag::CorsEnabled
        | QWebEngineUrlScheme::Flag::FetchApiAllowed);

Source: src/main.cpp:130 through :135. Each of the five answers a different question: whether the scheme counts as a secure context, whether it is a local-resource scheme, whether local access is open, whether cross-origin requests are allowed, whether fetch may reach it. All five are on for concrete reasons — the page fetches the volume binary, assets share the page's origin, and the data layer is reached cross-origin — but this is also the widest trust surface in the project, five permissions pushed to roughly https width in one place. Changing it deserves a reason per flag, not a copy of the block.

The next question is who answers. AppSchemeHandler has exactly four branches:

Request Handling Source
app://app/ empty path normalised to index.html src/schemepath.cpp:17 through :19
app://app/console (extension-less deep link) normalised to index.html as well src/schemepath.cpp:23 through :26
app://app/__volume/current.bin bypasses the filesystem, served by the provider src/appschemehandler.cpp:31 through :35
app://app/assets/index-abc.js read from disk, MIME type by extension :56 through :91
anything else that does not exist (including traversal attempts) UrlNotFound, no rewrite :46 through :54

The fallback rule is short, but it has to exist as its own thing: scheme::resolveRequestPath (src/schemepath.cpp:10 through :29) strips the leading /, sends an empty path to the entry page, and treats any extension-less route-like path as index.html. The character set is limited to letters, digits and / _ -, so a path like /../etc/passwd is never quietly laundered into the front page — it still goes through the canonical check and 404s. All the handler does is one call (src/appschemehandler.cpp:29), which separates "who answers" from "how it falls back".

That rule has unit tests behind it: tests/scheme_path_test.cpp covers the root, two deep-link shapes (/console, /review/7), asset pass-through, virtual-resource pass-through, and suspicious paths left unwritten, running as SchemePathUnitTests under ctest.

The bridge side is unaffected either way: the official bridge only requires a transport with send and onmessage (frontend/public/qwebchannel.js:20 through :27), and protocol types are independent of the URL scheme (:8).

Boundary: Without history routing and without absolute-root assets, switching schemes is just one more handler to maintain. That is exactly this project's state — there is no router dependency (no react-router, no wouter in frontend/package.json), the fallback is written and will never fire, so what it bought is "no host-side change when routing arrives later", not "404s gone today".

Replacement two: when the frontend is built no longer rests with a human

Failure: Once the frontend and C++ share one data contract, "the human remembers to run them in the right order" does not hold. Forgetting the frontend, running a stale artifact, or having the C++ side see the previous resources/web all surface as "the code is right, the output is wrong", and nothing raises an error. That is not a defect of some build system; it is the price of decoupling the two builds under specific constraints.

Replacement: Hang the frontend build onto the C++ dependency chain, so make cpp no longer means "compile C++ only" but "configure and compile C++, with the frontend synced".

Evidence: The two comment lines at Makefile:7 through Makefile:8 are not rhetoric; they describe the build graph. What actually pins it down is the CMake ALL target:

add_custom_target(frontend-build ALL
    COMMAND "${BASH_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/frontend-build.sh"
    COMMENT "Building React frontend (Vite) → resources/web (skipped if unchanged)"
    VERBATIM
)

Source: CMakeLists.txt:44 through CMakeLists.txt:48. ALL is the keyword: it turns the frontend from "an optional target" into "a default predecessor of every build", rather than relying on the order in which lines are written in the Makefile. The script itself compares frontend sources and skips when nothing changed, so the added dependency does not degrade incremental builds into full rebuilds; the configure target also skips CMake configuration when build.ninja already exists, leaving regeneration to ninja (Makefile:70). Build variables are fixed at the top of the file and overridable from the environment (Makefile:15 through :17, Makefile:12), so the chain does not collapse into one hard-coded path on another machine.

Boundary: When the Web page is only an optional debug panel and not part of the main interface, hanging the frontend onto the main build chain just slows compilation down.

Replacement three: link health is no longer inferred from a single frame's age

Failure: A working bridge only means messages can be sent and received. Arrival times shift wholesale when the render process is busy, the compositor queues, or the page is throttled while invisible; when the render process is busy, several updates landing in the same event-loop turn are read out in one go, and QWebChannel does not mark which stretch was a batch of backlogged samples — so one frame's age mistakes batch queueing for a slow link. There is a second layer too: the tsUs of a real-time sample is the acquisition instant, while the tsUs of a DICOM volume is the host-side parse-completion instant; subtracting offsets against one device clock yields an absurd age.

Replacement: Turn each channel's arrival times into a stateful statistical model — an explicit state set, per-channel thresholds, and batch delivery judged separately from real delay.

Evidence: Channel (frontend/src/latency.ts:14), SignalState (:17), and ChannelHealth's ageMs and staleAfterMs (:19 through :24) turn "interrupted" from a UI impression into a queryable value; BatchSeries's samples and gaps (:146) separate delay from backlog; volume is listed in HOST_STAMPED_CHANNELS (frontend/src/latency.ts:115) and therefore takes no device-clock offset subtraction.

The time base deserves its own note: frontend/src/latency.ts:65 uses performance.timeOrigin + performance.now() (module comment at :9). performance.now() is a monotonic clock, and timeOrigin anchors that monotonic reading to the wall-clock origin, so intervals are immune to NTP correction or a user changing the system clock; the volume channel's tsUs, by contrast, is wall-clock at parse completion. Different semantics — mixing them is simply wrong.

Boundary: The model holds only while the link is a continuous stream. alarm is an event channel that records only "how long this one took" and has no age/interruption semantics; volume is a one-shot parse on the order of seconds, and a 100 ms link budget would judge it slow forever, so it gets its own budget.

Replacement four: missing DICOM fields no longer fall back to defaults

Failure: DCMTK's findAndGetFloat64 writes 0 into the output when the tag is missing. So "read the rescale slope and use it" yields slope=0 on MR series that usually have no Rescale tag, and the whole volume turns all-zero and black; the sample brain T1 happened to carry an explicit 1/0, which is why the trap stayed hidden. The same class of problem shows up in bit depth: truncating 16-bit data with >> 8 erases the effective value.

Replacement: Fall back explicitly to the initial value the caller set; carry presence in a separate field instead of letting a number double as sentinel; store pixels at their original width.

Evidence: The trap and the fallback live in the same file — the comment explains DCMTK's behavior, and the code pins the fallback on two bad() branches:

    // rescale slope / intercept(CT 常非 1/0,MR 多为 1/0,但不可假定)
    //
    // 注意:DCMTK 的 findAndGetFloat64 在标签缺失时会把出参写成 0(不是保留
    // 原值)。之前直接 `findAndGetFloat64(DCM_RescaleSlope, slope)` 会让没有
    // Rescale 标签的序列(MR 很常见)变成 slope=0 → 整个体积全零 → 黑屏。
    // 样例脑部 T1 恰好显式写了 1/0,所以这个坑一直被掩盖。
    double slope = 1.0, intercept = 0.0;
    if (ds->findAndGetFloat64(DCM_RescaleSlope, slope).bad())
        slope = 1.0;
    if (ds->findAndGetFloat64(DCM_RescaleIntercept, intercept).bad())
        intercept = 0.0;

Source: src/dicomreader.cpp:90 through src/dicomreader.cpp:100 — the fallback has to be written out, or the 1.0 / 0.0 the caller set gets eaten by that 0.

The same idea is clearer in the structure: Slice splits "is there a Z" into a separate field, and raw keeps the original 16-bit width.

struct Slice {
    std::vector<uint16_t> raw; // rows × cols(行主序),8 位数据也统一存为 uint16
    int rows = 0;
    int cols = 0;
    double z = 0.0;      // 空间 Z(ImagePositionPatient 第 3 轴)
    bool hasZ = false;   // 是否真的读到了 Z —— 不能用 z==0.0 当哨兵

Source: src/dicomreader.cpp:28 through src/dicomreader.cpp:33. hasZ exists so that z == 0.0 need not double as a sentinel, and std::vector<uint16_t> preserves full bit depth — both reasons are in the comments rather than reconstructed after the fact.

That fallback has no unit test behind it: tests/ holds only bridge_test.cpp and volume_stats_test.cpp, with no DICOM parsing cases. The minimum matrix worth adding is four rows:

Case slope / intercept Expectation
CT with an explicit Rescale 2 / -1024 converted from the original values, no fallback
MR without the Rescale tag unreadable (DCMTK writes 0 into the out-params) falls back to 1 / 0, volume not black
Explicit zero values 0 / 0 treated as genuine zeros, not overwritten by the fallback
No ImagePositionPatient no Z hasZ=false, excluded from slice-spacing maths

The first three rows check that the fallback does not eat a legitimate zero; the fourth checks that absence is not impersonated by a value — which is what the Slice boolean is for.

Boundary: Only fields where zero is a legitimate value need that extra boolean. In a format where 0 naturally means "absent", the sentinel is the cheaper spelling.

Replacement five: from string regexes to layered data minimisation

Failure: Reduced to "run a regex before shipping", de-identification stands or falls on two things that are rarely written down — rule order, and whether there is an allowlist underneath. Paths often embed a DICOM UID (/data/1.2.840.113619…/slice.dcm), and running the UID rule first cuts the path in the middle, leaving a shorter but far more conspicuous bare path behind; a denylist also never catches up with new fields — a vendor adds one tag, a debug build logs one more field, and the data is out.

Replacement: Split it into three stages in a fixed order — path folding, UID folding, field allowlist. Be precise about the reach: this is minimisation at the string layer, not de-identification. PHI does not live only in paths and UIDs.

Evidence: In scrubText (src/lumesink.cpp:23) the path rule runs before the UID rule, with a character class that admits spaces so macOS directory names like Application Support are covered; the UID rule uses \d+(?:\.\d+){2,}, so three-segment forms such as 2.25.<integer> do not slip through, at the cost of folding IPv4-looking strings as well.

QString scrubText(const QString &text)
{
    QString out = text;
    // 路径先于 UID 折叠:路径里常带 DICOM UID,先吃掉整段才不会留下半截。
    // 字符类允许空格(macOS 的 "Application Support" 这类目录名很常见),
    // 到句子标点或换行停止;宁可连尾随描述一起折掉,也不能留下半截路径。
    static const QRegularExpression homePathRe(
        QStringLiteral("~/[^\\r\\n,;\"'。;,、]+"));
    static const QRegularExpression windowsPathRe(
        QStringLiteral("[A-Za-z]:[\\\\/][^\\r\\n,;\"'。;,、]+"));
    static const QRegularExpression unixPathRe(
        QStringLiteral("(?:/Users|/home|/private|/tmp|/var|/opt|/Library|/Applications|/System|/Volumes)"
                       "/[^\\r\\n,;\"'。;,、]+"));
    // DICOM UID 可以只有三段(2.25.<整数> 是 UUID 派生形式);旧正则要求五段,
    // 会把 2.25.* 与 1.2.840.10008 这类短 UID 原样放行。IPv4 与此同形,会一并
    // 折叠成 <uid>,属于可接受的过度脱敏:本地 JSONL 仍是完整权威记录。
    static const QRegularExpression uidRe(QStringLiteral("\\d+(?:\\.\\d+){2,}"));
    out.replace(homePathRe, QStringLiteral("<path>"));
    out.replace(windowsPathRe, QStringLiteral("<path>"));
    out.replace(unixPathRe, QStringLiteral("<path>"));
    out.replace(uidRe, QStringLiteral("<uid>"));
    return out;
}

Source: src/lumesink.cpp:23 through :45.

Stabilizing identifier fields falls to digestForLume: the lume-qt| prefix plus SHA-256, truncated to 16 hex characters (src/lumesink.cpp:16 through :20), keeps a value stable inside this project's domain without colliding with other SHA-256 usages elsewhere.

Boundary: By layer, two of the three are done and the third is empty.

  • Layer one, string folding: covers "paths and UIDs that already made it into a string", nothing more.
  • Layer two, key allowlist: sanitizeValue recurses through objects and arrays (src/lumesink.cpp:206 through :217), so nesting does not leak keys; but isAllowedLumeKey grants by key, not by path. The same key is a timing field (ageMs) in one place and free text in another, and a flat allowlist cannot tell them apart. A stronger version has to grant by path.
  • Layer three, at rest: the local JSONL is still sensitive data. Not leaving the machine is not the same as being safe — file permissions, retention, backup and cleanup are nobody's job among those three regexes; prunePacsStoreIfConfigured only keeps "delete nothing by default" true, which is not a retention policy.

One class of thing sits outside this mechanism altogether: PatientName, InstitutionName, private tags, free-text descriptions, exception and debug output. scrubText processes strings, not the data model, so it cannot see that the field itself is called patient name.

Which is why the section title had to change: "one regex to three fixed stages" reads as if three regexes were a de-identification scheme. The accurate description is a fixed order at the string layer plus a key allowlist at the structure layer — together, the first two layers of layered minimisation, no more.

Boundaries: outside the intersection, and the lines that must not be crossed

Read the five replacements backwards and you get the criteria for staying on the default path. That reads better as a table than as prose — left to right it says "when to switch", right to left "when to stay":

Project condition What to take Why
Single page, no routing, assets not tied to an absolute root file:// a scheme swap just adds one more handler
SPA with history routing app:// plus an explicit fallback rule the scheme only provides the place; the rule is yours to write
Frontend and backend share a data contract frontend build as a build-graph edge human ordering does not hold artefacts consistent
Continuous real-time stream per-channel health model one frame's age cannot separate backlog from delay
Zero can be a legitimate value explicit presence flag a value doubling as a sentinel swallows a real 0
Medical data going outbound string-layer folding plus key allowlist a denylist never catches up

Not a list of concessions, but the same thing read from both sides: where the left column does not hold, the right-hand machinery buys nothing but complexity.

A few lines should not be crossed even when the premises hold, because crossing them turns a trade-off into an error. First, the direction of de-identification: isAllowedLumeKey states that the outbound payload keeps only fields needed for audit and timing, and drops unknown ones rather than passing them by default — a missing field costs less than PHI leaving the machine, so "pass by default plus a denylist" swaps defense in depth for a single point. The same holds for rule order inside scrubText: reverse it and half a path survives. Second, clock sources stay separate: the volume channel's tsUs is host-side time, and merging it "for cleaner handling" turns the age on the dashboard into a fake number. Third, retention cleanup must not be treated as on by default: prunePacsStoreIfConfigured returns early when the environment variable is empty or non-positive (if (env.isEmpty()) return; and if (days <= 0) return;, src/bridge.cpp:25 through :29), and removing that check turns "deletes nothing by default" into "deletes by default".

Fourth, process uniqueness. The data directory and the volume-rendering preferences both assume a single writer; refusing a second instance is not fastidiousness but a guard against two processes overwriting the same files. QLockFile was not used casually here: its staleness test reads file age and process liveness together, and setting staleLockTime to 0 turns the liveness check off with it, so after a kill -9 the app can no longer start at all (the comment at src/main.cpp:35 through :41 spells out that trade-off). The lock is taken with O_CREAT | O_EXCL and the process writes its own pid into it; an expired lock is resolved purely on PID liveness:

    // 持有者还活着(EPERM 说明进程存在但属于别人)→ 拒绝启动。
    if (pid > 0 && (::kill(static_cast<pid_t>(pid), 0) == 0 || errno == EPERM)) {
        if (holderPid) *holderPid = pid;
        return false;
    }
    // 死进程留下的锁:清掉,下一轮重新用 O_EXCL 抢。
    QFile::remove(path);

Excerpt, src/main.cpp:57 through :63; the function starts at :42, the comment sits at :35 through :41.

To check where those boundaries sit, the cheapest route is to run the replacements before and after with the repository's own targets:

make all          # full build (frontend + C++), see Makefile:37
make bridge_test  # bridge layer only, see Makefile:195
make cpp          # configure + compile C++, frontend synced, see Makefile:8
make frontend     # frontend only (artifacts → resources/web), see Makefile:7
make clean        # clean build and frontend artifacts, see Makefile:86

The difference is not line length on the command line: the former needs a human to guarantee order, the latter has the build graph guarantee it.

One last line: counterintuitive does not mean universally true. The default path is right inside its intersection, and this set of replacements is right inside its premises; engineering judgment is never about which road is more advanced, but about which intersection the project is standing in.

Source code navigation

Repository: https://github.com/erishen/lume-qt

  • Makefile
  • CMakeLists.txt
  • frontend/public/qwebchannel.js
  • frontend/src/latency.ts
  • src/main.cpp
  • src/dicomreader.cpp
  • src/lumesink.cpp
  • src/bridge.cpp
  • tools/lume-medmon/app.lume

Why not load the packaged frontend directly from file://?

file:// has no server-side fallback: a deep-link refresh under history routing lands on an empty path, and packaged assets referenced by an absolute root path do not resolve. As soon as the page needs SPA routing or a custom cache policy, this road stops working, so lume-qt serves the page through the custom app:// scheme instead.

Why can't link health be judged from a single frame's age?

QWebChannel may merge several signals into one delivery when the render process is busy, and looking only at one frame’s age mistakes “batch queueing” for “a slow link”. latency.ts uses ChannelHealth‘s ageMs and staleAfterMs to detect interruption, and BatchSeries‘s samples and gaps to separate real delay from backlog, see frontend/src/latency.ts:146.

What happens when a DICOM rescale slope cannot be read?

DCMTK’s findAndGetFloat64 writes 0 into the output when the tag is missing, so an MR series without a Rescale tag gets slope=0 and the whole volume turns all-zero. lume-qt falls back to the initial value set by the caller, and carries “missing” as a separate state instead of letting 0 double as a sentinel, see src/dicomreader.cpp:33.

When should the default path be kept?

For apps that hold up with a single page, no routing, low-frequency bridging, clean data, and a single instance by agreement, the default path is still the simplest answer; a custom scheme, build-chain sync, and a per-channel health model are prices paid for specific constraints, and without those constraints a replacement is just extra code.

Comments

Leave a reply

Your email address will not be published. Required fields are marked *

AI Engineering Practices & Open Source Projects

Shop Web Chat Nsbp About Privacy

@ 2026 ESN
沪ICP备2024079226号-1   沪公网安备31010502007082号