@telorun/http-server 0.18.0 → 0.18.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @telorun/http-server
 
+## 0.18.1
+
+### Patch Changes
+
+- 8a9b494: Inbound dispatch now goes through `ctx.rootContext()` — the route handler, the
+  `notFoundHandler`, and a `contentTypeParsers` parser all receive a context
+  minted for the request rather than whatever was ambient when the route was
+  registered.
+
+  No behaviour changes for an app today: a route handler already ran on a
+  per-request cancellation context, and the other two are dispatched from socket
+  callbacks where the ambient is empty anyway. What changes is that the guarantee
+  is now _stated_ rather than incidental. Execution zones (`kernel/specs/execution-zones.md`
+  §7) make it a conformance obligation on every inbound registrant, and the
+  analyzer's hard error on `trigger.inbound` edges — a zone requirement reaching
+  an HTTP route is `ZONE_REQUIREMENT_UNSATISFIED` — rests on it holding. Before,
+  it held because every shipped inbound kind happens to be a `Telo.Service`,
+  which is a property of those kinds rather than of the edge.
+
+  - @telorun/http-dispatch@0.4.2
+
 ## 0.18.0
 
 ### Minor Changes

package/README.md

@@ -27,8 +27,8 @@ Language- and framework-agnostic HTTP server for Telo. Declarative routes, schem
 kind: Telo.Application
 metadata: { name: hello-http, version: 1.0.0 }
 imports:
-  Http: std/http-server@0.19.1
-  JS: std/javascript@0.7.0
+  Http: oci://ghcr.io/telorun/http-server@0.19.1
+  JS: oci://ghcr.io/telorun/javascript@0.7.0
 targets: [ !ref Server ]
 ---
 kind: Http.Server

package/dist/http-api-controller.js

