obsidian-integration-testing 12.0.0 → 12.1.1

package/dist/lib/cjs/adb-device-list.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var adb_device_list_exports = {};
+__export(adb_device_list_exports, {
+  checkIsDeviceListed: () => checkIsDeviceListed,
+  listOnlineDeviceIds: () => listOnlineDeviceIds,
+  parseAdbDevices: () => parseAdbDevices
+});
+module.exports = __toCommonJS(adb_device_list_exports);
+const ONLINE_DEVICE_STATE = "device";
+function checkIsDeviceListed(params) {
+  return parseAdbDevices(params.devicesOutput).some((entry) => entry.deviceId === params.deviceId);
+}
+function listOnlineDeviceIds(devicesOutput) {
+  return parseAdbDevices(devicesOutput).filter((entry) => entry.state === ONLINE_DEVICE_STATE).map((entry) => entry.deviceId);
+}
+function parseAdbDevices(devicesOutput) {
+  const entries = [];
+  for (const rawLine of devicesOutput.split("\n")) {
+    const line = rawLine.trim();
+    const separatorIndex = line.indexOf("	");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    entries.push({
+      deviceId: line.slice(0, separatorIndex).trim(),
+      state: line.slice(separatorIndex + 1).trim()
+    });
+  }
+  return entries;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsDeviceListed,
+  listOnlineDeviceIds,
+  parseAdbDevices
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/adb-device-list.d.cts

@@ -0,0 +1,72 @@
+/**
+ * @file
+ *
+ * Pure helpers for parsing `adb devices` output.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the parsing stays unit-testable — the factory itself shells out
+ * to `adb`.
+ *
+ * The listing answers two **different** questions, and conflating them is a
+ * defect rather than a nicety:
+ *
+ * - *Is the device usable?* — only a device in the `device` state is, which is
+ *   what the session preflight asks ({@link listOnlineDeviceIds}).
+ * - *Is the device gone?* — a dying emulator drops to `offline` while it still
+ *   holds the AVD's `multiinstance.lock` and its console port, so teardown must
+ *   treat **any** listed state as "still here" ({@link checkIsDeviceListed}).
+ *   Reading `offline` as gone is what lets the next run collide with a leftover.
+ */
+/**
+ * One row of `adb devices`.
+ */
+export interface AdbDeviceEntry {
+    /**
+    The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+    /**
+    The device state adb reports, e.g. `device`, `offline`, `unauthorized`.
+     */
+    readonly state: string;
+}
+/**
+ * Parameters for {@link checkIsDeviceListed}.
+ */
+export interface CheckIsDeviceListedParams {
+    /**
+    The device UDID to look for.
+     */
+    readonly deviceId: string;
+    /**
+    Raw stdout of `adb devices`.
+     */
+    readonly devicesOutput: string;
+}
+/**
+ * Decides whether a device is still listed at all, **in any state**.
+ *
+ * This is teardown's question, not the preflight's: an emulator that answers
+ * `offline` has not released the AVD.
+ *
+ * @param params - The listing output and the device to look for.
+ * @returns `true` when the device appears in the listing, whatever its state.
+ */
+export declare function checkIsDeviceListed(params: CheckIsDeviceListedParams): boolean;
+/**
+ * Lists the devices that are actually usable — those in the `device` state.
+ *
+ * @param devicesOutput - Raw stdout of `adb devices`.
+ * @returns The online device IDs, in listed order.
+ */
+export declare function listOnlineDeviceIds(devicesOutput: string): string[];
+/**
+ * Parses the rows of `adb devices` into device IDs and states.
+ *
+ * Every row is `<id>\t<state>`; the `List of devices attached` header and the
+ * `* daemon … *` banner carry no tab, which is what distinguishes them.
+ *
+ * @param devicesOutput - Raw stdout of `adb devices`.
+ * @returns One entry per listed device, in listed order.
+ */
+export declare function parseAdbDevices(devicesOutput: string): AdbDeviceEntry[];

package/dist/lib/cjs/adb.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var adb_exports = {};
+__export(adb_exports, {
+  runAdbBinary: () => runAdbBinary,
+  runAdbText: () => runAdbText,
+  runAdbTextWithoutDevice: () => runAdbTextWithoutDevice
+});
+module.exports = __toCommonJS(adb_exports);
+var import_node_child_process = require("node:child_process");
+const OUTPUT_MAX_BUFFER_IN_BYTES = 67108864;
+async function runAdbBinary(params) {
+  const commandArguments = ["-s", params.deviceId, ...params.commandArguments];
+  return await new Promise((resolve, reject) => {
+    (0, import_node_child_process.execFile)("adb", commandArguments, { encoding: "buffer", maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES }, (error, stdout) => {
+      if (error) {
+        reject(new Error(`Failed to run 'adb ${commandArguments.join(" ")}': ${error.message}. Is ADB installed and in PATH?`));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+async function runAdbText(params) {
+  const stdout = await runAdbBinary(params);
+  return new TextDecoder().decode(stdout).trim();
+}
+async function runAdbTextWithoutDevice(commandArguments) {
+  return await new Promise((resolve, reject) => {
+    (0, import_node_child_process.execFile)("adb", [...commandArguments], { encoding: "utf-8", maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES }, (error, stdout) => {
+      if (error) {
+        reject(new Error(`Failed to run 'adb ${commandArguments.join(" ")}': ${error.message}. Is ADB installed and in PATH?`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runAdbBinary,
+  runAdbText,
+  runAdbTextWithoutDevice
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/adb.d.cts

@@ -0,0 +1,61 @@
+/**
+ * @file
+ *
+ * Runs `adb` and hands back what it printed — as text, or as raw bytes.
+ *
+ * The harness already shells out to `adb` in half a dozen places inside
+ * `transport-factory` / `transport-appium`, but always through `exec`, which
+ * decodes stdout as UTF-8. That is fine for `devices` and `settings get` and
+ * fatally wrong for `exec-out screencap -p`, whose stdout is a PNG: decoding it
+ * as text corrupts every byte above 0x7F. Hence the two runners here — the same
+ * command shape, differing only in whether the output is decoded.
+ *
+ * These are the process layer for the device-facing helpers a capture suite
+ * uses (`device-screenshot`, `device-settings`, `soft-keyboard`); they are not a
+ * general-purpose adb wrapper and deliberately do not try to become one.
+ *
+ * Every function here shells out, so the whole module is integration-time code.
+ * That is also why the parsing and geometry these helpers depend on live in
+ * their own modules — the same split `adb-device-list` already has from the
+ * transport factory, so a sort rule can never move a unit-tested function
+ * inside a coverage-ignored block.
+ */
+/**
+ * Parameters for {@link runAdbBinary} and {@link runAdbText}.
+ */
+export interface RunAdbParams {
+    /**
+     * The arguments to pass after `-s <deviceId>`, e.g. `['shell', 'input', 'tap', '10', '20']`.
+     */
+    readonly commandArguments: readonly string[];
+    /**
+     * The device to address, as `adb devices` lists it.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Runs `adb -s <deviceId> <commandArguments>` and returns stdout **undecoded**.
+ *
+ * @param params - The device and the arguments to run.
+ * @returns A {@link Promise} that resolves to the raw stdout bytes.
+ * @throws Error if adb could not be run, or exited non-zero.
+ */
+export declare function runAdbBinary(params: RunAdbParams): Promise<Uint8Array>;
+/**
+ * Runs `adb -s <deviceId> <commandArguments>` and returns stdout as trimmed text.
+ *
+ * @param params - The device and the arguments to run.
+ * @returns A {@link Promise} that resolves to stdout, with surrounding whitespace removed.
+ * @throws Error if adb could not be run, or exited non-zero.
+ */
+export declare function runAdbText(params: RunAdbParams): Promise<string>;
+/**
+ * Runs `adb <commandArguments>` with no device selected.
+ *
+ * Only `devices` needs this — every other call in this family addresses one device.
+ *
+ * @param commandArguments - The arguments to run.
+ * @returns A {@link Promise} that resolves to stdout, with surrounding whitespace removed.
+ * @throws Error if adb could not be run, or exited non-zero.
+ */
+export declare function runAdbTextWithoutDevice(commandArguments: readonly string[]): Promise<string>;

package/dist/lib/cjs/android-sdk.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var android_sdk_exports = {};
+__export(android_sdk_exports, {
+  resolveEmulatorBinaryPath: () => resolveEmulatorBinaryPath
+});
+module.exports = __toCommonJS(android_sdk_exports);
+var import_node_path = require("node:path");
+var import_node_process = __toESM(require("node:process"), 1);
+function resolveEmulatorBinaryPath() {
+  return (0, import_node_path.join)(resolveAndroidSdkRoot(), "emulator", "emulator");
+}
+function resolveAndroidSdkRoot() {
+  const sdkRoot = import_node_process.default.env["ANDROID_HOME"] ?? import_node_process.default.env["ANDROID_SDK_ROOT"];
+  if (!sdkRoot) {
+    throw new Error(
+      "Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set."
+    );
+  }
+  return sdkRoot;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveEmulatorBinaryPath
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2FuZHJvaWQtc2RrLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUmVzb2x2ZXMgdGhlIEFuZHJvaWQgU0RLIGJpbmFyaWVzIHRoZSBoYXJuZXNzIHNoZWxscyBvdXQgdG8uXG4gKlxuICogTGl2ZXMgaGVyZSByYXRoZXIgdGhhbiBhcyBhIHByaXZhdGUgbWV0aG9kIG9uIHRoZSBpbnRlZ3JhdGlvbi1vbmx5XG4gKiBgdHJhbnNwb3J0LWZhY3RvcnlgIGJlY2F1c2UgaXQgaXMgYW4gKiphZ3JlZW1lbnQqKiwgbm90IGFuIGltcGxlbWVudGF0aW9uXG4gKiBkZXRhaWw6IGBzY3JpcHRzL2VtdWxhdG9yLXdlZGdlLXByb2JlLnRzYCBleGlzdHMgdG8gcmVwcm9kdWNlIGEgaG9zdCBmYXVsdCBieVxuICogYm9vdGluZyB0aGUgZW11bGF0b3IgZXhhY3RseSBhcyBhIHJ1biB3b3VsZCwgYW5kIGEgcHJvYmUgdGhhdCByZXNvbHZlZCBhXG4gKiBkaWZmZXJlbnQgYmluYXJ5IHRoYW4gdGhlIGhhcm5lc3Mgd291bGQgcXVpZXRseSBtZWFzdXJlIHNvbWV0aGluZyBlbHNlLiBPbmVcbiAqIGZ1bmN0aW9uLCBvbmUgYW5zd2VyLCBib3RoIGNhbGxlcnMuXG4gKlxuICogVGhlIGxvb2t1cCBpdHNlbGYgaXMgdGhlIFNESydzIG93biBjb252ZW50aW9uIFx1MjAxNCBgQU5EUk9JRF9IT01FYCBmaXJzdCwgdGhlbiB0aGVcbiAqIG9sZGVyIGBBTkRST0lEX1NES19ST09UYCBcdTIwMTQgYW5kIGl0IGRlbGliZXJhdGVseSBkb2VzICoqbm90KiogZmFsbCBiYWNrIHRvIGFcbiAqIHBsYXRmb3JtLWRlZmF1bHQgaW5zdGFsbCBwYXRoLiBBIHdyb25nIGd1ZXNzIHdvdWxkIGJvb3Qgc29tZSBvdGhlciBTREsnc1xuICogZW11bGF0b3IgYW5kIHJlcG9ydCBvbiBpdCBhcyB0aG91Z2ggaXQgd2VyZSB0aGUgY29uZmlndXJlZCBvbmU7IGFuIGVycm9yIHRoYXRcbiAqIG5hbWVzIGJvdGggdmFyaWFibGVzIGlzIHRoZSBzaG9ydGVyIHJvdXRlIHRvIGEgd29ya2luZyBzZXR1cC5cbiAqL1xuXG5pbXBvcnQgeyBqb2luIH0gZnJvbSAnbm9kZTpwYXRoJztcbmltcG9ydCBwcm9jZXNzIGZyb20gJ25vZGU6cHJvY2Vzcyc7XG5cbi8qKlxuICogUmVzb2x2ZXMgdGhlIGBlbXVsYXRvcmAgYmluYXJ5IGZyb20gdGhlIEFuZHJvaWQgU0RLIHJvb3QuXG4gKlxuICogTm8gZXh0ZW5zaW9uIGlzIGFwcGVuZGVkOiBOb2RlJ3MgcHJvY2VzcyBzcGF3bmluZyByZXNvbHZlcyBgZW11bGF0b3IuZXhlYCBvblxuICogV2luZG93cyBvbiBpdHMgb3duLCBhbmQgdGhlIHNhbWUgcGF0aCBzdHJpbmcgaXMgd2hhdCB0aGUgU0RLJ3Mgb3duIHRvb2xpbmdcbiAqIGRvY3VtZW50cy5cbiAqXG4gKiBAcmV0dXJucyBUaGUgYWJzb2x1dGUgcGF0aCB0byB0aGUgYGVtdWxhdG9yYCBiaW5hcnkuXG4gKiBAdGhyb3dzIFdoZW4gbmVpdGhlciBgQU5EUk9JRF9IT01FYCBub3IgYEFORFJPSURfU0RLX1JPT1RgIGlzIHNldC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVFbXVsYXRvckJpbmFyeVBhdGgoKTogc3RyaW5nIHtcbiAgcmV0dXJuIGpvaW4ocmVzb2x2ZUFuZHJvaWRTZGtSb290KCksICdlbXVsYXRvcicsICdlbXVsYXRvcicpO1xufVxuXG5mdW5jdGlvbiByZXNvbHZlQW5kcm9pZFNka1Jvb3QoKTogc3RyaW5nIHtcbiAgY29uc3Qgc2RrUm9vdCA9IHByb2Nlc3MuZW52WydBTkRST0lEX0hPTUUnXSA/PyBwcm9jZXNzLmVudlsnQU5EUk9JRF9TREtfUk9PVCddO1xuICBpZiAoIXNka1Jvb3QpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAnQ2Fubm90IGZpbmQgQW5kcm9pZCBlbXVsYXRvcjogbmVpdGhlciBBTkRST0lEX0hPTUUgbm9yIEFORFJPSURfU0RLX1JPT1QgZW52aXJvbm1lbnQgdmFyaWFibGUgaXMgc2V0LidcbiAgICApO1xuICB9XG5cbiAgcmV0dXJuIHNka1Jvb3Q7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQW1CQSx1QkFBcUI7QUFDckIsMEJBQW9CO0FBWWIsU0FBUyw0QkFBb0M7QUFDbEQsYUFBTyx1QkFBSyxzQkFBc0IsR0FBRyxZQUFZLFVBQVU7QUFDN0Q7QUFFQSxTQUFTLHdCQUFnQztBQUN2QyxRQUFNLFVBQVUsb0JBQUFBLFFBQVEsSUFBSSxjQUFjLEtBQUssb0JBQUFBLFFBQVEsSUFBSSxrQkFBa0I7QUFDN0UsTUFBSSxDQUFDLFNBQVM7QUFDWixVQUFNLElBQUk7QUFBQSxNQUNSO0FBQUEsSUFDRjtBQUFBLEVBQ0Y7QUFFQSxTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbInByb2Nlc3MiXQp9Cg==

package/dist/lib/cjs/android-sdk.d.cts

@@ -0,0 +1,29 @@
+/**
+ * @file
+ *
+ * Resolves the Android SDK binaries the harness shells out to.
+ *
+ * Lives here rather than as a private method on the integration-only
+ * `transport-factory` because it is an **agreement**, not an implementation
+ * detail: `scripts/emulator-wedge-probe.ts` exists to reproduce a host fault by
+ * booting the emulator exactly as a run would, and a probe that resolved a
+ * different binary than the harness would quietly measure something else. One
+ * function, one answer, both callers.
+ *
+ * The lookup itself is the SDK's own convention — `ANDROID_HOME` first, then the
+ * older `ANDROID_SDK_ROOT` — and it deliberately does **not** fall back to a
+ * platform-default install path. A wrong guess would boot some other SDK's
+ * emulator and report on it as though it were the configured one; an error that
+ * names both variables is the shorter route to a working setup.
+ */
+/**
+ * Resolves the `emulator` binary from the Android SDK root.
+ *
+ * No extension is appended: Node's process spawning resolves `emulator.exe` on
+ * Windows on its own, and the same path string is what the SDK's own tooling
+ * documents.
+ *
+ * @returns The absolute path to the `emulator` binary.
+ * @throws When neither `ANDROID_HOME` nor `ANDROID_SDK_ROOT` is set.
+ */
+export declare function resolveEmulatorBinaryPath(): string;

package/dist/lib/cjs/app-startup-progress.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var app_startup_progress_exports = {};
+__export(app_startup_progress_exports, {
+  buildStartupTimeoutMessage: () => buildStartupTimeoutMessage,
+  checkAppStarted: () => checkAppStarted,
+  checkLayoutReady: () => checkLayoutReady,
+  classifyAppStartupProbe: () => classifyAppStartupProbe,
+  compareAppStartupMilestones: () => compareAppStartupMilestones
+});
+module.exports = __toCommonJS(app_startup_progress_exports);
+const MILESTONE_ORDER = [
+  "no-webview",
+  "no-app",
+  "no-workspace",
+  "workspace-not-ready",
+  "layout-ready"
+];
+const APP_STARTED_MILESTONE = "no-workspace";
+const MILESTONE_DESCRIPTIONS = {
+  "layout-ready": "the workspace finished laying out",
+  "no-app": "the WebView answered, but `globalThis.app` never appeared",
+  "no-webview": "the WebView never answered a single probe",
+  "no-workspace": "`globalThis.app` appeared, but `app.workspace` never did",
+  "workspace-not-ready": "`app.workspace` exists, but `layoutReady` never became true"
+};
+const PHASE_DESCRIPTIONS = {
+  "app-start": "Obsidian Mobile did not finish starting",
+  "layout-ready": "Obsidian layout did not become ready"
+};
+function buildStartupTimeoutMessage(params) {
+  const {
+    elapsedInMilliseconds,
+    milestone,
+    phase,
+    pollCount,
+    slowestRoundTripInMilliseconds,
+    timeoutInMilliseconds
+  } = params;
+  return `${PHASE_DESCRIPTIONS[phase]} within ${String(timeoutInMilliseconds)}ms (elapsed ${String(elapsedInMilliseconds)}ms). Furthest progress: ${MILESTONE_DESCRIPTIONS[milestone]}. Probed ${String(pollCount)} time(s), slowest round-trip ${String(slowestRoundTripInMilliseconds)}ms. A handful of probes each taking tens of seconds means a contended guest, not a slow Obsidian \u2014 let the emulator go idle before the run, or raise \`deviceIdleTimeoutInMilliseconds\`.`;
+}
+function checkAppStarted(milestone) {
+  return compareAppStartupMilestones(milestone, APP_STARTED_MILESTONE) >= 0;
+}
+function checkLayoutReady(milestone) {
+  return milestone === "layout-ready";
+}
+function classifyAppStartupProbe(probeResult) {
+  if (!probeResult) {
+    return "no-webview";
+  }
+  if (!probeResult.hasApp) {
+    return "no-app";
+  }
+  if (!probeResult.hasWorkspace) {
+    return "no-workspace";
+  }
+  return probeResult.isLayoutReady ? "layout-ready" : "workspace-not-ready";
+}
+function compareAppStartupMilestones(left, right) {
+  return MILESTONE_ORDER.indexOf(left) - MILESTONE_ORDER.indexOf(right);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildStartupTimeoutMessage,
+  checkAppStarted,
+  checkLayoutReady,
+  classifyAppStartupProbe,
+  compareAppStartupMilestones
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/app-startup-progress.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for tracking how far Obsidian Mobile has got through its startup\n * after `location.reload()`, and for describing where it stalled when a budget\n * runs out.\n *\n * Startup is watched as a **ladder of milestones**, not a single boolean,\n * because the two halves of it cost wildly different amounts of time and only\n * one of them is Obsidian's fault. Reaching `globalThis.app` is the app cold\n * start \u2014 the WebView reloading, the guest still churning \u2014 and on a cold or\n * contended emulator it can take minutes. Everything after it is Obsidian\n * opening the vault and loading plugins, which **L19** measured at ~1s (\u22648.4s\n * under 12-core + disk + memory stress). Charging both to one 90s wall clock is\n * what made a first run after a machine restart fail by design, so the transport\n * runs them as two budgets and uses these helpers to tell them apart.\n *\n * Kept separate from the integration-only `transport-appium` (excluded from unit\n * tests) so the classification and message formatting stay unit-testable \u2014 the\n * polling itself needs a real device.\n */\n\n/**\n * How far Obsidian has got through its startup, as seen from one WebView probe.\n *\n * Ordered from least to most advanced; {@link compareAppStartupMilestones}\n * relies on that order.\n */\nexport type AppStartupMilestone =\n  | 'layout-ready'\n  | 'no-app'\n  | 'no-webview'\n  | 'no-workspace'\n  | 'workspace-not-ready';\n\n/**\n * Which of the two startup budgets was being spent when it ran out.\n */\nexport type AppStartupPhase = 'app-start' | 'layout-ready';\n\n/**\n * Parameters for {@link buildStartupTimeoutMessage}.\n */\nexport interface BuildStartupTimeoutMessageParams {\n  /**\n  How long this phase's budget had been spent when it ran out.\n   */\n  readonly elapsedInMilliseconds: number;\n\n  /**\n  The furthest milestone reached before the budget ran out.\n   */\n  readonly milestone: AppStartupMilestone;\n\n  /**\n  The phase whose budget ran out.\n   */\n  readonly phase: AppStartupPhase;\n\n  /**\n  How many probes were made during the phase.\n   */\n  readonly pollCount: number;\n\n  /**\n  The slowest single probe round-trip observed during the phase.\n   */\n  readonly slowestRoundTripInMilliseconds: number;\n\n  /**\n  The budget that ran out.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * The raw shape a WebView startup probe reports back.\n *\n * Mirrors what the injected probe function can observe without importing\n * anything: whether the global `app` object exists yet, whether its `workspace`\n * does, and whether that workspace has finished laying out.\n */\nexport interface StartupProbeResult {\n  /**\n  Whether `globalThis.app` is defined.\n   */\n  readonly hasApp: boolean;\n\n  /**\n  Whether `app.workspace` is defined.\n   */\n  readonly hasWorkspace: boolean;\n\n  /**\n  Whether `app.workspace.layoutReady` is truthy.\n   */\n  readonly isLayoutReady: boolean;\n}\n\n/**\n * The milestone ladder, least to most advanced. The index in this array *is*\n * the ordering used by {@link compareAppStartupMilestones}.\n */\nconst MILESTONE_ORDER: readonly AppStartupMilestone[] = [\n  'no-webview',\n  'no-app',\n  'no-workspace',\n  'workspace-not-ready',\n  'layout-ready'\n];\n\n/**\n * The milestone at which the app-start phase is satisfied: `globalThis.app`\n * exists, so the WebView has reloaded and Obsidian's own boot has begun. What\n * remains from here is Obsidian work, which the tight layout-ready budget\n * covers.\n */\nconst APP_STARTED_MILESTONE: AppStartupMilestone = 'no-workspace';\n\n/**\n * Human-readable descriptions of each milestone, used in the timeout message so\n * the failure names what never happened instead of only what was hoped for.\n */\nconst MILESTONE_DESCRIPTIONS: Record<AppStartupMilestone, string> = {\n  'layout-ready': 'the workspace finished laying out',\n  'no-app': 'the WebView answered, but `globalThis.app` never appeared',\n  'no-webview': 'the WebView never answered a single probe',\n  'no-workspace': '`globalThis.app` appeared, but `app.workspace` never did',\n  'workspace-not-ready': '`app.workspace` exists, but `layoutReady` never became true'\n};\n\n/**\n * What each phase was waiting for, used in the timeout message.\n */\nconst PHASE_DESCRIPTIONS: Record<AppStartupPhase, string> = {\n  'app-start': 'Obsidian Mobile did not finish starting',\n  'layout-ready': 'Obsidian layout did not become ready'\n};\n\n/**\n * Builds the diagnostic message for a startup budget that ran out.\n *\n * It names the milestone actually reached, the poll count and the slowest probe\n * round-trip, because those three together separate the failure modes **L19**\n * could not tell apart from the old message: a genuine Obsidian slowdown shows\n * many fast polls stalled at one milestone, whereas a contended guest shows a\n * handful of polls each taking tens of seconds.\n *\n * @param params - The phase, the milestone reached, and the timing evidence.\n * @returns A human-readable error message.\n */\nexport function buildStartupTimeoutMessage(params: BuildStartupTimeoutMessageParams): string {\n  const {\n    elapsedInMilliseconds,\n    milestone,\n    phase,\n    pollCount,\n    slowestRoundTripInMilliseconds,\n    timeoutInMilliseconds\n  } = params;\n\n  return `${PHASE_DESCRIPTIONS[phase]} within ${String(timeoutInMilliseconds)}ms `\n    + `(elapsed ${String(elapsedInMilliseconds)}ms). Furthest progress: ${MILESTONE_DESCRIPTIONS[milestone]}. `\n    + `Probed ${String(pollCount)} time(s), slowest round-trip ${String(slowestRoundTripInMilliseconds)}ms. `\n    + 'A handful of probes each taking tens of seconds means a contended guest, not a slow Obsidian \u2014 '\n    + 'let the emulator go idle before the run, or raise `deviceIdleTimeoutInMilliseconds`.';\n}\n\n/**\n * Reports whether the app-start phase is satisfied at this milestone.\n *\n * @param milestone - The milestone the latest probe reported.\n * @returns `true` once `globalThis.app` exists, so the layout-ready budget may start.\n */\nexport function checkAppStarted(milestone: AppStartupMilestone): boolean {\n  return compareAppStartupMilestones(milestone, APP_STARTED_MILESTONE) >= 0;\n}\n\n/**\n * Reports whether the layout-ready phase is satisfied at this milestone.\n *\n * @param milestone - The milestone the latest probe reported.\n * @returns `true` once the workspace has finished laying out.\n */\nexport function checkLayoutReady(milestone: AppStartupMilestone): boolean {\n  return milestone === 'layout-ready';\n}\n\n/**\n * Turns a WebView probe into a milestone.\n *\n * A probe that could not run at all \u2014 `undefined`, because `browser.execute()`\n * threw while the page was mid-reload \u2014 is the least advanced milestone rather\n * than an error: during a reload it is the expected reading.\n *\n * @param probeResult - What the probe reported, or `undefined` when it threw.\n * @returns The milestone that reading represents.\n */\nexport function classifyAppStartupProbe(probeResult: StartupProbeResult | undefined): AppStartupMilestone {\n  if (!probeResult) {\n    return 'no-webview';\n  }\n  if (!probeResult.hasApp) {\n    return 'no-app';\n  }\n  if (!probeResult.hasWorkspace) {\n    return 'no-workspace';\n  }\n  return probeResult.isLayoutReady ? 'layout-ready' : 'workspace-not-ready';\n}\n\n/**\n * Orders two milestones on the startup ladder.\n *\n * @param left - The first milestone.\n * @param right - The second milestone.\n * @returns A negative number when `left` is less advanced, `0` when equal, a positive number when more advanced.\n */\nexport function compareAppStartupMilestones(left: AppStartupMilestone, right: AppStartupMilestone): number {\n  return MILESTONE_ORDER.indexOf(left) - MILESTONE_ORDER.indexOf(right);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuGA,MAAM,kBAAkD;AAAA,EACtD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAQA,MAAM,wBAA6C;AAMnD,MAAM,yBAA8D;AAAA,EAClE,gBAAgB;AAAA,EAChB,UAAU;AAAA,EACV,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,uBAAuB;AACzB;AAKA,MAAM,qBAAsD;AAAA,EAC1D,aAAa;AAAA,EACb,gBAAgB;AAClB;AAcO,SAAS,2BAA2B,QAAkD;AAC3F,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,SAAO,GAAG,mBAAmB,KAAK,CAAC,WAAW,OAAO,qBAAqB,CAAC,eAC3D,OAAO,qBAAqB,CAAC,2BAA2B,uBAAuB,SAAS,CAAC,YAC3F,OAAO,SAAS,CAAC,gCAAgC,OAAO,8BAA8B,CAAC;AAGvG;AAQO,SAAS,gBAAgB,WAAyC;AACvE,SAAO,4BAA4B,WAAW,qBAAqB,KAAK;AAC1E;AAQO,SAAS,iBAAiB,WAAyC;AACxE,SAAO,cAAc;AACvB;AAYO,SAAS,wBAAwB,aAAkE;AACxG,MAAI,CAAC,aAAa;AAChB,WAAO;AAAA,EACT;AACA,MAAI,CAAC,YAAY,QAAQ;AACvB,WAAO;AAAA,EACT;AACA,MAAI,CAAC,YAAY,cAAc;AAC7B,WAAO;AAAA,EACT;AACA,SAAO,YAAY,gBAAgB,iBAAiB;AACtD;AASO,SAAS,4BAA4B,MAA2B,OAAoC;AACzG,SAAO,gBAAgB,QAAQ,IAAI,IAAI,gBAAgB,QAAQ,KAAK;AACtE;",
  "names": []
}


package/dist/lib/cjs/app-startup-progress.d.cts

@@ -0,0 +1,128 @@
+/**
+ * @file
+ *
+ * Pure helpers for tracking how far Obsidian Mobile has got through its startup
+ * after `location.reload()`, and for describing where it stalled when a budget
+ * runs out.
+ *
+ * Startup is watched as a **ladder of milestones**, not a single boolean,
+ * because the two halves of it cost wildly different amounts of time and only
+ * one of them is Obsidian's fault. Reaching `globalThis.app` is the app cold
+ * start — the WebView reloading, the guest still churning — and on a cold or
+ * contended emulator it can take minutes. Everything after it is Obsidian
+ * opening the vault and loading plugins, which **L19** measured at ~1s (≤8.4s
+ * under 12-core + disk + memory stress). Charging both to one 90s wall clock is
+ * what made a first run after a machine restart fail by design, so the transport
+ * runs them as two budgets and uses these helpers to tell them apart.
+ *
+ * Kept separate from the integration-only `transport-appium` (excluded from unit
+ * tests) so the classification and message formatting stay unit-testable — the
+ * polling itself needs a real device.
+ */
+/**
+ * How far Obsidian has got through its startup, as seen from one WebView probe.
+ *
+ * Ordered from least to most advanced; {@link compareAppStartupMilestones}
+ * relies on that order.
+ */
+export type AppStartupMilestone = 'layout-ready' | 'no-app' | 'no-webview' | 'no-workspace' | 'workspace-not-ready';
+/**
+ * Which of the two startup budgets was being spent when it ran out.
+ */
+export type AppStartupPhase = 'app-start' | 'layout-ready';
+/**
+ * Parameters for {@link buildStartupTimeoutMessage}.
+ */
+export interface BuildStartupTimeoutMessageParams {
+    /**
+    How long this phase's budget had been spent when it ran out.
+     */
+    readonly elapsedInMilliseconds: number;
+    /**
+    The furthest milestone reached before the budget ran out.
+     */
+    readonly milestone: AppStartupMilestone;
+    /**
+    The phase whose budget ran out.
+     */
+    readonly phase: AppStartupPhase;
+    /**
+    How many probes were made during the phase.
+     */
+    readonly pollCount: number;
+    /**
+    The slowest single probe round-trip observed during the phase.
+     */
+    readonly slowestRoundTripInMilliseconds: number;
+    /**
+    The budget that ran out.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * The raw shape a WebView startup probe reports back.
+ *
+ * Mirrors what the injected probe function can observe without importing
+ * anything: whether the global `app` object exists yet, whether its `workspace`
+ * does, and whether that workspace has finished laying out.
+ */
+export interface StartupProbeResult {
+    /**
+    Whether `globalThis.app` is defined.
+     */
+    readonly hasApp: boolean;
+    /**
+    Whether `app.workspace` is defined.
+     */
+    readonly hasWorkspace: boolean;
+    /**
+    Whether `app.workspace.layoutReady` is truthy.
+     */
+    readonly isLayoutReady: boolean;
+}
+/**
+ * Builds the diagnostic message for a startup budget that ran out.
+ *
+ * It names the milestone actually reached, the poll count and the slowest probe
+ * round-trip, because those three together separate the failure modes **L19**
+ * could not tell apart from the old message: a genuine Obsidian slowdown shows
+ * many fast polls stalled at one milestone, whereas a contended guest shows a
+ * handful of polls each taking tens of seconds.
+ *
+ * @param params - The phase, the milestone reached, and the timing evidence.
+ * @returns A human-readable error message.
+ */
+export declare function buildStartupTimeoutMessage(params: BuildStartupTimeoutMessageParams): string;
+/**
+ * Reports whether the app-start phase is satisfied at this milestone.
+ *
+ * @param milestone - The milestone the latest probe reported.
+ * @returns `true` once `globalThis.app` exists, so the layout-ready budget may start.
+ */
+export declare function checkAppStarted(milestone: AppStartupMilestone): boolean;
+/**
+ * Reports whether the layout-ready phase is satisfied at this milestone.
+ *
+ * @param milestone - The milestone the latest probe reported.
+ * @returns `true` once the workspace has finished laying out.
+ */
+export declare function checkLayoutReady(milestone: AppStartupMilestone): boolean;
+/**
+ * Turns a WebView probe into a milestone.
+ *
+ * A probe that could not run at all — `undefined`, because `browser.execute()`
+ * threw while the page was mid-reload — is the least advanced milestone rather
+ * than an error: during a reload it is the expected reading.
+ *
+ * @param probeResult - What the probe reported, or `undefined` when it threw.
+ * @returns The milestone that reading represents.
+ */
+export declare function classifyAppStartupProbe(probeResult: StartupProbeResult | undefined): AppStartupMilestone;
+/**
+ * Orders two milestones on the startup ladder.
+ *
+ * @param left - The first milestone.
+ * @param right - The second milestone.
+ * @returns A negative number when `left` is less advanced, `0` when equal, a positive number when more advanced.
+ */
+export declare function compareAppStartupMilestones(left: AppStartupMilestone, right: AppStartupMilestone): number;