@farmslot/adapter-web 0.4.1 → 0.6.0

package/CHANGELOG.md

@@ -6,6 +6,16 @@ All notable changes to `@farmslot/adapter-web` are tracked here.
 
 - Active-development baseline; add user-facing changes here before release or package publication.
 
+## 0.6.0 - 2026-10-08
+
+- Add `web-dapp` (`@farmslot/adapter-web/web-dapp`, an ESM subpath): `createWebDappAdapter({ id, signerModule, cli, hooks })` returns an `@farmslot/adapter-sdk` `PlatformAdapter` for a web app under test whose dev server the slot owns, moved from mm-harness's Web Terminal adapter. It runs a slot browser and wallet host with the injected strict wallet or a host-supplied extension signer, held to the testnet venue of the adapter that extends it. See the adapter-web reference for the signer module, venue policy and hooks.
+- Publish with adapter-sdk 0.7.1 and recipe-runner 0.27.0 so consumers share one adapter-sdk and one recipe-runner copy.
+
+## 0.5.0 - 2026-10-08
+
+- `launchBrowser` takes an optional `progress` callback for the caller's stage: starting the browser, waiting for the CDP listener (with the attempt count, about every 5 s), loading the extension over CDP and opening the start window. The `[launch]` log lines are unchanged.
+- Publish with adapter-sdk 0.7.0 and recipe-runner 0.26.0 so consumers share one adapter-sdk copy.
+
 ## 0.4.1 - 2026-10-07
 
 - `network-observer`: `createExtensionNetworkObserver` takes an optional `extensionId`, the extension to capture. Without it the observer still takes the first extension with a target, which in a branded Chrome can be a component or policy extension listed before the one under test.

package/README.md

@@ -29,8 +29,9 @@ Docs: https://farmslot.io/docs/reference/adapter-web
 | `slot-title`                   | prefix the extension home tab's title with the farm slot id, kept across the page's own title resets                      |
 | `validation-process-ownership` | find and stop the processes that own a slot profile                                                                       |
 | `validation-launch-supervisor` | supervised child for one validation launch: port lease, quarantine and cleanup                                            |
+| `web-dapp`                     | the generic web-dapp lifecycle as an adapter-sdk `PlatformAdapter` (ESM): slot browser, wallet host, readiness, stop      |
 
-Sources are CommonJS (`src/**/*.cjs`) and ship as is; `yarn build` emits `.d.cts` declarations. Every library subpath can be `require`d or `import`ed with named imports, except `validation-launch-supervisor`: it is a child-process entry (it runs when loaded), so hosts `require.resolve` it and fork it.
+Sources are CommonJS (`src/**/*.cjs`) and ship as is; `yarn build` emits `.d.cts` declarations. `web-dapp` is the exception: its sources are ESM (`src/web-dapp/**/*.mjs`, declarations `.d.mts`), because its leaf scripts run as their own node processes. Every library subpath can be `require`d or `import`ed with named imports, except `validation-launch-supervisor`: it is a child-process entry (it runs when loaded), so hosts `require.resolve` it and fork it.
 
 ## Launching a browser
 
