@gfdelarue/testkit 0.3.0

package/dist/engines/node-vitest/runtime/data/scenario.js

@@ -0,0 +1,2 @@
+import{stringFromUnknown as h}from"./primitives.js";import E from"node:crypto";import F from"node:fs";import{parseRuntimeFixtureManifestEntries as M,resolveRuntimeFixtureEntry as v}from"../../../contracts/fixture-manifest.js";import{readNodeVitestRuntimeInput as N}from"../runtime-input.js";import{TestRunner as R,test as O}from"vitest";import{createDataHttpClient as V,readDataContext as C}from"./http.js";const j=/(authorization|cookie|password|secret|token|api[_-]?key|private[_-]?key)/iu,$=String,p=globalThis.__TESTKIT_DATA_FLOW_STATE__??ne();globalThis.__TESTKIT_DATA_FLOW_STATE__=p;const A=new WeakSet;export function isDataScenarioCase(e){return A.has(e)}export function dataScenario(e,t,r){const{options:n,run:s}=Q(t,r);O(e,async()=>{const i=B(e,n);p.scenarios.push(i);const c=k(i);let d=!1,w;try{await s(c)}catch(q){d=!0,w=q,i.error=ee(q)}finally{D(i)}if(d)throw w;if(i.budgetFailures.length>0)throw new Error(Y(i))},n.timeoutMs||n.timeout);const u=R.getCurrentSuite().tasks.at(-1);if(u?.type!=="test")throw new Error("dataScenario did not register a native test case");A.add(u)}export function createDataTrace(e="trace"){return k(B(e,{}))}export function measureJsonBytes(e){return Buffer.byteLength(JSON.stringify(e??null))}export function stableHash(e){const t=S(e);if(t===void 0)throw new TypeError("stableHash(...) requires a serializable value");return E.createHash("sha256").update(t).digest("hex")}function k(e){const t={...C(),addFinding(r,n,s={}){return e.findings.push({severity:X(r),message:a(n,"finding message"),details:f(s)}),t},actor(r,n={}){return m(e,"actor",r,n),t},budget(r){return T(e,r)},bytes(r,n,s={}){return t.metric(r,n,{...s,kind:"bytes",unit:s.unit||"bytes"})},count(r,n=1,s={}){return t.metric(r,n,{...s,kind:"count",unit:s.unit||"count"})},duration(r,n,s={}){return t.metric(r,n,{...s,kind:"duration",unit:s.unit||"ms"})},event(r,n={}){return e.events.push({atMs:Date.now()-e.startedAtMs,name:a(r,"event name"),details:f(n)}),t},externalCall(r,n={}){const s=g(n);return m(e,"external-call",r,s),typeof s.durationMs=="number"&&t.duration(`${r}.external.duration`,s.durationMs),typeof s.requestBytes=="number"&&t.bytes(`${r}.external.request.bytes`,s.requestBytes),typeof s.responseBytes=="number"&&t.bytes(`${r}.external.response.bytes`,s.responseBytes),typeof s.costMinor=="number"&&t.money(`${r}.external.cost`,s.costMinor),t},fixture(r){return I(r,t)},expectMetric(r){return T(e,r)},expectSequence(r){return _(e,r)},finding(r,n,s={}){return t.addFinding(r,n,s)},async http(r={}){return V({...r,recorder:r.recorder||t})},metric(r,n,s={}){return H(e,r,n,s),t},money(r,n,s={}){return t.metric(r,n,{...s,kind:"money",unit:s.unit||"minor"})},ratio(r,n,s={}){return t.metric(r,n,{...s,kind:"ratio",unit:s.unit||"ratio"})},reconcile(r,n={}){return m(e,"reconciliation",r,n),t},record(r,n={}){const s=g(n);return m(e,"record",r,s),typeof s.count=="number"&&t.count(`${r}.record.count`,s.count),t},recordCache(r,{hits:n=0,misses:s=0,reads:u=0,writes:i=0}={}){const c=a(r,"cache metric name");t.count(`${c}.cache.hits`,n),t.count(`${c}.cache.misses`,s),t.count(`${c}.cache.reads`,u),t.count(`${c}.cache.writes`,i);const d=n+s;return d>0&&t.ratio(`${c}.cache.hit_rate`,n/d),t},recordHttpRequest(r){return t.count("http.request.count",1),t.bytes("http.request.bytes",r.bodyBytes||0),t.bytes("http.response.bytes",r.responseBytes||0),t.duration("http.request.duration",r.durationMs||0),t.sequence("http.methods",[r.method]),t.sequence("http.paths",[r.path]),t.event("http.request",{durationMs:r.durationMs||0,method:r.method,path:r.path,requestBytes:r.bodyBytes||0,responseBytes:r.responseBytes||0,status:r.status}),t},recordLlmUsage(r,n={}){const s=a(r,"llm usage name");for(const[u,i]of Object.entries(n))typeof i=="number"&&Number.isFinite(i)&&t.count(`${s}.${re(u)}`,i,{unit:u.toLowerCase().includes("cost")?"minor":"tokens"});return t},recordRpc(r,{method:n,requestBytes:s=0,responseBytes:u=0}={}){const i=a(r,"rpc metric name");return t.count(`${i}.rpc.count`,1),n&&t.sequence(`${i}.rpc.methods`,[n]),t.bytes(`${i}.rpc.request.bytes`,s),t.bytes(`${i}.rpc.response.bytes`,u),t},sequence(r,n,s={}){return P(e,r,n,s),t},sequenceBudget(r){return _(e,r)},system(r,n={}){return m(e,"system",r,n),t},transition(r,n={}){return m(e,"transition",r,n),t}};return Object.freeze(t)}function I(e,t=null){const r=L(e),n=F.readFileSync(r.absolutePath);return t?.count("fixture.count",1,{dimensions:{path:r.path}}),t?.bytes("fixture.bytes",n.byteLength,{dimensions:{path:r.path}}),{buffer(){return Buffer.from(n)},contentType:r.contentType,filename:r.filename,json(){return JSON.parse(n.toString("utf8"))},path:r.path,sha256:r.sha256,sizeBytes:r.sizeBytes,text(s="utf8"){return n.toString(s)}}}function L(e){const t=a(e,"fixture name"),r=J();return v(r.entries,t)}function J(){const e=N();return e===null?{entries:[]}:{entries:M(e.fixtures,"Node/Vitest data fixture manifest")}}function T(e,t){const r=a(t,"metric budget name");return{atLeast(n,s={}){return o(e,{name:r,target:"metric",operator:">=",expected:n,message:s.message}),this},atMost(n,s={}){return o(e,{name:r,target:"metric",operator:"<=",expected:n,message:s.message}),this},equals(n,s={}){return o(e,{name:r,target:"metric",operator:"==",expected:n,message:s.message}),this},greaterThan(n,s={}){return o(e,{name:r,target:"metric",operator:">",expected:n,message:s.message}),this},lessThan(n,s={}){return o(e,{name:r,target:"metric",operator:"<",expected:n,message:s.message}),this},required(n={}){return o(e,{name:r,target:"metric",operator:"exists",message:n.message}),this},relativeToBaseline(n){return o(e,{name:r,target:"metric",operator:"baseline_relative",message:n.message,thresholdVersion:n.thresholdVersion,policy:{kind:"baseline_relative",baselineRunId:n.runId,direction:n.direction||"increase",maximumRelativeDelta:n.maximumRelativeDelta,minimumAbsoluteDelta:n.minimumAbsoluteDelta||0,requiredSamples:n.requiredSamples||1}}),this}}}function _(e,t){const r=a(t,"sequence budget name");return{equals(n,s={}){return o(e,{name:r,target:"sequence",operator:"sequence==",expected:x(n),message:s.message}),this},includesOnly(n,s={}){return o(e,{name:r,target:"sequence",operator:"sequenceOnly",expected:x(n),message:s.message}),this},required(n={}){return o(e,{name:r,target:"sequence",operator:"exists",message:n.message}),this}}}function B(e,t){return{budgets:[],budgetFailures:[],budgetResults:[],description:t.description||null,events:[],evidence:[],error:null,findings:[],finishedAtMs:null,metrics:[],name:a(e,"data scenario name"),sequences:[],startedAtMs:Date.now(),status:"running"}}function D(e){return e.status!=="running"||(e.finishedAtMs=Date.now(),e.budgetResults=e.budgets.map(t=>U(e,t)),e.budgetFailures=e.budgetResults.filter(t=>t.status==="failed"),e.status=e.error||e.budgetFailures.length>0?"failed":"passed"),e}export function dataFlowState(){return p}export function finalizeDataFlowState(){for(const e of p.scenarios)D(e);return p}function H(e,t,r,n={}){const s=r;if(!Number.isFinite(s))throw new Error(`Data metric "${t}" must be a finite number`);e.metrics.push({description:l(n.description),dimensions:z(n.dimensions??{}),kind:l(n.kind)||"metric",name:a(t,"metric name"),unit:l(n.unit),value:s})}function P(e,t,r,n={}){const s=x(r).map(u=>$(u));e.sequences.push({description:l(n.description),dimensions:z(n.dimensions??{}),name:a(t,"sequence name"),values:s})}function o(e,t){e.budgets.push({...t,message:l(t.message)})}function m(e,t,r,n={}){const s=g(n);e.evidence.push({atMs:Date.now()-e.startedAtMs,details:f(s),kind:t,name:a(r,`${t} evidence name`),status:l(s.status)||null})}function g(e){return y(e)?e:{value:e}}function U(e,t){const r=t.target==="sequence"?Z(e,t.name):W(e,t.name),n=K(t,r),s=t.message||G(t,r,n);return t.target==="metric"?{...t,actual:r,expected:t.expected??null,message:s,status:n?"passed":"failed"}:{...t,actual:r,expected:t.expected??null,message:s,status:n?"passed":"failed"}}function K(e,t){if(e.target==="metric")return e.operator==="baseline_relative"?!0:e.operator==="exists"?t!==null:typeof t!="number"?!1:e.operator==="<="?t<=Number(e.expected):e.operator===">="?t>=Number(e.expected):e.operator==="<"?t<Number(e.expected):e.operator===">"?t>Number(e.expected):Object.is(t,Number(e.expected));if(e.operator==="exists")return t!==null;if(!Array.isArray(t))return!1;if(e.operator==="sequence==")return te(t,e.expected);const r=new Set((e.expected??[]).map(n=>h(n)));return t.every(n=>r.has(n))}function W(e,t){for(let r=e.metrics.length-1;r>=0;r-=1)if(e.metrics[r].name===t)return e.metrics[r].value;return null}function Z(e,t){const r=[];for(const n of e.sequences)n.name===t&&r.push(...n.values);return r.length>0?r:null}function G(e,t,r){if(e.operator==="baseline_relative"){const n=e.policy?.kind==="baseline_relative"?e.policy.baselineRunId:null;return`metric "${e.name}" will be compared with immutable run ${n||"<missing>"}`}return e.operator==="exists"?r?`${e.target} "${e.name}" was recorded`:`${e.target} "${e.name}" was not recorded`:`${e.target} "${e.name}" expected ${e.operator} ${JSON.stringify(e.expected)}, got ${JSON.stringify(t)}`}function Y(e){return[`Data-flow budgets failed in "${e.name}":`,...e.budgetFailures.map(t=>`- ${t.message}`)].join(`
+`)}function Q(e,t){if(typeof e=="function")return{options:{},run:e};if(typeof t!="function")throw new Error("dataScenario(name, options?, run) requires a run callback");return{options:e,run:t}}function x(e){return ae(e)?[...e]:[e]}function a(e,t){const r=h(e).trim();if(!r)throw new Error(`${t} must be a non-empty string`);return r}function l(e){if(e==null)return null;const t=h(e).trim();return t||null}function X(e){const t=h(e||"info").toLowerCase();return ie(t)?t:"info"}function f(e){if(Array.isArray(e))return e.map(r=>f(r));if(!y(e))return e;const t={};for(const[r,n]of Object.entries(e))t[r]=j.test(r)?"[redacted]":f(n);return t}function ee(e){return e instanceof Error?{message:e.message,name:e.name,stack:e.stack??null}:{message:b(e,"message")??se(e),name:b(e,"name")??"Error",stack:b(e,"stack")}}function S(e){return Array.isArray(e)?`[${e.map(t=>S(t)).join(",")}]`:y(e)?`{${Object.keys(e).sort().map(t=>{const r=S(e[t]);return`${JSON.stringify(t)}:${r??"undefined"}`}).join(",")}}`:JSON.stringify(e)}function te(e,t){return!Array.isArray(e)||!Array.isArray(t)||e.length!==t.length?!1:e.every((r,n)=>String(r)===String(t[n]))}function re(e){return e.replace(/([a-z0-9])([A-Z])/g,"$1_$2").replace(/[^a-zA-Z0-9]+/g,"_").replace(/^_+|_+$/g,"").toLowerCase()}function ne(){return{emitted:!1,scenarios:[]}}function z(e){const t=f(e);return y(t)?t:{}}function b(e,t){if(!y(e))return null;try{const r=Reflect.get(e,t);return typeof r=="string"?r:null}catch{return null}}function se(e){try{return $(e)}catch{return"Unknown thrown value"}}function ie(e){return e==="error"||e==="info"||e==="waste"||e==="watch"}function ae(e){return Array.isArray(e)}function y(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}

