@storyshelf/core 0.7.0 → 0.9.0-next-d2cc082

package/dist/adapters/remote-lease-attempt.mjs

@@ -0,0 +1,39 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+// src/adapters/remote-lease-attempt.ts
+const attempts = /* @__PURE__ */ new Set();
+/** Start an attempt tied to the run's signal; a signal already aborted stops it at once. */
+function startAttempt(parent) {
+	const controller = new AbortController();
+	const onAbort = () => {
+		attempt.stop();
+	};
+	const attempt = {
+		controller,
+		stopped: false,
+		stop: () => {
+			attempt.stopped = true;
+			controller.abort();
+		},
+		detach: () => {
+			parent?.removeEventListener("abort", onAbort);
+		}
+	};
+	attempts.add(attempt);
+	if (parent?.aborted === true) attempt.stop();
+	else parent?.addEventListener("abort", onAbort, { once: true });
+	return attempt;
+}
+/** The attempt is over: forget it and stop listening to the run's signal. */
+function endAttempt(attempt) {
+	attempts.delete(attempt);
+	attempt.detach();
+}
+/** Stop every attempt still pending (shutdown). */
+function stopAllAttempts() {
+	for (const attempt of attempts) attempt.stop();
+}
+export { endAttempt, startAttempt, stopAllAttempts };
+
+//# sourceMappingURL=remote-lease-attempt.mjs.map

package/dist/adapters/remote-lease-attempt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-lease-attempt.mjs","names":[],"sources":["../../src/adapters/remote-lease-attempt.ts"],"sourcesContent":["/** A `connect` attempt in flight, so a cancel or shutdown can reach it (ADR 0007, decision 4). */\n\n/** A `connect` attempt in flight: aborted by its deadline, a cancel or shutdown. */\nexport interface Attempt {\n  readonly controller: AbortController;\n  stopped: boolean;\n  stop(): void;\n  /** Stop listening to the run's signal, so retries do not pile up listeners on it. */\n  detach(): void;\n}\n\nconst attempts = new Set<Attempt>();\n\n/** Start an attempt tied to the run's signal; a signal already aborted stops it at once. */\nexport function startAttempt(parent?: AbortSignal): Attempt {\n  const controller = new AbortController();\n  const onAbort = (): void => {\n    attempt.stop();\n  };\n  const attempt: Attempt = {\n    controller,\n    stopped: false,\n    stop: () => {\n      attempt.stopped = true;\n      controller.abort();\n    },\n    detach: () => {\n      parent?.removeEventListener(\"abort\", onAbort);\n    },\n  };\n  attempts.add(attempt);\n  if (parent?.aborted === true) {\n    attempt.stop();\n  } else {\n    parent?.addEventListener(\"abort\", onAbort, { once: true });\n  }\n  return attempt;\n}\n\n/** The attempt is over: forget it and stop listening to the run's signal. */\nexport function endAttempt(attempt: Attempt): void {\n  attempts.delete(attempt);\n  attempt.detach();\n}\n\n/** Stop every attempt still pending (shutdown). */\nexport function stopAllAttempts(): void {\n  for (const attempt of attempts) {\n    attempt.stop();\n  }\n}\n"],"mappings":";;;;AAWA,MAAM,2BAAW,IAAI,IAAa;;AAGlC,SAAgB,aAAa,QAA+B;CAC1D,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,gBAAsB;EAC1B,QAAQ,KAAK;CACf;CACA,MAAM,UAAmB;EACvB;EACA,SAAS;EACT,YAAY;GACV,QAAQ,UAAU;GAClB,WAAW,MAAM;EACnB;EACA,cAAc;GACZ,QAAQ,oBAAoB,SAAS,OAAO;EAC9C;CACF;CACA,SAAS,IAAI,OAAO;CACpB,IAAI,QAAQ,YAAY,MACtB,QAAQ,KAAK;MAEb,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAE3D,OAAO;AACT;;AAGA,SAAgB,WAAW,SAAwB;CACjD,SAAS,OAAO,OAAO;CACvB,QAAQ,OAAO;AACjB;;AAGA,SAAgB,kBAAwB;CACtC,KAAK,MAAM,WAAW,UACpB,QAAQ,KAAK;AAEjB"}

package/dist/adapters/remote-lease-error.d.mts

@@ -0,0 +1,25 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+/** What a connect failure means for the retry loop and for the target. */
+interface RemoteConnectErrorOptions {
+  /** `false` stops the retries and fails the job (default `true`: retried). */
+  transient?: boolean | undefined;
+  /**
+   * For `transient: false`: `target` (default) also marks the target unavailable until restart,
+   * `job` fails only this job and keeps the target offered (a per-shard server that is gone).
+   */
+  scope?: "target" | "job" | undefined;
+  /** A lease the failed `connect` already took, released as `failed`. */
+  lease?: unknown;
+  cause?: unknown;
+}
+/** An error a function `connect` throws to say how the runner should treat the failure. */
+declare class RemoteConnectError extends Error {
+  readonly name = "RemoteConnectError";
+  readonly transient: boolean;
+  readonly scope: "target" | "job";
+  readonly lease: unknown;
+  constructor(message: string, options?: RemoteConnectErrorOptions);
+}
+export { RemoteConnectError, RemoteConnectErrorOptions };
+//# sourceMappingURL=remote-lease-error.d.mts.map

package/dist/adapters/remote-lease-error.mjs

@@ -0,0 +1,54 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { isRetryableConnectError } from "../utils/connect-retry.mjs";
+// src/adapters/remote-lease-error.ts
+/** How a connect failure is classified (ADR 0007, decision 4): retried or not, and what it does to the target. */
+/** An error a function `connect` throws to say how the runner should treat the failure. */
+var RemoteConnectError = class extends Error {
+	name = "RemoteConnectError";
+	transient;
+	scope;
+	lease;
+	constructor(message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.transient = options.transient ?? true;
+		this.scope = options.scope ?? "target";
+		this.lease = options.lease;
+	}
+};
+/** Marks the error of a `connect` abandoned because the run was cancelled or the process is shutting down. */
+const STOPPED = Symbol("remote connect stopped");
+/** The error of a `connect` that was cancelled or cut short by shutdown: never retried. */
+function stoppedError() {
+	return Object.assign(/* @__PURE__ */ new Error("cancelled while connecting"), { [STOPPED]: true });
+}
+/** What a connect error means: whether to retry it, and whether it marks the target unavailable. */
+function classify(error) {
+	if (typeof error === "object" && error !== null && STOPPED in error) return {
+		retry: false,
+		unavailable: false
+	};
+	if (error instanceof RemoteConnectError) return {
+		retry: error.transient,
+		unavailable: !error.transient && error.scope !== "job"
+	};
+	const retry = isRetryableConnectError(error);
+	return {
+		retry,
+		unavailable: !retry
+	};
+}
+/** A provider's thrown value as a {@link RemoteConnectError}: transient unless it says `transient: false`. */
+function connectErrorOf(error) {
+	const flags = typeof error === "object" && error !== null ? error : {};
+	return new RemoteConnectError(`acquire failed: ${error instanceof Error ? error.message : String(error)}`, {
+		cause: error,
+		transient: flags.transient !== false,
+		scope: flags.scope === "job" ? "job" : "target",
+		lease: flags.lease
+	});
+}
+export { RemoteConnectError, classify, connectErrorOf, stoppedError };
+
+//# sourceMappingURL=remote-lease-error.mjs.map

package/dist/adapters/remote-lease-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-lease-error.mjs","names":[],"sources":["../../src/adapters/remote-lease-error.ts"],"sourcesContent":["/** How a connect failure is classified (ADR 0007, decision 4): retried or not, and what it does to the target. */\nimport { isRetryableConnectError } from \"../utils/connect-retry.ts\";\n\n/** What a connect failure means for the retry loop and for the target. */\nexport interface RemoteConnectErrorOptions {\n  /** `false` stops the retries and fails the job (default `true`: retried). */\n  transient?: boolean | undefined;\n  /**\n   * For `transient: false`: `target` (default) also marks the target unavailable until restart,\n   * `job` fails only this job and keeps the target offered (a per-shard server that is gone).\n   */\n  scope?: \"target\" | \"job\" | undefined;\n  /** A lease the failed `connect` already took, released as `failed`. */\n  lease?: unknown;\n  cause?: unknown;\n}\n\n/** An error a function `connect` throws to say how the runner should treat the failure. */\nexport class RemoteConnectError extends Error {\n  override readonly name = \"RemoteConnectError\";\n  readonly transient: boolean;\n  readonly scope: \"target\" | \"job\";\n  readonly lease: unknown;\n\n  constructor(message: string, options: RemoteConnectErrorOptions = {}) {\n    super(message, options.cause === undefined ? undefined : { cause: options.cause });\n    this.transient = options.transient ?? true;\n    this.scope = options.scope ?? \"target\";\n    this.lease = options.lease;\n  }\n}\n\n/** Marks the error of a `connect` abandoned because the run was cancelled or the process is shutting down. */\nconst STOPPED = Symbol(\"remote connect stopped\");\n\n/** The error of a `connect` that was cancelled or cut short by shutdown: never retried. */\nexport function stoppedError(): Error {\n  return Object.assign(new Error(\"cancelled while connecting\"), { [STOPPED]: true });\n}\n\n/** What a connect error means: whether to retry it, and whether it marks the target unavailable. */\nexport function classify(error: unknown): { retry: boolean; unavailable: boolean } {\n  if (typeof error === \"object\" && error !== null && STOPPED in error) {\n    return { retry: false, unavailable: false };\n  }\n  if (error instanceof RemoteConnectError) {\n    return { retry: error.transient, unavailable: !error.transient && error.scope !== \"job\" };\n  }\n  const retry = isRetryableConnectError(error);\n  return { retry, unavailable: !retry };\n}\n\n/** A provider's thrown value as a {@link RemoteConnectError}: transient unless it says `transient: false`. */\nexport function connectErrorOf(error: unknown): RemoteConnectError {\n  const flags = (typeof error === \"object\" && error !== null ? error : {}) as {\n    transient?: unknown;\n    scope?: unknown;\n    lease?: unknown;\n  };\n  return new RemoteConnectError(\n    `acquire failed: ${error instanceof Error ? error.message : String(error)}`,\n    {\n      cause: error,\n      transient: flags.transient !== false,\n      scope: flags.scope === \"job\" ? \"job\" : \"target\",\n      lease: flags.lease,\n    },\n  );\n}\n"],"mappings":";;;;;;;AAkBA,IAAa,qBAAb,cAAwC,MAAM;CAC5C,OAAyB;CACzB;CACA;CACA;CAEA,YAAY,SAAiB,UAAqC,CAAC,GAAG;EACpE,MAAM,SAAS,QAAQ,UAAU,KAAA,IAAY,KAAA,IAAY,EAAE,OAAO,QAAQ,MAAM,CAAC;EACjF,KAAK,YAAY,QAAQ,aAAa;EACtC,KAAK,QAAQ,QAAQ,SAAS;EAC9B,KAAK,QAAQ,QAAQ;CACvB;AACF;;AAGA,MAAM,UAAU,OAAO,wBAAwB;;AAG/C,SAAgB,eAAsB;CACpC,OAAO,OAAO,uBAAO,IAAI,MAAM,4BAA4B,GAAG,GAAG,UAAU,KAAK,CAAC;AACnF;;AAGA,SAAgB,SAAS,OAA0D;CACjF,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,WAAW,OAC5D,OAAO;EAAE,OAAO;EAAO,aAAa;CAAM;CAE5C,IAAI,iBAAiB,oBACnB,OAAO;EAAE,OAAO,MAAM;EAAW,aAAa,CAAC,MAAM,aAAa,MAAM,UAAU;CAAM;CAE1F,MAAM,QAAQ,wBAAwB,KAAK;CAC3C,OAAO;EAAE;EAAO,aAAa,CAAC;CAAM;AACtC;;AAGA,SAAgB,eAAe,OAAoC;CACjE,MAAM,QAAS,OAAO,UAAU,YAAY,UAAU,OAAO,QAAQ,CAAC;CAKtE,OAAO,IAAI,mBACT,mBAAmB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,KACxE;EACE,OAAO;EACP,WAAW,MAAM,cAAc;EAC/B,OAAO,MAAM,UAAU,QAAQ,QAAQ;EACvC,OAAO,MAAM;CACf,CACF;AACF"}

