@volter/twin-standard 1.0.157 → 1.0.159

package/dist/src/assessment.d.ts

@@ -23,6 +23,7 @@ export declare function assessPack(packDir: string, options?: AssessmentOptions)
         }[];
         replay: {
             equal: boolean;
+            diagnostics: string[];
             runs: number;
             firstSha256: string;
             secondSha256: string;
@@ -53,7 +54,7 @@ export declare function assessPack(packDir: string, options?: AssessmentOptions)
         };
         at: string;
         retentionNotApplicable?: string | undefined;
-        measured: boolean;
+        measured: true;
         passed: boolean;
         scope: string;
         package: any;
@@ -74,6 +75,15 @@ export declare function assessPack(packDir: string, options?: AssessmentOptions)
                 package: string;
                 version: string;
             };
+            peers: {
+                package: string;
+                version: string;
+            }[];
+            sdks: {
+                package: string;
+                version: string;
+                entry: string;
+            }[];
             dependencyLockSha256: string;
             appLocal: boolean;
         };
@@ -103,8 +113,8 @@ export declare function assessPack(packDir: string, options?: AssessmentOptions)
             mode: string;
         };
     } | {
-        measured: boolean;
-        passed: boolean;
+        measured: false;
+        passed: false;
         failures: string[];
     };
     integrity?: string | undefined;

package/dist/src/assessment.js

@@ -16,6 +16,7 @@ import { conformance } from "./conformance.js";
 import { inMemoryWorld, walk, withPinnedWorldDraws, usePacks } from "./walk/behavior-journey.js";
 import { compilePackFacts } from "./pack-facts.js";
 import { expandFills } from "./walk/journey-kit.js";
+import { compareReplays } from "./walk/replay.js";
 import { runConsumerWorkflow } from "./consumer.js";
 const canonical = (value) => value && typeof value === 'object' ? Array.isArray(value) ? value.map(canonical) : Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)])) : value;
 const json = (value) => JSON.stringify(canonical(value));