package/dist/engines/node-vitest/runtime/data/types.d.ts

@@ -0,0 +1,412 @@
+import type { HttpMethods } from "../../../../config/authoring/http-methods.js";
+import type { HttpProfileAuth, HttpProfileEnv, HttpProfileHeaderBuilder } from "../../../../config/authoring/runtime.js";
+import type { RuntimeEnv } from "../../../../config/authoring/http-execution-contract.js";
+export declare const DATA_ARTIFACT_KIND = "testkit.data-flow";
+export declare const DATA_REPORT_KIND = "testkit.data-flow.report";
+export declare const DATA_SCHEMA_VERSION = 1;
+export type UnknownRecord = Record<string, unknown>;
+export type DataFindingSeverity = "error" | "info" | "waste" | "watch";
+export type DataScenarioStatus = "failed" | "passed" | "running";
+export type DataMetricBudgetOperator = "<" | "<=" | "==" | ">" | ">=" | "baseline_relative" | "exists";
+export type DataSequenceBudgetOperator = "exists" | "sequence==" | "sequenceOnly";
+export interface DataScenarioOptions {
+    description?: string;
+    timeout?: number;
+    timeoutMs?: number;
+}
+export interface DataMetricOptions {
+    description?: string;
+    dimensions?: UnknownRecord;
+    kind?: string;
+    unit?: string;
+}
+export interface DataSequenceOptions {
+    description?: string;
+    dimensions?: UnknownRecord;
+}
+export interface DataEvidenceDetails extends UnknownRecord {
+    status?: string;
+}
+export interface DataBudgetOptions {
+    message?: string;
+}
+export interface DataBaselineBudgetOptions extends DataBudgetOptions {
+    direction?: "decrease" | "increase";
+    maximumRelativeDelta: number;
+    minimumAbsoluteDelta?: number;
+    requiredSamples?: number;
+    runId: string;
+    thresholdVersion?: string;
+}
+export interface DataMetricBudget {
+    atLeast(value: number, options?: DataBudgetOptions): this;
+    atMost(value: number, options?: DataBudgetOptions): this;
+    equals(value: number, options?: DataBudgetOptions): this;
+    greaterThan(value: number, options?: DataBudgetOptions): this;
+    lessThan(value: number, options?: DataBudgetOptions): this;
+    relativeToBaseline(options: DataBaselineBudgetOptions): this;
+    required(options?: DataBudgetOptions): this;
+}
+export interface DataSequenceBudget {
+    equals(values: readonly unknown[], options?: DataBudgetOptions): this;
+    includesOnly(values: readonly unknown[], options?: DataBudgetOptions): this;
+    required(options?: DataBudgetOptions): this;
+}
+export interface DataFixture {
+    buffer(): Buffer;
+    contentType: string;
+    filename: string;
+    json(): unknown;
+    path: string;
+    sha256: string;
+    sizeBytes: number;
+    text(encoding?: BufferEncoding): string;
+}
+export interface DataHttpResponse {
+    body: string;
+    cookies: Record<string, Array<{
+        value: string;
+    }>>;
+    durationMs: number;
+    headers: Record<string, string>;
+    json(): unknown;
+    method: string;
+    path: string;
+    status: number;
+    url: string;
+}
+export interface DataHttpRequestOptions {
+    contentTypeJson?: boolean;
+    signal?: AbortSignal;
+}
+export interface DataActorSession {
+    [key: string]: unknown;
+    actorIndex?: number;
+    email?: string | null;
+    name?: string | null;
+    organizationKey?: string | null;
+    organizationName?: string | null;
+    session?: UnknownRecord | null;
+}
+export interface DataSessionBundle {
+    actors: Record<string, DataActorSession | undefined>;
+    primaryActor: string | null;
+}
+export interface DataHttpHeaderContext {
+    actor: DataActorSession | null;
+    actorName: string | null;
+    sessionBundle: DataSessionBundle | null;
+}
+export type DataHttpHeaderBuilder = (context: DataHttpHeaderContext) => Record<string, string>;
+export interface DataHttpClientOptions {
+    baseUrl?: string;
+    defaultActor?: string;
+    defaultHeaders?: Record<string, string>;
+    getHeaders?: DataHttpHeaderBuilder;
+    getRawHeaders?: DataHttpHeaderBuilder;
+    profile?: string;
+    recorder?: DataHttpRecorder;
+    sessionBundle?: DataSessionBundle;
+    trace?: DataHttpRecorder;
+}
+export interface DataHttpRequest {
+    (method: string, path: string, body?: unknown, headers?: Record<string, string>, options?: DataHttpRequestOptions): Promise<DataHttpResponse>;
+}
+export type DataActorRawRequest = DataHttpRequest & HttpMethods<Promise<DataHttpResponse>, [headers?: Record<string, string>, options?: DataHttpRequestOptions]>;
+export interface DataRootRawRequest extends DataHttpRequest, Pick<HttpMethods<Promise<DataHttpResponse>, [headers?: Record<string, string>, options?: DataHttpRequestOptions]>, "get" | "post"> {
+    as(actorName: string): DataActorRawRequest;
+}
+export interface DataHttpMethods extends HttpMethods<Promise<DataHttpResponse>, [
+    headers?: Record<string, string>,
+    options?: DataHttpRequestOptions
+]> {
+    headers(extraHeaders?: Record<string, string>): Record<string, string>;
+    rawHeaders(extraHeaders?: Record<string, string>): Record<string, string>;
+    request(method: string, path: string, body?: unknown, headers?: Record<string, string>, options?: DataHttpRequestOptions): Promise<DataHttpResponse>;
+}
+export interface DataActorHttpClient extends DataHttpMethods {
+    raw: DataActorRawRequest;
+    rawReq: DataActorRawRequest;
+}
+export interface DataHttpActor {
+    email: string | null;
+    headers: Record<string, string>;
+    index: number;
+    key: string;
+    name: string | null;
+    organizationKey: string | null;
+    organizationName: string | null;
+    rawHeaders: Record<string, string>;
+    rawReq: DataActorRawRequest;
+    req: DataActorHttpClient;
+    session: UnknownRecord | null;
+}
+export interface DataHttpActors {
+    get(name: string): DataHttpActor;
+    has(name: string): boolean;
+    list(): DataHttpActor[];
+    names: string[];
+    primary: DataHttpActor | null;
+}
+export interface DataHttpClient extends DataHttpMethods {
+    actor?: DataHttpActor | null;
+    actors?: DataHttpActors;
+    as(actorName: string): DataActorHttpClient;
+    baseUrl: string;
+    env?: HttpProfileEnv;
+    raw: DataRootRawRequest;
+    rawReq: DataRootRawRequest;
+}
+export interface DataHttpRequestRecord {
+    bodyBytes?: number;
+    durationMs?: number;
+    method: string;
+    path: string;
+    requestHeaders?: Record<string, string>;
+    responseBytes?: number;
+    status?: number;
+}
+export interface DataHttpRecorder {
+    recordHttpRequest(entry: DataHttpRequestRecord): unknown;
+}
+export interface DataExternalCallDetails extends DataEvidenceDetails {
+    costMinor?: number;
+    durationMs?: number;
+    requestBytes?: number;
+    responseBytes?: number;
+}
+export interface DataScenarioContext extends DataRuntimeContext, DataHttpRecorder {
+    addFinding(severity: string, message: string, details?: UnknownRecord): this;
+    actor(name: string, details?: DataEvidenceDetails): this;
+    budget(metricName: string): DataMetricBudget;
+    bytes(name: string, value: number, options?: DataMetricOptions): this;
+    count(name: string, value?: number, options?: DataMetricOptions): this;
+    duration(name: string, value: number, options?: DataMetricOptions): this;
+    event(name: string, details?: UnknownRecord): this;
+    expectMetric(metricName: string): DataMetricBudget;
+    expectSequence(sequenceName: string): DataSequenceBudget;
+    externalCall(name: string, details?: DataExternalCallDetails): this;
+    finding(severity: string, message: string, details?: UnknownRecord): this;
+    fixture(name: string): DataFixture;
+    http(options?: DataHttpProfileOptions): Promise<DataHttpClient>;
+    metric(name: string, value: number, options?: DataMetricOptions): this;
+    money(name: string, value: number, options?: DataMetricOptions): this;
+    ratio(name: string, value: number, options?: DataMetricOptions): this;
+    reconcile(name: string, details?: DataEvidenceDetails): this;
+    record(name: string, details?: DataEvidenceDetails & {
+        count?: number;
+    }): this;
+    recordHttpRequest(entry: DataHttpRequestRecord): this;
+    recordCache(name: string, values?: {
+        hits?: number;
+        misses?: number;
+        reads?: number;
+        writes?: number;
+    }): this;
+    recordLlmUsage(name: string, usage?: Record<string, number>): this;
+    recordRpc(name: string, entry?: {
+        method?: string;
+        requestBytes?: number;
+        responseBytes?: number;
+    }): this;
+    sequence(name: string, values: unknown, options?: DataSequenceOptions): this;
+    sequenceBudget(sequenceName: string): DataSequenceBudget;
+    system(name: string, details?: DataEvidenceDetails): this;
+    transition(name: string, details?: DataEvidenceDetails): this;
+}
+export interface DataRuntimeContext extends UnknownRecord {
+    baseUrl?: string | null;
+    engineId?: "node-vitest";
+    readonly env: Readonly<Record<string, string>>;
+    profileId?: "node-vitest-data";
+    serviceName?: string;
+    task?: {
+        file?: string;
+        id?: number | string;
+        suiteName?: string;
+        testType: "data";
+    };
+}
+export type DataHttpProfileAuth = HttpProfileAuth<DataSessionBundle>;
+export interface DataHttpProfileOptions extends DataHttpClientOptions {
+    auth?: DataHttpProfileAuth | null;
+    env?: HttpProfileEnv;
+    headers?: HttpProfileHeaderBuilder<DataSessionBundle>;
+    rawHeaders?: HttpProfileHeaderBuilder<DataSessionBundle>;
+}
+export interface ResolvedDataHttpProfileOptions extends Omit<DataHttpProfileOptions, "auth" | "env" | "headers" | "rawHeaders"> {
+    auth: DataHttpProfileAuth | null;
+    env: HttpProfileEnv | undefined;
+    headers: HttpProfileHeaderBuilder<DataSessionBundle> | undefined;
+    rawHeaders: HttpProfileHeaderBuilder<DataSessionBundle> | undefined;
+}
+export interface DataMetric {
+    aggregation?: string;
+    description: string | null;
+    dimensions: UnknownRecord;
+    intervalMs?: number | null;
+    kind: string;
+    name: string;
+    unit: string | null;
+    value: number;
+}
+export interface DataSequence {
+    description: string | null;
+    dimensions: UnknownRecord;
+    name: string;
+    values: string[];
+}
+export interface DataEvidence {
+    atMs: number;
+    details: unknown;
+    kind: string;
+    name: string;
+    status: string | null;
+}
+export interface DataEvent {
+    atMs: number;
+    details: unknown;
+    name: string;
+}
+export interface DataFinding {
+    details: unknown;
+    message: string;
+    severity: DataFindingSeverity;
+}
+export interface SerializedDataError {
+    message: string;
+    name: string;
+    stack: string | null;
+}
+export type DataPerformancePolicyInput = {
+    kind: "absolute";
+    operator: "<" | "<=" | ">" | ">=";
+    requiredSamples?: number;
+    value: number;
+} | {
+    baselineRunId: string;
+    direction?: "decrease" | "increase";
+    kind: "baseline_relative";
+    maximumRelativeDelta: number;
+    minimumAbsoluteDelta?: number;
+    requiredSamples?: number;
+} | {
+    kind: "exact";
+    requiredSamples?: number;
+    value: number;
+};
+export interface DataMetricBudgetInput {
+    expected?: number;
+    message: string | null;
+    metricKey?: string | null;
+    name: string;
+    operator: DataMetricBudgetOperator;
+    policy?: DataPerformancePolicyInput;
+    target: "metric";
+    thresholdVersion?: string | null;
+}
+export interface DataSequenceBudgetInput {
+    expected?: unknown[];
+    message: string | null;
+    name: string;
+    operator: DataSequenceBudgetOperator;
+    target: "sequence";
+}
+export type DataBudgetInput = DataMetricBudgetInput | DataSequenceBudgetInput;
+export type DataBudgetDraft = (Omit<DataMetricBudgetInput, "message"> & {
+    message?: string;
+}) | (Omit<DataSequenceBudgetInput, "message"> & {
+    message?: string;
+});
+export interface DataBudgetResultBase {
+    actual: number | string[] | null;
+    message: string;
+    status: "failed" | "passed";
+}
+export type DataBudgetResult = (Omit<DataMetricBudgetInput, "expected" | "message"> & DataBudgetResultBase & {
+    expected: number | null;
+}) | (Omit<DataSequenceBudgetInput, "expected" | "message"> & DataBudgetResultBase & {
+    expected: unknown[] | null;
+});
+export interface DataScenarioState {
+    budgetFailures: DataBudgetResult[];
+    budgetResults: DataBudgetResult[];
+    budgets: DataBudgetInput[];
+    description: string | null;
+    error: SerializedDataError | null;
+    events: DataEvent[];
+    evidence: DataEvidence[];
+    findings: DataFinding[];
+    finishedAtMs: number | null;
+    metrics: DataMetric[];
+    name: string;
+    sequences: DataSequence[];
+    startedAtMs: number;
+    status: DataScenarioStatus;
+}
+export interface DataScenarioReport {
+    budgetFailures: DataBudgetResult[];
+    budgets: DataBudgetResult[];
+    description: string | null;
+    durationMs: number;
+    error: SerializedDataError | null;
+    events: DataEvent[];
+    evidence: DataEvidence[];
+    findings: DataFinding[];
+    metrics: DataMetric[];
+    name: string;
+    sequences: DataSequence[];
+    status: "failed" | "passed";
+}
+export interface DataFlowReport {
+    file: string | null;
+    generatedAt: string;
+    kind: typeof DATA_ARTIFACT_KIND;
+    scenarios: DataScenarioReport[];
+    schemaVersion: typeof DATA_SCHEMA_VERSION;
+    summary: {
+        budgetFailures: number;
+        failed: number;
+        findingCounts: Record<DataFindingSeverity, number>;
+        passed: number;
+        scenarios: number;
+        status: "failed" | "passed";
+    };
+    summaryText: string;
+    taskId: string | null;
+}
+export interface DataFlowState {
+    emitted: boolean;
+    scenarios: DataScenarioState[];
+}
+export interface DataFixtureManifestEntry {
+    absolutePath: string;
+    aliases: string[];
+    contentType: string;
+    filename: string;
+    path: string;
+    sha256: string;
+    sizeBytes: number;
+}
+export interface DataFixtureManifest {
+    entries: DataFixtureManifestEntry[];
+}
+export interface SerializedRequestBody {
+    body: NonNullable<RequestInit["body"]> | undefined;
+}
+export interface DataActorsContext {
+    actor: DataHttpActor | null;
+    actors: DataHttpActors;
+}
+export type ResolvedDataHttpEnv = HttpProfileEnv & RuntimeEnv & {
+    BASE: string;
+    rawEnv: NodeJS.ProcessEnv;
+};
+export interface FetchProfileResponse {
+    body: string;
+    cookies: Record<string, Array<{
+        value: string;
+    }>>;
+    headers: Record<string, string>;
+    status: number;
+}

