@mysten-incubation/devstack 0.0.0

package/dist/build-integrations/playwright/errors.d.mts

@@ -0,0 +1,82 @@
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/build-integrations/playwright/errors.d.ts
+declare const PlaywrightManifestDiscoveryError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "PlaywrightManifestDiscoveryError";
+} & Readonly<A>;
+/**
+ * The manifest could not be located on disk (no stack-scoped file
+ * along the walk-up path) AND the requested endpoint has no
+ * conventional URL fallback in the endpoint declaration registry.
+ *
+ * Recovery: run `devstack up` once to materialize the manifest, OR
+ * pass an explicit `baseURL` to the Playwright config helpers to
+ * bypass the discovery path.
+ */
+declare class PlaywrightManifestDiscoveryError extends PlaywrightManifestDiscoveryError_base<{
+  readonly message: string;
+  readonly searchedPaths: ReadonlyArray<string>;
+  readonly endpointKey?: string;
+  readonly recoveryHint: string;
+}> {}
+declare const PlaywrightManifestShapeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "PlaywrightManifestShapeError";
+} & Readonly<A>;
+/**
+ * The manifest file was located but failed to decode against
+ * `ManifestEnvelopeSchema`. Wraps the substrate's `ManifestError`
+ * (reason = `decode-failed` | `version-mismatch`) with a recovery
+ * recipe targeted at the Playwright user (delete + re-run `devstack
+ * up` rather than the engine-side recovery).
+ */
+declare class PlaywrightManifestShapeError extends PlaywrightManifestShapeError_base<{
+  readonly message: string;
+  readonly manifestPath: string;
+  readonly phase: 'shape' | 'parse' | 'version-mismatch';
+  readonly recoveryHint: string;
+  readonly cause?: unknown;
+}> {}
+declare const PlaywrightEndpointNotFoundError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "PlaywrightEndpointNotFoundError";
+} & Readonly<A>;
+/**
+ * The manifest decoded but the requested endpoint name/alias is not
+ * present.
+ * Typically caused by a typo in user config or by referencing an
+ * endpoint owned by a plugin not present in the resolved stack.
+ */
+declare class PlaywrightEndpointNotFoundError extends PlaywrightEndpointNotFoundError_base<{
+  readonly message: string;
+  readonly endpointKey: string;
+  readonly endpointName?: string;
+  readonly available: ReadonlyArray<string>;
+  readonly manifestKeys?: ReadonlyArray<string>;
+  readonly recoveryHint: string;
+}> {}
+declare const PlaywrightWalletAdapterError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "PlaywrightWalletAdapterError";
+} & Readonly<A>;
+/**
+ * The wallet-context test helper failed to reach the dev wallet's
+ * HTTP API (the supervisor's wallet plugin exposes an endpoint that
+ * tests POST to for sign-tx flows). Typical causes: supervisor not
+ * up, wallet endpoint not yet registered in the manifest, network
+ * partition between test runner and supervisor.
+ *
+ * This tag is throwable from in-spec helpers AND constructible by
+ * `wallet-context.ts` callers; it carries enough detail to format a
+ * Playwright-friendly assertion failure.
+ */
+declare class PlaywrightWalletAdapterError extends PlaywrightWalletAdapterError_base<{
+  readonly message: string;
+  readonly operation: 'sign-tx' | 'list-accounts' | 'switch-account' | 'fetch';
+  readonly url?: string;
+  readonly status?: number;
+  readonly cause?: unknown;
+}> {}
+/** Discriminated union of every error the Playwright preset emits. */
+type PlaywrightIntegrationError = PlaywrightManifestDiscoveryError | PlaywrightManifestShapeError | PlaywrightEndpointNotFoundError | PlaywrightWalletAdapterError;
+//#endregion
+export { PlaywrightEndpointNotFoundError, PlaywrightIntegrationError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError, PlaywrightWalletAdapterError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/build-integrations/playwright/errors.mjs

@@ -0,0 +1,43 @@
+import { Data } from "effect";
+//#region src/build-integrations/playwright/errors.ts
+/**
+* The manifest could not be located on disk (no stack-scoped file
+* along the walk-up path) AND the requested endpoint has no
+* conventional URL fallback in the endpoint declaration registry.
+*
+* Recovery: run `devstack up` once to materialize the manifest, OR
+* pass an explicit `baseURL` to the Playwright config helpers to
+* bypass the discovery path.
+*/
+var PlaywrightManifestDiscoveryError = class extends Data.TaggedError("PlaywrightManifestDiscoveryError") {};
+/**
+* The manifest file was located but failed to decode against
+* `ManifestEnvelopeSchema`. Wraps the substrate's `ManifestError`
+* (reason = `decode-failed` | `version-mismatch`) with a recovery
+* recipe targeted at the Playwright user (delete + re-run `devstack
+* up` rather than the engine-side recovery).
+*/
+var PlaywrightManifestShapeError = class extends Data.TaggedError("PlaywrightManifestShapeError") {};
+/**
+* The manifest decoded but the requested endpoint name/alias is not
+* present.
+* Typically caused by a typo in user config or by referencing an
+* endpoint owned by a plugin not present in the resolved stack.
+*/
+var PlaywrightEndpointNotFoundError = class extends Data.TaggedError("PlaywrightEndpointNotFoundError") {};
+/**
+* The wallet-context test helper failed to reach the dev wallet's
+* HTTP API (the supervisor's wallet plugin exposes an endpoint that
+* tests POST to for sign-tx flows). Typical causes: supervisor not
+* up, wallet endpoint not yet registered in the manifest, network
+* partition between test runner and supervisor.
+*
+* This tag is throwable from in-spec helpers AND constructible by
+* `wallet-context.ts` callers; it carries enough detail to format a
+* Playwright-friendly assertion failure.
+*/
+var PlaywrightWalletAdapterError = class extends Data.TaggedError("PlaywrightWalletAdapterError") {};
+//#endregion
+export { PlaywrightEndpointNotFoundError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError, PlaywrightWalletAdapterError };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/build-integrations/playwright/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../src/build-integrations/playwright/errors.ts"],"sourcesContent":["// Playwright build-integration errors.\n//\n// Architecture (distilled/23-build-integrations.md § Playwright):\n// every failure surface for the preset is a tagged error so the\n// config-load (synchronous, runs before any supervisor exists) can\n// raise a structured signal with an embedded recovery recipe rather\n// than an opaque downstream NPE.\n//\n// Scope discipline: this surface owns FOUR error tags. Anything that\n// would be a fifth tag is either upstream (manifest schema error from\n// the L0 substrate, which we re-raise unchanged) or a programmer\n// defect (Effect.die / throw — not part of this contract).\n//\n// The Playwright config-load is synchronous (Playwright's\n// `defineConfig` is sync), so these errors are constructed and\n// thrown rather than `Effect.fail`-ed. The surface mirrors the\n// `Data.TaggedError` shape so the tags are uniform across the\n// codebase, but the catch sites are `try` / `instanceof` in\n// Playwright host code.\n\nimport { Data } from 'effect';\n\n// -----------------------------------------------------------------------------\n// Discovery — manifest could not be located and no conventional URL\n// fallback exists for the requested endpoint.\n// -----------------------------------------------------------------------------\n\n/**\n * The manifest could not be located on disk (no stack-scoped file\n * along the walk-up path) AND the requested endpoint has no\n * conventional URL fallback in the endpoint declaration registry.\n *\n * Recovery: run `devstack up` once to materialize the manifest, OR\n * pass an explicit `baseURL` to the Playwright config helpers to\n * bypass the discovery path.\n */\nexport class PlaywrightManifestDiscoveryError extends Data.TaggedError(\n\t'PlaywrightManifestDiscoveryError',\n)<{\n\treadonly message: string;\n\treadonly searchedPaths: ReadonlyArray<string>;\n\treadonly endpointKey?: string;\n\treadonly recoveryHint: string;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Shape — manifest exists but failed to decode against the L0\n// envelope schema.\n// -----------------------------------------------------------------------------\n\n/**\n * The manifest file was located but failed to decode against\n * `ManifestEnvelopeSchema`. Wraps the substrate's `ManifestError`\n * (reason = `decode-failed` | `version-mismatch`) with a recovery\n * recipe targeted at the Playwright user (delete + re-run `devstack\n * up` rather than the engine-side recovery).\n */\nexport class PlaywrightManifestShapeError extends Data.TaggedError('PlaywrightManifestShapeError')<{\n\treadonly message: string;\n\treadonly manifestPath: string;\n\treadonly phase: 'shape' | 'parse' | 'version-mismatch';\n\treadonly recoveryHint: string;\n\treadonly cause?: unknown;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Endpoint lookup — manifest decoded fine but the requested endpoint\n// is absent from the flat lookup.\n// -----------------------------------------------------------------------------\n\n/**\n * The manifest decoded but the requested endpoint name/alias is not\n * present.\n * Typically caused by a typo in user config or by referencing an\n * endpoint owned by a plugin not present in the resolved stack.\n */\nexport class PlaywrightEndpointNotFoundError extends Data.TaggedError(\n\t'PlaywrightEndpointNotFoundError',\n)<{\n\treadonly message: string;\n\treadonly endpointKey: string;\n\treadonly endpointName?: string;\n\treadonly available: ReadonlyArray<string>;\n\treadonly manifestKeys?: ReadonlyArray<string>;\n\treadonly recoveryHint: string;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Wallet adapter — the in-spec wallet helper could not talk to the\n// dev wallet's HTTP API.\n// -----------------------------------------------------------------------------\n\n/**\n * The wallet-context test helper failed to reach the dev wallet's\n * HTTP API (the supervisor's wallet plugin exposes an endpoint that\n * tests POST to for sign-tx flows). Typical causes: supervisor not\n * up, wallet endpoint not yet registered in the manifest, network\n * partition between test runner and supervisor.\n *\n * This tag is throwable from in-spec helpers AND constructible by\n * `wallet-context.ts` callers; it carries enough detail to format a\n * Playwright-friendly assertion failure.\n */\nexport class PlaywrightWalletAdapterError extends Data.TaggedError('PlaywrightWalletAdapterError')<{\n\treadonly message: string;\n\treadonly operation: 'sign-tx' | 'list-accounts' | 'switch-account' | 'fetch';\n\treadonly url?: string;\n\treadonly status?: number;\n\treadonly cause?: unknown;\n}> {}\n\n// -----------------------------------------------------------------------------\n// Union for catch sites that want to handle every surface tag.\n// -----------------------------------------------------------------------------\n\n/** Discriminated union of every error the Playwright preset emits. */\nexport type PlaywrightIntegrationError =\n\t| PlaywrightManifestDiscoveryError\n\t| PlaywrightManifestShapeError\n\t| PlaywrightEndpointNotFoundError\n\t| PlaywrightWalletAdapterError;\n"],"mappings":";;;;;;;;;;;AAoCA,IAAa,mCAAb,cAAsD,KAAK,YAC1D,mCACA,CAKE;;;;;;;;AAcH,IAAa,+BAAb,cAAkD,KAAK,YAAY,+BAA+B,CAM/F;;;;;;;AAaH,IAAa,kCAAb,cAAqD,KAAK,YACzD,kCACA,CAOE;;;;;;;;;;;;AAkBH,IAAa,+BAAb,cAAkD,KAAK,YAAY,+BAA+B,CAM/F"}

package/dist/build-integrations/playwright/global-setup.d.mts

@@ -0,0 +1,64 @@
+import { ResolveStackContextOptions } from "./stack-context.mjs";
+
+//#region src/build-integrations/playwright/global-setup.d.ts
+/** Playwright's `globalSetup` signature is `() => Promise<void | (() =>
+ *  Promise<void>)>` — we model it explicitly so the preset compiles
+ *  without `@playwright/test`. */
+type PlaywrightGlobalSetup = () => Promise<void | (() => Promise<void>)>;
+/**
+ * The shape global-setup writes to disk for in-spec tests to read.
+ * Tests do NOT re-walk-up to find the manifest at every assertion —
+ * they read this prepared fixture, which is faster and avoids a
+ * subtle cwd-mismatch class of failure when Playwright runs tests
+ * from a worker process.
+ *
+ * The fixture is written to a Playwright-known path (resolved from
+ * env Playwright populates) so worker processes pick it up. The
+ * setup also stamps `DEVSTACK_MANIFEST_PATH` into the worker env so
+ * `wallet-context` can reach the file without re-running discovery.
+ */
+interface PlaywrightStackFixture {
+  readonly endpoints: Readonly<Record<string, string>>;
+  readonly walletEndpoint: string | null;
+  readonly manifestPath: string;
+  readonly stack: string;
+  readonly app: string;
+}
+interface DefineGlobalSetupOptions extends ResolveStackContextOptions {
+  /**
+   * Verify the manifest's `endpoints` has at least one entry. The
+   * supervisor's manifest writer always emits at least the `app`
+   * endpoint, so an empty `endpoints` lookup means the supervisor
+   * crashed before reaching its eager snapshot-and-write — fail
+   * fast here rather than letting tests time out.
+   */
+  readonly requireNonEmptyEndpoints?: boolean;
+  /**
+   * Verify the named endpoints exist in the manifest. Used to fail
+   * fast when a test suite depends on a specific plugin (wallet,
+   * sui-faucet) being present in the resolved stack.
+   */
+  readonly requireEndpoints?: ReadonlyArray<string>;
+  /**
+   * Pre-warm the stack context — read the manifest once and stash
+   * the result on `globalThis` so tests don't repeat the disk read.
+   * Default: `true`.
+   */
+  readonly preloadContext?: boolean;
+}
+/**
+ * Build a Playwright `globalSetup` function. The returned function
+ * matches the signature Playwright expects (a default export of a
+ * module path; we return the function so the preset can wire it).
+ */
+declare const buildGlobalSetup: (options?: DefineGlobalSetupOptions) => PlaywrightGlobalSetup;
+/** The slot on `globalThis` where the prewarmed stack context lives.
+ *  In-spec helpers (`wallet-context.ts`) read from here when present
+ *  to avoid a second disk read. */
+declare const STACK_CONTEXT_SLOT: "__devstackPlaywrightStackContext__";
+/** Read the slot. Returns `null` if global-setup didn't run (e.g. the
+ *  user opted out by passing `globalSetup: null`). */
+declare const readStashedFixture: () => PlaywrightStackFixture | null;
+//#endregion
+export { DefineGlobalSetupOptions, PlaywrightGlobalSetup, PlaywrightStackFixture, STACK_CONTEXT_SLOT, buildGlobalSetup, readStashedFixture };
+//# sourceMappingURL=global-setup.d.mts.map

package/dist/build-integrations/playwright/global-setup.mjs

@@ -0,0 +1,44 @@
+import { readStackContext } from "./stack-context.mjs";
+//#region src/build-integrations/playwright/global-setup.ts
+/**
+* Build a Playwright `globalSetup` function. The returned function
+* matches the signature Playwright expects (a default export of a
+* module path; we return the function so the preset can wire it).
+*/
+const buildGlobalSetup = (options = {}) => {
+	return async () => {
+		const ctx = readStackContext(options);
+		if (options.requireNonEmptyEndpoints === true) {
+			if (ctx.endpointNames.length === 0) throw new Error(`devstack manifest at ${ctx.manifestPath} has no endpoints. The supervisor likely failed before its eager snapshot write; check the dev server logs for plugin acquire errors.`);
+		}
+		const required = options.requireEndpoints ?? [];
+		const missing = [];
+		for (const key of required) if (ctx.endpointMaybe(key) === null) missing.push(key);
+		if (missing.length > 0) throw new Error(`devstack manifest at ${ctx.manifestPath} is missing required endpoints: ${missing.join(", ")}. available endpoint names: ${ctx.endpointNames.join(", ") || "(none)"}. raw manifest keys: ${ctx.manifestEndpointKeys.join(", ") || "(none)"}.`);
+		if (options.preloadContext ?? true) stashStackContext(ctx);
+	};
+};
+buildGlobalSetup();
+/** The slot on `globalThis` where the prewarmed stack context lives.
+*  In-spec helpers (`wallet-context.ts`) read from here when present
+*  to avoid a second disk read. */
+const STACK_CONTEXT_SLOT = "__devstackPlaywrightStackContext__";
+const stashStackContext = (ctx) => {
+	const fixture = {
+		endpoints: Object.fromEntries(ctx.endpointNames.map((name) => [name, ctx.endpoint(name)])),
+		walletEndpoint: ctx.endpointMaybe("wallet"),
+		manifestPath: ctx.manifestPath,
+		stack: ctx.manifest.identity.stack,
+		app: ctx.manifest.identity.app
+	};
+	globalThis[STACK_CONTEXT_SLOT] = fixture;
+};
+/** Read the slot. Returns `null` if global-setup didn't run (e.g. the
+*  user opted out by passing `globalSetup: null`). */
+const readStashedFixture = () => {
+	return globalThis["__devstackPlaywrightStackContext__"] ?? null;
+};
+//#endregion
+export { STACK_CONTEXT_SLOT, buildGlobalSetup, readStashedFixture };
+
+//# sourceMappingURL=global-setup.mjs.map

package/dist/build-integrations/playwright/global-setup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-setup.mjs","names":[],"sources":["../../../src/build-integrations/playwright/global-setup.ts"],"sourcesContent":["// Playwright `globalSetup` hook.\n//\n// Architecture (distilled/23-build-integrations.md § Playwright):\n//\n//   What it needs: the same manifest as Vite (...) but with a\n//   cold-start fallback (...) — Playwright config-load runs BEFORE\n//   the supervisor spawns to write the manifest.\n//\n//   How it hooks in: the spawned `pnpm dev` (default `command`) brings\n//   up the supervisor, which writes the real manifest. Playwright\n//   polls `webServer.url` until reachable.\n//\n// This module is the third hook in that chain (config-load → webServer\n// spawn → globalSetup). By the time it runs, the supervisor IS up and\n// the manifest has been written; globalSetup verifies invariants and\n// populates fixtures the in-spec tests rely on (e.g. preloads the\n// stack context so each test doesn't repeat the disk read; warms the\n// wallet adapter; resolves the test-account list).\n//\n// What it does NOT do:\n//   - Boot the supervisor. (`webServer.command` does that.)\n//   - Wait on `webServer.url`. (Playwright does that.)\n//   - Write any state. (Read-only.)\n//\n// Returns a teardown function (the inverse hook Playwright supports\n// via `globalTeardown` indirection — we return the teardown so the\n// preset's `globalTeardown` can call it).\n\nimport {\n\treadStackContext,\n\ttype ResolveStackContextOptions,\n\ttype StackContext,\n} from './stack-context.ts';\n\n// -----------------------------------------------------------------------------\n// Public shape Playwright expects\n// -----------------------------------------------------------------------------\n\n/** Playwright's `globalSetup` signature is `() => Promise<void | (() =>\n *  Promise<void>)>` — we model it explicitly so the preset compiles\n *  without `@playwright/test`. */\nexport type PlaywrightGlobalSetup = () => Promise<void | (() => Promise<void>)>;\n\n// -----------------------------------------------------------------------------\n// Fixture payload\n// -----------------------------------------------------------------------------\n\n/**\n * The shape global-setup writes to disk for in-spec tests to read.\n * Tests do NOT re-walk-up to find the manifest at every assertion —\n * they read this prepared fixture, which is faster and avoids a\n * subtle cwd-mismatch class of failure when Playwright runs tests\n * from a worker process.\n *\n * The fixture is written to a Playwright-known path (resolved from\n * env Playwright populates) so worker processes pick it up. The\n * setup also stamps `DEVSTACK_MANIFEST_PATH` into the worker env so\n * `wallet-context` can reach the file without re-running discovery.\n */\nexport interface PlaywrightStackFixture {\n\treadonly endpoints: Readonly<Record<string, string>>;\n\treadonly walletEndpoint: string | null;\n\treadonly manifestPath: string;\n\treadonly stack: string;\n\treadonly app: string;\n}\n\n// -----------------------------------------------------------------------------\n// Configurable factory\n// -----------------------------------------------------------------------------\n\nexport interface DefineGlobalSetupOptions extends ResolveStackContextOptions {\n\t/**\n\t * Verify the manifest's `endpoints` has at least one entry. The\n\t * supervisor's manifest writer always emits at least the `app`\n\t * endpoint, so an empty `endpoints` lookup means the supervisor\n\t * crashed before reaching its eager snapshot-and-write — fail\n\t * fast here rather than letting tests time out.\n\t */\n\treadonly requireNonEmptyEndpoints?: boolean;\n\n\t/**\n\t * Verify the named endpoints exist in the manifest. Used to fail\n\t * fast when a test suite depends on a specific plugin (wallet,\n\t * sui-faucet) being present in the resolved stack.\n\t */\n\treadonly requireEndpoints?: ReadonlyArray<string>;\n\n\t/**\n\t * Pre-warm the stack context — read the manifest once and stash\n\t * the result on `globalThis` so tests don't repeat the disk read.\n\t * Default: `true`.\n\t */\n\treadonly preloadContext?: boolean;\n}\n\n/**\n * Build a Playwright `globalSetup` function. The returned function\n * matches the signature Playwright expects (a default export of a\n * module path; we return the function so the preset can wire it).\n */\nexport const buildGlobalSetup = (options: DefineGlobalSetupOptions = {}): PlaywrightGlobalSetup => {\n\treturn async () => {\n\t\tconst ctx = readStackContext(options);\n\n\t\tif (options.requireNonEmptyEndpoints === true) {\n\t\t\tif (ctx.endpointNames.length === 0) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`devstack manifest at ${ctx.manifestPath} has no endpoints. ` +\n\t\t\t\t\t\t`The supervisor likely failed before its eager snapshot ` +\n\t\t\t\t\t\t`write; check the dev server logs for plugin acquire errors.`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tconst required = options.requireEndpoints ?? [];\n\t\tconst missing: string[] = [];\n\t\tfor (const key of required) {\n\t\t\tif (ctx.endpointMaybe(key) === null) missing.push(key);\n\t\t}\n\t\tif (missing.length > 0) {\n\t\t\tthrow new Error(\n\t\t\t\t`devstack manifest at ${ctx.manifestPath} is missing required ` +\n\t\t\t\t\t`endpoints: ${missing.join(', ')}. ` +\n\t\t\t\t\t`available endpoint names: ${ctx.endpointNames.join(', ') || '(none)'}. ` +\n\t\t\t\t\t`raw manifest keys: ${ctx.manifestEndpointKeys.join(', ') || '(none)'}.`,\n\t\t\t);\n\t\t}\n\n\t\tif (options.preloadContext ?? true) {\n\t\t\tstashStackContext(ctx);\n\t\t}\n\n\t\t// Return value: `void` (no teardown). Playwright accepts\n\t\t// `() => Promise<void>` here.\n\t};\n};\n\n/** Default export shape that mirrors what Playwright's\n *  `defineConfig.globalSetup` resolves: a module whose default export\n *  is the setup function. */\nexport default buildGlobalSetup();\n\n// -----------------------------------------------------------------------------\n// Global stash\n// -----------------------------------------------------------------------------\n\n/** The slot on `globalThis` where the prewarmed stack context lives.\n *  In-spec helpers (`wallet-context.ts`) read from here when present\n *  to avoid a second disk read. */\nexport const STACK_CONTEXT_SLOT = '__devstackPlaywrightStackContext__' as const;\n\ninterface GlobalSlot {\n\t[STACK_CONTEXT_SLOT]?: PlaywrightStackFixture;\n}\n\nconst stashStackContext = (ctx: StackContext): void => {\n\tconst fixture: PlaywrightStackFixture = {\n\t\tendpoints: Object.fromEntries(ctx.endpointNames.map((name) => [name, ctx.endpoint(name)])),\n\t\twalletEndpoint: ctx.endpointMaybe('wallet'),\n\t\tmanifestPath: ctx.manifestPath,\n\t\tstack: ctx.manifest.identity.stack,\n\t\tapp: ctx.manifest.identity.app,\n\t};\n\t(globalThis as unknown as GlobalSlot)[STACK_CONTEXT_SLOT] = fixture;\n};\n\n/** Read the slot. Returns `null` if global-setup didn't run (e.g. the\n *  user opted out by passing `globalSetup: null`). */\nexport const readStashedFixture = (): PlaywrightStackFixture | null => {\n\tconst slot = (globalThis as unknown as GlobalSlot)[STACK_CONTEXT_SLOT];\n\treturn slot ?? null;\n};\n"],"mappings":";;;;;;;AAqGA,MAAa,oBAAoB,UAAoC,EAAE,KAA4B;AAClG,QAAO,YAAY;EAClB,MAAM,MAAM,iBAAiB,QAAQ;AAErC,MAAI,QAAQ,6BAA6B;OACpC,IAAI,cAAc,WAAW,EAChC,OAAM,IAAI,MACT,wBAAwB,IAAI,aAAa,uIAGzC;;EAIH,MAAM,WAAW,QAAQ,oBAAoB,EAAE;EAC/C,MAAM,UAAoB,EAAE;AAC5B,OAAK,MAAM,OAAO,SACjB,KAAI,IAAI,cAAc,IAAI,KAAK,KAAM,SAAQ,KAAK,IAAI;AAEvD,MAAI,QAAQ,SAAS,EACpB,OAAM,IAAI,MACT,wBAAwB,IAAI,aAAa,kCAC1B,QAAQ,KAAK,KAAK,CAAC,8BACJ,IAAI,cAAc,KAAK,KAAK,IAAI,SAAS,uBAChD,IAAI,qBAAqB,KAAK,KAAK,IAAI,SAAS,GACvE;AAGF,MAAI,QAAQ,kBAAkB,KAC7B,mBAAkB,IAAI;;;AAWV,kBAAkB;;;;AASjC,MAAa,qBAAqB;AAMlC,MAAM,qBAAqB,QAA4B;CACtD,MAAM,UAAkC;EACvC,WAAW,OAAO,YAAY,IAAI,cAAc,KAAK,SAAS,CAAC,MAAM,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC;EAC1F,gBAAgB,IAAI,cAAc,SAAS;EAC3C,cAAc,IAAI;EAClB,OAAO,IAAI,SAAS,SAAS;EAC7B,KAAK,IAAI,SAAS,SAAS;EAC3B;AACA,YAAqC,sBAAsB;;;;AAK7D,MAAa,2BAA0D;AAEtE,QADc,WAAA,yCACC"}

package/dist/build-integrations/playwright/index.d.mts

@@ -0,0 +1,6 @@
+import { PLAYWRIGHT_ENV, ResolveStackContextOptions, ResolvedEndpoint, StackContext, conventionalUrlFor, discoverManifestPath, makeStackContext, readManifestSync, readStackContext, resolveEndpointUrl } from "./stack-context.mjs";
+import { DevstackPlaywrightBaseConfigOptions, DevstackPlaywrightEndpointOptions, DevstackPlaywrightProjectsOptions, DevstackPlaywrightUseOptions, DevstackPlaywrightWebServerOptions, PlaywrightBaseConfigShape, PlaywrightProjectShape, PlaywrightUseConfigShape, PlaywrightWebServerConfigShape, devstackPlaywrightBaseConfig, devstackPlaywrightProjects, devstackPlaywrightUse, devstackPlaywrightWebServer, resolveDevstackPlaywrightBaseURL } from "./config.mjs";
+import { DefineGlobalSetupOptions, PlaywrightGlobalSetup, PlaywrightStackFixture, STACK_CONTEXT_SLOT, buildGlobalSetup, readStashedFixture } from "./global-setup.mjs";
+import { DAPP_KIT_SLOT, DevAccount, PlaywrightPageLike, SignTxRequest, SignTxResponse, WALLET_ENDPOINT_KEY, WalletAdapter, WalletAdapterOptions, connectAs, createWalletAdapter, loadStackManifest, selectAccount } from "./wallet-context.mjs";
+import { PlaywrightEndpointNotFoundError, PlaywrightIntegrationError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError, PlaywrightWalletAdapterError } from "./errors.mjs";
+export { DAPP_KIT_SLOT, type DefineGlobalSetupOptions, type DevAccount, type DevstackPlaywrightBaseConfigOptions, type DevstackPlaywrightEndpointOptions, type DevstackPlaywrightProjectsOptions, type DevstackPlaywrightUseOptions, type DevstackPlaywrightWebServerOptions, PLAYWRIGHT_ENV, type PlaywrightBaseConfigShape, PlaywrightEndpointNotFoundError, type PlaywrightGlobalSetup, type PlaywrightIntegrationError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError, type PlaywrightPageLike, type PlaywrightProjectShape, type PlaywrightStackFixture, type PlaywrightUseConfigShape, PlaywrightWalletAdapterError, type PlaywrightWebServerConfigShape, type ResolveStackContextOptions, type ResolvedEndpoint, STACK_CONTEXT_SLOT, type SignTxRequest, type SignTxResponse, type StackContext, WALLET_ENDPOINT_KEY, type WalletAdapter, type WalletAdapterOptions, buildGlobalSetup, connectAs, conventionalUrlFor, createWalletAdapter, devstackPlaywrightBaseConfig, devstackPlaywrightProjects, devstackPlaywrightUse, devstackPlaywrightWebServer, discoverManifestPath, loadStackManifest, makeStackContext, readManifestSync, readStackContext, readStashedFixture, resolveDevstackPlaywrightBaseURL, resolveEndpointUrl, selectAccount };

package/dist/build-integrations/playwright/index.mjs

@@ -0,0 +1,6 @@
+import { PlaywrightEndpointNotFoundError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError, PlaywrightWalletAdapterError } from "./errors.mjs";
+import { PLAYWRIGHT_ENV, conventionalUrlFor, discoverManifestPath, makeStackContext, readManifestSync, readStackContext, resolveEndpointUrl } from "./stack-context.mjs";
+import { devstackPlaywrightBaseConfig, devstackPlaywrightProjects, devstackPlaywrightUse, devstackPlaywrightWebServer, resolveDevstackPlaywrightBaseURL } from "./config.mjs";
+import { STACK_CONTEXT_SLOT, buildGlobalSetup, readStashedFixture } from "./global-setup.mjs";
+import { DAPP_KIT_SLOT, WALLET_ENDPOINT_KEY, connectAs, createWalletAdapter, loadStackManifest, selectAccount } from "./wallet-context.mjs";
+export { DAPP_KIT_SLOT, PLAYWRIGHT_ENV, PlaywrightEndpointNotFoundError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError, PlaywrightWalletAdapterError, STACK_CONTEXT_SLOT, WALLET_ENDPOINT_KEY, buildGlobalSetup, connectAs, conventionalUrlFor, createWalletAdapter, devstackPlaywrightBaseConfig, devstackPlaywrightProjects, devstackPlaywrightUse, devstackPlaywrightWebServer, discoverManifestPath, loadStackManifest, makeStackContext, readManifestSync, readStackContext, readStashedFixture, resolveDevstackPlaywrightBaseURL, resolveEndpointUrl, selectAccount };

package/dist/build-integrations/playwright/stack-context.d.mts

@@ -0,0 +1,95 @@
+import { EndpointEntry, ManifestEnvelope } from "../../substrate/manifest.mjs";
+
+//#region src/build-integrations/playwright/stack-context.d.ts
+/** Centralized env-var names this surface consults. Kept in sync with
+ *  the CLI's `ENV_VARS` table. */
+declare const PLAYWRIGHT_ENV: {
+  readonly STATE_DIR: "DEVSTACK_STATE_DIR";
+  readonly STACK: "DEVSTACK_STACK";
+  readonly MANIFEST_PATH: "DEVSTACK_MANIFEST_PATH";
+  readonly ROUTER_HOST_SUFFIX: "DEVSTACK_ROUTER_HOST_SUFFIX";
+  readonly ROUTER_PORT: "DEVSTACK_ROUTER_PORT";
+};
+interface ResolveStackContextOptions {
+  /** Working directory to start the walk-up from. */
+  readonly cwd?: string;
+  /** Explicit manifest path. Wins over discovery + env. */
+  readonly manifestPath?: string;
+  /** Explicit `<stateDir>` root override. Combined with `stack` to
+   *  form `<root>/stacks/<stack>/manifest.json`. */
+  readonly stateDir?: string;
+  /** Stack name override. Defaults to env `DEVSTACK_STACK`. */
+  readonly stack?: string;
+  /** Env bag (defaults to `process.env`). Injectable for tests. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
+}
+interface StackContext {
+  readonly manifest: ManifestEnvelope;
+  readonly manifestPath: string;
+  readonly endpointNames: ReadonlyArray<string>;
+  readonly manifestEndpointKeys: ReadonlyArray<string>;
+  readonly endpoint: (endpointNameOrAlias: string) => string;
+  readonly endpointMaybe: (endpointNameOrAlias: string) => string | null;
+  readonly endpointEntry: (endpointNameOrAlias: string) => EndpointEntry;
+}
+interface ResolvedEndpoint {
+  readonly url: string;
+  readonly source: 'manifest' | 'conventional';
+  readonly endpointKey: string;
+  readonly endpointName: string;
+}
+/**
+ * Find the stack-scoped manifest by walking up from `cwd` looking for
+ * `.devstack/stacks/<stack>/manifest.json`. Returns the absolute path
+ * + the list of paths probed, or `null` on miss.
+ */
+declare const discoverManifestPath: (options?: ResolveStackContextOptions) => {
+  readonly path: string;
+  readonly searched: ReadonlyArray<string>;
+} | null;
+/**
+ * Synchronously read + decode the manifest at `manifestPath`. Throws
+ * `PlaywrightManifestShapeError` on JSON-parse or schema-decode
+ * failure, or version mismatch. Used by callers that already know
+ * the path (preset's webServer.url resolution + global-setup).
+ */
+declare const readManifestSync: (manifestPath: string) => ManifestEnvelope;
+/**
+ * Cold-start URL fallback for endpoints with a conventional host
+ * pattern. Playwright config-load runs BEFORE the supervisor writes
+ * the manifest; the preset MUST be able to resolve a `baseURL`
+ * without a manifest read.
+ *
+ * The route table shape matches `runtime/coldStartUrl`; Playwright
+ * only supplies its conventional endpoint hints while the shared
+ * runtime helper owns host formatting.
+ */
+declare const conventionalUrlFor: (endpointKey: string, opts?: {
+  readonly stack?: string;
+  readonly hostSuffix?: string;
+  readonly port?: number;
+  readonly app?: string;
+  readonly cwd?: string;
+  readonly env?: Readonly<Record<string, string | undefined>>;
+}) => string | null;
+/**
+ * Synchronously resolve the full stack context. Throws on missing
+ * manifest (no cold-start fallback here — caller wants the typed
+ * envelope, not a guessed URL).
+ */
+declare const readStackContext: (options?: ResolveStackContextOptions) => StackContext;
+/** Project an in-memory envelope (test fixtures use this) into the
+ *  same accessor shape as the on-disk read. */
+declare const makeStackContext: (envelope: ManifestEnvelope, manifestPath: string) => StackContext;
+/**
+ * Resolve a URL for a single endpoint with cold-start fallback to the
+ * conventional URL when the manifest is absent. Throws when both the
+ * manifest and the conventional table miss.
+ */
+declare const resolveEndpointUrl: (endpointNameOrAlias: string, options?: ResolveStackContextOptions & {
+  readonly port?: number;
+  readonly hostSuffix?: string;
+}) => ResolvedEndpoint;
+//#endregion
+export { PLAYWRIGHT_ENV, ResolveStackContextOptions, ResolvedEndpoint, StackContext, conventionalUrlFor, discoverManifestPath, makeStackContext, readManifestSync, readStackContext, resolveEndpointUrl };
+//# sourceMappingURL=stack-context.d.mts.map

package/dist/build-integrations/playwright/stack-context.mjs

@@ -0,0 +1,277 @@
+import { ManifestDiscoveryError, ManifestShapeError } from "../runtime/errors.mjs";
+import { discoverManifestPath as discoverManifestPath$1 } from "../runtime/discover.mjs";
+import { EndpointRegistry } from "../runtime/endpoint-registry.mjs";
+import { manifestEnvelopeFromStackContext, readStackContext as readStackContext$1 } from "../runtime/read-stack-context.mjs";
+import { coldStartUrl, conventionalRoutesFromHints } from "../runtime/cold-start-url.mjs";
+import { PlaywrightEndpointNotFoundError, PlaywrightManifestDiscoveryError, PlaywrightManifestShapeError } from "./errors.mjs";
+//#region src/build-integrations/playwright/stack-context.ts
+/** Centralized env-var names this surface consults. Kept in sync with
+*  the CLI's `ENV_VARS` table. */
+const PLAYWRIGHT_ENV = {
+	STATE_DIR: "DEVSTACK_STATE_DIR",
+	STACK: "DEVSTACK_STACK",
+	MANIFEST_PATH: "DEVSTACK_MANIFEST_PATH",
+	ROUTER_HOST_SUFFIX: "DEVSTACK_ROUTER_HOST_SUFFIX",
+	ROUTER_PORT: "DEVSTACK_ROUTER_PORT"
+};
+const PLAYWRIGHT_ENDPOINT_ALIASES = {
+	app: "dev",
+	wallet: "wallet-app"
+};
+const PLAYWRIGHT_DEFAULT_ROUTER_PORTS = {
+	app: 5175,
+	dev: 5175,
+	wallet: 5175,
+	"wallet-app": 5175
+};
+const playwrightEndpointNameFor = (endpointNameOrAlias) => PLAYWRIGHT_ENDPOINT_ALIASES[endpointNameOrAlias] ?? endpointNameOrAlias;
+const endpointRegistryFromEnvelope = (envelope) => {
+	const entries = [];
+	for (const raw of Object.values(envelope.endpoints)) entries.push({
+		name: raw.name,
+		url: raw.url,
+		displayUrl: raw.displayUrl,
+		wireProtocol: raw.wireProtocol,
+		pluginKey: raw.pluginKey,
+		endpointKey: raw.endpointKey
+	});
+	return new EndpointRegistry(entries);
+};
+const buildRuntimeDiscoverOpts = (options) => {
+	const env = options.env ?? process.env;
+	const stack = options.stack ?? env[PLAYWRIGHT_ENV.STACK] ?? "main";
+	const stateDir = options.stateDir ?? env[PLAYWRIGHT_ENV.STATE_DIR];
+	return {
+		env,
+		stack,
+		...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+		...options.manifestPath !== void 0 ? { override: options.manifestPath } : {},
+		...stateDir !== void 0 && stateDir !== "" ? { stateDir } : {}
+	};
+};
+/**
+* Find the stack-scoped manifest by walking up from `cwd` looking for
+* `.devstack/stacks/<stack>/manifest.json`. Returns the absolute path
+* + the list of paths probed, or `null` on miss.
+*/
+const discoverManifestPath = (options = {}) => {
+	const path = discoverManifestPath$1(buildRuntimeDiscoverOpts(options));
+	if (path === void 0) return null;
+	return {
+		path,
+		searched: [path]
+	};
+};
+/**
+* Synchronously read + decode the manifest at `manifestPath`. Throws
+* `PlaywrightManifestShapeError` on JSON-parse or schema-decode
+* failure, or version mismatch. Used by callers that already know
+* the path (preset's webServer.url resolution + global-setup).
+*/
+const readManifestSync = (manifestPath) => {
+	try {
+		return manifestEnvelopeFromStackContext(readStackContext$1({ manifestPath }));
+	} catch (cause) {
+		if (cause instanceof ManifestShapeError) throw new PlaywrightManifestShapeError({
+			message: cause.phase === "version" ? `manifest at ${manifestPath} version mismatch: ${cause.message}` : `manifest at ${manifestPath} does not match the envelope schema`,
+			manifestPath,
+			phase: cause.phase === "version" ? "version-mismatch" : "shape",
+			recoveryHint: cause.phase === "version" ? "Re-run `devstack up` to write a manifest at the current version, or upgrade @mysten-incubation/devstack to a build-integration that understands the new envelope." : `Delete \`${manifestPath}\` and run \`devstack up\`. If the error persists, the build-integration is older than the supervisor.`,
+			cause
+		});
+		if (cause instanceof ManifestDiscoveryError) throw new PlaywrightManifestShapeError({
+			message: `failed to read manifest at ${manifestPath}`,
+			manifestPath,
+			phase: "parse",
+			recoveryHint: "Confirm the file exists and is readable. Run `devstack up` to regenerate it if the supervisor was interrupted mid-write.",
+			cause
+		});
+		throw cause;
+	}
+};
+/**
+* Cold-start URL fallback for endpoints with a conventional host
+* pattern. Playwright config-load runs BEFORE the supervisor writes
+* the manifest; the preset MUST be able to resolve a `baseURL`
+* without a manifest read.
+*
+* The route table shape matches `runtime/coldStartUrl`; Playwright
+* only supplies its conventional endpoint hints while the shared
+* runtime helper owns host formatting.
+*/
+const conventionalUrlFor = (endpointKey, opts = {}) => {
+	const stack = opts.stack ?? "main";
+	const env = opts.env ?? process.env;
+	const envPort = Number.parseInt(env[PLAYWRIGHT_ENV.ROUTER_PORT] ?? "", 10);
+	const resolvedPort = opts.port ?? (Number.isFinite(envPort) && envPort > 0 ? envPort : void 0) ?? PLAYWRIGHT_DEFAULT_ROUTER_PORTS[endpointKey];
+	if (resolvedPort === void 0 || !Number.isFinite(resolvedPort) || resolvedPort <= 0) return null;
+	const routes = conventionalRoutesFromHints([
+		{
+			endpoint: "app",
+			service: "dev"
+		},
+		{
+			endpoint: "dev",
+			service: "dev"
+		},
+		{
+			endpoint: "sui-rpc",
+			service: "sui-rpc"
+		},
+		{
+			endpoint: "sui-faucet",
+			service: "sui-faucet"
+		},
+		{
+			endpoint: "walrus-aggregator",
+			service: "walrus-aggregator"
+		},
+		{
+			endpoint: "walrus-publisher",
+			service: "walrus-publisher"
+		},
+		{
+			endpoint: "seal",
+			service: "seal"
+		},
+		{
+			endpoint: "wallet",
+			service: "api"
+		},
+		{
+			endpoint: "wallet-app",
+			service: "api"
+		}
+	], resolvedPort);
+	if (!routes.has(endpointKey)) return null;
+	return coldStartUrl(endpointKey, {
+		routes,
+		stack,
+		...opts.app !== void 0 ? { app: opts.app } : {},
+		...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+		...opts.hostSuffix !== void 0 ? { hostSuffix: opts.hostSuffix } : {}
+	});
+};
+/**
+* Synchronously resolve the full stack context. Throws on missing
+* manifest (no cold-start fallback here — caller wants the typed
+* envelope, not a guessed URL).
+*/
+const readStackContext = (options = {}) => {
+	try {
+		return projectFromRuntime(readStackContext$1(buildRuntimeDiscoverOpts(options)));
+	} catch (err) {
+		if (err instanceof ManifestDiscoveryError) throw new PlaywrightManifestDiscoveryError({
+			message: "no manifest found along walk-up path or env override",
+			searchedPaths: err.path !== void 0 ? [err.path] : [],
+			recoveryHint: "Run `devstack up` from your example app's directory to write the manifest, or set DEVSTACK_MANIFEST_PATH to an explicit path."
+		});
+		if (err instanceof ManifestShapeError) throw new PlaywrightManifestShapeError({
+			message: err.message,
+			manifestPath: err.path,
+			phase: err.phase === "version" ? "version-mismatch" : err.phase,
+			recoveryHint: `Delete \`${err.path}\` and run \`devstack up\` to regenerate.`,
+			cause: err
+		});
+		throw err;
+	}
+};
+const projectFromRuntime = (ctx) => {
+	return makeStackContext(manifestEnvelopeFromStackContext(ctx), ctx.manifestPath);
+};
+/** Project an in-memory envelope (test fixtures use this) into the
+*  same accessor shape as the on-disk read. */
+const makeStackContext = (envelope, manifestPath) => {
+	const endpoints = endpointRegistryFromEnvelope(envelope);
+	const manifestEndpointKeys = Object.keys(envelope.endpoints).sort();
+	const endpointNames = endpoints.names();
+	const notFound = (endpointKey, endpointName) => new PlaywrightEndpointNotFoundError({
+		message: `no endpoint \`${endpointKey}\` (resolved endpoint name \`${endpointName}\`) in manifest at ${manifestPath}`,
+		endpointKey,
+		endpointName,
+		available: endpointNames,
+		manifestKeys: manifestEndpointKeys,
+		recoveryHint: `Available endpoint names: ${endpointNames.join(", ") || "(none)"}. Raw manifest keys: ${manifestEndpointKeys.join(", ") || "(none)"}. Check the plugin emitting this endpoint is present in your stack, or check for a typo in the endpoint name.`
+	});
+	const findEndpoint = (endpointNameOrAlias) => endpoints.byName(playwrightEndpointNameFor(endpointNameOrAlias));
+	const rawEntryFor = (resolved) => {
+		const byMapKey = envelope.endpoints[resolved.endpointKey];
+		if (byMapKey !== void 0) return byMapKey;
+		const byEntryKey = Object.values(envelope.endpoints).find((entry) => entry.endpointKey === resolved.endpointKey);
+		if (byEntryKey !== void 0) return byEntryKey;
+		return {
+			name: resolved.name,
+			url: resolved.url,
+			displayUrl: resolved.displayUrl,
+			wireProtocol: resolved.wireProtocol,
+			pluginKey: resolved.pluginKey,
+			endpointKey: resolved.endpointKey
+		};
+	};
+	return {
+		manifest: envelope,
+		manifestPath,
+		endpointNames,
+		manifestEndpointKeys,
+		endpoint: (endpointNameOrAlias) => {
+			const endpointName = playwrightEndpointNameFor(endpointNameOrAlias);
+			const entry = findEndpoint(endpointNameOrAlias);
+			if (entry === void 0) throw notFound(endpointNameOrAlias, endpointName);
+			return entry.url;
+		},
+		endpointMaybe: (endpointNameOrAlias) => findEndpoint(endpointNameOrAlias)?.url ?? null,
+		endpointEntry: (endpointNameOrAlias) => {
+			const endpointName = playwrightEndpointNameFor(endpointNameOrAlias);
+			const entry = findEndpoint(endpointNameOrAlias);
+			if (entry === void 0) throw notFound(endpointNameOrAlias, endpointName);
+			return rawEntryFor(entry);
+		}
+	};
+};
+/**
+* Resolve a URL for a single endpoint with cold-start fallback to the
+* conventional URL when the manifest is absent. Throws when both the
+* manifest and the conventional table miss.
+*/
+const resolveEndpointUrl = (endpointNameOrAlias, options = {}) => {
+	const endpointName = playwrightEndpointNameFor(endpointNameOrAlias);
+	let ctx;
+	try {
+		ctx = readStackContext(options);
+	} catch (err) {
+		if (!(err instanceof PlaywrightManifestDiscoveryError)) throw err;
+	}
+	if (ctx !== void 0) {
+		const entry = ctx.endpointEntry(endpointNameOrAlias);
+		return {
+			url: entry.url,
+			source: "manifest",
+			endpointKey: entry.endpointKey,
+			endpointName
+		};
+	}
+	const env = options.env ?? process.env;
+	const fallback = conventionalUrlFor(endpointNameOrAlias, {
+		stack: options.stack ?? env[PLAYWRIGHT_ENV.STACK] ?? "main",
+		...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+		...options.hostSuffix !== void 0 ? { hostSuffix: options.hostSuffix } : env[PLAYWRIGHT_ENV.ROUTER_HOST_SUFFIX] !== void 0 ? { hostSuffix: env[PLAYWRIGHT_ENV.ROUTER_HOST_SUFFIX] } : {},
+		...options.port !== void 0 ? { port: options.port } : {},
+		...options.env !== void 0 ? { env: options.env } : {}
+	});
+	if (fallback !== null) return {
+		url: fallback,
+		source: "conventional",
+		endpointKey: endpointNameOrAlias,
+		endpointName
+	};
+	throw new PlaywrightManifestDiscoveryError({
+		message: `no manifest found and no conventional fallback for endpoint \`${endpointNameOrAlias}\` (resolved endpoint name \`${endpointName}\`)`,
+		searchedPaths: [],
+		endpointKey: endpointNameOrAlias,
+		recoveryHint: "Run `devstack up` to materialize the manifest before invoking playwright, or pass an explicit `baseURL`."
+	});
+};
+//#endregion
+export { PLAYWRIGHT_ENV, conventionalUrlFor, discoverManifestPath, makeStackContext, readManifestSync, readStackContext, resolveEndpointUrl };
+
+//# sourceMappingURL=stack-context.mjs.map