@volter/twin-standard 1.0.73 → 1.0.75

package/dist/src/clients/harness.d.ts

@@ -32,5 +32,8 @@ export type ClientCase = {
  *  proxy forwards a caller of the vendor's https host (twin-fetch.ts, twinPublicBase: the links and socket URLs the pack
  *  answers are then the vendor's secure ones). Answers the proxy's port. */
 export declare function worldProxy(served: number): Promise<number>;
+/** HTTP to a served pack, with the vendor Host and manual redirects. Each call owns a fresh connection;
+ * its caller's abort signal retires that request, including an unfinished response body. */
+export declare function servedHttpFetch(port: number): typeof fetch;
 /** The context for a pack reached at `port` of this machine (the World's proxy in front of it). */
 export declare function clientContext(port: number, host: string, env: Record<string, string>, scenarioPath: string): ClientContext;

package/dist/src/clients/harness.js

@@ -37,37 +37,60 @@ export async function worldProxy(served) {
     server.unref();
     return server.address().port;
 }
-/** The context for a pack reached at `port` of this machine (the World's proxy in front of it). */
-export function clientContext(port, host, env, scenarioPath) {
-    const routedFetch = (async (input, init) => {
+/** HTTP to a served pack, with the vendor Host and manual redirects. Each call owns a fresh connection;
+ * its caller's abort signal retires that request, including an unfinished response body. */
+export function servedHttpFetch(port) {
+    return (async (input, init) => {
         const request = new Request(input, init);
         const url = new URL(request.url);
         const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : Buffer.from(await request.arrayBuffer());
         const headers = Object.fromEntries(request.headers);
         headers.host = url.host;
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : request.signal);
         return new Promise((resolve, reject) => {
-            const sent = httpRequest({ host: '127.0.0.1', port, method: request.method, path: `${url.pathname}${url.search}`, headers }, (res) => {
+            const cleanup = () => signal.removeEventListener('abort', abort);
+            const failed = (error) => { cleanup(); reject(error); };
+            const sent = httpRequest({ host: '127.0.0.1', port, method: request.method, path: `${url.pathname}${url.search}`, headers, agent: false }, (res) => {
                 const chunks = [];
                 res.on('data', (c) => chunks.push(c));
                 res.on('end', () => {
+                    cleanup();
                     const answer = new Headers();
                     for (const [k, v] of Object.entries(res.headers))
                         if (v !== undefined)
                             for (const one of Array.isArray(v) ? v : [v])
                                 answer.append(k, one);
-                    resolve(new Response(res.statusCode === 204 || res.statusCode === 304 ? null : Buffer.concat(chunks), { status: res.statusCode ?? 0, headers: answer }));
+                    try {
+                        resolve(new Response(request.method === 'HEAD' || res.statusCode === 204 || res.statusCode === 205 || res.statusCode === 304 ? null : Buffer.concat(chunks), { status: res.statusCode ?? 0, headers: answer }));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
                 });
-                res.on('error', reject);
+                res.on('error', failed);
             });
-            sent.on('error', reject);
+            const abort = () => {
+                const error = new Error('served HTTP request aborted');
+                sent.destroy(error);
+                failed(error);
+            };
+            sent.on('error', failed);
+            signal.addEventListener('abort', abort, { once: true });
+            if (signal.aborted) {
+                abort();
+                return;
+            }
             sent.end(body);
         });
     });
+}
+/** The context for a pack reached at `port` of this machine (the World's proxy in front of it). */
+export function clientContext(port, host, env, scenarioPath) {
     const agent = new (class extends HttpsAgent {
         createConnection() { return connect(port, '127.0.0.1'); }
     })({ keepAlive: false });
     return {
-        host, env, fetch: routedFetch, agent,
+        host, env, fetch: servedHttpFetch(port), agent,
         connect: () => connect(port, '127.0.0.1'),
         scenario: (doc) => writeFileSync(scenarioPath, JSON.stringify(doc)),
     };

package/dist/src/conformance.js

@@ -26,6 +26,7 @@ import { tmpdir } from 'node:os';
 import { basename, dirname, extname, join, matchesGlob, relative, resolve } from 'node:path';
 import { citations, sourceHeld } from "./check-sources.js";
 import { fileURLToPath } from 'node:url';
+import { servedHttpFetch } from "./clients/harness.js";
 const pascal = (s) => s.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join('');
 const readJson = (p) => (existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : undefined);
 /** The pack's units: the pack and each lane in it (a directory with its own src/manifest.ts and no package.json). */
@@ -379,15 +380,18 @@ async function lifeServed(pack) {
                 env.VOLTER_WORLD_BOOT_ID = before;
         }
         const port = server.inspectPort ?? server.port;
+        const http = servedHttpFetch(port);
         return {
             // the vendor's URL as the application called it, sent to the served pack: its host carried in the Host header
             fetch: async (request) => {
-                const url = new URL(request.url);
-                const headers = new Headers(request.headers);
-                headers.set('host', url.host);
-                const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : await request.arrayBuffer();
-                const answer = await within(10_000, fetch(`http://127.0.0.1:${port}${url.pathname}${url.search}`, { method: request.method, headers, redirect: 'manual', keepalive: false, ...(body ? { body } : {}) }));
-                return answer === 'timeout' ? new Response(`no answer in 10 s from the served pack (${request.method} ${url.pathname})`, { status: 599 }) : answer;
+                const abort = new AbortController();
+                try {
+                    const answer = await within(10_000, http(request, { signal: abort.signal }));
+                    return answer === 'timeout' ? new Response(`no answer in 10 s from the served pack (${request.method} ${new URL(request.url).pathname})`, { status: 599 }) : answer;
+                }
+                finally {
+                    abort.abort();
+                }
             },
             // a socket opened as an application opens it: a WebSocket to the served port, the vendor's host in its Host header
             socket: (url, headers) => new WebSocket(`ws://127.0.0.1:${port}${url}`, { headers }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/twin-standard",
-  "version": "1.0.73",
+  "version": "1.0.75",
   "description": "The Protocol 3 standard for Volter twin packs: the criteria a pack is graded by, the grader, the gate a pack repository and the twin catalog run on every change and submission, and the spec derivation the grade checks against. Pin a version: every place a pack is judged judges by that standard.",
   "keywords": [
     "twin",
@@ -75,7 +75,7 @@
     "yaml": "2.9.0"
   },
   "peerDependencies": {
-    "@volter/world-core": "3.0.81",
+    "@volter/world-core": "3.0.83",
     "@volter/world-runtime": "*",
     "playwright": "^1.63.0"
   },

package/src/clients/harness.ts

@@ -67,34 +67,51 @@ export async function worldProxy(served: number): Promise<number> {
   return (server.address() as AddressInfo).port;
 }
 
-/** The context for a pack reached at `port` of this machine (the World's proxy in front of it). */
-export function clientContext(port: number, host: string, env: Record<string, string>, scenarioPath: string): ClientContext {
-  const routedFetch = (async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+/** HTTP to a served pack, with the vendor Host and manual redirects. Each call owns a fresh connection;
+ * its caller's abort signal retires that request, including an unfinished response body. */
+export function servedHttpFetch(port: number): typeof fetch {
+  return (async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
     const request = new Request(input, init);
     const url = new URL(request.url);
     const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : Buffer.from(await request.arrayBuffer());
     const headers: Record<string, string> = Object.fromEntries(request.headers);
     headers.host = url.host;
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : request.signal);
     return new Promise<Response>((resolve, reject) => {
-      const sent = httpRequest({ host: '127.0.0.1', port, method: request.method, path: `${url.pathname}${url.search}`, headers }, (res) => {
+      const cleanup = () => signal.removeEventListener('abort', abort);
+      const failed = (error: Error) => { cleanup(); reject(error); };
+      const sent = httpRequest({ host: '127.0.0.1', port, method: request.method, path: `${url.pathname}${url.search}`, headers, agent: false }, (res) => {
         const chunks: Buffer[] = [];
         res.on('data', (c: Buffer) => chunks.push(c));
         res.on('end', () => {
+          cleanup();
           const answer = new Headers();
           for (const [k, v] of Object.entries(res.headers)) if (v !== undefined) for (const one of Array.isArray(v) ? v : [v]) answer.append(k, one);
-          resolve(new Response(res.statusCode === 204 || res.statusCode === 304 ? null : Buffer.concat(chunks), { status: res.statusCode ?? 0, headers: answer }));
+          try { resolve(new Response(request.method === 'HEAD' || res.statusCode === 204 || res.statusCode === 205 || res.statusCode === 304 ? null : Buffer.concat(chunks), { status: res.statusCode ?? 0, headers: answer })); }
+          catch (error) { reject(error); }
         });
-        res.on('error', reject);
+        res.on('error', failed);
       });
-      sent.on('error', reject);
+      const abort = () => {
+        const error = new Error('served HTTP request aborted');
+        sent.destroy(error);
+        failed(error);
+      };
+      sent.on('error', failed);
+      signal.addEventListener('abort', abort, { once: true });
+      if (signal.aborted) { abort(); return; }
       sent.end(body);
     });
   }) as typeof fetch;
+}
+
+/** The context for a pack reached at `port` of this machine (the World's proxy in front of it). */
+export function clientContext(port: number, host: string, env: Record<string, string>, scenarioPath: string): ClientContext {
   const agent = new (class extends HttpsAgent {
     createConnection(): Socket { return connect(port, '127.0.0.1'); }
   })({ keepAlive: false });
   return {
-    host, env, fetch: routedFetch, agent,
+    host, env, fetch: servedHttpFetch(port), agent,
     connect: () => connect(port, '127.0.0.1'),
     scenario: (doc) => writeFileSync(scenarioPath, JSON.stringify(doc)),
   };

package/src/conformance.ts

@@ -19,6 +19,7 @@ import { basename, dirname, extname, join, matchesGlob, relative, resolve } from
 import type { TwinStream } from '@volter/world-core';
 import { citations, sourceHeld, type SourceRecord } from './check-sources.ts';
 import { fileURLToPath } from 'node:url';
+import { servedHttpFetch } from './clients/harness.ts';
 
 export type ConformanceResult = { id: string; asks: string; failures: string[]; note?: string };
 
@@ -334,15 +335,15 @@ async function lifeServed(pack: string): Promise<string[]> {
     let server: Served;
     try { server = await serve(pack, { root, ...options }); } finally { if (before === undefined) delete env.VOLTER_WORLD_BOOT_ID; else env.VOLTER_WORLD_BOOT_ID = before; }
     const port = server.inspectPort ?? server.port;
+    const http = servedHttpFetch(port);
     return {
       // the vendor's URL as the application called it, sent to the served pack: its host carried in the Host header
       fetch: async (request: Request): Promise<Response> => {
-        const url = new URL(request.url);
-        const headers = new Headers(request.headers);
-        headers.set('host', url.host);
-        const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : await request.arrayBuffer();
-        const answer = await within(10_000, fetch(`http://127.0.0.1:${port}${url.pathname}${url.search}`, { method: request.method, headers, redirect: 'manual', keepalive: false, ...(body ? { body } : {}) }));
-        return answer === 'timeout' ? new Response(`no answer in 10 s from the served pack (${request.method} ${url.pathname})`, { status: 599 }) : answer;
+        const abort = new AbortController();
+        try {
+          const answer = await within(10_000, http(request, { signal: abort.signal }));
+          return answer === 'timeout' ? new Response(`no answer in 10 s from the served pack (${request.method} ${new URL(request.url).pathname})`, { status: 599 }) : answer;
+        } finally { abort.abort(); }
       },
       // a socket opened as an application opens it: a WebSocket to the served port, the vendor's host in its Host header
       socket: (url: string, headers: Record<string, string>) => new WebSocket(`ws://127.0.0.1:${port}${url}`, { headers } as unknown as string[]),