Recompiling an LPC File Over HTTP Updates the Next HTTP Response Without DGD Restart

Claim

In the eOS-Harness MVA running against DGD 1.7.9 plus the eOS-kernellib HTTP/1 platform, a POST /compile request whose body is new LPC source for /usr/Test/hello.c changes the response of the very next GET /greet from the baseline cold-boot string to the new string. The DGD process is the same process across both GET requests -- no restart, no statedump-and-reload, no operator-console intervention. The recompile is initiated from outside DGD (HTTP curl) and mediated by application LPC (compile_object(HELLO, body)); the platform's response to the compile is to update the program registry in place, and the next request that resolves "/usr/Test/hello"->greet() finds the new master and executes the new logic.

Grounds

This is an Empirical Observation. The grounds are a captured smoke sequence run 2026-05-13 against the live MVA demonstration instance.

Setup (verifiable from repo state):

Baseline hello.c (cold-boot state):

/* SPDX-License-Identifier: BSD-2-Clause-Patent */
string greet()
{
    return "Hello from eOS-Harness Test/hello.\n";
}

Boot sequence:

$ rm -f state/snapshot state/boot.log
$ <runtime-provisioning script>
$ ./bin/dgd <instance config>
...
** Initialization complete.

** Initialization complete. reached in under one second; lsof -nP -iTCP -sTCP:LISTEN shows dgd ... TCP 127.0.0.1:8023 (LISTEN) and TCP 127.0.0.1:8080 (LISTEN).

Request 1 -- baseline GET:

$ curl -i http://127.0.0.1:8080/greet
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 35
Connection: close

Hello from eOS-Harness Test/hello.

The body is the baseline string the cold-boot compilation of hello.c returned from greet(). The dispatch path is obj/server::receiveRequest -> sys/httpd::query_root_handler("greet") -> Test/sys/hello_handler::handle(GET, "greet", ...) -> "/usr/Test/hello"->greet().

Request 2 -- POST a new source body:

A new source body is staged (the precise sed-substitution used here is incidental; any LPC-equivalent change to the greet() return value would suffice):

/* SPDX-License-Identifier: BSD-2-Clause-Patent */
string greet()
{
    return "Hot-reloaded greeting from eOS-Harness.\n";
}

$ curl -i -X POST --data-binary @new-hello.c http://127.0.0.1:8080/compile
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 25
Connection: close

Compiled /usr/Test/hello

The dispatch path is obj/server::receiveRequest -> expectEntity(Content-Length) -> obj/server::receiveEntity (after the platform switches the connection to MODE_RAW and reads the body) -> Test/sys/hello_handler::handleCompile(body) -> compile_object(HELLO, body) at src/usr/Test/sys/hello_handler.c:84. The kfun compile_object(path, source) compiles the supplied source under the given runtime path, replacing the existing master object's program registry entry. The response body "Compiled /usr/Test/hello" confirms compile_object returned a non-nil object reference and the dispatcher caught no LPC error.

Request 3 -- next baseline GET:

$ curl -i http://127.0.0.1:8080/greet
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 40
Connection: close

Hot-reloaded greeting from eOS-Harness.

The body is the new string from the source posted in request 2. The dispatch path is identical to request 1 -- the dispatcher's call to "/usr/Test/hello"->greet() resolves to the same master object name, but the master's program is now the recompiled one.

Process identity check: a single DGD process served all three requests. The lsof listener PID is unchanged between request 1 and request 3; the boot log records no ** System halted. entry between them; the next ** System halted. entry appears only after the eventual SIGINT shutdown. No statedump was invoked. No operator-console session was opened.

What the evidence establishes:

What the evidence does not establish:

The empirical sequence uses sequential curl requests, not concurrent ones. The hot-reload Conviction's "in-flight operations finish with the old logic" half is not directly demonstrated by this sequence. A request that began during the compile-and-swap window might or might not finish with the old logic; this evidence does not adjudicate. Demonstrating the in-flight half would require a concurrent-request probe (issue a long-running greet() -- by changing hello.c to a call_out-deferred response -- then POST /compile while it is in flight, and observe whether the deferred response uses the version current when the call started or the version current when the call returns). The MVA's scope at authoring time did not include this concurrent-request probe; it is named here as the explicit limit of the current Empirical claim.

What Would Revise It

Sources

Relations