@@ -107,6 +108,28 @@ const binding = createWalletRequestBinding({
 });
 ```
 
+## Web-dapp adapter
+
+`@farmslot/adapter-web/web-dapp` (ESM) is the lifecycle of a web app under test whose dev server the slot owns. `createWebDappAdapter({ id, signerModule, cli, hooks })` returns an `@farmslot/adapter-sdk` `PlatformAdapter`: launch, stop, runtime status, doctor checks, logs and the wallet request-log findings. It runs one slot browser per slot, and a wallet host attached to it over CDP that records the wallet requests (and, with `signer=injected`, answers them with the strict wallet from `dapp`).
+
+- **Venue policy.** The app's venue (the hosts a testnet run blocks and serves, the typed data to refuse, the start page) comes from the adapter that `extends: 'web-dapp'`: its policy module goes to `RECIPE_WEB_DAPP_POLICY` through `bindWebDappPolicy(adapter)`. Bare web-dapp has no policy and refuses to launch. `fencePolicy` and `assertPolicyDigest` hold the module and what it imports to the files the plugin digest covers.
+- **Served network.** A policy that declares served hosts (`venueHosts().served`) has the wallet host wait for the app to request one of them, which proves the dev server serves testnet. A policy for an app whose page makes no venue request of its own (such as test-dapp-multichain, whose wallet traffic goes through the extension) opts out explicitly: `venueHosts()` returns `served: []` with `servedCheck: 'not-applicable'`. The check is then skipped, and `networkEnforcement.served` in `browser.json` and the `network-enforcement` entry of the wallet request log say `not-applicable`. An empty `served` without that opt-out keeps the check, which fails closed, so a policy that computes its served hosts can't lose the check by finding none. Listing served hosts and opting out together is refused. Mainnet blocking is enforced either way.
+- **Signers.** `signer=injected` needs nothing. `signer=extension` belongs to the host: a signer module exports `signers.extension` with `prepareProfile` (load the extension, seed the profile; returns `{ browserArgs, secrets, state }` and may carry an `afterBrowserStart` step; both steps get `trackSecret` for key-material files), `confirm` (required with `prepareProfile`: without it the wallet host would close the wallet's own windows) and `readinessChecks`. `signers.injected.identity` sets the EIP-6963 identity the injected strict wallet presents. The module path (`signerModule`, `--signer-module` or `RECIPE_WEB_DAPP_SIGNER_MODULE`) is the one source: readiness, launch, verify and the wallet host all load it, and `createWebDappAdapter` throws if given an in-process `signers` object. With no signer requested, the signer is `extension` when a module is configured and `injected` otherwise, so a host whose module exports only `injected` sets the signer explicitly (`--signer injected` or `TERMINAL_SIGNER=injected`).
+- **Hooks.** The action set, console capture, and network and performance observation are the host's; pass them as `hooks`. `diagnostics`, `readiness` and `harness` merge over the generic members.
+- **Leaves.** `webDappLeafPath('launch' | 'wallet-host' | 'inject' | 'verify' | 'stop' | 'cleanup')` names the CLI scripts.
+- **Test fixture.** `test/fixtures/web-dapp-test-plugin` is a `test-dapp` adapter for MetaMask's test-dapp-multichain. That dapp needs `signer=extension` with a host signer module: it talks to the wallet through the Multichain API, which the injected EIP-1193 strict wallet cannot drive.
+- **Kept for compatibility.** These generic-code names still carry the host's old product name, because renaming them needs both sides to change together: the `TERMINAL_*` environment names (`TERMINAL_CHROME_BIN`, `TERMINAL_APP_PORT`, `TERMINAL_SIGNER`, `TERMINAL_ACCOUNT`, `TERMINAL_HEADLESS`, `TERMINAL_SLOW_MO`, `TERMINAL_WINDOW`, `TERMINAL_SCREEN`); `MM_HARNESS_SERVED_TIMEOUT_MS`, `MM_HARNESS_APP_COMMIT_TIMEOUT_MS` and `MM_HARNESS_FOCUS_SETTLE_MS`; the `--mm-harness-owner` process marker (process ownership is matched on argv); the `mm-harness-probe=1` probe marker; and the `mm-harness-hud` overlay element.
+
+```js
+import { createWebDappAdapter } from '@farmslot/adapter-web/web-dapp';
+
+const adapter = createWebDappAdapter({
+  id: 'web-dapp',
+  signerModule: '/path/to/signers.mjs', // exports { signers: { extension, injected } }; omit for injected-only
+  hooks: { actions },
+});
+```
+
 ## Resolver CLI
 
 `browser-resolver.cjs` is also a command, for hosts that need a bounded child process (a hung CDP call can't stall the caller). Every command finishes within 120 s, exits 0 on success and 1 with the error message on stderr otherwise. Hosts can keep their own script path by calling `runCli(argv)`.

package/dist/launch-browser.d.cts

@@ -56,6 +56,16 @@ export type LaunchBrowserOptions = {
      * Progress lines (default stderr).
      */
     log?: ((line: string) => void) | undefined;
+    /**
+     * What the launch is waiting for, for a caller's stage handle (`stage.progress`).
+     */
+    progress?: ((progress: {
+        message?: string;
+        waitingFor?: string;
+        current?: number;
+        total?: number;
+        unit?: string;
+    }) => void) | undefined;
 };
 /**
  * @typedef {object} LaunchBrowserOptions
@@ -77,6 +87,8 @@ export type LaunchBrowserOptions = {
  * @property {string} [rerunCommand] Command named in "Next:" hints.
  * @property {number} [focusSettleMs] macOS: wait before the one focus check (default 1000).
  * @property {(line: string) => void} [log] Progress lines (default stderr).
+ * @property {(progress: { message?: string, waitingFor?: string, current?: number, total?: number, unit?: string }) => void} [progress]
+ *   What the launch is waiting for, for a caller's stage handle (`stage.progress`).
  */
 /**
  * @param {LaunchBrowserOptions} options

package/dist/web-dapp/cleanup.d.mts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+export function cleanupWebDappRuntime({ target, cdpPort, resetProfile }: {
+    target: any;
+    cdpPort: any;
+    resetProfile?: boolean | undefined;
+}): Promise<{
+    status: string;
+    target: string;
+    stopped: {
+        name: string;
+        pid: number;
+    }[];
+    cdpPortFree: any;
+    removed: string[];
+}>;

package/dist/web-dapp/index.d.mts

@@ -0,0 +1,123 @@
+/**
+ * The absolute path of a leaf script (`launch`, `wallet-host`, `inject`,
+ * `verify`, `stop` or `cleanup`).
+ * @param {'launch' | 'wallet-host' | 'inject' | 'verify' | 'stop' | 'cleanup'} name
+ */
+export function webDappLeafPath(name: "launch" | "wallet-host" | "inject" | "verify" | "stop" | "cleanup"): string;
+/**
+ * A file in the slot's runtime directory (the realpath of the target, as the
+ * launcher uses): <checkout>/<runtime>/<adapter id>/<name>.
+ * @param {string} target
+ * @param {string} name
+ */
+export function webDappRuntimeFile(target: string, name: string): string;
+/** @param {Record<string, string | boolean>} options */
+export function webDappOnlyLaunchFlags(options: Record<string, string | boolean>): ("--signer" | "--account" | "--fresh-profile" | "--headless" | "--headful" | "--slow-mo" | "--network" | "--mainnet-confirmation")[];
+/**
+ * The leaf prints one JSON document (compact with --json, indented without).
+ * Parse it whole; fall back to the last line for any log noise before it.
+ * @param {string} output
+ * @returns {Record<string, unknown>}
+ */
+export function parseWebDappLauncherOutput(output: string): Record<string, unknown>;
+export function webDappAppPort(): number | undefined;
+export function webDappCdpPort(): number | undefined;
+/**
+ * Bind the venue policy of an adapter that extends web-dapp: its module path
+ * goes to RECIPE_WEB_DAPP_POLICY, which web-dapp's members, leaf processes and
+ * live actions read for this command. Called when the host adopts the adapter.
+ * @template {{ extends?: string, policy?: { module?: unknown } }} T
+ * @param {T} adapter
+ * @returns {T}
+ */
+export function bindWebDappPolicy<T extends {
+    extends?: string;
+    policy?: {
+        module?: unknown;
+    };
+}>(adapter: T): T;
+/**
+ * @param {readonly string[]} lines
+ * @returns {import('@farmslot/adapter-sdk').AdapterLogFinding[]}
+ */
+export function walletRequestFindings(lines: readonly string[]): import("@farmslot/adapter-sdk").AdapterLogFinding[];
+/**
+ * @typedef {Partial<Omit<import('@farmslot/adapter-sdk').PlatformAdapter, 'id' | 'sdkVersion' | 'harness'>> & {
+ *   harness?: Partial<import('@farmslot/adapter-sdk').AdapterHarness>,
+ * }} WebDappAdapterHooks
+ */
+/**
+ * @typedef {object} WebDappAdapterOptions
+ * @property {string} [id] The adapter id; web-dapp by default.
+ * @property {string} [signerModule] Absolute path of the ESM module exporting
+ *   `signers` (see lib/signers.mjs). The one source of the signer hooks: readiness
+ *   loads it in this process and launch, verify and the wallet host load it in theirs.
+ * @property {string} [cli] The host's bin name, for `Next:` lines. farmslot-recipe by default.
+ * @property {WebDappAdapterHooks} [hooks]
+ *   Anything of the PlatformAdapter the host supplies or replaces. `actions` is
+ *   required in practice (web-dapp ships no action manifest); `diagnostics`,
+ *   `readiness` and `harness` merge over the generic members, the rest replace.
+ */
+/**
+ * @param {WebDappAdapterOptions} [factoryOptions]
+ * @returns {import('@farmslot/adapter-sdk').PlatformAdapter}
+ */
+export function createWebDappAdapter(factoryOptions?: WebDappAdapterOptions): import("@farmslot/adapter-sdk").PlatformAdapter;
+export { cleanupWebDappRuntime } from "./cleanup.mjs";
+export { installWebDappRuntime } from "./inject.mjs";
+export const WEB_DAPP_CONSOLE_FILES: Readonly<{
+    app: "app-console.log";
+    extension: "extension-console.log";
+    collectorLog: "console-tail.log";
+    pidFile: "console-tail.pid";
+}>;
+export const WEB_DAPP_ONLY_LAUNCH_OPTIONS: Readonly<{
+    signer: "--signer";
+    account: "--account";
+    freshProfile: "--fresh-profile";
+    headless: "--headless";
+    headful: "--headful";
+    slowMo: "--slow-mo";
+    network: "--network";
+    mainnetConfirmation: "--mainnet-confirmation";
+}>;
+export type WebDappAdapterHooks = Partial<Omit<import("@farmslot/adapter-sdk").PlatformAdapter, "id" | "sdkVersion" | "harness">> & {
+    harness?: Partial<import("@farmslot/adapter-sdk").AdapterHarness>;
+};
+export type WebDappAdapterOptions = {
+    /**
+     * The adapter id; web-dapp by default.
+     */
+    id?: string | undefined;
+    /**
+     * Absolute path of the ESM module exporting
+     * `signers` (see lib/signers.mjs). The one source of the signer hooks: readiness
+     * loads it in this process and launch, verify and the wallet host load it in theirs.
+     */
+    signerModule?: string | undefined;
+    /**
+     * The host's bin name, for `Next:` lines. farmslot-recipe by default.
+     */
+    cli?: string | undefined;
+    /**
+     * Anything of the PlatformAdapter the host supplies or replaces. `actions` is
+     * required in practice (web-dapp ships no action manifest); `diagnostics`,
+     * `readiness` and `harness` merge over the generic members, the rest replace.
+     */
+    hooks?: WebDappAdapterHooks | undefined;
+};
+import { loadSigners } from './lib/signers.mjs';
+import { POLICY_ENV } from './lib/policy.mjs';
+import { check } from './lib/readiness.mjs';
+import { SIGNER_MODULE_ENV } from './lib/signers.mjs';
+import { webDappAdapterId } from './lib/policy.mjs';
+import { webDappPolicy } from './lib/policy.mjs';
+export { loadSigners, POLICY_ENV, check as readinessCheck, SIGNER_MODULE_ENV, webDappAdapterId, webDappPolicy };
+export { backgroundWindowParams, checkFocusAfterLaunch, chromeForTestingCandidates, LAUNCH_SERVICES, LAUNCH_TIMEOUTS, launchMethodFor, launchWebDappBrowser, macApplicationForExecutable, parseLaunchArgs, resolveBrowser, SPAWN, spawnDetached } from "./launch.mjs";
+export { hostOf, hostResolverRules, isBlockedUrl } from "./lib/blocked-hosts.mjs";
+export { browserWebSocketUrl, CdpClient } from "./lib/cdp-client.mjs";
+export { recipeHarnessPath, recipeRuntimeDir, recipeRuntimePath, shellQuote, walletFixturePath } from "./lib/paths.mjs";
+export { assertPolicyDigest, fencePolicy, POLICY_DIGEST_ENV, PolicyFenceError } from "./lib/policy-fence.mjs";
+export { cdpListenerPids, ownedBrowserPids, OWNER_FLAG, OWNER_KINDS, ownerMarker, ownsProcess, pidAlive, portFree, stopConsoleCollector, stopWebDappBrowser, terminate } from "./lib/processes.mjs";
+export { assertLaunchNetwork, DEV_SERVER_PID_FILE, devServerTestnetDiagnostic, pythonFor, webDappReadiness } from "./lib/readiness.mjs";
+export { accountName, appOrigin, appPort, canonicalPath, cdpPort, DEFAULT_ACCOUNT, fixtureAccount, fixtureEntry, fixturePath, loadWalletFixture, readBrowserState, readJsonFile, resolveAccountAddress, resolveSigner, SIGNER_MODES, viemAccountFromEntry, webDappRuntimeDir, webDappRuntimePath, writePrivateJson } from "./lib/runtime.mjs";

package/dist/web-dapp/inject.d.mts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export function installWebDappRuntime({ target, fixture, force }: {
+    target: any;
+    fixture: any;
+    force?: boolean | undefined;
+}): {
+    status: string;
+    target: string;
+    fixture: string;
+    fixturePath: string;
+    accounts: any;
+};

package/dist/web-dapp/launch.d.mts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+export function parseLaunchArgs(argv: any, env?: NodeJS.ProcessEnv): {
+    account: string;
+    'fresh-profile': boolean;
+    headless: boolean;
+    headful: boolean;
+    json: boolean;
+} | {
+    help: boolean;
+};
+export function chromeForTestingCandidates(home?: string, platform?: NodeJS.Platform, arch?: NodeJS.Architecture): string[];
+export function resolveBrowser(env?: NodeJS.ProcessEnv, candidates?: string[]): Promise<{
+    bin: string;
+    version: string | null;
+    source: string;
+}>;
+export function macApplicationForExecutable(executable: any): string | null;
+export function launchMethodFor(executable: any, { platform }?: {
+    platform?: NodeJS.Platform | undefined;
+}): "launch-services" | "spawn";
+export function checkFocusAfterLaunch(runtime: any, previous: any, { ourPids, focus }?: {
+    ourPids?: number[] | undefined;
+    focus?: any;
+}): any;
+export function backgroundWindowParams(url: any, placement: any): {
+    left?: any;
+    top?: any;
+    width?: any;
+    height?: any;
+    url: any;
+    newWindow: boolean;
+    background: boolean;
+};
+export function spawnDetached(command: any, args: any, { logFile, pidFile, env }: {
+    logFile: any;
+    pidFile: any;
+    env?: NodeJS.ProcessEnv | undefined;
+}): Promise<any>;
+export function writePrivateFile(file: any, text: any): void;
+/**
+ * @param {Record<string, any>} args the parsed launch flags (see `parseLaunchArgs`)
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {{ timeouts?: { browserStartMs: number, hostReadyMs: number } }} [options]
+ */
+export function launchWebDappBrowser(args: Record<string, any>, env?: NodeJS.ProcessEnv, { timeouts }?: {
+    timeouts?: {
+        browserStartMs: number;
+        hostReadyMs: number;
+    };
+}): Promise<any>;
+export const SPAWN: "spawn";
+export const LAUNCH_SERVICES: "launch-services";
+export const LAUNCH_TIMEOUTS: Readonly<{
+    browserStartMs: 90000;
+    hostReadyMs: 180000;
+}>;

package/dist/web-dapp/lib/blocked-hosts.d.mts

@@ -0,0 +1,3 @@
+export function hostOf(url: any): string | null;
+export function isBlockedUrl(url: any, hosts: any): any;
+export function hostResolverRules(hosts: any): string;

package/dist/web-dapp/lib/cdp-client.d.mts

@@ -0,0 +1,8 @@
+export function browserWebSocketUrl(port: any, timeoutMs?: number): Promise<any>;
+export class CdpClient {
+    static connect(url: any): Promise<CdpClient>;
+    on(method: any, handler: any): () => any;
+    send(method: any, params?: {}, sessionId?: undefined): Promise<any>;
+    close(): void;
+    #private;
+}

package/dist/web-dapp/lib/display.d.mts

@@ -0,0 +1,26 @@
+export function resolveHeadless({ headless, headful, nodeHeadless, nodeHeadful, env, }?: {
+    env?: NodeJS.ProcessEnv | undefined;
+}): boolean;
+export function resolveSlowMo({ flag, node, env }?: {
+    env?: NodeJS.ProcessEnv | undefined;
+}): number;
+export function detectScreen(env?: NodeJS.ProcessEnv): any;
+export function windowPlacement({ cdpPort, env, screen }?: {
+    env?: NodeJS.ProcessEnv | undefined;
+    screen?: null | undefined;
+}): {
+    zoom: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    source: any;
+};
+export function zoomLevel(zoom: any): number;
+export function writeProfileZoom(profile: any, zoom: any): void;
+export function browserDisplayArgs({ headless, placement }: {
+    headless: any;
+    placement: any;
+}): string[];
+export const MIN_LAYOUT_WIDTH: 1460;
+export const MIN_ZOOM: 0.5;

package/dist/web-dapp/lib/hud.d.mts

@@ -0,0 +1,14 @@
+export function nextHudState(prior: any, node?: {}, nodeId?: string): {
+    seq: any;
+    title: any;
+    current: any;
+    last: any;
+    finished: null;
+};
+export function hudFile(runtimeDir: any): string;
+export function readHudState(runtimeDir: any): any;
+export function writeHudState(runtimeDir: any, state: any): void;
+export function clearHudState(runtimeDir: any): void;
+export function hudRenderExpression(state: any, appOrigin: any): string;
+export const HUD_ELEMENT: "mm-harness-hud";
+export const HUD_FILE: "hud.json";

package/dist/web-dapp/lib/paths.d.mts

@@ -0,0 +1,11 @@
+export function validateRelativeRecipePath(name: any, value: any): any;
+/** The checkout-relative runtime directory: `RECIPE_RUNTIME_DIR`, else the default. */
+export function recipeRuntimeDir(): any;
+/** The checkout-relative overlay directory: `RECIPE_HARNESS_ROOT`, else the default. */
+export function recipeHarnessRoot(): any;
+export function recipeRuntimePath(projectRoot: any, ...segments: any[]): string;
+export function recipeHarnessPath(projectRoot: any, ...segments: any[]): string;
+export function walletFixturePath(projectRoot: any): string;
+export function shellQuote(value: any): string;
+export const DEFAULT_RECIPE_RUNTIME_DIR: "temp/recipe/runtime";
+export const DEFAULT_RECIPE_HARNESS_ROOT: "temp/recipe/harness";

package/dist/web-dapp/lib/policy-fence.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Check a policy module against `covered`, the real paths of the files the
+ * plugin digest covers, and return the digest of the policy's files. Throws
+ * PolicyFenceError when one of them is not covered.
+ */
+export function fencePolicy({ file, covered, scope }: {
+    file: any;
+    covered: any;
+    scope: any;
+}): string;
+/** Refuse a policy whose files changed since mm-harness bound it (`digest`). */
+export function assertPolicyDigest(file: any, digest: any): void;
+export const POLICY_DIGEST_ENV: "RECIPE_WEB_DAPP_POLICY_DIGEST";
+export class PolicyFenceError extends Error {
+    constructor(message: any);
+    code: string;
+    userAction: string;
+}

package/dist/web-dapp/lib/policy.d.mts

@@ -0,0 +1,4 @@
+export function webDappPolicy(env?: NodeJS.ProcessEnv): any;
+export function webDappAdapterId(env?: NodeJS.ProcessEnv): any;
+export const POLICY_ENV: "RECIPE_WEB_DAPP_POLICY";
+export const POLICY_VERSION: 1;

package/dist/web-dapp/lib/processes.d.mts

@@ -0,0 +1,57 @@
+export function pidAlive(pid: any): boolean;
+export function processCommand(pid: any): string;
+export function ownerMarker(kind: any, runtimeDir: any): string;
+export function ownsProcess(kind: any, pid: any, runtimeDir: any, command?: string): boolean;
+export function portFree(port: any): Promise<any>;
+export function terminate(pid: any, graceMs?: number): Promise<boolean>;
+/**
+ * @param {string} target
+ * @param {{ log?: (message: string) => void, runtimeDir?: string }} [options]
+ */
+export function stopConsoleCollector(target: string, { log, runtimeDir }?: {
+    log?: (message: string) => void;
+    runtimeDir?: string;
+}): Promise<{
+    stopped: null;
+    foreign?: undefined;
+    stale?: undefined;
+} | {
+    stopped: number;
+    foreign?: undefined;
+    stale?: undefined;
+} | {
+    stopped: null;
+    foreign: number;
+    stale?: undefined;
+} | {
+    stopped: null;
+    stale: number;
+    foreign?: undefined;
+}>;
+export function ownedBrowserPids(runtimeDir: any): number[];
+export function cdpListenerPids(port: any): number[];
+/**
+ * @param {string} target
+ * @param {{ cdpPort?: number, log?: (message: string) => void, runtimeDir?: string }} [options]
+ */
+export function stopWebDappBrowser(target: string, { cdpPort, log, runtimeDir }?: {
+    cdpPort?: number;
+    log?: (message: string) => void;
+    runtimeDir?: string;
+}): Promise<{
+    stopped: {
+        name: string;
+        pid: number;
+    }[];
+    stale: {
+        name: string;
+        pid: number;
+    }[];
+    foreign: {
+        name: string;
+        pid: number;
+    }[];
+    cdpPortFree: any;
+}>;
+export const OWNER_FLAG: "--mm-harness-owner";
+export const OWNER_KINDS: readonly string[];

package/dist/web-dapp/lib/readiness.d.mts

@@ -0,0 +1,85 @@
+/**
+ * @param {string} id
+ * @param {boolean} ok
+ * @param {string} detail
+ * @param {{ required?: boolean, status?: 'pass' | 'fail' | 'warn' }} [options]
+ */
+export function check(id: string, ok: boolean, detail: string, { required, status }?: {
+    required?: boolean;
+    status?: "pass" | "fail" | "warn";
+}): {
+    id: string;
+    status: "fail" | "pass" | "warn";
+    required: boolean;
+    detail: string;
+};
+export function pythonFor({ found, platform, developerDir }: {
+    found: any;
+    platform?: NodeJS.Platform | undefined;
+    developerDir: any;
+}): any;
+export function environmentValue(env: any, name: any): any;
+export function nextServerMode(argv: any): any;
+/**
+ * @param {string} target
+ * @param {{ appPort?: number, variable?: string, probe?: typeof systemProbe }} [options]
+ */
+export function devServerTestnetDiagnostic(target: string, { appPort, variable, probe }?: {
+    appPort?: number;
+    variable?: string;
+    probe?: typeof systemProbe;
+}): {
+    known: boolean;
+    forced: boolean;
+    detail: any;
+};
+/**
+ * @param {string} _target
+ * @param {{ network?: string | null, mainnetConfirmation?: string }} [options]
+ * @returns {'testnet' | 'mainnet'}
+ */
+export function assertLaunchNetwork(_target: string, { network, mainnetConfirmation }?: {
+    network?: string | null;
+    mainnetConfirmation?: string;
+}): "testnet" | "mainnet";
+/**
+ * @param {{
+ *   policy?: any,
+ *   signers?: Record<string, any>,
+ *   target: string,
+ *   appPort?: number,
+ *   cdpPort?: number,
+ *   signer?: string,
+ *   account?: string,
+ *   env?: NodeJS.ProcessEnv,
+ *   probeBrowser?: (env: NodeJS.ProcessEnv) => Promise<{ bin: string, version: string | null, source: string }>,
+ * }} options
+ */
+export function webDappReadiness({ policy, signers, target, appPort, cdpPort, signer, account, env, probeBrowser, }: {
+    policy?: any;
+    signers?: Record<string, any>;
+    target: string;
+    appPort?: number;
+    cdpPort?: number;
+    signer?: string;
+    account?: string;
+    env?: NodeJS.ProcessEnv;
+    probeBrowser?: (env: NodeJS.ProcessEnv) => Promise<{
+        bin: string;
+        version: string | null;
+        source: string;
+    }>;
+}): Promise<{
+    status: string;
+    checks: any[];
+    failed: any[];
+    browser: any;
+}>;
+export const DEV_SERVER_PID_FILE: "temp/farmslot/next-dev.pid";
+export const systemProbe: Readonly<{
+    listeners: (port: any) => any;
+    parents: () => Map<any, any>;
+    cwd: (pid: any) => any;
+    procArgs: (pid: any) => any;
+}>;
+export const MAINNET_CONFIRMATION: "REAL_FUNDS";

package/dist/web-dapp/lib/runtime.d.mts

@@ -0,0 +1,29 @@
+export function canonicalPath(target: any): string;
+export function webDappRuntimeDir(projectRoot: any): string;
+export function webDappRuntimePath(projectRoot: any, ...segments: any[]): string;
+export function appPort(input?: {}, env?: NodeJS.ProcessEnv): number;
+export function appOrigin(input?: {}, env?: NodeJS.ProcessEnv): string;
+export function cdpPort(input?: {}, env?: NodeJS.ProcessEnv): number;
+export function readJsonFile(file: any): Promise<any>;
+export function writePrivateJson(file: any, value: any): Promise<void>;
+export function readBrowserState(projectRoot: any): Promise<any>;
+export function resolveSigner(raw: any, fallback?: string): string;
+export function accountName(input?: {}, browserState?: null): any;
+export function fixturePath(projectRoot: any, env?: NodeJS.ProcessEnv): string;
+export function loadWalletFixture(projectRoot: any, env?: NodeJS.ProcessEnv): Promise<{
+    file: string;
+    fixture: any;
+}>;
+export function fixtureEntry(fixture: any, name: any): any;
+export function viemAccountFromEntry(entry: any, projectRoot: any): any;
+export function fixtureAccount(projectRoot: any, name: any, env?: NodeJS.ProcessEnv): Promise<any>;
+export function resolveAccountAddress(input: any, env?: NodeJS.ProcessEnv): Promise<{
+    name: any;
+    address: any;
+}>;
+export const SIGNER_MODES: readonly string[];
+export const DEFAULT_ACCOUNT: "dev1";
+import { POLICY_ENV } from './policy.mjs';
+import { webDappAdapterId } from './policy.mjs';
+import { webDappPolicy } from './policy.mjs';
+export { POLICY_ENV, webDappAdapterId, webDappPolicy };

package/dist/web-dapp/lib/signers.d.mts

@@ -0,0 +1,13 @@
+export function defaultSigner(signerModule: any, env?: NodeJS.ProcessEnv): "extension" | "injected";
+export function loadSigners(env?: NodeJS.ProcessEnv): Promise<any>;
+export function injectedWalletIdentity(signers?: {}): any;
+export const SIGNER_MODULE_ENV: "RECIPE_WEB_DAPP_SIGNER_MODULE";
+export const GENERIC_INJECTED_IDENTITY: Readonly<{
+    info: Readonly<{
+        uuid: "5d1e5b4e-e2e0-4c3f-9a1d-000000000001";
+        name: "Strict test wallet";
+        icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>";
+        rdns: "io.farmslot.strict-wallet";
+    }>;
+    isMetaMask: false;
+}>;

package/dist/web-dapp/lib/viem.d.mts

@@ -0,0 +1 @@
+export function loadViemAccounts(projectRoot: any): any;

package/dist/web-dapp/stop.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/web-dapp/verify.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/web-dapp/wallet-host.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};