@gfdelarue/testkit 0.3.0

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

@@ -0,0 +1,167 @@
+import{ownedRuntimeInputModuleUrl as w}from"../../runtime-input-file.js";import b from"node:crypto";import n from"node:fs/promises";import o from"node:path";import{fileURLToPath as j,pathToFileURL as g}from"node:url";import{managedNodeModuleResolutionBootstrapSource as P}from"../../managed-module-resolution.js";import{materializePlaywrightRuntimeInput as v,playwrightRuntimeInputBootstrapSource as T}from"../runtime/runtime-input.js";import{nativeReporterFile as k}from"../../adapters/native-report.js";export class PlaywrightConsumerConfigurationError extends Error{constructor(r){const t=r instanceof Error?r:new Error(String(r));super(t.message,{cause:t}),this.name="PlaywrightConsumerConfigurationError"}}export function playwrightExactFileFilter(e){return d(e)}export async function writePlaywrightTaskWorkspace(e){let r;try{F(e.inputs.supportModules),r=await D(e.rootDirectory,e.inputs)}catch(m){throw new PlaywrightConsumerConfigurationError(m)}await n.mkdir(e.taskDirectory,{recursive:!0}),await n.mkdir(e.artifactDirectory,{recursive:!0});const t=b.randomUUID(),i=o.join(e.taskDirectory,`playwright-${t}.config.mjs`),a=o.join(e.taskDirectory,`playwright-${t}.input-bootstrap.mjs`),l=o.join(e.taskDirectory,`playwright-${t}.resolution-bootstrap.cjs`),f=o.join(e.taskDirectory,"testkit-playwright-report.json"),p=o.join(e.artifactDirectory,"playwright-output");await n.mkdir(p);const c=o.join(e.artifactDirectory,"playwright-attachments");await n.mkdir(c,{mode:448,recursive:!1});const u=await v({baseUrl:e.baseUrl,directory:e.taskDirectory,endpoints:e.endpoints,inputs:e.inputs,invocationId:e.invocationId,orchestration:e.orchestration,taskId:e.taskId}),y=k("playwright");return await h(l,playwrightResolutionBootstrapSource(e.managedModuleEntrypoints,{consumerRoots:[e.rootDirectory],trustedImporterFiles:[i,a],trustedInternalEntrypoints:[e.moduleFile,y,j(w)]})),await h(a,T({digest:u.digest,file:u.file,sizeBytes:u.sizeBytes,invocationId:e.invocationId,taskId:e.taskId})),await h(i,x({baseConfigFile:r,baseUrl:e.baseUrl,browserFile:e.browserFile,inputBootstrapFile:a,outputDirectory:p,reporterFile:y,report:{attachmentDirectory:c,identity:{engineId:"playwright",invocationId:e.invocationId,taskId:e.taskId,sourceFile:e.sourceFile},reportFile:f,workspaceDirectory:e.taskDirectory},rootDirectory:e.rootDirectory,sourceFile:e.sourceFile})),{attachmentDirectory:c,configFile:i,inputBootstrapFile:a,outputDirectory:p,reportFile:f,resolutionBootstrapFile:l}}export function playwrightResolutionBootstrapSource(e,r){const t={authoring:s(e.authoring,"authoring"),cli:s(e.cli,"cli"),playwright:s(e.playwright,"playwright"),playwrightCore:s(e.playwrightCore,"playwrightCore"),playwrightTest:s(e.playwrightTest,"playwrightTest"),root:s(e.root,"root"),rootPackageJson:s(e.rootPackageJson,"rootPackageJson")},i={"@playwright/test":t.playwrightTest,playwright:t.playwright,"playwright-core":t.playwrightCore};return P({consumerRoots:r.consumerRoots,direct:{"@gfdelarue/testkit":t.root,"@gfdelarue/testkit/package.json":t.rootPackageJson,"@gfdelarue/testkit/playwright":t.authoring},directBridgeRoots:[o.dirname(t.root)],engineLabel:"Playwright",forbiddenConsumerPackagePrefixes:[],packageAnchors:i,reservedPackageNames:["@gfdelarue/testkit"],stateSymbol:"@gfdelarue/testkit/playwright-resolution-hooks/v1",trustedImporterFiles:r.trustedImporterFiles,trustedInternalEntrypoints:r.trustedInternalEntrypoints,verifiedParentlessPackageFiles:{playwright:["lib/common/process.js"]},verifiedProcessEntrypoints:[t.cli]})}function s(e,r){if(!o.isAbsolute(e))throw new Error(`Resolved Playwright installation ${r} entrypoint must be absolute`);return e}function x(e){return`
+import path from "node:path";
+import { createRequire } from "node:module";
+
+const OPTIONS = ${JSON.stringify({baseConfigUrl:e.baseConfigFile===null?null:g(e.baseConfigFile).href,baseUrl:e.baseUrl,browserFile:e.browserFile,exactTaskMatchSource:d(e.sourceFile),originalConfigDirectory:e.baseConfigFile===null?e.rootDirectory:o.dirname(e.baseConfigFile),originalConfigFile:e.baseConfigFile??o.join(e.rootDirectory,"__testkit_playwright_config__.mjs"),inputBootstrapUrl:g(e.inputBootstrapFile).href,outputDirectory:e.outputDirectory,report:e.report,reporterFile:e.reporterFile,rootDirectory:e.rootDirectory,sourceFile:e.sourceFile})};
+const inputBootstrap = await import(OPTIONS.inputBootstrapUrl);
+if (typeof inputBootstrap.installPlaywrightRuntimeInput !== "function")
+  throw new Error("Managed Playwright runtime-input bootstrap is invalid");
+await inputBootstrap.installPlaywrightRuntimeInput();
+const imported = OPTIONS.baseConfigUrl === null ? { default: {} } : await import(OPTIONS.baseConfigUrl);
+const base = imported.default ?? imported;
+if (!base || typeof base !== "object" || Array.isArray(base))
+  throw new Error("supportModules.playwrightConfig must default-export a Playwright config object");
+const resolver = createRequire(OPTIONS.originalConfigFile);
+const builtInReporters = new Set(["list", "line", "dot", "json", "junit", "null", "github", "html", "blob"]);
+const exactTaskMatch = new RegExp(OPTIONS.exactTaskMatchSource, "u");
+
+function absolutePath(value) {
+  return typeof value === "string" && value.length > 0
+    ? path.resolve(OPTIONS.originalConfigDirectory, value)
+    : value;
+}
+
+function absoluteTemplate(value) {
+  return typeof value === "string" && value.length > 0 && !path.isAbsolute(value)
+    ? path.join(OPTIONS.originalConfigDirectory, value)
+    : value;
+}
+
+function normalizeExpect(expect) {
+  if (!expect || typeof expect !== "object" || Array.isArray(expect)) return expect;
+  const screenshot = expect.toHaveScreenshot;
+  const aria = expect.toMatchAriaSnapshot;
+  return {
+    ...expect,
+    ...(screenshot && typeof screenshot === "object" ? {
+      toHaveScreenshot: {
+        ...screenshot,
+        ...(screenshot.stylePath === undefined ? {} : {
+          stylePath: Array.isArray(screenshot.stylePath)
+            ? screenshot.stylePath.map(absolutePath)
+            : absolutePath(screenshot.stylePath),
+        }),
+        ...(screenshot.pathTemplate === undefined ? {} : {
+          pathTemplate: absoluteTemplate(screenshot.pathTemplate),
+        }),
+      },
+    } : {}),
+    ...(aria && typeof aria === "object" && aria.pathTemplate !== undefined ? {
+      toMatchAriaSnapshot: { ...aria, pathTemplate: absoluteTemplate(aria.pathTemplate) },
+    } : {}),
+  };
+}
+
+function normalizeUse(use, label) {
+  const value = use && typeof use === "object" && !Array.isArray(use) ? use : {};
+  if (value.browserName !== undefined && value.browserName !== "chromium")
+    throw new Error(label + ".browserName must be chromium for the managed Playwright engine");
+  if (value.channel !== undefined)
+    throw new Error(label + ".channel is incompatible with the managed Playwright browser");
+  if (value.connectOptions !== undefined)
+    throw new Error(label + ".connectOptions is incompatible with the managed Playwright browser");
+  return {
+    ...value,
+    browserName: "chromium",
+    baseURL: OPTIONS.baseUrl,
+    launchOptions: {
+      ...(value.launchOptions && typeof value.launchOptions === "object" ? value.launchOptions : {}),
+      executablePath: OPTIONS.browserFile,
+    },
+  };
+}
+
+function normalizeSetups(value) {
+  if (value === undefined) return [];
+  return (Array.isArray(value) ? value : [value]).map(absolutePath);
+}
+
+function normalizeReporterEntry(entry) {
+  const tuple = typeof entry === "string" ? [entry] : entry;
+  if (!Array.isArray(tuple) || typeof tuple[0] !== "string") return tuple;
+  return [builtInReporters.has(tuple[0]) ? tuple[0] : resolver.resolve(tuple[0]), ...tuple.slice(1)];
+}
+
+function normalizeReporters(value) {
+  const entries = value === undefined
+    ? []
+    : typeof value === "string"
+      ? [[value]]
+      : isReporterTuple(value)
+        ? [value]
+        : value;
+  return [
+    ...entries.map(normalizeReporterEntry).filter(Boolean),
+    [OPTIONS.reporterFile, OPTIONS.report],
+  ];
+}
+
+function isReporterTuple(value) {
+  return Array.isArray(value)
+    && typeof value[0] === "string"
+    && (value.length === 1
+      || (value.length === 2
+        && value[1] !== null
+        && typeof value[1] === "object"
+        && !Array.isArray(value[1])));
+}
+
+function supportProjectNames(projects) {
+  const names = new Set();
+  for (const project of projects) {
+    if (!project || typeof project !== "object" || Array.isArray(project)) continue;
+    if (Array.isArray(project.dependencies)) {
+      for (const dependency of project.dependencies) {
+        if (typeof dependency === "string") names.add(dependency);
+      }
+    }
+    if (typeof project.teardown === "string") names.add(project.teardown);
+  }
+  return names;
+}
+
+function normalizeProject(project, index, supportNames) {
+  if (!project || typeof project !== "object" || Array.isArray(project))
+    throw new Error("Playwright config.projects[" + index + "] must be an object");
+  const isSupportProject = typeof project.name === "string" && supportNames.has(project.name);
+  return {
+    ...project,
+    ...(project.testDir === undefined ? {} : { testDir: absolutePath(project.testDir) }),
+    ...(project.snapshotDir === undefined ? {} : { snapshotDir: absolutePath(project.snapshotDir) }),
+    ...(project.snapshotPathTemplate === undefined ? {} : {
+      snapshotPathTemplate: absoluteTemplate(project.snapshotPathTemplate),
+    }),
+    expect: normalizeExpect(project.expect),
+    ...(isSupportProject ? {} : { testMatch: exactTaskMatch }),
+    use: normalizeUse(project.use, "Playwright config.projects[" + index + "].use"),
+    outputDir: OPTIONS.outputDirectory,
+  };
+}
+
+const projects = Array.isArray(base.projects) ? base.projects : null;
+const supportNames = projects === null ? new Set() : supportProjectNames(projects);
+
+export default {
+  ...base,
+  testDir: base.testDir === undefined ? OPTIONS.rootDirectory : absolutePath(base.testDir),
+  ...(projects === null ? { testMatch: exactTaskMatch } : {}),
+  ...(base.snapshotDir === undefined ? {} : { snapshotDir: absolutePath(base.snapshotDir) }),
+  ...(base.snapshotPathTemplate === undefined ? {} : {
+    snapshotPathTemplate: absoluteTemplate(base.snapshotPathTemplate),
+  }),
+  ...(base.tsconfig === undefined ? {} : { tsconfig: absolutePath(base.tsconfig) }),
+  expect: normalizeExpect(base.expect),
+  use: normalizeUse(base.use, "Playwright config.use"),
+  ...(projects === null ? {} : {
+    projects: projects.map((project, index) => normalizeProject(project, index, supportNames)),
+  }),
+  globalSetup: normalizeSetups(base.globalSetup),
+  globalTeardown: normalizeSetups(base.globalTeardown),
+  outputDir: OPTIONS.outputDirectory,
+  preserveOutput: "always",
+  reporter: normalizeReporters(base.reporter),
+  webServer: undefined,
+  fullyParallel: false,
+  workers: 1,
+};
+`}function d(e){return`^${e.split(/[\\/]+/u).map(r=>r.replace(/[.*+?^${}()|[\]\\]/gu,"\\$&")).join("[\\\\/]")}$`}async function D(e,r){if(!Object.hasOwn(r.supportModules,"playwrightConfig"))return null;const t=r.supportModules.playwrightConfig;if(!o.isAbsolute(t))throw new Error("supportModules.playwrightConfig must be an absolute path");return I(e,t,"supportModules.playwrightConfig")}function F(e){const r=Object.keys(e).filter(t=>t!=="playwrightConfig");if(r.length>0)throw new Error(`Playwright engine does not support support module(s): ${r.join(", ")}`)}async function I(e,r,t){const i=o.resolve(e,r),a=await n.realpath(i);if(!O(e,a))throw new Error(`${t} must stay within the consumer root`);if(!(await n.stat(a)).isFile())throw new Error(`${t} must be a regular file`);return a}function O(e,r){const t=o.relative(e,r);return t===""||!t.startsWith("..")&&!o.isAbsolute(t)}async function h(e,r){const t=await n.open(e,"wx",384);try{await t.writeFile(r,"utf8")}finally{await t.close()}}