package/dist/adapters/remote-lease-held.d.mts

@@ -0,0 +1,15 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { RemoteConnection, RemoteLeaseOutcome } from "./remote-browser.mjs";
+import "../logger.mjs";
+/** A connection held until its render ends. */
+interface HeldConnection {
+  /** The connection to open (with its lease, for scrubbing): the function's result, or the fixed object. */
+  readonly connection: RemoteConnection & {
+    lease?: unknown;
+  };
+  /** Release the lease with how the render ended; later calls do nothing (the first outcome wins). */
+  end(outcome: RemoteLeaseOutcome, error?: unknown): Promise<void>;
+}
+export { HeldConnection };
+//# sourceMappingURL=remote-lease-held.d.mts.map

package/dist/adapters/remote-lease-held.mjs

@@ -0,0 +1,86 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+// src/adapters/remote-lease-held.ts
+const held = /* @__PURE__ */ new Set();
+const warnedNoLease = /* @__PURE__ */ new Set();
+/** Release every lease still held, as `cancelled`. */
+async function releaseAllHeld() {
+	await Promise.all([...held].map(async (lease) => {
+		await lease.end("cancelled");
+	}));
+}
+/** `pending`, or the error `onTimeout` makes after `ms`. */
+async function withDeadline(pending, ms, onTimeout) {
+	let timer;
+	const deadline = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			reject(onTimeout());
+		}, ms);
+	});
+	try {
+		return await Promise.race([pending, deadline]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function noLease(connection) {
+	return {
+		connection,
+		end: async () => {
+			await Promise.resolve();
+		}
+	};
+}
+/**
+* Hold `lease` for `connection`: `end` calls the service's `release` once, bounded by
+* `timeouts.releaseMs`, and a failing or hanging release is logged (class only) and never thrown.
+* No lease means nothing to release: a warning says so once per target when `release` is set.
+*/
+function holdLease(entry, lease, connection, logger) {
+	const { release, timeouts } = entry.remote;
+	if (lease === void 0) {
+		if (release !== void 0 && !warnedNoLease.has(entry.target)) {
+			warnedNoLease.add(entry.target);
+			logger?.warn({ target: entry.target }, "remote release is set but connect returned no lease, so release is skipped");
+		}
+		return noLease(connection);
+	}
+	let ended = false;
+	const connectionHeld = {
+		connection: {
+			...connection,
+			lease
+		},
+		end: async (outcome, error) => {
+			if (ended) return;
+			ended = true;
+			held.delete(connectionHeld);
+			await runRelease(entry, async () => {
+				await release?.(lease, {
+					outcome,
+					error
+				});
+			}, timeouts.releaseMs, {
+				logger,
+				outcome
+			});
+		}
+	};
+	held.add(connectionHeld);
+	return connectionHeld;
+}
+async function runRelease(entry, call, timeoutMs, log) {
+	try {
+		await withDeadline(call(), timeoutMs, () => Object.assign(/* @__PURE__ */ new Error(`release timed out after ${timeoutMs} ms`), { name: "ReleaseTimeout" }));
+	} catch (error) {
+		log.logger?.warn({
+			target: entry.target,
+			outcome: log.outcome,
+			err: error instanceof Error ? error.name : "Error"
+		}, "remote browser release failed");
+	}
+}
+export { holdLease, noLease, releaseAllHeld, withDeadline };
+
+//# sourceMappingURL=remote-lease-held.mjs.map

package/dist/adapters/remote-lease-held.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-lease-held.mjs","names":[],"sources":["../../src/adapters/remote-lease-held.ts"],"sourcesContent":["/** A connection held until its render ends, and the one release it owes (ADR 0007, decision 4). */\nimport type { Logger } from \"../logger.ts\";\nimport type { RemoteConnection, RemoteLeaseOutcome, RemoteTarget } from \"./remote-browser.ts\";\n\n/** A connection held until its render ends. */\nexport interface HeldConnection {\n  /** The connection to open (with its lease, for scrubbing): the function's result, or the fixed object. */\n  readonly connection: RemoteConnection & { lease?: unknown };\n  /** Release the lease with how the render ended; later calls do nothing (the first outcome wins). */\n  end(outcome: RemoteLeaseOutcome, error?: unknown): Promise<void>;\n}\n\nconst held = new Set<HeldConnection>();\nconst warnedNoLease = new Set<string>();\n\n/** Release every lease still held, as `cancelled`. */\nexport async function releaseAllHeld(): Promise<void> {\n  await Promise.all(\n    [...held].map(async (lease) => {\n      await lease.end(\"cancelled\");\n    }),\n  );\n}\n\n/** `pending`, or the error `onTimeout` makes after `ms`. */\nexport async function withDeadline<T>(\n  pending: Promise<T>,\n  ms: number,\n  onTimeout: () => Error,\n): Promise<T> {\n  let timer: NodeJS.Timeout | undefined;\n  const deadline = new Promise<never>((_, reject) => {\n    timer = setTimeout(() => {\n      reject(onTimeout());\n    }, ms);\n  });\n  try {\n    return await Promise.race([pending, deadline]);\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\nexport function noLease(connection: RemoteConnection): HeldConnection {\n  return {\n    connection,\n    end: async () => {\n      await Promise.resolve();\n    },\n  };\n}\n\n/**\n * Hold `lease` for `connection`: `end` calls the service's `release` once, bounded by\n * `timeouts.releaseMs`, and a failing or hanging release is logged (class only) and never thrown.\n * No lease means nothing to release: a warning says so once per target when `release` is set.\n */\nexport function holdLease(\n  entry: RemoteTarget,\n  lease: unknown,\n  connection: RemoteConnection,\n  logger?: Logger,\n): HeldConnection {\n  const { release, timeouts } = entry.remote;\n  if (lease === undefined) {\n    if (release !== undefined && !warnedNoLease.has(entry.target)) {\n      warnedNoLease.add(entry.target);\n      logger?.warn(\n        { target: entry.target },\n        \"remote release is set but connect returned no lease, so release is skipped\",\n      );\n    }\n    return noLease(connection);\n  }\n  let ended = false;\n  const connectionHeld: HeldConnection = {\n    connection: { ...connection, lease },\n    end: async (outcome, error) => {\n      if (ended) {\n        return;\n      }\n      ended = true;\n      held.delete(connectionHeld);\n      await runRelease(\n        entry,\n        async () => {\n          await release?.(lease as never, { outcome, error });\n        },\n        timeouts.releaseMs,\n        { logger, outcome },\n      );\n    },\n  };\n  held.add(connectionHeld);\n  return connectionHeld;\n}\n\nasync function runRelease(\n  entry: RemoteTarget,\n  call: () => Promise<void>,\n  timeoutMs: number,\n  log: { logger: Logger | undefined; outcome: RemoteLeaseOutcome },\n): Promise<void> {\n  try {\n    await withDeadline(call(), timeoutMs, () =>\n      Object.assign(new Error(`release timed out after ${timeoutMs} ms`), {\n        name: \"ReleaseTimeout\",\n      }),\n    );\n  } catch (error) {\n    // Never the lease or the error text: either can carry a credential.\n    log.logger?.warn(\n      {\n        target: entry.target,\n        outcome: log.outcome,\n        err: error instanceof Error ? error.name : \"Error\",\n      },\n      \"remote browser release failed\",\n    );\n  }\n}\n"],"mappings":";;;;AAYA,MAAM,uBAAO,IAAI,IAAoB;AACrC,MAAM,gCAAgB,IAAI,IAAY;;AAGtC,eAAsB,iBAAgC;CACpD,MAAM,QAAQ,IACZ,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,OAAO,UAAU;EAC7B,MAAM,MAAM,IAAI,WAAW;CAC7B,CAAC,CACH;AACF;;AAGA,eAAsB,aACpB,SACA,IACA,WACY;CACZ,IAAI;CACJ,MAAM,WAAW,IAAI,SAAgB,GAAG,WAAW;EACjD,QAAQ,iBAAiB;GACvB,OAAO,UAAU,CAAC;EACpB,GAAG,EAAE;CACP,CAAC;CACD,IAAI;EACF,OAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,QAAQ,CAAC;CAC/C,UAAU;EACR,aAAa,KAAK;CACpB;AACF;AAEA,SAAgB,QAAQ,YAA8C;CACpE,OAAO;EACL;EACA,KAAK,YAAY;GACf,MAAM,QAAQ,QAAQ;EACxB;CACF;AACF;;;;;;AAOA,SAAgB,UACd,OACA,OACA,YACA,QACgB;CAChB,MAAM,EAAE,SAAS,aAAa,MAAM;CACpC,IAAI,UAAU,KAAA,GAAW;EACvB,IAAI,YAAY,KAAA,KAAa,CAAC,cAAc,IAAI,MAAM,MAAM,GAAG;GAC7D,cAAc,IAAI,MAAM,MAAM;GAC9B,QAAQ,KACN,EAAE,QAAQ,MAAM,OAAO,GACvB,4EACF;EACF;EACA,OAAO,QAAQ,UAAU;CAC3B;CACA,IAAI,QAAQ;CACZ,MAAM,iBAAiC;EACrC,YAAY;GAAE,GAAG;GAAY;EAAM;EACnC,KAAK,OAAO,SAAS,UAAU;GAC7B,IAAI,OACF;GAEF,QAAQ;GACR,KAAK,OAAO,cAAc;GAC1B,MAAM,WACJ,OACA,YAAY;IACV,MAAM,UAAU,OAAgB;KAAE;KAAS;IAAM,CAAC;GACpD,GACA,SAAS,WACT;IAAE;IAAQ;GAAQ,CACpB;EACF;CACF;CACA,KAAK,IAAI,cAAc;CACvB,OAAO;AACT;AAEA,eAAe,WACb,OACA,MACA,WACA,KACe;CACf,IAAI;EACF,MAAM,aAAa,KAAK,GAAG,iBACzB,OAAO,uBAAO,IAAI,MAAM,2BAA2B,UAAU,IAAI,GAAG,EAClE,MAAM,iBACR,CAAC,CACH;CACF,SAAS,OAAO;EAEd,IAAI,QAAQ,KACV;GACE,QAAQ,MAAM;GACd,SAAS,IAAI;GACb,KAAK,iBAAiB,QAAQ,MAAM,OAAO;EAC7C,GACA,+BACF;CACF;AACF"}