@@ -73,7 +74,8 @@ export async function assessPack(packDir, options = {}) {
     const coverageOf = (result) => !instrumented || result.ambiguous ? null : { total: declared.length, exercised: result.exercised.length, percent: 100 * result.exercised.length / declared.length, operations: result.exercised, missing: declared.filter((id) => !result.exercised.includes(id)) };
     async function replay(served) {
         const world = inMemoryWorld('catalog-replay');
-        const failures = [], trace = [];
+        const failures = [];
+        const trace = [];
         const exercised = new Set();
         const signatures = new WeakMap();
         let ambiguous = false;
@@ -94,7 +96,7 @@ export async function assessPack(packDir, options = {}) {
             exercised.add(id);
         });
         try {
-            await withPinnedWorldDraws(() => walk(structuredClone(life), world.root(), failures, { beats: true, ...(served ? { served } : {}), hooks: { after: (step, path, answer) => trace.push({ name: step.name ?? '', path, status: answer.status, body: answer.body }) } }));
+            await withPinnedWorldDraws(() => walk(structuredClone(life), world.root(), failures, { beats: true, ...(served ? { served } : {}), hooks: { after: (step, path, answer) => trace.push({ name: step.name ?? '', path, status: answer.status, body: answer.body, ...(answer.sql ? { sql: answer.sql } : {}), ...(answer.connection ? { connection: answer.connection } : {}) }) } }));
             return { failures, trace, exercised: [...exercised].sort(), ambiguous };
         }
         finally {
@@ -103,9 +105,10 @@ export async function assessPack(packDir, options = {}) {
         }
     }
     const first = await replay(), second = await replay();
-    const replayEqual = first.trace.length > 0 && json(first.trace) === json(second.trace);
+    const comparison = compareReplays(first.trace, second.trace);
+    const replayEqual = comparison.equal;
     const coverage = coverageOf(first);
-    const quick = { scope: 'packaged-customer-journey; in-process', steps: life.steps.length, answered: first.trace.length, failures: [...first.failures, ...second.failures], replay: { equal: replayEqual, runs: 2, firstSha256: hash(first.trace), secondSha256: hash(second.trace) }, operationCoverage: coverage, servedOperations, surface: owners ? { total: declared.length, served: servedOperations.length, gap: declared.length - servedOperations.length } : null, codeCoverage: null, stateTransitionCoverage: null };
+    const quick = { scope: 'packaged-customer-journey; in-process', steps: life.steps.length, answered: first.trace.length, failures: [...first.failures, ...second.failures], replay: { equal: replayEqual, diagnostics: comparison.diagnostics, runs: 2, firstSha256: hash(first.trace), secondSha256: hash(second.trace) }, operationCoverage: coverage, servedOperations, surface: owners ? { total: declared.length, served: servedOperations.length, gap: declared.length - servedOperations.length } : null, codeCoverage: null, stateTransitionCoverage: null };
     let browser = { measured: false, reason: options.browser ? 'Journey has a wire Chromium fetch cannot exercise' : 'Browser target not requested' };
     const httpOnly = life.steps.every((step) => 'method' in step || 'wait' in step);
     if (options.browser && httpOnly) {
@@ -113,13 +116,13 @@ export async function assessPack(packDir, options = {}) {
         const transport = await chromiumServed(packDir, life.host ?? 'twin.local', 'http-journey');
         try {
             const a = await replay(transport.served), b = await replay(transport.served);
-            browser = { measured: true, target: 'HTTP customer journey replay through Chromium at each request origin; authored HTTP headers and observed wire responses', responseObservation: 'Transport observes status, headers and body, including redirects and Set-Cookie; these are not JavaScript-visible response claims', applicationOriginCorsCoverage: null, cookieJarCoverage: null, version: transport.version, answered: a.trace.length, failures: [...a.failures, ...b.failures], replay: { equal: a.trace.length > 0 && json(a.trace) === json(b.trace), firstSha256: hash(a.trace), secondSha256: hash(b.trace), runs: 2 }, operationCoverage: coverageOf(a), domCoverage: null, clock: transport.clock };
+            const compared = compareReplays(a.trace, b.trace);
+            browser = { measured: true, target: 'HTTP customer journey replay through Chromium at each request origin; authored HTTP headers and observed wire responses', responseObservation: 'Transport observes status, headers and body, including redirects and Set-Cookie; these are not JavaScript-visible response claims', applicationOriginCorsCoverage: null, cookieJarCoverage: null, version: transport.version, answered: a.trace.length, failures: [...a.failures, ...b.failures], replay: { equal: compared.equal, diagnostics: compared.diagnostics, firstSha256: hash(a.trace), secondSha256: hash(b.trace), runs: 2 }, operationCoverage: coverageOf(a), domCoverage: null, clock: transport.clock };
         }
         finally {
             await transport.stop();
         }
     }
-    const conform = options.conformance === false ? null : await conformance(packDir);
     let consumer;
     try {
         consumer = options.consumer ? await runConsumerWorkflow(packDir, options.consumer) : { measured: false, passed: false, failures: ['Installed customer workflow was not prepared'] };
@@ -127,6 +130,7 @@ export async function assessPack(packDir, options = {}) {
     catch (error) {
         consumer = { measured: false, passed: false, failures: [error.message] };
     }
+    const conform = options.conformance === false ? null : await conformance(packDir, consumer.measured ? { consumer } : {});
     const ready = gates.length > 0 && gates.every((gate) => !gate.failures.length) && !quick.failures.length && replayEqual && conform !== null && conform.length > 0 && conform.every((result) => !result.failures.length) && consumer.measured && consumer.passed && (!options.browser || !httpOnly || browser.measured === true && browser.failures.length === 0 && browser.replay.equal);
     // the artifact assessed, by the integrity its prepared consumer verified the installed candidate against (consumer.ts)
     return { schemaVersion: 1, vendor, package: manifest.name, version: manifest.version, ...(consumer.integrity ? { integrity: consumer.integrity } : {}), ready, gates: gates.map((gate) => ({ ...gate, unit: gate.unit === packDir ? vendor : `${vendor}/${gate.unit.slice(packDir.length + 1)}` })), quick, browser, conformance: conform, consumer };

package/dist/src/browser-assessment.js

@@ -1,20 +1,12 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 // Browser transport for the existing journey engine. A container supplies network isolation in catalog execution.
 import { join } from 'node:path';
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { worldNow } from '@volter/world-core/runtime';
+import { packFetch } from "./walk/vendor-fetch.js";
 export async function chromiumServed(packDir, host, mode = 'browser-fetch') {
     const { chromium } = await import('playwright');
-    const mod = await import(__rewriteRelativeImportExtension(join(packDir, 'src/index.ts')));
-    const factory = Object.entries(mod).find(([name, value]) => /^create\w+Fetch$/.test(name) && !/TwinFetch$/.test(name) && typeof value === 'function')?.[1];
+    const factory = await packFetch(packDir);
     if (!factory)
         throw new Error('Browser assessment needs the pack HTTP fetch factory');
     const library = ['/usr/lib/x86_64-linux-gnu/faketime/libfaketimeMT.so.1', '/usr/lib/aarch64-linux-gnu/faketime/libfaketimeMT.so.1'].find(existsSync);
@@ -41,7 +33,7 @@ export async function chromiumServed(packDir, host, mode = 'browser-fetch') {
     }
     const served = async (root, options) => {
         syncClock();
-        const fetchPack = factory({ root, ...options });
+        const fetchPack = factory(root, options);
         const context = await browser.newContext({ serviceWorkers: 'block', locale: 'en-US', timezoneId: 'UTC' });
         const pages = [];
         const pending = new Map();
@@ -96,7 +88,7 @@ export async function chromiumServed(packDir, host, mode = 'browser-fetch') {
         };
         return {
             scheme: 'https',
-            fetch: async (request, options) => {
+            fetch: Object.assign(async (request, options) => {
                 const entry = await acquire(mode === 'http-journey' ? new URL(request.url).origin : `https://${host}`);
                 const { page } = entry;
                 const observation = { request };
@@ -128,8 +120,19 @@ export async function chromiumServed(packDir, host, mode = 'browser-fetch') {
                     pending.delete(page);
                     entry.busy = false;
                 }
+            }, {
+                managedDatabaseUrl: fetchPack.managedDatabaseUrl,
+                managedDatabaseClock: fetchPack.managedDatabaseClock,
+                managedDatabaseConnection: fetchPack.managedDatabaseConnection,
+            }),
+            stop: async () => {
+                try {
+                    await context.close();
+                }
+                finally {
+                    await fetchPack.stopDatabase?.();
+                }
             },
-            stop: () => context.close(),
         };
     };
     return { served, version: browser.version(), clock: { native: 'World time through libfaketime', nativePrecisionMs: 1000, javascriptPrecisionMs: 1, monotonic: 'elapsed machine time' }, stop: async () => { try {

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

@@ -30,10 +30,31 @@ export type ClientCase = {
 /** The World's proxy in front of a pack served on `served`: it ends the caller's TLS (here, none was begun) and forwards
  *  each request and socket upgrade to the pack with `x-forwarded-proto: https`, the vendor's Host unchanged, as a World's
  *  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. */
+ *  answers are then the vendor's secure ones). Its stop settles every connection it opened. */
+export declare function worldProxy(served: number, observe?: (request: {
+    url: string;
+    headers: Headers;
+}, answer: {
+    status: number;
+}) => void): Promise<{
+    port: number;
+    stop: () => Promise<void>;
+}>;
+/** A served socket either opens within its five-second handshake or closes under the same owner. */
+export declare function openWebSocket(socket: WebSocket): Promise<boolean>;
+/** One request and its complete body share the check's ten-second lifetime, including caller cancellation. */
+export declare function readHttpResponse(fetcher: (request: Request) => Promise<Response>, request: Request): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    text: string;
+    bodyBytes: Uint8Array;
+    bodyError?: {
+        message: string;
+        cancelled: boolean;
+    };
+}>;
+/** HTTP to a served pack, with the vendor Host and manual redirects. Headers resolve before the streamed body;
+ * its caller's abort signal owns the fresh connection until the body ends or is cancelled. */
 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). */
 /** `raw`: a raw protocol's served port (SMTP's listener), which a connection reaches directly, as a World passes a raw TCP

package/dist/src/clients/harness.js

@@ -11,16 +11,38 @@ import { writeFileSync } from 'node:fs';
 /** The World's proxy in front of a pack served on `served`: it ends the caller's TLS (here, none was begun) and forwards
  *  each request and socket upgrade to the pack with `x-forwarded-proto: https`, the vendor's Host unchanged, as a World's
  *  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 async function worldProxy(served) {
+ *  answers are then the vendor's secure ones). Its stop settles every connection it opened. */
+export async function worldProxy(served, observe) {
+    const sockets = new Set();
+    const requests = new Set();
+    const track = (socket) => { if (sockets.has(socket))
+        return; sockets.add(socket); socket.once('close', () => sockets.delete(socket)); };
     const server = createServer((req, res) => {
         const forward = httpRequest({ host: '127.0.0.1', port: served, method: req.method, path: req.url, headers: { ...req.headers, 'x-forwarded-proto': 'https' } }, (answer) => {
+            if (observe) {
+                answer.on('end', () => {
+                    const headers = new Headers();
+                    for (const [name, value] of Object.entries(req.headers))
+                        if (value !== undefined)
+                            for (const one of Array.isArray(value) ? value : [value])
+                                headers.append(name, one);
+                    observe({ url: `https://${headers.get('x-volter-twin-original-host') ?? headers.get('host')}${req.url}`, headers }, { status: answer.statusCode ?? 502 });
+                });
+            }
+            answer.on('error', () => res.destroy());
             res.writeHead(answer.statusCode ?? 502, answer.headers);
             answer.pipe(res);
         });
-        forward.on('error', () => { res.writeHead(502); res.end(); });
+        requests.add(forward);
+        forward.once('close', () => requests.delete(forward));
+        forward.on('error', () => { if (!res.headersSent)
+            res.writeHead(502); res.end(); });
+        forward.on('socket', track);
+        req.on('aborted', () => forward.destroy());
+        res.on('close', () => forward.destroy());
         req.pipe(forward);
     });
+    server.on('connection', track);
     server.on('upgrade', (req, socket, head) => {
         const upstream = connect(served, '127.0.0.1', () => {
             const lines = [`${req.method} ${req.url} HTTP/1.1`, ...Object.entries({ ...req.headers, 'x-forwarded-proto': 'https' }).flatMap(([k, v]) => (Array.isArray(v) ? v : [v]).map((x) => `${k}: ${x}`)), '', ''];
@@ -30,15 +52,115 @@ export async function worldProxy(served) {
             upstream.pipe(socket);
             socket.pipe(upstream);
         });
+        track(upstream);
         upstream.on('error', () => socket.destroy());
         socket.on('error', () => upstream.destroy());
+        socket.on('close', () => upstream.destroy());
+    });
+    await new Promise((done, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => { server.off('error', reject); done(); });
     });
-    await new Promise((r) => server.listen(0, '127.0.0.1', () => r()));
     server.unref();
-    return server.address().port;
+    let stopping;
+    return {
+        port: server.address().port,
+        stop: () => stopping ??= (async () => {
+            const closed = new Promise((done, reject) => server.close((error) => error ? reject(error) : done()));
+            const pending = [...requests].map((request) => new Promise((done) => { request.once('close', () => done()); request.destroy(); }));
+            const connections = [...sockets].map((socket) => new Promise((done) => { socket.once('close', () => done()); socket.destroy(); }));
+            await Promise.all([closed, ...pending, ...connections]);
+        })(),
+    };
 }
-/** 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. */
+/** A served socket either opens within its five-second handshake or closes under the same owner. */
+export function openWebSocket(socket) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (opened) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.removeEventListener('open', openedSocket);
+            socket.removeEventListener('error', failed);
+            socket.removeEventListener('close', failed);
+            try {
+                if (!opened)
+                    socket.close();
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            resolve(opened);
+        };
+        const openedSocket = () => finish(true);
+        const failed = () => finish(false);
+        const timer = setTimeout(failed, 5000);
+        socket.addEventListener('open', openedSocket, { once: true });
+        socket.addEventListener('error', failed, { once: true });
+        socket.addEventListener('close', failed, { once: true });
+    });
+}
+/** One request and its complete body share the check's ten-second lifetime, including caller cancellation. */
+export async function readHttpResponse(fetcher, request) {
+    request.signal.throwIfAborted();
+    const abort = new AbortController();
+    const signal = AbortSignal.any([request.signal, abort.signal]);
+    const timer = setTimeout(() => abort.abort(new DOMException('request exceeded 10 s', 'TimeoutError')), 10_000);
+    let cancel;
+    const interrupted = new Promise((_, reject) => {
+        cancel = () => reject(signal.reason);
+        signal.addEventListener('abort', cancel, { once: true });
+        if (signal.aborted)
+            cancel();
+    });
+    let reader;
+    try {
+        const arriving = fetcher(new Request(request, { signal })).then((response) => {
+            if (signal.aborted)
+                void response.body?.cancel(signal.reason).catch(() => undefined);
+            return response;
+        });
+        const response = await Promise.race([arriving, interrupted]);
+        reader = response.body?.getReader();
+        const chunks = [];
+        let size = 0;
+        let bodyError;
+        try {
+            if (reader)
+                for (;;) {
+                    const chunk = await Promise.race([reader.read(), interrupted]);
+                    if (chunk.done)
+                        break;
+                    chunks.push(chunk.value);
+                    size += chunk.value.byteLength;
+                }
+        }
+        catch (error) {
+            bodyError = { message: String(error), cancelled: signal.aborted || error instanceof Error && ['AbortError', 'TimeoutError'].includes(error.name) };
+            void reader?.cancel(error).catch(() => undefined);
+        }
+        const bodyBytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bodyBytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        const cookies = response.headers.getSetCookie();
+        return { status: response.status, headers: { ...Object.fromEntries(response.headers), ...(cookies.length ? { 'set-cookie': cookies.join(', ') } : {}) },
+            text: new TextDecoder().decode(bodyBytes), bodyBytes, ...(bodyError ? { bodyError } : {}) };
+    }
+    finally {
+        clearTimeout(timer);
+        if (cancel)
+            signal.removeEventListener('abort', cancel);
+        reader?.releaseLock();
+    }
+}
+/** HTTP to a served pack, with the vendor Host and manual redirects. Headers resolve before the streamed body;
+ * its caller's abort signal owns the fresh connection until the body ends or is cancelled. */
 export function servedHttpFetch(port) {
     return (async (input, init) => {
         const request = new Request(input, init);
@@ -49,28 +171,68 @@ export function servedHttpFetch(port) {
         const signal = init?.signal ?? (input instanceof Request ? input.signal : request.signal);
         return new Promise((resolve, reject) => {
             const cleanup = () => signal.removeEventListener('abort', abort);
-            const failed = (error) => { cleanup(); reject(error); };
+            let responseFailed;
+            const failed = (error) => { cleanup(); if (responseFailed)
+                responseFailed(error);
+            else
+                reject(error); };
             const sent = httpRequest({ host: '127.0.0.1', port, method: request.method, path: `${url.pathname}${url.search}`, headers, agent: false }, (res) => {
+                res.pause();
+                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);
                 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);
-                    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 }));
+                let controller;
+                let ended = false, cancelled = false, bodyError;
+                const pump = () => {
+                    if (cancelled)
+                        return;
+                    while (chunks.length && (controller.desiredSize ?? 0) > 0)
+                        controller.enqueue(chunks.shift());
+                    if (chunks.length || (controller.desiredSize ?? 0) <= 0) {
+                        res.pause();
+                        return;
                     }
-                    catch (error) {
-                        reject(error);
+                    // Do not error until the reader has taken queued bytes: an errored web stream discards its queue.
+                    if (bodyError) {
+                        cancelled = true;
+                        controller.error(bodyError);
                     }
+                    else if (ended) {
+                        cancelled = true;
+                        controller.close();
+                    }
+                    else
+                        res.resume();
+                };
+                const body = new ReadableStream({
+                    start(value) { controller = value; },
+                    pull() { pump(); },
+                    cancel() { cancelled = true; chunks.length = 0; cleanup(); res.destroy(); sent.destroy(); },
                 });
-                res.on('error', failed);
+                responseFailed = (error) => { bodyError ??= error; cleanup(); pump(); };
+                res.on('data', (chunk) => { chunks.push(chunk); pump(); });
+                res.on('end', () => { ended = true; cleanup(); pump(); });
+                res.on('error', responseFailed);
+                res.on('close', () => { if (!res.complete && !cancelled)
+                    responseFailed(new Error('HTTP response closed before completion')); });
+                const noBody = request.method === 'HEAD' || res.statusCode === 204 || res.statusCode === 205 || res.statusCode === 304;
+                try {
+                    resolve(new Response(noBody ? null : body, { status: res.statusCode ?? 0, headers: answer }));
+                    if (noBody)
+                        res.resume();
+                }
+                catch (error) {
+                    cancelled = true;
+                    cleanup();
+                    res.destroy();
+                    reject(error);
+                }
             });
             const abort = () => {
-                const error = new Error('served HTTP request aborted');
+                const error = signal.reason instanceof Error ? signal.reason : new Error('served HTTP request aborted');
                 sent.destroy(error);
                 failed(error);
             };

package/dist/src/clients/jira.js

@@ -1,3 +1,14 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { standardPackageFile } from "../package-file.js";
+const { importSdk } = await import(__rewriteRelativeImportExtension(new URL('import.mjs', standardPackageFile('client-sdks/')).href));
+const { Version3Client, HttpException } = await importSdk('jira.js');
 const README = 'https://www.npmjs.com/package/jira.js/v/5.4.0';
 const CREATE = 'https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-rest-api-3-issue-post';
 const ADF = 'https://developer.atlassian.com/cloud/jira/platform/apis/document/structure/';
@@ -12,7 +23,6 @@ async function site(c, slug, apiToken) {
     const email = `admin@${slug}.example`;
     const made = await door('/_twin/sites', { name: slug, admin: { name: 'Admin', email, password: 'sdk-case-2026' } });
     const token = apiToken ?? (await door('/_twin/api-token', { site: slug, email, password: 'sdk-case-2026' })).apiToken;
-    const { Version3Client } = await import('jira.js');
     const jira = new Version3Client({ host: `https://${slug}.atlassian.net`, authentication: { basic: { email, apiToken: token } }, baseRequestConfig: { httpsAgent: c.agent } });
     return { jira, admin: made.admin };
 }
@@ -55,7 +65,6 @@ export const cases = [
         asks: 'a request with an API token the account never made is refused, and the client throws its HttpException carrying the status',
         source: `${README} "\`HttpException\`: Server responded with an error (includes parsed error details)"`,
         async run(c) {
-            const { HttpException } = await import('jira.js');
             const { jira } = await site(c, 'sdk-refused', 'ATATT-not-a-token-this-account-made');
             try {
                 await jira.projects.searchProjects({ maxResults: 50 });

package/dist/src/clients/run.js

@@ -20,19 +20,24 @@ if (!Array.isArray(cases) || cases.length === 0)
     throw new Error(`${job.vendor} client module declares no cases; there is no SDK execution evidence`);
 // every connection a case makes goes through the World's proxy, as an application's does in a World
 const proxy = await worldProxy(job.port);
-// Bind only this artifact's declared vendor hosts to the assessed server. The enclosing World's
-// injector stays active, and untwinned destinations keep its refusal policy.
-const require = createRequire(import.meta.url);
-require('@volter/world-core/pack-facts').extendPackFacts([job.packFacts]);
-const facts = JSON.parse(readFileSync(job.packFacts, 'utf8')).packs[job.vendor];
-const keys = [...new Set((facts.hosts ?? []).map((rule) => rule.key ?? job.vendor))];
-require('@volter/world-core/inject').install(Object.fromEntries(keys.map((key) => [key, `http://127.0.0.1:${proxy}`])));
-const context = clientContext(proxy, job.host, job.env, job.scenarioPath, job.raw ? job.port : undefined);
-for (const c of cases) {
-    const failures = await Promise.race([
-        c.run(context).catch((e) => [`the case threw: ${e.message}`]),
-        new Promise((r) => setTimeout(() => r(['no outcome in 30 s']), 30_000)),
-    ]);
-    process.stdout.write(`${JSON.stringify({ id: c.id, asks: c.asks, failures })}\n`);
+try {
+    // Bind only this artifact's declared vendor hosts to the assessed server. The enclosing World's
+    // injector stays active, and untwinned destinations keep its refusal policy.
+    const require = createRequire(import.meta.url);
+    require('@volter/world-core/pack-facts').extendPackFacts([job.packFacts]);
+    const facts = JSON.parse(readFileSync(job.packFacts, 'utf8')).packs[job.vendor];
+    const keys = [...new Set((facts.hosts ?? []).map((rule) => rule.key ?? job.vendor))];
+    require('@volter/world-core/inject').install(Object.fromEntries(keys.map((key) => [key, `http://127.0.0.1:${proxy.port}`])));
+    const context = clientContext(proxy.port, job.host, job.env, job.scenarioPath, job.raw ? job.port : undefined);
+    for (const c of cases) {
+        const failures = await Promise.race([
+            c.run(context).catch((e) => [`the case threw: ${e.message}`]),
+            new Promise((r) => setTimeout(() => r(['no outcome in 30 s']), 30_000)),
+        ]);
+        process.stdout.write(`${JSON.stringify({ id: c.id, asks: c.asks, failures })}\n`);
+    }
+}
+finally {
+    await proxy.stop();
 }
 process.exit(0);

package/dist/src/clients/tinybird.js

@@ -1,6 +1,16 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { standardPackageFile } from "../package-file.js";
+const { importSdk } = await import(__rewriteRelativeImportExtension(new URL('import.mjs', standardPackageFile('client-sdks/')).href));
+const { createTinybirdApi, TinybirdApiError } = await importSdk('@tinybirdco/sdk/api');
 const SDK = 'https://unpkg.com/@tinybirdco/sdk@0.0.84/src/api/api.ts';
-async function client(c, fetch = c.fetch) {
-    const { createTinybirdApi } = await import('@tinybirdco/sdk/api');
+function client(c, fetch = c.fetch) {
     return createTinybirdApi({ baseUrl: `https://${c.host}`, token: c.env.TINYBIRD_API_KEY ?? c.env.TINYBIRD_TOKEN ?? '', fetch });
 }
 export const cases = [
@@ -9,8 +19,7 @@ export const cases = [
         asks: 'a request token override is used instead of the Workspace token, and its refusal retains the status and JSON error in TinybirdApiError',
         source: `${SDK} "Error thrown by TinybirdApi when a response is not OK"`,
         async run(c) {
-            const { TinybirdApiError } = await import('@tinybirdco/sdk/api');
-            const api = await client(c);
+            const api = client(c);
             try {
                 await api.ingest('client_case_events', { label: 'refused' }, { token: 'throwaway-invalid-token' });
                 return ['the invalid request token was accepted'];
@@ -36,7 +45,7 @@ export const cases = [
         async run(c) {
             let calls = 0;
             const routed = ((input, init) => { calls++; return c.fetch(input, init); });
-            const api = await client(c, routed);
+            const api = client(c, routed);
             try {
                 await api.ingest('client_case_events', { timestamp: new Date('2024-01-15T10:30:00Z') });
                 return ['a Date object was accepted for ingestion'];
@@ -60,7 +69,7 @@ export const cases = [
         asks: 'an object query parameter becomes JSON and the Endpoint uses its value rather than the object string representation',
         source: `${SDK} "Plain objects (e.g. p.json() params) become JSON strings; Dates are rejected;"`,
         async run(c) {
-            const api = await client(c);
+            const api = client(c);
             await api.requestJson('/v0/datasources', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ name: 'client_json_rows', schema: 'name String' }).toString() });
             await api.ingestBatch('client_json_rows', [{ name: 'selected' }, { name: 'excluded' }], { wait: true });
             await api.requestJson('/v0/pipes', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name: 'client_json_filter', nodes: [{ name: 'endpoint', type: 'endpoint', sql: "%\nSELECT name FROM client_json_rows WHERE name = {{JSON(filters, '{\"name\":\"selected\"}').get('name')}}" }] }) });

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

@@ -0,0 +1,2 @@
+import type { ClientCase } from './harness.js';
+export declare const cases: ClientCase[];