package/dist/engines/playwright/adapter/evidence-validation.d.ts

@@ -0,0 +1,12 @@
+export declare function nonNegativeInteger(value: unknown, label: string): number;
+export declare function optionalNonNegativeInteger(value: unknown, label: string): number | null;
+export declare function nonNegativeNumber(value: unknown, label: string): number;
+export declare function requireNonEmptyString(value: unknown, label: string): string;
+export declare function optionalNonEmptyString(value: unknown): string | null;
+export declare function portableReportPath(value: string): string;
+export declare function portableRelativePath(rootDirectory: string, candidate: string): string;
+export declare function requireRecord(value: unknown, label: string): Record<string, unknown>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isPathWithin(rootDirectory: string, candidate: string): boolean;
+export declare function isMissingFileError(error: unknown): boolean;
+export declare function toError(error: unknown): Error;

package/dist/engines/playwright/adapter/evidence-validation.js

@@ -0,0 +1 @@
+import e from"node:path";export function nonNegativeInteger(t,r){if(typeof t!="number"||!Number.isSafeInteger(t)||t<0)throw new Error(`${r} must be a non-negative safe integer`);return t}export function optionalNonNegativeInteger(t,r){return t==null?null:nonNegativeInteger(t,r)}export function nonNegativeNumber(t,r){if(typeof t!="number"||!Number.isFinite(t)||t<0)throw new Error(`${r} must be a non-negative finite number`);return t}export function requireNonEmptyString(t,r){const n=optionalNonEmptyString(t);if(n===null)throw new Error(`${r} must be a non-empty string`);return n}export function optionalNonEmptyString(t){return typeof t=="string"&&t.trim().length>0?t.trim():null}export function portableReportPath(t){return t.replaceAll("\\","/")}export function portableRelativePath(t,r){return portableReportPath(e.relative(t,r))}export function requireRecord(t,r){if(!isRecord(t))throw new Error(`${r} must contain an object`);return t}export function isRecord(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}export function isPathWithin(t,r){const n=e.relative(t,r);return n===""||!n.startsWith("..")&&!e.isAbsolute(n)}export function isMissingFileError(t){return t instanceof Error&&"code"in t&&t.code==="ENOENT"}export function toError(t){return t instanceof Error?t:new Error(String(t))}

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