package/dist/adapters/remote-lease-shutdown.d.mts

@@ -0,0 +1,12 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+/**
+ * Stop everything remote this process holds, for a runner shutting down: abort pending `connect`
+ * calls, release every lease still held as `cancelled`, then run the shutdown hooks (pools close
+ * their resources). A server is not left running by a process that is gone.
+ */
+declare function shutdownRemote(): Promise<void>;
+/** Run `hook` on shutdown; returns the function that unregisters it. */
+declare function onRemoteShutdown(hook: () => Promise<void>): () => void;
+export { onRemoteShutdown, shutdownRemote };
+//# sourceMappingURL=remote-lease-shutdown.d.mts.map

package/dist/adapters/remote-lease-shutdown.mjs

@@ -0,0 +1,32 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { stopAllAttempts } from "./remote-lease-attempt.mjs";
+import { releaseAllHeld } from "./remote-lease-held.mjs";
+import { resetAllLimiters } from "./remote-limiter.mjs";
+// src/adapters/remote-lease-shutdown.ts
+/** Stopping everything remote the process holds, for a runner shutting down (ADR 0007, decision 4). */
+const shutdownHooks = /* @__PURE__ */ new Set();
+/**
+* Stop everything remote this process holds, for a runner shutting down: abort pending `connect`
+* calls, release every lease still held as `cancelled`, then run the shutdown hooks (pools close
+* their resources). A server is not left running by a process that is gone.
+*/
+async function shutdownRemote() {
+	stopAllAttempts();
+	resetAllLimiters();
+	await releaseAllHeld();
+	await Promise.all([...shutdownHooks].map(async (hook) => {
+		await hook();
+	}));
+}
+/** Run `hook` on shutdown; returns the function that unregisters it. */
+function onRemoteShutdown(hook) {
+	shutdownHooks.add(hook);
+	return () => {
+		shutdownHooks.delete(hook);
+	};
+}
+export { onRemoteShutdown, shutdownRemote };
+
+//# sourceMappingURL=remote-lease-shutdown.mjs.map