package/dist/engines/node-vitest/runtime/data/types.js

@@ -0,0 +1 @@
+export const DATA_ARTIFACT_KIND="testkit.data-flow",DATA_REPORT_KIND="testkit.data-flow.report",DATA_SCHEMA_VERSION=1;

package/dist/engines/node-vitest/runtime/runtime-input.d.ts

@@ -0,0 +1,63 @@
+import type { EngineJsonObject, EngineJsonValue } from "../../api/index.js";
+import { type OwnedFileRecord } from "../../runtime-input-file.js";
+export declare const NODE_VITEST_RUNTIME_INPUT_VERSION: 1;
+export declare const NODE_VITEST_RUNTIME_INPUT_FILENAME = "runtime-input.json";
+export declare const NODE_VITEST_RUNTIME_INPUT_FILE_ENV = "TESTKIT_NODE_VITEST_INPUT_FILE";
+export declare const NODE_VITEST_RUNTIME_INPUT_SHA256_ENV = "TESTKIT_NODE_VITEST_INPUT_SHA256";
+export declare const NODE_VITEST_RUNTIME_INPUT_SYMBOL = "elench.testkit.node-vitest.runtime-input.v1";
+export declare const NODE_VITEST_DATA_BUDGET_FAILURE_DETAIL_KIND = "data-flow-budget";
+export declare const NODE_VITEST_DATA_FAILURE_DETAILS_ARTIFACT_KIND = "testkit.failure-details";
+export declare const NODE_VITEST_DATA_FAILURE_DETAILS_ARTIFACT_NAME = "data-flow-failure-details";
+/**
+ * The real process environment contains only invocation-owned OS directories,
+ * locale, and small Testkit controls. This cross-platform budget stays below
+ * Windows' environment-block ceiling; ordinary consumer variables live in the
+ * owned input file instead.
+ */
+export declare const MAX_NODE_VITEST_SPAWN_ENVIRONMENT_UNITS: number;
+export type NodeVitestProfileId = "node-vitest-contract" | "node-vitest-data";
+export interface NodeVitestDataBudgetFailureDetail {
+    readonly actual: EngineJsonValue;
+    readonly checkName: string;
+    readonly count: 1;
+    readonly expected: EngineJsonValue;
+    readonly groupPath: readonly [string];
+    readonly key: string;
+    readonly kind: typeof NODE_VITEST_DATA_BUDGET_FAILURE_DETAIL_KIND;
+    readonly message: string;
+    readonly title: string;
+}
+export interface NodeVitestDataFailureDetailsArtifact {
+    readonly failures: readonly NodeVitestDataBudgetFailureDetail[];
+    readonly phase: "exec";
+}
+export interface NodeVitestRuntimeInputDocument {
+    readonly context: EngineJsonObject;
+    readonly engineId: "node-vitest";
+    readonly environment: Readonly<Record<string, string>>;
+    readonly fixtures: EngineJsonObject;
+    readonly invocationId: string;
+    readonly profileId: NodeVitestProfileId;
+    readonly setupData?: EngineJsonValue;
+    readonly taskId: string;
+    readonly version: typeof NODE_VITEST_RUNTIME_INPUT_VERSION;
+}
+export type NodeVitestRuntimeInput = NodeVitestRuntimeInputDocument;
+export type OwnedNodeVitestRuntimeInput = OwnedFileRecord;
+export interface InstallNodeVitestRuntimeInputRequest {
+    readonly expectedFile: string;
+    readonly expectedInvocationId: string;
+    readonly expectedProfileId: NodeVitestProfileId;
+    readonly expectedSha256: string;
+    readonly expectedTaskId: string;
+}
+export declare function writeOwnedNodeVitestRuntimeInput(taskDirectory: string, document: NodeVitestRuntimeInputDocument): Promise<OwnedNodeVitestRuntimeInput>;
+export declare function verifyOwnedNodeVitestRuntimeInput(input: OwnedNodeVitestRuntimeInput): Promise<void>;
+export declare function selectNodeVitestForwardedEnvironment(input: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+export declare function assertNodeVitestSpawnEnvironmentBudget(environment: Readonly<Record<string, string>>): void;
+/** Runs from the engine-owned Node bootstrap before any tool or consumer code. */
+export declare function installNodeVitestRuntimeInput(request: Readonly<InstallNodeVitestRuntimeInputRequest>): Promise<void>;
+/** Reasserts small engine controls after Vitest creates its worker environment. */
+export declare function applyNodeVitestEngineEnvironment(): void;
+/** Reads the engine-installed document from the current Vitest worker. */
+export declare function readNodeVitestRuntimeInput(): NodeVitestRuntimeInput | null;

package/dist/engines/node-vitest/runtime/runtime-input.js

@@ -0,0 +1 @@
+import m from"node:fs/promises";import w from"node:path";import{readVerifiedOwnedFile as f,writeOwnedRuntimeInput as S,RUNTIME_INPUT_BYTE_MEASURE as O}from"../../runtime-input-file.js";import{requireBoundedJsonValue as h,RUNTIME_INPUT_JSON_BOUNDS as V}from"../../contracts/json-bounds.js";import{ENGINE_PROCESS_RESERVED_ENVIRONMENT_KEYS as l,installManagedProcessEnvironmentOverlay as R}from"../../../process/index.js";export const NODE_VITEST_RUNTIME_INPUT_VERSION=1,NODE_VITEST_RUNTIME_INPUT_FILENAME="runtime-input.json",NODE_VITEST_RUNTIME_INPUT_FILE_ENV="TESTKIT_NODE_VITEST_INPUT_FILE",NODE_VITEST_RUNTIME_INPUT_SHA256_ENV="TESTKIT_NODE_VITEST_INPUT_SHA256",NODE_VITEST_RUNTIME_INPUT_SYMBOL="elench.testkit.node-vitest.runtime-input.v1",NODE_VITEST_DATA_BUDGET_FAILURE_DETAIL_KIND="data-flow-budget",NODE_VITEST_DATA_FAILURE_DETAILS_ARTIFACT_KIND="testkit.failure-details",NODE_VITEST_DATA_FAILURE_DETAILS_ARTIFACT_NAME="data-flow-failure-details";const E={filename:NODE_VITEST_RUNTIME_INPUT_FILENAME,label:"Node/Vitest runtime input",maxSizeBytes:8*1024*1024},N=512,I=4*1024*1024,x=new Set(["BASE_URL","FORCE_COLOR","NODE_OPTIONS","NO_COLOR","UPDATE_SNAPSHOT",...l].map(t=>t.toUpperCase()));export const MAX_NODE_VITEST_SPAWN_ENVIRONMENT_UNITS=24*1024;export async function writeOwnedNodeVitestRuntimeInput(t,e){return S(t,e,E)}export async function verifyOwnedNodeVitestRuntimeInput(t){await f(t,E)}export function selectNodeVitestForwardedEnvironment(t){const e={...t};return _(e),e}export function assertNodeVitestSpawnEnvironmentBudget(t){if(Object.entries(t).reduce((n,[o,r])=>n+o.length+r.length+2,1)>MAX_NODE_VITEST_SPAWN_ENVIRONMENT_UNITS)throw new Error(`Node/Vitest process environment exceeds the ${MAX_NODE_VITEST_SPAWN_ENVIRONMENT_UNITS.toString()} character environment-block budget`)}export async function installNodeVitestRuntimeInput(t){const e=process.env[NODE_VITEST_RUNTIME_INPUT_FILE_ENV],n=process.env[NODE_VITEST_RUNTIME_INPUT_SHA256_ENV];if(e!==t.expectedFile)throw new Error("Node/Vitest runtime input pointer does not match its engine-owned path");if(n!==t.expectedSha256)throw new Error("Node/Vitest runtime input digest does not match its prepared value");const o=await m.lstat(t.expectedFile),r={directory:w.dirname(t.expectedFile),file:t.expectedFile,sha256:t.expectedSha256,sizeBytes:o.size},c=await f(r,E);let i;try{i=JSON.parse(c)}catch(u){throw new Error("Node/Vitest runtime input contains invalid JSON",{cause:u})}const s=a(p(i));if(s.invocationId!==t.expectedInvocationId||s.profileId!==t.expectedProfileId||s.taskId!==t.expectedTaskId)throw new Error("Node/Vitest runtime input identity does not match its task");R({environment:s.environment,label:"Node/Vitest"}),Object.defineProperty(globalThis,Symbol.for(NODE_VITEST_RUNTIME_INPUT_SYMBOL),{configurable:!0,enumerable:!1,value:s,writable:!1}),applyNodeVitestEngineEnvironment()}export function applyNodeVitestEngineEnvironment(){const t=readNodeVitestRuntimeInput();if(t===null)throw new Error("Node/Vitest runtime input is not installed");const e=t.context.baseUrl;typeof e=="string"?process.env.BASE_URL=e:Reflect.deleteProperty(process.env,"BASE_URL")}export function readNodeVitestRuntimeInput(){const t=Reflect.get(globalThis,Symbol.for(NODE_VITEST_RUNTIME_INPUT_SYMBOL));return t===void 0?null:a(p(t,"Installed Node/Vitest runtime input"))}function p(t,e="Node/Vitest runtime input"){if(h(t,e,V,O),!d(t))throw new Error(`${e} must contain an object`);const n=new Set(["context","engineId","environment","fixtures","invocationId","profileId","setupData","taskId","version"]);for(const r of Object.keys(t))if(!n.has(r))throw new Error(`${e} contains unknown field ${r}`);if(t.version!==NODE_VITEST_RUNTIME_INPUT_VERSION)throw new Error(`${e}.version must be 1`);if(t.engineId!=="node-vitest")throw new Error(`${e}.engineId must be "node-vitest"`);if(!A(t.profileId))throw new Error(`${e}.profileId is invalid`);if(!d(t.context)||!d(t.fixtures))throw new Error(`${e} context and fixtures must be objects`);const o=y(t.environment,`${e}.environment`);return _(o),{context:t.context,engineId:"node-vitest",environment:o,fixtures:t.fixtures,invocationId:T(t.invocationId,`${e}.invocationId`),profileId:t.profileId,...Object.hasOwn(t,"setupData")?{setupData:t.setupData}:{},taskId:T(t.taskId,`${e}.taskId`),version:NODE_VITEST_RUNTIME_INPUT_VERSION}}function _(t){const e=Object.entries(t);if(e.length>N)throw new Error(`Node/Vitest forwarded environment exceeds the ${N.toString()} entry limit`);let n=0;const o=new Set;for(const[r,c]of e){D(r,c,"Node/Vitest forwarded environment");const i=r.toUpperCase();if(o.has(i))throw new Error(`Node/Vitest forwarded environment contains case-insensitive duplicate key ${r}`);if(o.add(i),i.startsWith("TESTKIT_")||i.startsWith("VITEST_")||x.has(i))throw new Error(`Node/Vitest forwarded environment contains reserved key ${r}`);n+=Buffer.byteLength(r)+Buffer.byteLength(c)+2}if(n>I)throw new Error(`Node/Vitest forwarded environment exceeds the ${I.toString()} byte limit`)}function y(t,e){if(!d(t))throw new Error(`${e} must be an object`);const n=Object.entries(t);if(!n.every(o=>typeof o[1]=="string"))throw new Error(`${e} values must all be strings`);return Object.fromEntries(n)}function D(t,e,n){if(t.length===0||t.includes("=")||t.includes("\0"))throw new Error(`${n} contains an invalid variable name`);if(e.includes("\0"))throw new Error(`${n}.${t} contains a NUL character`)}function a(t){if(t!==null&&typeof t=="object"&&!Object.isFrozen(t)){Object.freeze(t);for(const e of Object.values(t))a(e)}return t}function T(t,e){if(typeof t!="string"||t.length===0)throw new Error(`${e} must be a non-empty string`);return t}function A(t){return t==="node-vitest-contract"||t==="node-vitest-data"}function d(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}

package/dist/engines/playwright/adapter/adapter.d.ts

@@ -0,0 +1,18 @@
+import { type ProcessClassification } from "../../adapters/execution.js";
+import { type EngineExecutionRequest, type EngineExecutionResult, type EngineFailureEvidence, type EngineInvocationScope } from "../../api/index.js";
+import { createNativeInvocationProcessEnvironment, type ManagedProcessResult } from "../../../process/index.js";
+import type { PlaywrightInstallation } from "../../installations/playwright.js";
+import { writePlaywrightTaskWorkspace } from "./config.js";
+import { type CollectedPlaywrightEvidence } from "./evidence.js";
+export declare const PLAYWRIGHT_SPAWN_ENVIRONMENT_MAX_BYTES: number;
+export interface PlaywrightAdapterDependencies {
+    createInvocationEnvironment: typeof createNativeInvocationProcessEnvironment;
+    removeOwnedDirectory(directory: string): Promise<void>;
+    writeTaskWorkspace(request: Parameters<typeof writePlaywrightTaskWorkspace>[0]): ReturnType<typeof writePlaywrightTaskWorkspace>;
+}
+export declare const playwrightAdapterDependencies: PlaywrightAdapterDependencies;
+export declare function executePlaywrightEngine(request: Readonly<EngineExecutionRequest<"playwright">>, installation: Readonly<PlaywrightInstallation>, scope: EngineInvocationScope, dependencies?: PlaywrightAdapterDependencies): Promise<EngineExecutionResult>;
+export declare function classifyPlaywrightProcessResult(result: ManagedProcessResult, collected: CollectedPlaywrightEvidence, timeoutMs: number, deadlineExceeded: boolean): ProcessClassification;
+export declare function playwrightEvidenceCollectionFailure(result: ManagedProcessResult, error: unknown): EngineFailureEvidence;
+export declare function playwrightSpawnEnvironmentBytes(environment: Readonly<Record<string, string>>): number;
+export declare function playwrightPreparationFailure(error: unknown, cleanupFailures: readonly Error[]): EngineFailureEvidence;

package/dist/engines/playwright/adapter/adapter.js

@@ -0,0 +1 @@
+import{makeTempDirAsync as _}from"../../../process/files/temp-dir.js";import{classifyManagedProcessResult as A,terminalOutcome as v,processOutputEvidence as F,failureFromError as T,firstOutputLine as D,processExitFailure as N,toError as E,executeEngineTasks as x,managedProcessFailure as M}from"../../adapters/execution.js";import{requireRootDirectory as b,requireAbsoluteWorkspacePath as R,requireConsumerFile as C,safeSegment as O}from"../../adapters/workspace.js";import l from"node:fs/promises";import W from"node:path";import{setTimeout as B}from"node:timers/promises";import{pathToFileURL as Y}from"node:url";import{isEngineTaskDeadlineExceededReason as U,resolveEngineTaskInputs as $}from"../../api/index.js";import{createNativeInvocationProcessEnvironment as H,runManagedProcess as K}from"../../../process/index.js";import{PlaywrightConsumerConfigurationError as G,playwrightExactFileFilter as V,writePlaywrightTaskWorkspace as j}from"./config.js";import{collectPlaywrightEvidence as J}from"./evidence.js";import{engineEvidenceIdentity as z}from"../../adapters/evidence-identity.js";const d={codePrefix:"PLAYWRIGHT",label:"Playwright"};export const PLAYWRIGHT_SPAWN_ENVIRONMENT_MAX_BYTES=24*1024;const S=64;class k extends Error{constructor(r){const e=E(r);super(e.message,{cause:e}),this.name="PlaywrightConsumerPreparationError"}}export const playwrightAdapterDependencies={createInvocationEnvironment:H,removeOwnedDirectory:Z,writeTaskWorkspace:j};const X=new Set(["EBUSY","ENOTEMPTY","EPERM"]),Q=5;async function Z(t){for(let r=0;;r+=1)try{await l.rm(t,{force:!0,recursive:!0});return}catch(e){const i=e instanceof Error&&"code"in e?e.code:void 0;if(r===Q||typeof i!="string"||!X.has(i))throw e;await B((r+1)*100)}}export async function executePlaywrightEngine(t,r,e,i=playwrightAdapterDependencies){const o=await q(t,r,i,e);return x(t,o.tasks,d,(n,a)=>rr(t,o,n,a),nr(t,o.installation))}async function q(t,r,e,i){const o=await b(t.workspace.rootDirectory);R(t.workspace.temporaryDirectory,"temporary directory"),R(t.workspace.artifactDirectory,"artifact directory"),await l.mkdir(t.workspace.temporaryDirectory,{recursive:!0}),await l.mkdir(t.workspace.artifactDirectory,{recursive:!0});const n=await l.realpath(t.workspace.temporaryDirectory),a=await l.realpath(t.workspace.artifactDirectory),s=await _(`playwright-${O(t.invocationId)}-`,{parentDir:n});i.defer(()=>e.removeOwnedDirectory(s));const p=await e.createInvocationEnvironment(s);i.defer(()=>e.removeOwnedDirectory(p.temporaryDirectory));const h=[];for(const[L,c]of t.tasks.entries()){const g=$(t,c),I=`${L.toString().padStart(3,"0")}-${O(c.id)}`,P=W.join(s,I),u=await _(`${I}-`,{parentDir:a});try{const y=or(t,c.serviceName),f=await ar(()=>C(o,c.file,"Playwright task file")),m=await e.writeTaskWorkspace({artifactDirectory:u,baseUrl:y,browserFile:r.browserExecutable,endpoints:t.target.endpoints,inputs:g,invocationId:t.invocationId,managedModuleEntrypoints:{authoring:r.authoringEntrypoints.authoring,cli:r.family.cli,playwright:r.family.playwright.entrypoint,playwrightCore:r.family.playwrightCore.entrypoint,playwrightTest:r.family.playwrightTest.entrypoint,root:r.authoringEntrypoints.root,rootPackageJson:r.authoringEntrypoints.rootPackageJson},moduleFile:r.family.playwrightTest.entrypoint,orchestration:c.orchestration,rootDirectory:o,serviceName:c.serviceName,sourceFile:f,taskDirectory:P,taskId:c.id});i.defer(async()=>{try{await e.removeOwnedDirectory(m.attachmentDirectory)}catch(w){if(!(w instanceof Error&&"code"in w&&w.code==="ENOTDIR"))throw w}}),h.push({artifactDirectory:u,inputs:g,task:c,preparationFailure:null,prepared:{baseUrl:y,sourceFile:f,workspace:m}})}catch(y){const f=(await sr([P,u],e)).map(m=>m.error);h.push({artifactDirectory:u,inputs:g,task:c,preparationFailure:playwrightPreparationFailure(y,f),prepared:null})}}return Object.freeze({installation:r,invocationEnvironment:p.environment,rootDirectory:o,tasks:Object.freeze(h)})}async function rr(t,r,e,i){const o=Math.max(0,e.task.deadlineMs-i),n=await K({args:[r.installation.family.cli,"test",V(e.prepared.sourceFile),"--config",e.prepared.workspace.configFile],cwd:r.rootDirectory,displayLabel:"Playwright",env:tr(t,r,e),executable:process.execPath,signal:t.signal,timeoutMs:o});let a;try{a=await J({identity:{engineId:"playwright",invocationId:t.invocationId,taskId:e.task.id,sourceFile:e.prepared.sourceFile},artifactDirectory:e.artifactDirectory,outputDirectory:e.prepared.workspace.outputDirectory,reportFile:e.prepared.workspace.reportFile,rootDirectory:r.rootDirectory,sourceFile:e.prepared.sourceFile,stderr:n.stderr,stdout:n.stdout})}catch(p){return v(e.task.id,"failed",i,F(n),playwrightEvidenceCollectionFailure(n,p))}const s=classifyPlaywrightProcessResult(n,a,e.task.timeoutMs,U(t.signal.reason));return v(e.task.id,s.status,i,a.evidence,s.failure)}export function classifyPlaywrightProcessResult(t,r,e,i){const o=A(t,e,i,d);if(o!==null)return o;if(r.outputLimit!==null){const s=r.outputLimit;return{failure:{code:"PLAYWRIGHT_OUTPUT_ARTIFACT_LIMIT",details:{...s},message:`Playwright output exceeded its ${s.limit.toString()} ${s.kind==="bytes"?"byte aggregate":"entry"} artifact limit`},status:"failed"}}const n=r.attachmentFailures.find(s=>s.code==="PLAYWRIGHT_ATTACHMENT_LIMIT");if(n!==void 0)return{failure:n,status:"failed"};if(r.report.failure!==null)return r.report;const a=r.attachmentFailures.at(0);return a!==void 0?{failure:a,status:"failed"}:t.exitCode!==0?N(t,d,D(t.stderr)??D(t.stdout)):r.reportError!==null?{failure:{...T(r.reportError,"PLAYWRIGHT_REPORT_INVALID"),classification:"infra"},status:"failed"}:r.report}export function playwrightEvidenceCollectionFailure(t,r){const e=E(r);return M(t,d,e)??{...T(e,"PLAYWRIGHT_EVIDENCE_FAILED"),classification:"infra"}}function tr(t,r,e){const i={...r.invocationEnvironment},o=e.task,n=e.prepared.workspace.inputBootstrapFile,a=e.prepared.workspace.resolutionBootstrapFile;return Object.assign(i,{BASE_URL:e.prepared.baseUrl,FORCE_COLOR:"0",NO_COLOR:"1",PLAYWRIGHT_BROWSERS_PATH:r.installation.registry.canonicalValue,PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD:"1",TESTKIT_ACTIVE:"1",TESTKIT_INTERNAL_FILE_DEADLINE_MS:String(o.deadlineMs),TESTKIT_INTERNAL_FILE_TIMEOUT_SECONDS:String(Math.max(1,Math.ceil(o.timeoutMs/1e3))),TESTKIT_INVOCATION_ID:t.invocationId,TESTKIT_LEASE_DIR:o.orchestration.lease.directory,TESTKIT_LEASE_ID:o.orchestration.lease.id,TESTKIT_MODE:o.orchestration.mode,...o.orchestration.runtimeId===void 0?{}:{TESTKIT_RUNTIME_ID:o.orchestration.runtimeId},TESTKIT_TEST_FILE:o.file,TESTKIT_TEST_ID:o.id}),i.NODE_OPTIONS=er(a,n),ir(i),i}function er(t,r){return["--experimental-strip-types",`--require=${JSON.stringify(t)}`,`--import=${JSON.stringify(Y(r).href)}`].join(" ")}export function playwrightSpawnEnvironmentBytes(t){return Object.entries(t).reduce((r,[e,i])=>r+(process.platform==="win32"?(e.length+i.length+2)*2:Buffer.byteLength(e,"utf8")+Buffer.byteLength(i,"utf8")+2),0)}function ir(t){if(Object.keys(t).length>S)throw new Error(`Playwright physical spawn environment exceeds its ${S.toString()} entry limit`);if(playwrightSpawnEnvironmentBytes(t)>PLAYWRIGHT_SPAWN_ENVIRONMENT_MAX_BYTES)throw new Error(`Playwright physical spawn environment exceeds its ${PLAYWRIGHT_SPAWN_ENVIRONMENT_MAX_BYTES.toString()} byte limit`)}function or(t,r){const e=t.target.endpoints[r];if(typeof e!="string"||e.trim().length===0)throw new Error(`Playwright task service ${r} does not have a published endpoint`);let i;try{i=new URL(e)}catch(o){throw new Error(`Playwright task service ${r} endpoint is not a valid URL`,{cause:o})}if(i.protocol!=="http:"&&i.protocol!=="https:")throw new Error(`Playwright task service ${r} endpoint must use http or https`);return i.href}function nr(t,r){return{...z({engineId:"playwright",installationKind:"root-playwright-family",profile:t.profile}),browserName:"chromium",packages:{playwright:r.family.playwright.version,playwrightCore:r.family.playwrightCore.version,playwrightTest:r.family.playwrightTest.version},registryMode:r.registry.mode}}export function playwrightPreparationFailure(t,r){if(r.length===0)return{...T(t,"PLAYWRIGHT_PREPARE_FAILED"),classification:t instanceof k||t instanceof G?"product":"infra"};const e=E(t);return{classification:"infra",code:"PLAYWRIGHT_PREPARE_CLEANUP_FAILED",details:{cleanupFailures:r.map(i=>i.message),preparationFailure:e.message},message:`Playwright task preparation failed and its partial workspace could not be removed: ${r.map(i=>i.message).join("; ")}`,...e.stack===void 0?{}:{stack:e.stack}}}async function ar(t){try{return await t()}catch(r){throw new k(r)}}async function sr(t,r){const e=[];for(const i of t)try{await r.removeOwnedDirectory(i)}catch(o){e.push({directory:i,error:E(o)})}return e}

package/dist/engines/playwright/adapter/attachments.d.ts

@@ -0,0 +1,25 @@
+import type { NativeReportOptions } from "../../adapters/native-report.js";
+export declare const MAX_ATTACHMENT_BYTES: number;
+export declare const MAX_TOTAL_ATTACHMENT_BYTES: number;
+export interface PlaywrightReporterOptions extends NativeReportOptions {
+    readonly attachmentDirectory: string;
+}
+export type PlaywrightAttachmentError = {
+    readonly kind: "individual" | "total";
+    readonly limit: number;
+    readonly observed: number;
+} | {
+    readonly kind: "io";
+    readonly message: string;
+};
+export interface PlaywrightAttachment {
+    readonly name: string;
+    readonly contentType: string;
+    readonly specId: string;
+    readonly specTitle: string;
+    readonly retry: number;
+    readonly path?: string;
+    readonly error?: PlaywrightAttachmentError;
+}
+export declare function attachmentLimitError(size: number, total: number): PlaywrightAttachmentError | null;
+export declare function attachmentIoError(error: unknown): PlaywrightAttachmentError;

package/dist/engines/playwright/adapter/attachments.js

@@ -0,0 +1 @@
+export const MAX_ATTACHMENT_BYTES=67108864,MAX_TOTAL_ATTACHMENT_BYTES=268435456;export function attachmentLimitError(T,A){if(T<=67108864&&A<=268435456)return null;const t=T>67108864;return{kind:t?"individual":"total",limit:t?67108864:268435456,observed:t?T:A}}export function attachmentIoError(T){return{kind:"io",message:(T instanceof Error?T.message:String(T)).slice(0,4096)||"Attachment I/O failed"}}

package/dist/engines/playwright/adapter/config.d.ts

@@ -0,0 +1,45 @@
+import type { EngineExecutionInputs, EngineTaskOrchestration } from "../../api/index.js";
+export interface PlaywrightWorkspaceRequest {
+    readonly artifactDirectory: string;
+    readonly baseUrl: string;
+    readonly browserFile: string;
+    readonly endpoints: Readonly<Record<string, string>>;
+    readonly inputs: EngineExecutionInputs;
+    readonly invocationId: string;
+    readonly managedModuleEntrypoints: PlaywrightManagedModuleEntrypoints;
+    readonly moduleFile: string;
+    readonly orchestration: EngineTaskOrchestration;
+    readonly rootDirectory: string;
+    readonly serviceName: string;
+    readonly sourceFile: string;
+    readonly taskDirectory: string;
+    readonly taskId: string;
+}
+export interface PlaywrightTaskWorkspace {
+    readonly attachmentDirectory: string;
+    readonly configFile: string;
+    readonly inputBootstrapFile: string;
+    readonly outputDirectory: string;
+    readonly reportFile: string;
+    readonly resolutionBootstrapFile: string;
+}
+export interface PlaywrightManagedModuleEntrypoints {
+    readonly authoring: string;
+    readonly cli: string;
+    readonly playwright: string;
+    readonly playwrightCore: string;
+    readonly playwrightTest: string;
+    readonly root: string;
+    readonly rootPackageJson: string;
+}
+export interface PlaywrightResolutionBoundary {
+    readonly consumerRoots: readonly string[];
+    readonly trustedImporterFiles: readonly string[];
+    readonly trustedInternalEntrypoints: readonly string[];
+}
+export declare class PlaywrightConsumerConfigurationError extends Error {
+    constructor(error: unknown);
+}
+export declare function playwrightExactFileFilter(file: string): string;
+export declare function writePlaywrightTaskWorkspace(request: Readonly<PlaywrightWorkspaceRequest>): Promise<PlaywrightTaskWorkspace>;
+export declare function playwrightResolutionBootstrapSource(entrypoints: Readonly<PlaywrightManagedModuleEntrypoints>, boundary: Readonly<PlaywrightResolutionBoundary>): string;