@@ -0,0 +1,32 @@
+import type { EngineEvidence, EngineFailureEvidence } from "../../api/index.js";
+import { type EvidenceFileAccess } from "../../adapters/evidence-files.js";
+import { type NativeReportIdentity } from "../../adapters/native-report.js";
+export interface PlaywrightEvidenceRequest {
+    readonly identity: NativeReportIdentity;
+    readonly artifactDirectory: string;
+    readonly outputDirectory: string;
+    readonly reportFile: string;
+    readonly rootDirectory: string;
+    readonly sourceFile: string;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+export interface PlaywrightReportClassification {
+    readonly failure: EngineFailureEvidence | null;
+    readonly status: "failed" | "not_run" | "passed" | "skipped";
+}
+export interface CollectedPlaywrightEvidence {
+    readonly attachmentFailures: readonly EngineFailureEvidence[];
+    readonly evidence: EngineEvidence;
+    readonly outputLimit: PlaywrightOutputArtifactLimit | null;
+    readonly report: PlaywrightReportClassification;
+    readonly reportError: Error | null;
+}
+export interface PlaywrightOutputArtifactLimit {
+    readonly bytes: number;
+    readonly entries: number;
+    readonly kind: "bytes" | "entries";
+    readonly limit: number;
+    readonly observed: number;
+}
+export declare function collectPlaywrightEvidence(request: Readonly<PlaywrightEvidenceRequest>, fileAccess?: EvidenceFileAccess): Promise<CollectedPlaywrightEvidence>;

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

@@ -0,0 +1 @@
+import P from"node:fs/promises";import d from"node:path";import{evidenceArtifact as A,evidenceFileAccess as J,readStableJsonFile as V,snapshotStableEvidenceFile as z,stableEvidenceFromBuffer as K,writeOwnedEvidenceFile as D}from"../../adapters/evidence-files.js";import{materializePlaywrightFailureDetails as Q}from"./failure-details.js";import{isMissingFileError as Z,isPathWithin as _,nonNegativeInteger as v,nonNegativeNumber as B,optionalNonEmptyString as $,optionalNonNegativeInteger as C,portableRelativePath as Y,portableReportPath as H,requireNonEmptyString as b,requireRecord as S,toError as q}from"./evidence-validation.js";import{readNativeReport as tt}from"../../adapters/native-report.js";import{attachmentLimitError as et,attachmentIoError as it,MAX_ATTACHMENT_BYTES as G,MAX_TOTAL_ATTACHMENT_BYTES as rt}from"./attachments.js";const nt=64*1024*1024,W=1e4,F=512*1024*1024,at=2*1024*1024,X=128,st=".testkit-playwright-evidence",ot=/(?:^|\n)(?:Error:\s*)?No tests found(?:\.|\n|$)/u;class M extends Error{limit;constructor(t){super(gt(t)),this.limit=t,this.name="PlaywrightOutputArtifactLimitError"}}export async function collectPlaywrightEvidence(e,t=J){await P.mkdir(e.artifactDirectory,{recursive:!0});const c=await P.realpath(e.artifactDirectory),s=await P.realpath(e.rootDirectory),a=d.join(c,st);await P.mkdir(a,{mode:448,recursive:!1});const i=[],l=[];for(const o of["stdout","stderr"]){const g=e[o];if(g.length===0)continue;i.push({stream:o,text:g});const y=K(Buffer.from(g,"utf8")),E=await D(a,`${o}.log`,y.contents);l.push(A(E,y,"text/plain; charset=utf-8","engine.process-output",`playwright-${o}`,`${y.sizeBytes.toString()} bytes`))}let u=null,p=null,h=new Set,f=[];try{const o=await V(e.reportFile,nt,"Testkit native Playwright report",t);if(o.file===null)u=new Error("Playwright did not produce its Testkit native report");else{p=lt(tt(o.value,e.identity).result);const g=await D(a,"testkit-playwright-report.json",o.file.contents);l.push(A(g,o.file,"application/json","engine.testkit-playwright-report","testkit-playwright-report","Testkit native Playwright report")),i.push(...p.logs);const y=await Q(a,p.failureDetails);y!==null&&l.push(y);const E=await dt(c,a,s,p.attachments,t);l.push(...E.artifacts),h=E.sourcePaths,f=E.failures}}catch(o){u=q(o)}let r={artifacts:[],bytes:0,entries:0},n=null;try{r=await ht(c,a,e.outputDirectory,h,t),l.push(...r.artifacts)}catch(o){if(!(o instanceof M))throw o;n=o.limit,i.push({stream:"engine",text:o.message})}const m=ct(p,s,e.sourceFile),w=n??r;return{attachmentFailures:f,evidence:{artifacts:l,logs:i,metrics:[...Object.entries(p?.stats??{}).map(([o,g])=>({name:o==="duration"?"playwright.duration":`playwright.tests.${o}`,unit:o==="duration"?"milliseconds":"tests",value:g})),...["bytes","entries"].map(o=>({name:`playwright.output.${o}`,unit:o,value:w[o]}))],...p===null?{}:{native:{playwright:{attachmentFailures:f.map(o=>({...o})),specs:p.specs,stats:p.stats}}}},outputLimit:n,report:m,reportError:u}}function ct(e,t,c){if(e===null)return{failure:null,status:"failed"};const s=e.specs.filter((i,l)=>d.relative(d.normalize(c),e.sourceFiles[l])===""),a=e.failureMessages.length>0&&e.failureMessages.every(i=>ot.test(i));return e.stats.unexpected>0||e.failureMessages.length>0&&(!a||s.length>0)?{failure:{...e.failureMessages.some(i=>/browserType\.launch(?:PersistentContext)?:/u.test(i)&&/Executable doesn't exist|Host system is missing dependencies|error while loading shared libraries|Failed to launch/u.test(i))?{classification:"infra"}:{},code:"PLAYWRIGHT_SPECS_FAILED",details:{stats:e.stats,specs:e.specs.slice(0,50)},message:e.failureMessages.at(0)??`${e.stats.unexpected.toString()} Playwright test(s) failed`},status:"failed"}:s.length>0?{failure:null,status:s.every(i=>i.status==="skipped")?"skipped":"passed"}:{failure:{code:"PLAYWRIGHT_NO_TESTS",details:{file:Y(t,c),reportedSpecs:e.specs.slice(0,50),stats:e.stats},message:"Selected Playwright task did not execute any tests"},status:"failed"}}function lt(e){const t=S(e,"Playwright native report result"),c=mt(t.stats),s=N(t.errors,"errors"),a=[],i=[],l=[],u=new Set,p={expected:0,flaky:0,skipped:0,unexpected:0};for(const r of k(t.specs,"specs")){const n=S(r,"Playwright native report spec"),m=b(n.id,"Playwright native spec.id");if(u.has(m))throw new Error("Playwright native report contains a duplicate test identity");u.add(m);const w=b(n.title,"Playwright native spec.title"),o=N(n.parents,"spec.parents");o.length>0&&(o[0]=H(o[0]));const g=H(b(n.file,"Playwright native spec.file")),y=b(n.sourceFile,"Playwright native spec.sourceFile");if(!d.isAbsolute(y)&&!d.win32.isAbsolute(y))throw new Error("Playwright native spec.sourceFile must be absolute");const E=x(n.projectName,"spec.projectName"),T=n.status;if(T!=="expected"&&T!=="flaky"&&T!=="skipped"&&T!=="unexpected")throw new Error("Playwright native spec.status is invalid");p[T]+=1;const I=N(n.failureMessages,"spec.failureMessages"),L=n.failureStack===null?null:x(n.failureStack,"spec.failureStack"),j=C(n.line,"Playwright native spec.line"),O=C(n.column,"Playwright native spec.column");T==="unexpected"&&(s.push(...I),l.push({kind:"playwright-spec",key:w,title:w,count:1,message:I[0]??`Playwright reported "${w}" as an unexpected failure`,...o.length===0?{}:{suitePath:o},location:{path:g,...j===null?{}:{line:j},...O===null?{}:{column:O}},...L===null?{}:{stack:L}})),i.push(y),a.push({durationMs:B(n.durationMs,"Playwright native spec.durationMs"),retries:v(n.retries,"Playwright native spec.retries"),file:g,projectName:E,status:T,title:[...o,w].filter(Boolean).join(" > ")})}for(const r of["expected","flaky","skipped","unexpected"])if(c[r]!==p[r])throw new Error("Playwright native report stats do not match its cases");const h=k(t.logs,"logs").map(r=>{const n=S(r,"Playwright native report log");if(n.stream!=="stdout"&&n.stream!=="stderr")throw new Error("Playwright native report log stream is invalid");return{stream:n.stream,text:x(n.text,"log.text")}});return{attachments:k(t.attachments,"attachments").map((r,n)=>ut(r,n,u)),failureDetails:l,failureMessages:s,logs:wt(h),sourceFiles:i,specs:a,stats:c}}function k(e,t){if(!Array.isArray(e))throw new Error(`Playwright native report ${t} must be an array`);return e}function N(e,t){return k(e,t).map(c=>x(c,t))}function x(e,t){if(typeof e!="string")throw new Error(`Playwright native report ${t} must be a string`);return e}function ut(e,t,c){const s=S(e,`Playwright attachment[${t.toString()}]`),a=b(s.specId,"Playwright attachment.specId");if(!c.has(a))throw new Error("Playwright native attachment references an unknown test identity");const i=$(s.path),l=s.error===void 0?void 0:pt(s.error);if(s.body!==void 0||i===null&&l===void 0)throw new Error("Playwright attachment must contain a path or an error");return{contentType:$(s.contentType)??"application/octet-stream",name:$(s.name)??`attachment-${t.toString()}`,specId:a,...i===null?{}:{path:i},...l===void 0?{}:{error:l},retry:v(s.retry,"Playwright attachment.retry"),specTitle:b(s.specTitle,"Playwright attachment.specTitle")}}function pt(e){const t=S(e,"Playwright attachment.error");if(t.kind==="io")return{kind:"io",message:b(t.message,"Playwright attachment.error.message")};const c=t.kind;if(c!=="individual"&&c!=="total")throw new Error("Playwright attachment.error has an invalid kind");const s=c==="individual"?G:rt,a=v(t.observed,"Playwright attachment.error.observed");if(t.limit!==s||a<=s)throw new Error("Playwright attachment.error has an invalid limit");return{kind:c,limit:s,observed:a}}function R(e,t){const{name:c,specId:s,specTitle:a,retry:i}=e,l=t.kind==="io"?t.message:`exceeds its ${t.limit.toString()} byte ${t.kind} limit (observed ${t.observed.toString()} bytes)`;return{code:t.kind==="io"?"PLAYWRIGHT_ATTACHMENT_FAILED":"PLAYWRIGHT_ATTACHMENT_LIMIT",...t.kind==="io"?{classification:"infra"}:{},details:{name:c,specId:s,specTitle:a,retry:i,...t},message:`Playwright attachment "${c}" (${a}, retry ${i.toString()}): ${l}`}}async function dt(e,t,c,s,a){const i=[],l=[],u=new Set;let p=0;const h=d.join(t,"attachments");s.length>0&&await P.mkdir(h,{mode:448,recursive:!1});for(const[f,r]of s.entries())try{if(r.error!==void 0){r.path!==void 0&&u.add(d.resolve(c,r.path)),l.push(R(r,r.error));continue}const n=await yt(r.path,c,e,a);u.add(n.file);const m=v(Number(n.identity.size),"Playwright attachment size"),w=et(m,p+m);if(w!==null){l.push(R(r,w));continue}const o=await z(n.file,G,"Playwright attachment",a,n.identity,h,`${f.toString().padStart(4,"0")}-${U(r.name)}${Pt(r)}`);p+=o.identity.sizeBytes,i.push({path:o.filePath,contentType:r.contentType,kind:"engine.playwright-attachment",name:r.name,summary:`${r.specTitle} retry ${r.retry.toString()}`,metadata:{...o.identity,specId:r.specId,specTitle:r.specTitle,retry:r.retry}})}catch(n){l.push(R(r,it(n)))}return{artifacts:i,failures:l,sourcePaths:u}}async function ht(e,t,c,s,a){try{const i=await a.lstat(c);if(!i.isDirectory()||i.isSymbolicLink())throw new Error("Playwright output directory must be a non-symbolic-link directory");const l=await P.realpath(c);if(!_(e,l))throw new Error("Playwright output directory escaped the artifact root");const u=await ft(l,s,a),p=[],h=d.join(t,"output");u.candidates.length>0&&await P.mkdir(h,{mode:448,recursive:!1});for(const[f,r]of u.candidates.entries()){const n=await z(r.file,F,"Playwright output file",a,r.identity,h,`${f.toString().padStart(5,"0")}-${U(d.basename(r.file))}${Et(r.file)}`);p.push(A(n.filePath,n.identity,vt(r.file),"engine.playwright-output",r.relativePath,"Playwright output"))}return{artifacts:p,bytes:u.bytes,entries:u.entries}}catch(i){if(Z(i))return{artifacts:[],bytes:0,entries:0};throw i}}async function ft(e,t,c){const s=[];let a=0,i=0;const l=[{depth:0,directory:e}];for(;l.length>0;){const u=l.pop();if(u===void 0)continue;if(u.depth>X)throw new Error(`Playwright output exceeds the ${X.toString()} level directory depth limit`);const p=u.directory,h=await P.readdir(p,{withFileTypes:!0});h.sort((f,r)=>f.name.localeCompare(r.name));for(const f of h){if(i+=1,i>W)throw new M({bytes:a,entries:i,kind:"entries",limit:W,observed:i});const r=d.join(p,f.name),n=await c.lstat(r);if(n.isSymbolicLink())throw new Error("Playwright output must not contain symbolic links");if(n.isDirectory()){l.push({depth:u.depth+1,directory:r});continue}if(!n.isFile())continue;if(n.size<0n||n.size>BigInt(Number.MAX_SAFE_INTEGER))throw new Error("Playwright output file has an invalid size");const m=Number(n.size);if(a+=m,!Number.isSafeInteger(a)||a>F)throw new M({bytes:a,entries:i,kind:"bytes",limit:F,observed:a});t.has(r)||s.push({file:r,identity:n,relativePath:Y(e,r)})}}return{bytes:a,candidates:s,entries:i}}function gt(e){return e.kind==="bytes"?`Playwright output exceeds its ${e.limit.toString()} byte aggregate limit (observed ${e.observed.toString()} bytes)`:`Playwright output exceeds its ${e.limit.toString()} entry limit (observed ${e.observed.toString()} entries)`}async function yt(e,t,c,s){if(e===void 0)throw new Error("Playwright path attachment did not declare a path");const a=d.resolve(t,e),i=await s.lstat(a);if(!i.isFile()||i.isSymbolicLink())throw new Error("Playwright attachment path must be a regular non-symbolic-link file");const l=await P.realpath(a);if(!_(t,l)&&!_(c,l))throw new Error("Playwright attachment path must stay within the consumer or artifact root");return{file:l,identity:i}}function mt(e){const t=S(e,"Playwright report.stats");return{expected:v(t.expected,"Playwright stats.expected"),unexpected:v(t.unexpected,"Playwright stats.unexpected"),flaky:v(t.flaky,"Playwright stats.flaky"),skipped:v(t.skipped,"Playwright stats.skipped"),duration:B(t.duration,"Playwright stats.duration")}}function wt(e){let t=at;const c=[];for(const s of e){if(t<=0)break;const i=Buffer.from(s.text,"utf8").subarray(0,t).toString("utf8");i.length>0&&c.push({...s,text:i}),t-=Buffer.byteLength(i)}return t<=0&&c.push({stream:"engine",text:"Playwright report log evidence was truncated at its bounded limit"}),c}function Pt(e){if(e.path!==void 0){const t=d.extname(e.path);if(/^\.[a-z0-9]{1,12}$/iu.test(t))return t}return e.contentType==="application/json"?".json":e.contentType.startsWith("text/")?".txt":e.contentType==="image/png"?".png":e.contentType==="image/jpeg"?".jpg":".bin"}function vt(e){const t=d.extname(e).toLowerCase();return t===".json"?"application/json":t===".zip"?"application/zip":t===".png"?"image/png":t===".jpg"||t===".jpeg"?"image/jpeg":t===".webm"?"video/webm":[".log",".txt",".md"].includes(t)?"text/plain; charset=utf-8":"application/octet-stream"}function Et(e){const t=d.extname(e).toLowerCase();return/^\.[a-z0-9]{1,12}$/u.test(t)?t:".bin"}function U(e){const t=e.trim().toLowerCase().replace(/[^a-z0-9._-]+/gu,"-").replace(/^-+|-+$/gu,"").slice(0,80);return t.length>0?t:"attachment"}

package/dist/engines/playwright/adapter/failure-details.d.ts

@@ -0,0 +1,2 @@
+import type { EngineArtifactEvidence, EngineJsonObject } from "../../api/index.js";
+export declare function materializePlaywrightFailureDetails(ownedEvidenceRoot: string, failureDetails: readonly EngineJsonObject[]): Promise<EngineArtifactEvidence | null>;

package/dist/engines/playwright/adapter/failure-details.js

@@ -0,0 +1,2 @@
+import{evidenceArtifact as a,stableEvidenceFromBuffer as l,writeOwnedEvidenceFile as s}from"../../adapters/evidence-files.js";export async function materializePlaywrightFailureDetails(n,t){if(t.length===0)return null;const e={phase:"exec",failures:t},i=l(Buffer.from(`${JSON.stringify(e,null,2)}
+`,"utf8")),r=await s(n,"playwright-failure-details.json",i.contents);return{...a(r,i,"application/json","testkit.failure-details","playwright-failure-details",`${t.length.toString()} failed Playwright spec${t.length===1?"":"s"}`),data:e}}

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

@@ -0,0 +1,3 @@
+export { executePlaywrightEngine } from "./adapter.js";
+export { readPlaywrightContext, type PlaywrightTestContext } from "../runtime/runtime-input.js";
+export { playwrightResolutionBootstrapSource, type PlaywrightManagedModuleEntrypoints, type PlaywrightResolutionBoundary, } from "./config.js";

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

@@ -0,0 +1 @@
+export{executePlaywrightEngine}from"./adapter.js";export{readPlaywrightContext}from"../runtime/runtime-input.js";export{playwrightResolutionBootstrapSource}from"./config.js";

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

@@ -0,0 +1,12 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestError } from "@playwright/test/reporter";
+import { type PlaywrightReporterOptions } from "./attachments.js";
+export default class TestkitPlaywrightReporter implements Reporter {
+    private readonly options;
+    private config;
+    private suite;
+    private readonly errors;
+    constructor(options: PlaywrightReporterOptions);
+    onBegin(config: FullConfig, suite: Suite): void;
+    onError(error: TestError): void;
+    onEnd(result: FullResult): Promise<void>;
+}

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

@@ -0,0 +1 @@
+import f from"node:path";import v from"node:fs/promises";import T from"node:crypto";import{writeNativeReport as j}from"../../adapters/native-report.js";import{writeOwnedEvidenceFile as D}from"../../adapters/evidence-files.js";import{attachmentIoError as M,attachmentLimitError as A}from"./attachments.js";export default class F{options;config;suite;errors=[];constructor(o){this.options=o}onBegin(o,l){this.config=o,this.suite=l}onError(o){this.errors.push(P(o))}async onEnd(o){const l=this.suite.allTests(),e={duration:o.duration,expected:0,flaky:0,skipped:0,unexpected:0},u=[],p=[];let m=0;const d=[];for(const r of l){const y=r.outcome();e[y]+=1;let g=0,h=0,w=[],b=null;for(const n of r.results){g+=n.duration,h=Math.max(h,n.retry);for(const t of["stdout","stderr"])for(const s of n[t])u.push({stream:t,text:typeof s=="string"?s:s.toString("utf8")});for(const t of n.attachments){const s={name:t.name,contentType:t.contentType,...t.path===void 0?{}:{path:t.path},specId:r.id,specTitle:r.title,retry:n.retry};try{let a=t.body?.byteLength;if(a===void 0){if(t.path===void 0)throw new Error("Attachment has no body or path");const c=await v.lstat(t.path);if(!c.isFile()||c.isSymbolicLink())throw new Error("Attachment path must be a regular non-symbolic-link file");a=c.size}const k=A(a,m+a);if(k!==null){p.push({...s,error:k});continue}let E=t.path;if(t.body!==void 0){const c=this.options.attachmentDirectory;if(await v.realpath(c)!==f.resolve(c))throw new Error("Attachment directory must not resolve through symbolic links");E=await D(c,T.randomUUID(),t.body)}p.push({...s,path:E}),m+=a}catch(a){p.push({...s,error:M(a)})}}n.errors.length>0&&(w=n.errors.map(P),b=n.errors.find(t=>t.stack)?.stack??null)}d.push({id:r.id,title:r.title,parents:I(r,this.config.rootDir),file:x(this.config.rootDir,r.location.file),sourceFile:r.location.file,projectName:r.parent.project()?.name??"",line:r.location.line,column:r.location.column,status:y,durationMs:g,retries:h,failureMessages:w,failureStack:b})}await j(this.options,{stats:e,specs:d,logs:u,attachments:p,errors:this.errors},64*1024*1024)}}function I(i,o){const l=[];for(let e=i.parent;e&&e.type!=="project"&&e.type!=="root";e=e.parent)l.unshift(e.type==="file"&&e.location?x(o,e.location.file):e.title);return l}function x(i,o){return f.relative(i,o).split(f.sep).join("/")}function P(i){return i.message?.trim()||i.stack?.trim()||i.value?.trim()||"Playwright reported an error"}

package/dist/engines/playwright/runtime/config-file.d.ts

@@ -0,0 +1,2 @@
+export declare const PLAYWRIGHT_CONFIG_FILENAMES: readonly string[];
+export declare function findPlaywrightConfigFile(directory: string): null | string;

package/dist/engines/playwright/runtime/config-file.js

@@ -0,0 +1 @@
+import r from"node:fs";import e from"node:path";export const PLAYWRIGHT_CONFIG_FILENAMES=Object.freeze(["playwright.config.ts","playwright.config.mts","playwright.config.js","playwright.config.mjs","playwright.config.cjs","playwright.config.cts"]);export function findPlaywrightConfigFile(t){for(const o of PLAYWRIGHT_CONFIG_FILENAMES){const i=e.join(t,o);try{if(r.statSync(i).isFile())return i}catch(n){if(c(n,"ENOENT"))continue;throw new Error(`Could not inspect optional support module ${i}`,{cause:n})}}return null}function c(t,o){return typeof t=="object"&&t!==null&&Reflect.get(t,"code")===o}

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

@@ -0,0 +1,24 @@
+import { type PlaywrightTestConfig } from "@playwright/test";
+export type DefinedTestkitPlaywrightConfig<TestArgs = object, WorkerArgs = object> = Omit<PlaywrightTestConfig<TestArgs, WorkerArgs>, "expect" | "globalTimeout" | "timeout" | "use" | "webServer"> & {
+    expect: Omit<NonNullable<PlaywrightTestConfig<TestArgs, WorkerArgs>["expect"]>, "timeout"> & {
+        timeout: number;
+    };
+    globalTimeout?: number;
+    timeout: number;
+    use: Omit<NonNullable<PlaywrightTestConfig<TestArgs, WorkerArgs>["use"]>, "actionTimeout" | "baseURL" | "navigationTimeout"> & {
+        actionTimeout: number;
+        baseURL?: string;
+        navigationTimeout: number;
+    };
+    webServer?: PlaywrightTestConfig<TestArgs, WorkerArgs>["webServer"];
+};
+export interface PlaywrightConfigOptions {
+    cwd?: string;
+    defaultFileTimeoutSeconds?: number;
+    dotenvFiles?: string[];
+    env?: NodeJS.ProcessEnv;
+    onlyWhenAllowed?: boolean;
+    override?: boolean;
+}
+export declare function defineTestkitConfig(): DefinedTestkitPlaywrightConfig;
+export declare function defineTestkitConfig<TestArgs = object, WorkerArgs = object>(config: PlaywrightTestConfig<TestArgs, WorkerArgs>, options?: PlaywrightConfigOptions): DefinedTestkitPlaywrightConfig<TestArgs, WorkerArgs>;

package/dist/engines/playwright/runtime/config.js

@@ -0,0 +1 @@
+import{DEFAULT_FILE_TIMEOUT_SECONDS as w,INTERNAL_FILE_TIMEOUT_SECONDS_ENV as b}from"../../../domain/file-timeout.js";import{readPlaywrightContext as E}from"./runtime-input.js";import{defineConfig as T}from"@playwright/test";import{loadDotenvFiles as y}from"../../../config/runtime/env/index.js";export function defineTestkitConfig(e={},n={}){const t=n.env||process.env;y({cwd:n.cwd,env:t,files:n.dotenvFiles||[".env.local"],onlyWhenAllowed:n.onlyWhenAllowed,override:n.override});const o=S(t,n.defaultFileTimeoutSeconds)*1e3,i=E(),c=i?.managed===!0,s=a(e.use,"Playwright config.use"),d=a(e.expect,"Playwright config.expect"),f=U(s.baseURL,"Playwright config.use.baseURL"),u=i?.baseUrl??t.BASE_URL??f,m={...s,...u?{baseURL:u}:{},actionTimeout:o,navigationTimeout:o},g={...e,...c?{globalTimeout:o}:{},timeout:o,expect:{...d,timeout:o},use:m,...c?{webServer:void 0}:{}};return T(g)}function S(e,n){const t=e[b],r=l(n??w);return t==null?r:l(t)}function l(e){const n=Number(e);if(!Number.isInteger(n)||n<=0)throw new Error("Playwright file timeout seconds must be a positive integer.");return n}function a(e,n){if(e==null)return{};if(!h(e))throw new Error(`${n} must be an object`);return e}function h(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function U(e,n){if(e!=null){if(typeof e!="string")throw new Error(`${n} must be a string`);return e}}

package/dist/engines/playwright/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export * from "@playwright/test";
+export { readPlaywrightContext, type PlaywrightTestContext } from "./runtime-input.js";
+export { defineTestkitConfig, type DefinedTestkitPlaywrightConfig, type PlaywrightConfigOptions } from "./config.js";
+export { assertSafeUiTarget, assertSafeUiTargets, createAuthedApiClient, createSandboxId, createUiSandbox, resolveBackendBaseUrl, resolveFrontendBaseUrl, waitForAnimationFrames, waitForElementStable, waitForImagesLoaded, waitForNetworkIdle, waitForUiSettled, type UiSandboxFixture, type UiSandboxOptions, } from "./sandbox.js";

package/dist/engines/playwright/runtime/index.js

@@ -0,0 +1 @@
+export*from"@playwright/test";export{readPlaywrightContext}from"./runtime-input.js";export{defineTestkitConfig}from"./config.js";export{assertSafeUiTarget,assertSafeUiTargets,createAuthedApiClient,createSandboxId,createUiSandbox,resolveBackendBaseUrl,resolveFrontendBaseUrl,waitForAnimationFrames,waitForElementStable,waitForImagesLoaded,waitForNetworkIdle,waitForUiSettled}from"./sandbox.js";

package/dist/engines/playwright/runtime/runtime-input.d.ts

@@ -0,0 +1,36 @@
+import type { EngineExecutionInputs, EngineJsonObject, EngineJsonValue, EngineTaskOrchestration } from "../../api/index.js";
+export declare const PLAYWRIGHT_RUNTIME_INPUT_MAX_BYTES: number;
+export declare const PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_BYTES: number;
+export declare const PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_ENTRIES = 512;
+export interface PlaywrightTestContext {
+    readonly baseUrl: string;
+    readonly endpoints: Readonly<Record<string, string>>;
+    readonly env: Readonly<Record<string, string>>;
+    readonly fixtures: EngineJsonObject;
+    readonly managed: true;
+    readonly setupData?: EngineJsonValue;
+    readonly uiConfig: EngineJsonObject;
+}
+export interface PlaywrightRuntimeInputRequest {
+    readonly baseUrl: string;
+    readonly directory: string;
+    readonly endpoints: Readonly<Record<string, string>>;
+    readonly inputs: EngineExecutionInputs;
+    readonly invocationId: string;
+    readonly orchestration: EngineTaskOrchestration;
+    readonly taskId: string;
+}
+export interface MaterializedPlaywrightRuntimeInput {
+    readonly sizeBytes: number;
+    readonly digest: string;
+    readonly file: string;
+}
+export declare function readPlaywrightContext(): PlaywrightTestContext | null;
+export declare function materializePlaywrightRuntimeInput(request: Readonly<PlaywrightRuntimeInputRequest>): Promise<MaterializedPlaywrightRuntimeInput>;
+export declare function playwrightRuntimeInputBootstrapSource(input: Readonly<{
+    digest: string;
+    file: string;
+    sizeBytes: number;
+    invocationId: string;
+    taskId: string;
+}>): string;

package/dist/engines/playwright/runtime/runtime-input.js

@@ -0,0 +1,151 @@
+import l from"node:fs/promises";import c from"node:path";import{writeOwnedRuntimeInput as m,ownedRuntimeInputModuleUrl as f}from"../../runtime-input-file.js";import{requireBoundedJsonValue as y,RUNTIME_INPUT_JSON_BOUNDS as h}from"../../contracts/json-bounds.js";import{ENGINE_PROCESS_RESERVED_ENVIRONMENT_KEYS as g,managedProcessEnvironmentOverlayInstallerSource as w}from"../../../process/index.js";export const PLAYWRIGHT_RUNTIME_INPUT_MAX_BYTES=4*1024*1024,PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_BYTES=2*1024*1024,PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_ENTRIES=512;const d=new Set(["BASE_URL","FORCE_COLOR","NODE_OPTIONS","NO_COLOR","PLAYWRIGHT_BROWSERS_PATH","PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD","TESTKIT_ACTIVE","TESTKIT_INTERNAL_FILE_DEADLINE_MS","TESTKIT_INTERNAL_FILE_TIMEOUT_SECONDS","TESTKIT_INVOCATION_ID","TESTKIT_RUNTIME_ID","TESTKIT_TEST_FILE","TESTKIT_TEST_ID",...g].map(e=>e.toUpperCase())),p={filename:"runtime-input.json",label:"Playwright runtime input",maxSizeBytes:PLAYWRIGHT_RUNTIME_INPUT_MAX_BYTES},E=Symbol.for("@gfdelarue/testkit/playwright-runtime-input/v1");export function readPlaywrightContext(){const e=Reflect.get(globalThis,E);return T(e)?e.context:null}export async function materializePlaywrightRuntimeInput(e){if(!c.isAbsolute(e.directory))throw new Error("Playwright runtime-input directory must be absolute");await l.mkdir(e.directory,{recursive:!0,mode:448}),process.platform!=="win32"&&await l.chmod(e.directory,448);const t=I(e.inputs.environment),r={baseUrl:v(e.baseUrl),endpoints:e.endpoints,engineId:"playwright",environment:t,fixtures:e.inputs.fixtures,invocationId:e.invocationId,managed:!0,schemaVersion:1,taskId:e.taskId,uiConfig:e.inputs.configuration??{},...e.inputs.setupData===void 0?{}:{setupData:e.inputs.setupData}},o=await m(e.directory,r,p);return{digest:o.sha256,file:o.file,sizeBytes:o.sizeBytes}}export function playwrightRuntimeInputBootstrapSource(e){const t=JSON.stringify({digest:e.digest,file:e.file,ownedInput:{directory:c.dirname(e.file),file:e.file,sha256:e.digest,sizeBytes:e.sizeBytes},protocol:p,invocationId:e.invocationId,jsonBounds:h,maximumEnvironmentBytes:PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_BYTES,maximumEnvironmentEntries:PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_ENTRIES,reservedEnvironmentKeys:[...d],taskId:e.taskId}),n=w(),r=`const requireBoundedJsonValue = (${y.toString()});`;return`
+import path from "node:path";
+import { readVerifiedOwnedFile } from ${JSON.stringify(f)};
+
+${n}
+${r}
+const OPTIONS = ${t};
+const STATE = Symbol.for("@gfdelarue/testkit/playwright-runtime-input/v1");
+
+export async function installPlaywrightRuntimeInput() {
+  const existing = installedRuntimeInput();
+  if (existing !== undefined) return existing;
+  if (!path.isAbsolute(OPTIONS.file))
+    throw new Error("Playwright runtime input file must be absolute");
+  if (!/^[a-f0-9]{64}$/u.test(OPTIONS.digest))
+    throw new Error("Playwright runtime input digest is invalid");
+  const contents = await readVerifiedOwnedFile(OPTIONS.ownedInput, OPTIONS.protocol);
+  const digest = OPTIONS.digest;
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (error) {
+    throw new Error("Playwright runtime input is not valid JSON", { cause: error });
+  }
+  const input = deepFreezeJson(validateRuntimeInput(parsed));
+  const installed = installedRuntimeInput();
+  if (installed !== undefined) return installed;
+  installManagedProcessEnvironmentOverlay({
+    environment: input.environment,
+    label: "Playwright",
+  });
+  const context = Object.freeze({
+    baseUrl: input.baseUrl,
+    endpoints: input.endpoints,
+    env: input.environment,
+    fixtures: input.fixtures,
+    managed: true,
+    ...(input.setupData === undefined ? {} : { setupData: input.setupData }),
+    uiConfig: input.uiConfig,
+  });
+  const state = Object.freeze({ context, digest, file: OPTIONS.file, input });
+  Object.defineProperty(globalThis, STATE, {
+    configurable: false,
+    enumerable: false,
+    value: state,
+    writable: false,
+  });
+  return state;
+}
+
+function installedRuntimeInput() {
+  const existing = globalThis[STATE];
+  if (existing !== undefined && (existing.file !== OPTIONS.file || existing.digest !== OPTIONS.digest || existing.context === undefined || existing.input === undefined))
+    throw new Error("Playwright process attempted to install conflicting runtime input");
+  return existing;
+}
+
+function deepFreezeJson(root) {
+  const pending = [root];
+  while (pending.length > 0) {
+    const value = pending.pop();
+    if (value === null || typeof value !== "object" || Object.isFrozen(value)) continue;
+    Object.freeze(value);
+    for (const child of Object.values(value)) pending.push(child);
+  }
+  return root;
+}
+
+function validateRuntimeInput(value) {
+  const input = requireRecord(value, "Playwright runtime input");
+  const allowed = new Set(["baseUrl", "endpoints", "engineId", "environment", "fixtures", "invocationId", "managed", "schemaVersion", "setupData", "taskId", "uiConfig"]);
+  for (const key of Object.keys(input)) {
+    if (!allowed.has(key)) throw new Error("Playwright runtime input contains unsupported field " + key);
+  }
+  for (const key of ["baseUrl", "endpoints", "engineId", "environment", "fixtures", "invocationId", "managed", "schemaVersion", "taskId", "uiConfig"]) {
+    if (!Object.prototype.hasOwnProperty.call(input, key))
+      throw new Error("Playwright runtime input is missing field " + key);
+  }
+  if (input.schemaVersion !== 1 || input.engineId !== "playwright")
+    throw new Error("Playwright runtime input has an unsupported identity");
+  if (input.managed !== true)
+    throw new Error("Playwright runtime input must be managed by Testkit");
+  if (typeof input.baseUrl !== "string" || input.baseUrl.trim().length === 0)
+    throw new Error("Playwright runtime input.baseUrl must be a non-empty string");
+  let parsedBaseUrl;
+  try {
+    parsedBaseUrl = new URL(input.baseUrl);
+  } catch (error) {
+    throw new Error("Playwright runtime input.baseUrl must be a valid URL", { cause: error });
+  }
+  if ((parsedBaseUrl.protocol !== "http:" && parsedBaseUrl.protocol !== "https:") || parsedBaseUrl.href !== input.baseUrl)
+    throw new Error("Playwright runtime input.baseUrl must be a canonical HTTP(S) URL");
+  if (input.invocationId !== OPTIONS.invocationId || input.taskId !== OPTIONS.taskId)
+    throw new Error("Playwright runtime input does not match its invocation and task");
+  requireStringRecord(input.endpoints, "Playwright runtime input.endpoints");
+  validateEnvironment(input.environment);
+  requireRecord(input.fixtures, "Playwright runtime input.fixtures");
+  requireRecord(input.uiConfig, "Playwright runtime input.uiConfig");
+  requireBoundedJsonValue(input, "Playwright runtime input", OPTIONS.jsonBounds, {
+    unitLabel: "bytes",
+    unitsOf: (text) => Buffer.byteLength(text, "utf8"),
+  });
+  return input;
+}
+
+function validateEnvironment(value) {
+  const environment = requireStringRecord(value, "Playwright runtime input.environment");
+  const keys = Object.keys(environment);
+  if (keys.length > OPTIONS.maximumEnvironmentEntries)
+    throw new Error("Playwright runtime input.environment exceeds its entry limit");
+  const canonicalKeys = new Set();
+  let bytes = 0;
+  for (const [key, entry] of Object.entries(environment)) {
+    validateEnvironmentEntry(key, entry);
+    const canonicalKey = key.toUpperCase();
+    if (canonicalKeys.has(canonicalKey))
+      throw new Error("Playwright runtime input.environment contains case-insensitive duplicate key " + key);
+    if (canonicalKey.startsWith("TESTKIT_") || canonicalKey.startsWith("PLAYWRIGHT_") || canonicalKey.startsWith("PWTEST_") || canonicalKey.startsWith("PW_TEST_") || OPTIONS.reservedEnvironmentKeys.includes(canonicalKey))
+      throw new Error("Playwright runtime input.environment contains reserved key " + key);
+    canonicalKeys.add(canonicalKey);
+    bytes += Buffer.byteLength(key, "utf8") + Buffer.byteLength(entry, "utf8") + 2;
+    if (bytes > OPTIONS.maximumEnvironmentBytes)
+      throw new Error("Playwright runtime input.environment exceeds its byte limit");
+  }
+  return environment;
+}
+
+function validateEnvironmentEntry(key, value) {
+  if (key.length === 0 || key.includes("=") || key.includes("\\0"))
+    throw new Error("Playwright runtime input.environment contains an invalid key");
+  if (value.includes("\\0"))
+    throw new Error("Playwright runtime input.environment contains an invalid value for " + key);
+}
+
+function requireStringRecord(value, label) {
+  const record = requireRecord(value, label);
+  for (const [key, entry] of Object.entries(record)) {
+    if (key.length === 0 || typeof entry !== "string")
+      throw new Error(label + " must contain only named string values");
+  }
+  return record;
+}
+
+function requireRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error(label + " must be an object");
+  return value;
+}
+
+await installPlaywrightRuntimeInput();
+`}function T(e){return!u(e)||!u(e.context)||!u(e.input)?!1:typeof e.digest=="string"&&typeof e.file=="string"&&e.input.engineId==="playwright"&&e.input.schemaVersion===1&&Object.isFrozen(e)&&Object.isFrozen(e.context)&&Object.isFrozen(e.input)}function u(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function I(e){const t=Object.create(null),n=new Set;let r=0;const o=Object.entries(e);if(o.length>PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_ENTRIES)throw new Error(`Playwright consumer environment exceeds its ${PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_ENTRIES.toString()} entry limit`);for(const[s,a]of o){O(s,a);const i=s.toUpperCase();if(n.has(i))throw new Error(`Playwright consumer environment contains case-insensitive duplicate key ${s}`);if(n.add(i),i.startsWith("TESTKIT_")||i.startsWith("PLAYWRIGHT_")||i.startsWith("PWTEST_")||i.startsWith("PW_TEST_")||d.has(i))throw new Error(`Playwright consumer environment contains reserved key ${s}`);if(r+=Buffer.byteLength(s,"utf8")+Buffer.byteLength(a,"utf8")+2,r>PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_BYTES)throw new Error(`Playwright consumer environment exceeds its ${PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_BYTES.toString()} byte limit`);t[s]=a}return t}function v(e){if(typeof e!="string"||e.trim().length===0)throw new Error("Playwright runtime input base URL must be non-empty");let t;try{t=new URL(e)}catch(n){throw new Error("Playwright runtime input base URL must be a valid URL",{cause:n})}if(t.protocol!=="http:"&&t.protocol!=="https:")throw new Error("Playwright runtime input base URL must use HTTP or HTTPS");return t.href}function O(e,t){if(e.length===0||e.includes("=")||e.includes("\0")||typeof t!="string")throw new Error("Playwright consumer environment contains an invalid key");if(t.includes("\0"))throw new Error(`Playwright consumer environment contains an invalid value for ${e}`)}

package/dist/engines/playwright/runtime/sandbox.d.ts

@@ -0,0 +1,84 @@
+import { type APIRequest, type APIRequestContext, type Page } from "@playwright/test";
+export interface UiSandboxOptions {
+    allowRemote?: boolean;
+    backendBaseUrl?: string;
+    baseUrl?: string;
+    frontendBaseUrl?: string;
+    headers?: Record<string, string>;
+    prefix?: string;
+}
+export interface UiSandboxFixture {
+    backendBaseUrl: string;
+    frontendBaseUrl: string;
+    id: string;
+    page: Page;
+}
+interface UiSandboxFixtures {
+    testkitSandbox: UiSandboxFixture;
+}
+export interface UiAnimationPage {
+    evaluate(pageFunction: (frameCount: number) => Promise<void>, frameCount: number): Promise<void>;
+}
+export interface UiNetworkIdlePage extends UiAnimationPage {
+    waitForLoadState(state: "domcontentloaded" | "load" | "networkidle", options?: {
+        timeout?: number;
+    }): Promise<void>;
+}
+interface StableElement {
+    getBoundingClientRect(): {
+        toJSON(): unknown;
+    };
+}
+interface UiStableLocator {
+    evaluate(pageFunction: (node: StableElement, requiredStableFrames: number) => Promise<void>, requiredStableFrames: number): Promise<void>;
+    waitFor(options: {
+        state: "visible";
+        timeout?: number;
+    }): Promise<void>;
+}
+export interface UiStableElementPage {
+    locator(selector: string): UiStableLocator;
+}
+interface ImageElement {
+    readonly complete: boolean;
+    addEventListener(type: "error" | "load", listener: () => void, options: {
+        once: true;
+    }): void;
+}
+interface UiImageLocator {
+    count(): Promise<number>;
+    nth(index: number): {
+        evaluate(pageFunction: (element: ImageElement) => Promise<void> | undefined): Promise<void>;
+    };
+}
+export interface UiImagesPage {
+    locator(selector: string): UiImageLocator;
+}
+interface UiTargetOptions {
+    allowRemote?: unknown;
+}
+export declare function createUiSandbox(options?: UiSandboxOptions): {
+    expect: import("@playwright/test").Expect<{}>;
+    test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & UiSandboxFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+};
+export declare function createSandboxId(options?: Pick<UiSandboxOptions, "prefix">): string;
+export declare function resolveFrontendBaseUrl(options?: UiSandboxOptions): string;
+export declare function resolveBackendBaseUrl(options?: UiSandboxOptions): string;
+export declare function assertSafeUiTarget(url: unknown, options?: UiTargetOptions): string;
+export declare function assertSafeUiTargets(urls?: readonly unknown[], options?: UiTargetOptions): string[];
+export declare function createAuthedApiClient(playwrightRequest?: APIRequest, options?: UiSandboxOptions): Promise<APIRequestContext>;
+export declare function waitForUiSettled(page: UiNetworkIdlePage, options?: {
+    frames?: number;
+    timeout?: number;
+}): Promise<void>;
+export declare function waitForAnimationFrames(page: UiAnimationPage, frames?: unknown): Promise<void>;
+export declare function waitForNetworkIdle(page: UiNetworkIdlePage, options?: {
+    frames?: number;
+    timeout?: number;
+}): Promise<void>;
+export declare function waitForElementStable(page: UiStableElementPage, selector: string, options?: {
+    frames?: number;
+    timeout?: number;
+}): Promise<void>;
+export declare function waitForImagesLoaded(page: UiImagesPage, containerSelector?: string | null): Promise<void>;
+export {};