package/dist/adapters/remote-lease-shutdown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-lease-shutdown.mjs","names":[],"sources":["../../src/adapters/remote-lease-shutdown.ts"],"sourcesContent":["import { stopAllAttempts } from \"./remote-lease-attempt.ts\";\n/** Stopping everything remote the process holds, for a runner shutting down (ADR 0007, decision 4). */\nimport { releaseAllHeld } from \"./remote-lease-held.ts\";\nimport { resetAllLimiters } from \"./remote-limiter.ts\";\n\nconst shutdownHooks = new Set<() => Promise<void>>();\n\n/**\n * Stop everything remote this process holds, for a runner shutting down: abort pending `connect`\n * calls, release every lease still held as `cancelled`, then run the shutdown hooks (pools close\n * their resources). A server is not left running by a process that is gone.\n */\nexport async function shutdownRemote(): Promise<void> {\n  stopAllAttempts();\n  resetAllLimiters();\n  await releaseAllHeld();\n  await Promise.all(\n    [...shutdownHooks].map(async (hook) => {\n      await hook();\n    }),\n  );\n}\n\n/** Run `hook` on shutdown; returns the function that unregisters it. */\nexport function onRemoteShutdown(hook: () => Promise<void>): () => void {\n  shutdownHooks.add(hook);\n  return () => {\n    shutdownHooks.delete(hook);\n  };\n}\n"],"mappings":";;;;;;;;AAKA,MAAM,gCAAgB,IAAI,IAAyB;;;;;;AAOnD,eAAsB,iBAAgC;CACpD,gBAAgB;CAChB,iBAAiB;CACjB,MAAM,eAAe;CACrB,MAAM,QAAQ,IACZ,CAAC,GAAG,aAAa,CAAC,CAAC,IAAI,OAAO,SAAS;EACrC,MAAM,KAAK;CACb,CAAC,CACH;AACF;;AAGA,SAAgB,iBAAiB,MAAuC;CACtE,cAAc,IAAI,IAAI;CACtB,aAAa;EACX,cAAc,OAAO,IAAI;CAC3B;AACF"}

package/dist/adapters/remote-lease.d.mts