@@ -139,7 +139,10 @@ export class HttpServerApi {
                 // Open a request span rooting this request's own trace: the handler (and
                 // its nested invokes) nest under it, and it's labelled with the route so
                 // the trace shows the actual method+path, attributed to this Http.Api.
-                const span = await this.ctx.openSpan(cancellation.context, {
+                // rootContext: an inbound registrant dispatches with a context that
+                // inherits nothing ambient — no zones, no trace parent, no caller token
+                // (the conformance obligation in kernel/specs/execution-zones.md §7).
+                const span = await this.ctx.openSpan(this.ctx.rootContext({ cancellation }), {
                     ref: { kind: "Http.Api", name: this.apiName },
                     label: `${route.request.method} ${route.request.path}`,
                     attributes: { method: route.request.method, path: route.request.path },

package/dist/http-server-controller.js

@@ -77,7 +77,12 @@ class HttpServer {
             else if (parser) {
                 this.app.addContentTypeParser(contentType, { parseAs: "string" }, async (_req, body, done) => {
                     try {
-                        done(null, await parser.invoke({ body }));
+                        // The bound entry point forwards every argument, so the root
+                        // context rides in as the InvokeContext — §7's obligation for an
+                        // inbound registrant. (This path still calls the instance
+                        // directly rather than going through `invokeResolved`, so it is
+                        // untraced; that predates zones and is tracked separately.)
+                        done(null, await parser.invoke({ body }, this.ctx.rootContext()));
                     }
                     catch (err) {
                         done(err, undefined);
@@ -230,7 +235,11 @@ class HttpServer {
                 };
                 let result;
                 try {
-                    result = await this.ctx.invoke(handler.kind, handler.name, invokeInput);
+                    // rootContext: an inbound registrant dispatches with a context that
+                    // inherits nothing ambient (kernel/specs/execution-zones.md §7).
+                    result = await this.ctx.invoke(handler.kind, handler.name, invokeInput, {
+                        ctx: this.ctx.rootContext(),
+                    });
                 }
                 catch (err) {
                     if (!isInvokeError(err))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/http-server",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "Telo HTTP Server module - HTTP server and API resource kinds for Telo manifests.",
   "keywords": [
     "telo",
@@ -55,7 +55,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.60.0"
+    "@telorun/sdk": "0.67.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/http-api-controller.ts

@@ -174,7 +174,10 @@ export class HttpServerApi implements ResourceInstance {
         // Open a request span rooting this request's own trace: the handler (and
         // its nested invokes) nest under it, and it's labelled with the route so
         // the trace shows the actual method+path, attributed to this Http.Api.
-        const span = await this.ctx.openSpan(cancellation.context, {
+        // rootContext: an inbound registrant dispatches with a context that
+        // inherits nothing ambient — no zones, no trace parent, no caller token
+        // (the conformance obligation in kernel/specs/execution-zones.md §7).
+        const span = await this.ctx.openSpan(this.ctx.rootContext({ cancellation }), {
           ref: { kind: "Http.Api", name: this.apiName },
           label: `${route.request.method} ${route.request.path}`,
           attributes: { method: route.request.method, path: route.request.path },

package/src/http-server-controller.ts

@@ -159,7 +159,12 @@ class HttpServer implements ResourceInstance {
           { parseAs: "string" },
           async (_req, body, done) => {
             try {
-              done(null, await parser.invoke({ body }));
+              // The bound entry point forwards every argument, so the root
+              // context rides in as the InvokeContext — §7's obligation for an
+              // inbound registrant. (This path still calls the instance
+              // directly rather than going through `invokeResolved`, so it is
+              // untraced; that predates zones and is tracked separately.)
+              done(null, await parser.invoke({ body }, this.ctx.rootContext()));
             } catch (err) {
               done(err as Error, undefined);
             }
@@ -322,7 +327,11 @@ class HttpServer implements ResourceInstance {
 
         let result: any;
         try {
-          result = await this.ctx.invoke(handler.kind, handler.name, invokeInput);
+          // rootContext: an inbound registrant dispatches with a context that
+          // inherits nothing ambient (kernel/specs/execution-zones.md §7).
+          result = await this.ctx.invoke(handler.kind, handler.name, invokeInput, {
+            ctx: this.ctx.rootContext(),
+          });
         } catch (err) {
           if (!isInvokeError(err)) throw err;
           return dispatchCatches(

package/tests/request-cancel.test.ts

@@ -1,4 +1,9 @@
-import { ERR_INVOKE_CANCELLED, InvokeError, createCancellationSource } from "@telorun/sdk";
+import {
+  ERR_INVOKE_CANCELLED,
+  InvokeError,
+  UNCANCELLABLE_CONTEXT,
+  createCancellationSource,
+} from "@telorun/sdk";
 import Fastify from "fastify";
 import net from "node:net";
 import type { AddressInfo } from "node:net";
@@ -45,6 +50,12 @@ describe("http-server request cancellation", () => {
       ensureKindRef: () => ({ kind: "Test.Handler", name: "SlowWork" }),
       moduleContext: { expandWith: (value: unknown) => value },
       createCancellationSource: () => createCancellationSource(),
+      // As the kernel implements it: an inbound registrant dispatches through a
+      // context it minted rather than the ambient (execution-zones spec §7), and
+      // the request's cancellation token rides in on it — which is what makes
+      // the disconnect below reach the handler.
+      rootContext: (opts?: { cancellation?: { context: unknown } }) =>
+        opts?.cancellation?.context ?? UNCANCELLABLE_CONTEXT,
       invokeResolved: (_kind: string, _name: string, h: typeof handler, input: unknown, c: unknown) =>
         h.invoke(input, c as { cancellation?: any }),
       emitEvent: () => {},

package/tests/request-span.test.ts

@@ -1,4 +1,4 @@
-import { createCancellationSource } from "@telorun/sdk";
+import { UNCANCELLABLE_CONTEXT, createCancellationSource } from "@telorun/sdk";
 import Fastify from "fastify";
 import type { AddressInfo } from "node:net";
 import { describe, expect, it } from "vitest";
@@ -31,6 +31,10 @@ describe("http-server request span", () => {
       ensureKindRef: () => ({ kind: "JS.Script", name: "Echo" }),
       moduleContext: { expandWith: (value: unknown) => value },
       createCancellationSource: () => createCancellationSource(),
+      // The controller dispatches through a context it minted rather than the
+      // ambient — execution-zones spec §7 — so the mock must offer it.
+      rootContext: (opts?: { cancellation?: { context: unknown } }) =>
+        opts?.cancellation?.context ?? UNCANCELLABLE_CONTEXT,
       invokeResolved: (_kind: string, _name: string, h: typeof handler, input: unknown) =>
         h.invoke(input),
       emitEvent: () => {},