@@ -0,0 +1,39 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { RemoteConnectContext, RemoteConnection, RemoteTarget } from "./remote-browser.mjs";
+import { Logger } from "../logger.mjs";
+import { HeldConnection } from "./remote-lease-held.mjs";
+import { RemoteConnectError, RemoteConnectErrorOptions } from "./remote-lease-error.mjs";
+import { onRemoteShutdown, shutdownRemote } from "./remote-lease-shutdown.mjs";
+/** Which run a connection is for. */
+interface ConnectLeasedContext {
+  buildId: string;
+  runId: string;
+  shardIndex?: number | undefined;
+  purpose: RemoteConnectContext["purpose"];
+  /** Aborts a pending `connect` when the run is cancelled. */
+  signal?: AbortSignal | undefined;
+}
+/** Options of {@link connectLeased}. */
+interface ConnectLeasedOptions<T> {
+  logger?: Logger | undefined;
+  /** The handshake over one connection; its failures are retried when connection-level. */
+  open: (connection: RemoteConnection) => Promise<T>;
+  /** One line saying what failed, with the connection's credentials removed. */
+  reasonOf: (error: unknown, connection: RemoteConnection & {
+    lease?: unknown;
+  }) => string;
+}
+/**
+ * Connect (calling `connect` when it is a function) and open the connection, as one retried
+ * attempt: a failed handshake releases its lease as `failed` before the next attempt connects
+ * again, so at most one lease is held per connection. On success the caller owns the returned
+ * lease and must call {@link HeldConnection.end}; on failure nothing is held and a
+ * {@link TargetLaunchError} is thrown.
+ */
+declare function connectLeased<T>(entry: RemoteTarget, context: ConnectLeasedContext, options: ConnectLeasedOptions<T>): Promise<{
+  value: T;
+  lease: HeldConnection;
+}>;
+export { ConnectLeasedContext, ConnectLeasedOptions, type HeldConnection, RemoteConnectError, type RemoteConnectErrorOptions, connectLeased, onRemoteShutdown, shutdownRemote };
+//# sourceMappingURL=remote-lease.d.mts.map

package/dist/adapters/remote-lease.mjs

@@ -0,0 +1,175 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { TargetLaunchError } from "./capture-target.mjs";
+import { hasSchemeFor, schemesOf } from "./remote-browser.mjs";
+import { retryConnect } from "../utils/connect-retry.mjs";
+import { endAttempt, startAttempt } from "./remote-lease-attempt.mjs";
+import { RemoteConnectError, classify, connectErrorOf, stoppedError } from "./remote-lease-error.mjs";
+import { holdLease, noLease, withDeadline } from "./remote-lease-held.mjs";
+import { shutdownEpoch, takeSlot } from "./remote-limiter.mjs";
+import { onRemoteShutdown, shutdownRemote } from "./remote-lease-shutdown.mjs";
+// src/adapters/remote-lease.ts
+/**
+* Connect (calling `connect` when it is a function) and open the connection, as one retried
+* attempt: a failed handshake releases its lease as `failed` before the next attempt connects
+* again, so at most one lease is held per connection. On success the caller owns the returned
+* lease and must call {@link HeldConnection.end}; on failure nothing is held and a
+* {@link TargetLaunchError} is thrown.
+*/
+async function connectLeased(entry, context, options) {
+	const { remote } = entry;
+	let current = typeof remote.connect === "function" ? { endpoint: "" } : remote.connect;
+	let attemptNo = 0;
+	try {
+		return await retryConnect(async () => {
+			attemptNo += 1;
+			const lease = await acquire(entry, context, attemptNo, options.logger);
+			current = lease.connection;
+			try {
+				return {
+					value: await options.open(lease.connection),
+					lease
+				};
+			} catch (error) {
+				await lease.end("failed", error);
+				throw error;
+			}
+		}, {
+			retries: remote.retry.attempts,
+			backoffMs: remote.retry.backoffMs,
+			retryable: (error) => classify(error).retry,
+			onRetry: (error, retry, delayMs) => {
+				options.logger?.warn({
+					target: entry.target,
+					retry,
+					delayMs,
+					reason: options.reasonOf(error, current)
+				}, "remote browser connect failed, retrying");
+			}
+		});
+	} catch (error) {
+		const reason = options.reasonOf(error, current);
+		throw new TargetLaunchError(entry.target, reason, {
+			cause: Object.assign(new Error(reason), { name: error instanceof Error ? error.name : "Error" }),
+			transient: !classify(error).unavailable
+		});
+	}
+}
+/**
+* One connection, counted under the service's `maxConnections` when it has one: the slot is taken
+* (waiting, cancellably) before `connect` runs and given back when the lease ends, or at once when
+* the connection never materialises. Without a cap this is just {@link open}.
+*/
+async function acquire(entry, context, attemptNo, logger) {
+	const epoch = shutdownEpoch();
+	const taking = takeSlot(entry, context.signal, logger);
+	const slot = taking === void 0 ? void 0 : await taking;
+	stopIfShutDown(slot, epoch);
+	try {
+		const held = await open(entry, context, attemptNo, logger);
+		return slot === void 0 ? held : withSlot(held, slot);
+	} catch (error) {
+		slot?.release();
+		throw error;
+	}
+}
+/**
+* A slot granted across a shutdown must not open a connection: the shutdown has already stopped the
+* attempts and collected the leases, so nothing would release it. The slot is given back and the
+* connection stops. Called right before `open`, with nothing awaited in between, so a shutdown cannot
+* slip into the gap (`open` registers its attempt synchronously).
+*/
+function stopIfShutDown(slot, epoch) {
+	if (slot !== void 0 && shutdownEpoch() !== epoch) {
+		slot.release();
+		throw stoppedError();
+	}
+}
+/** `held` that gives its slot back, once, after the lease is released. */
+function withSlot(held, slot) {
+	let ending;
+	return {
+		connection: held.connection,
+		end: async (outcome, error) => {
+			ending ??= endAndFree(held, slot, outcome, error);
+			await ending;
+		}
+	};
+}
+async function endAndFree(held, slot, outcome, error) {
+	try {
+		await held.end(outcome, error);
+	} finally {
+		slot.release();
+	}
+}
+async function open(entry, context, attemptNo, logger) {
+	const { remote } = entry;
+	if (typeof remote.connect !== "function") return noLease(remote.connect);
+	const attempt = startAttempt(context.signal);
+	try {
+		return await adopt(entry, await called(entry, context, attemptNo, attempt, logger), logger);
+	} finally {
+		endAttempt(attempt);
+	}
+}
+/** The function `connect` under its deadline; a lease that arrives after it is released at once. */
+async function called(entry, context, attemptNo, attempt, logger) {
+	if (attempt.stopped) throw stoppedError();
+	const pending = invoke(entry.remote.connect, {
+		engine: entry.engine,
+		buildId: context.buildId,
+		runId: context.runId,
+		shardIndex: context.shardIndex,
+		purpose: context.purpose,
+		attempt: attemptNo,
+		signal: attempt.controller.signal
+	});
+	const { acquireMs } = entry.remote.timeouts;
+	try {
+		return await withDeadline(pending, acquireMs, () => {
+			attempt.controller.abort();
+			releaseLate(entry, pending, logger).catch(() => {});
+			return new RemoteConnectError(`acquire timed out after ${acquireMs} ms`);
+		});
+	} catch (error) {
+		throw await failedConnect(entry, error, attempt, logger);
+	}
+}
+/** Call a sync or async `connect`, so a sync throw is a rejection like any other. */
+async function invoke(connect, context) {
+	return await connect(context);
+}
+/** A function `connect`'s failure as the error to throw, releasing a lease it carried. */
+async function failedConnect(entry, error, attempt, logger) {
+	const converted = error instanceof RemoteConnectError ? error : connectErrorOf(error);
+	if (converted.lease !== void 0) await holdLease(entry, converted.lease, { endpoint: "" }, logger).end("failed", converted);
+	return attempt.stopped ? stoppedError() : converted;
+}
+/** Check what a function `connect` returned against what the service declared, then hold it. */
+async function adopt(entry, result, logger) {
+	const problem = problemWith(entry, result);
+	if (problem === null) return holdLease(entry, result.lease, result, logger);
+	const lease = result?.lease;
+	if (lease !== void 0) await holdLease(entry, lease, { endpoint: "" }, logger).end("failed");
+	throw new RemoteConnectError(problem, {
+		transient: false,
+		scope: "job"
+	});
+}
+function problemWith(entry, result) {
+	if (typeof result !== "object" || result === null || typeof result.endpoint !== "string") return "connect must return an object with an endpoint";
+	const extra = Object.keys(result).filter((key) => key !== "endpoint" && key !== "headers" && key !== "lease");
+	if (extra.length > 0) return `connect returned ${extra.join(", ")}: protocol and reach are declared on remote(), not returned`;
+	const { protocol } = entry.remote;
+	return hasSchemeFor(protocol, result.endpoint) ? null : `connect returned an endpoint that is not a ${schemesOf(protocol)} URL`;
+}
+/** A connection that arrives after its deadline is released at once. */
+async function releaseLate(entry, pending, logger) {
+	const late = await pending.catch(() => null);
+	if (late?.lease !== void 0) await holdLease(entry, late.lease, { endpoint: "" }, logger).end("failed");
+}
+export { RemoteConnectError, connectLeased, onRemoteShutdown, shutdownRemote };
+
+//# sourceMappingURL=remote-lease.mjs.map

package/dist/adapters/remote-lease.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-lease.mjs","names":[],"sources":["../../src/adapters/remote-lease.ts"],"sourcesContent":["/**\n * Connecting to a remote browser over a lease (ADR 0007, decision 4): a function `connect` is\n * called per connection, and `release` once the render that used it has ended. The runners own the\n * handshake itself; this owns the pairing, so a lease is released exactly once on every path\n * (finish, failure, cancel, shutdown) and never logged.\n */\nimport type { Logger } from \"../logger.ts\";\nimport { retryConnect } from \"../utils/connect-retry.ts\";\nimport { TargetLaunchError } from \"./capture-target.ts\";\nimport {\n  hasSchemeFor,\n  schemesOf,\n  type RemoteConnectContext,\n  type RemoteConnection,\n  type RemoteLeaseOutcome,\n  type RemoteLeasedConnection,\n  type RemoteTarget,\n} from \"./remote-browser.ts\";\nimport { endAttempt, startAttempt, type Attempt } from \"./remote-lease-attempt.ts\";\nimport {\n  RemoteConnectError,\n  classify,\n  connectErrorOf,\n  stoppedError,\n} from \"./remote-lease-error.ts\";\nimport { holdLease, noLease, withDeadline, type HeldConnection } from \"./remote-lease-held.ts\";\nimport { shutdownEpoch, takeSlot, type ConnectionSlot } from \"./remote-limiter.ts\";\n\nexport { RemoteConnectError, type RemoteConnectErrorOptions } from \"./remote-lease-error.ts\";\nexport type { HeldConnection } from \"./remote-lease-held.ts\";\nexport { onRemoteShutdown, shutdownRemote } from \"./remote-lease-shutdown.ts\";\n\n/** Which run a connection is for. */\nexport interface ConnectLeasedContext {\n  buildId: string;\n  runId: string;\n  shardIndex?: number | undefined;\n  purpose: RemoteConnectContext[\"purpose\"];\n  /** Aborts a pending `connect` when the run is cancelled. */\n  signal?: AbortSignal | undefined;\n}\n\n/** Options of {@link connectLeased}. */\nexport interface ConnectLeasedOptions<T> {\n  logger?: Logger | undefined;\n  /** The handshake over one connection; its failures are retried when connection-level. */\n  open: (connection: RemoteConnection) => Promise<T>;\n  /** One line saying what failed, with the connection's credentials removed. */\n  reasonOf: (error: unknown, connection: RemoteConnection & { lease?: unknown }) => string;\n}\n\ntype ConnectFn = (\n  context: RemoteConnectContext,\n) => RemoteLeasedConnection | Promise<RemoteLeasedConnection>;\n\n/**\n * Connect (calling `connect` when it is a function) and open the connection, as one retried\n * attempt: a failed handshake releases its lease as `failed` before the next attempt connects\n * again, so at most one lease is held per connection. On success the caller owns the returned\n * lease and must call {@link HeldConnection.end}; on failure nothing is held and a\n * {@link TargetLaunchError} is thrown.\n */\nexport async function connectLeased<T>(\n  entry: RemoteTarget,\n  context: ConnectLeasedContext,\n  options: ConnectLeasedOptions<T>,\n): Promise<{ value: T; lease: HeldConnection }> {\n  const { remote } = entry;\n  let current: RemoteConnection & { lease?: unknown } =\n    typeof remote.connect === \"function\" ? { endpoint: \"\" } : remote.connect;\n  let attemptNo = 0;\n  try {\n    return await retryConnect(\n      async () => {\n        attemptNo += 1;\n        const lease = await acquire(entry, context, attemptNo, options.logger);\n        current = lease.connection;\n        try {\n          return { value: await options.open(lease.connection), lease };\n        } catch (error) {\n          await lease.end(\"failed\", error);\n          throw error;\n        }\n      },\n      {\n        retries: remote.retry.attempts,\n        backoffMs: remote.retry.backoffMs,\n        retryable: (error) => classify(error).retry,\n        onRetry: (error, retry, delayMs) => {\n          options.logger?.warn(\n            { target: entry.target, retry, delayMs, reason: options.reasonOf(error, current) },\n            \"remote browser connect failed, retrying\",\n          );\n        },\n      },\n    );\n  } catch (error) {\n    const reason = options.reasonOf(error, current);\n    throw new TargetLaunchError(entry.target, reason, {\n      cause: Object.assign(new Error(reason), {\n        name: error instanceof Error ? error.name : \"Error\",\n      }),\n      transient: !classify(error).unavailable,\n    });\n  }\n}\n\n/**\n * One connection, counted under the service's `maxConnections` when it has one: the slot is taken\n * (waiting, cancellably) before `connect` runs and given back when the lease ends, or at once when\n * the connection never materialises. Without a cap this is just {@link open}.\n */\nasync function acquire(\n  entry: RemoteTarget,\n  context: ConnectLeasedContext,\n  attemptNo: number,\n  logger: Logger | undefined,\n): Promise<HeldConnection> {\n  // No `await` without a cap: an uncapped connection starts exactly as it did before.\n  const epoch = shutdownEpoch();\n  const taking = takeSlot(entry, context.signal, logger);\n  const slot = taking === undefined ? undefined : await taking;\n  stopIfShutDown(slot, epoch);\n  try {\n    const held = await open(entry, context, attemptNo, logger);\n    return slot === undefined ? held : withSlot(held, slot);\n  } catch (error) {\n    slot?.release();\n    throw error;\n  }\n}\n\n/**\n * A slot granted across a shutdown must not open a connection: the shutdown has already stopped the\n * attempts and collected the leases, so nothing would release it. The slot is given back and the\n * connection stops. Called right before `open`, with nothing awaited in between, so a shutdown cannot\n * slip into the gap (`open` registers its attempt synchronously).\n */\nfunction stopIfShutDown(slot: ConnectionSlot | undefined, epoch: number): void {\n  if (slot !== undefined && shutdownEpoch() !== epoch) {\n    slot.release();\n    throw stoppedError();\n  }\n}\n\n/** `held` that gives its slot back, once, after the lease is released. */\nfunction withSlot(held: HeldConnection, slot: ConnectionSlot): HeldConnection {\n  let ending: Promise<void> | undefined;\n  return {\n    connection: held.connection,\n    // Every caller gets the first call's promise: the inner `end` returns at once for a second call,\n    // which would free the slot while the first release is still running.\n    end: async (outcome, error) => {\n      ending ??= endAndFree(held, slot, outcome, error);\n      await ending;\n    },\n  };\n}\n\nasync function endAndFree(\n  held: HeldConnection,\n  slot: ConnectionSlot,\n  outcome: RemoteLeaseOutcome,\n  error: unknown,\n): Promise<void> {\n  try {\n    await held.end(outcome, error);\n  } finally {\n    slot.release();\n  }\n}\n\nasync function open(\n  entry: RemoteTarget,\n  context: ConnectLeasedContext,\n  attemptNo: number,\n  logger: Logger | undefined,\n): Promise<HeldConnection> {\n  const { remote } = entry;\n  if (typeof remote.connect !== \"function\") {\n    return noLease(remote.connect);\n  }\n  const attempt = startAttempt(context.signal);\n  try {\n    const result = await called(entry, context, attemptNo, attempt, logger);\n    return await adopt(entry, result, logger);\n  } finally {\n    endAttempt(attempt);\n  }\n}\n\n/** The function `connect` under its deadline; a lease that arrives after it is released at once. */\nasync function called(\n  entry: RemoteTarget,\n  context: ConnectLeasedContext,\n  attemptNo: number,\n  attempt: Attempt,\n  logger: Logger | undefined,\n): Promise<RemoteLeasedConnection> {\n  if (attempt.stopped) {\n    // Cancelled during a backoff: never call the provider with a signal that is already aborted.\n    throw stoppedError();\n  }\n  const pending = invoke(entry.remote.connect as ConnectFn, {\n    engine: entry.engine,\n    buildId: context.buildId,\n    runId: context.runId,\n    shardIndex: context.shardIndex,\n    purpose: context.purpose,\n    attempt: attemptNo,\n    signal: attempt.controller.signal,\n  });\n  const { acquireMs } = entry.remote.timeouts;\n  try {\n    return await withDeadline(pending, acquireMs, () => {\n      attempt.controller.abort();\n      releaseLate(entry, pending, logger).catch(() => {});\n      return new RemoteConnectError(`acquire timed out after ${acquireMs} ms`);\n    });\n  } catch (error) {\n    throw await failedConnect(entry, error, attempt, logger);\n  }\n}\n\n/** Call a sync or async `connect`, so a sync throw is a rejection like any other. */\nasync function invoke(\n  connect: ConnectFn,\n  context: RemoteConnectContext,\n): Promise<RemoteLeasedConnection> {\n  return await connect(context);\n}\n\n/** A function `connect`'s failure as the error to throw, releasing a lease it carried. */\nasync function failedConnect(\n  entry: RemoteTarget,\n  error: unknown,\n  attempt: Attempt,\n  logger: Logger | undefined,\n): Promise<Error> {\n  const converted = error instanceof RemoteConnectError ? error : connectErrorOf(error);\n  if (converted.lease !== undefined) {\n    await holdLease(entry, converted.lease, { endpoint: \"\" }, logger).end(\"failed\", converted);\n  }\n  return attempt.stopped ? stoppedError() : converted;\n}\n\n/** Check what a function `connect` returned against what the service declared, then hold it. */\nasync function adopt(\n  entry: RemoteTarget,\n  result: RemoteLeasedConnection,\n  logger: Logger | undefined,\n): Promise<HeldConnection> {\n  const problem = problemWith(entry, result);\n  if (problem === null) {\n    return holdLease(entry, result.lease, result, logger);\n  }\n  const lease = (result as { lease?: unknown } | null)?.lease;\n  if (lease !== undefined) {\n    await holdLease(entry, lease, { endpoint: \"\" }, logger).end(\"failed\");\n  }\n  throw new RemoteConnectError(problem, { transient: false, scope: \"job\" });\n}\n\nfunction problemWith(entry: RemoteTarget, result: RemoteLeasedConnection): string | null {\n  if (typeof result !== \"object\" || result === null || typeof result.endpoint !== \"string\") {\n    return \"connect must return an object with an endpoint\";\n  }\n  const extra = Object.keys(result).filter(\n    (key) => key !== \"endpoint\" && key !== \"headers\" && key !== \"lease\",\n  );\n  if (extra.length > 0) {\n    return `connect returned ${extra.join(\", \")}: protocol and reach are declared on remote(), not returned`;\n  }\n  const { protocol } = entry.remote;\n  return hasSchemeFor(protocol, result.endpoint)\n    ? null\n    : `connect returned an endpoint that is not a ${schemesOf(protocol)} URL`;\n}\n\n/** A connection that arrives after its deadline is released at once. */\nasync function releaseLate(\n  entry: RemoteTarget,\n  pending: Promise<RemoteLeasedConnection>,\n  logger: Logger | undefined,\n): Promise<void> {\n  const late = await pending.catch(() => null);\n  if (late?.lease !== undefined) {\n    await holdLease(entry, late.lease, { endpoint: \"\" }, logger).end(\"failed\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8DA,eAAsB,cACpB,OACA,SACA,SAC8C;CAC9C,MAAM,EAAE,WAAW;CACnB,IAAI,UACF,OAAO,OAAO,YAAY,aAAa,EAAE,UAAU,GAAG,IAAI,OAAO;CACnE,IAAI,YAAY;CAChB,IAAI;EACF,OAAO,MAAM,aACX,YAAY;GACV,aAAa;GACb,MAAM,QAAQ,MAAM,QAAQ,OAAO,SAAS,WAAW,QAAQ,MAAM;GACrE,UAAU,MAAM;GAChB,IAAI;IACF,OAAO;KAAE,OAAO,MAAM,QAAQ,KAAK,MAAM,UAAU;KAAG;IAAM;GAC9D,SAAS,OAAO;IACd,MAAM,MAAM,IAAI,UAAU,KAAK;IAC/B,MAAM;GACR;EACF,GACA;GACE,SAAS,OAAO,MAAM;GACtB,WAAW,OAAO,MAAM;GACxB,YAAY,UAAU,SAAS,KAAK,CAAC,CAAC;GACtC,UAAU,OAAO,OAAO,YAAY;IAClC,QAAQ,QAAQ,KACd;KAAE,QAAQ,MAAM;KAAQ;KAAO;KAAS,QAAQ,QAAQ,SAAS,OAAO,OAAO;IAAE,GACjF,yCACF;GACF;EACF,CACF;CACF,SAAS,OAAO;EACd,MAAM,SAAS,QAAQ,SAAS,OAAO,OAAO;EAC9C,MAAM,IAAI,kBAAkB,MAAM,QAAQ,QAAQ;GAChD,OAAO,OAAO,OAAO,IAAI,MAAM,MAAM,GAAG,EACtC,MAAM,iBAAiB,QAAQ,MAAM,OAAO,QAC9C,CAAC;GACD,WAAW,CAAC,SAAS,KAAK,CAAC,CAAC;EAC9B,CAAC;CACH;AACF;;;;;;AAOA,eAAe,QACb,OACA,SACA,WACA,QACyB;CAEzB,MAAM,QAAQ,cAAc;CAC5B,MAAM,SAAS,SAAS,OAAO,QAAQ,QAAQ,MAAM;CACrD,MAAM,OAAO,WAAW,KAAA,IAAY,KAAA,IAAY,MAAM;CACtD,eAAe,MAAM,KAAK;CAC1B,IAAI;EACF,MAAM,OAAO,MAAM,KAAK,OAAO,SAAS,WAAW,MAAM;EACzD,OAAO,SAAS,KAAA,IAAY,OAAO,SAAS,MAAM,IAAI;CACxD,SAAS,OAAO;EACd,MAAM,QAAQ;EACd,MAAM;CACR;AACF;;;;;;;AAQA,SAAS,eAAe,MAAkC,OAAqB;CAC7E,IAAI,SAAS,KAAA,KAAa,cAAc,MAAM,OAAO;EACnD,KAAK,QAAQ;EACb,MAAM,aAAa;CACrB;AACF;;AAGA,SAAS,SAAS,MAAsB,MAAsC;CAC5E,IAAI;CACJ,OAAO;EACL,YAAY,KAAK;EAGjB,KAAK,OAAO,SAAS,UAAU;GAC7B,WAAW,WAAW,MAAM,MAAM,SAAS,KAAK;GAChD,MAAM;EACR;CACF;AACF;AAEA,eAAe,WACb,MACA,MACA,SACA,OACe;CACf,IAAI;EACF,MAAM,KAAK,IAAI,SAAS,KAAK;CAC/B,UAAU;EACR,KAAK,QAAQ;CACf;AACF;AAEA,eAAe,KACb,OACA,SACA,WACA,QACyB;CACzB,MAAM,EAAE,WAAW;CACnB,IAAI,OAAO,OAAO,YAAY,YAC5B,OAAO,QAAQ,OAAO,OAAO;CAE/B,MAAM,UAAU,aAAa,QAAQ,MAAM;CAC3C,IAAI;EAEF,OAAO,MAAM,MAAM,OAAO,MADL,OAAO,OAAO,SAAS,WAAW,SAAS,MAAM,GACpC,MAAM;CAC1C,UAAU;EACR,WAAW,OAAO;CACpB;AACF;;AAGA,eAAe,OACb,OACA,SACA,WACA,SACA,QACiC;CACjC,IAAI,QAAQ,SAEV,MAAM,aAAa;CAErB,MAAM,UAAU,OAAO,MAAM,OAAO,SAAsB;EACxD,QAAQ,MAAM;EACd,SAAS,QAAQ;EACjB,OAAO,QAAQ;EACf,YAAY,QAAQ;EACpB,SAAS,QAAQ;EACjB,SAAS;EACT,QAAQ,QAAQ,WAAW;CAC7B,CAAC;CACD,MAAM,EAAE,cAAc,MAAM,OAAO;CACnC,IAAI;EACF,OAAO,MAAM,aAAa,SAAS,iBAAiB;GAClD,QAAQ,WAAW,MAAM;GACzB,YAAY,OAAO,SAAS,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;GAClD,OAAO,IAAI,mBAAmB,2BAA2B,UAAU,IAAI;EACzE,CAAC;CACH,SAAS,OAAO;EACd,MAAM,MAAM,cAAc,OAAO,OAAO,SAAS,MAAM;CACzD;AACF;;AAGA,eAAe,OACb,SACA,SACiC;CACjC,OAAO,MAAM,QAAQ,OAAO;AAC9B;;AAGA,eAAe,cACb,OACA,OACA,SACA,QACgB;CAChB,MAAM,YAAY,iBAAiB,qBAAqB,QAAQ,eAAe,KAAK;CACpF,IAAI,UAAU,UAAU,KAAA,GACtB,MAAM,UAAU,OAAO,UAAU,OAAO,EAAE,UAAU,GAAG,GAAG,MAAM,CAAC,CAAC,IAAI,UAAU,SAAS;CAE3F,OAAO,QAAQ,UAAU,aAAa,IAAI;AAC5C;;AAGA,eAAe,MACb,OACA,QACA,QACyB;CACzB,MAAM,UAAU,YAAY,OAAO,MAAM;CACzC,IAAI,YAAY,MACd,OAAO,UAAU,OAAO,OAAO,OAAO,QAAQ,MAAM;CAEtD,MAAM,QAAS,QAAuC;CACtD,IAAI,UAAU,KAAA,GACZ,MAAM,UAAU,OAAO,OAAO,EAAE,UAAU,GAAG,GAAG,MAAM,CAAC,CAAC,IAAI,QAAQ;CAEtE,MAAM,IAAI,mBAAmB,SAAS;EAAE,WAAW;EAAO,OAAO;CAAM,CAAC;AAC1E;AAEA,SAAS,YAAY,OAAqB,QAA+C;CACvF,IAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,OAAO,OAAO,aAAa,UAC9E,OAAO;CAET,MAAM,QAAQ,OAAO,KAAK,MAAM,CAAC,CAAC,QAC/B,QAAQ,QAAQ,cAAc,QAAQ,aAAa,QAAQ,OAC9D;CACA,IAAI,MAAM,SAAS,GACjB,OAAO,oBAAoB,MAAM,KAAK,IAAI,EAAE;CAE9C,MAAM,EAAE,aAAa,MAAM;CAC3B,OAAO,aAAa,UAAU,OAAO,QAAQ,IACzC,OACA,8CAA8C,UAAU,QAAQ,EAAE;AACxE;;AAGA,eAAe,YACb,OACA,SACA,QACe;CACf,MAAM,OAAO,MAAM,QAAQ,YAAY,IAAI;CAC3C,IAAI,MAAM,UAAU,KAAA,GAClB,MAAM,UAAU,OAAO,KAAK,OAAO,EAAE,UAAU,GAAG,GAAG,MAAM,CAAC,CAAC,IAAI,QAAQ;AAE7E"}