obsidian-integration-testing 15.0.0 → 17.0.0

package/dist/lib/esm/host-process-query-verdict.d.mts

@@ -0,0 +1,196 @@
+/**
+ * @file
+ *
+ * Pure classification of the host process listing — deciding, from how
+ * `tasklist` / `ps` ended, *which* way it failed, and saying so in one line.
+ *
+ * The listing is what names the emulator backend a run owns, and therefore the
+ * only PID teardown can escalate to (**L56**). It is best-effort by design: a
+ * listing that cannot be produced yields no PIDs rather than failing the run.
+ * What it must never be is **unexplained**, and for three weeks it was:
+ *
+ * ```text
+ * Warning: could not list host processes (`tasklist`): Command failed: tasklist /FO CSV /NH
+ *
+ * Warning: `tasklist` listed no processes.
+ * ```
+ *
+ * Two defects in four lines. The pair is *contradictory* — the first says the
+ * command failed, the second says it ran and found nothing — and they were
+ * emitted together for a single failure, because a failed call resolves `''`
+ * and an empty string parses to zero rows. `zero-rows` exists to catch a
+ * listing that succeeded and yet returned nothing, which on a real host can
+ * only be a failed query; it is not a second opinion on a call that already
+ * reported an error.
+ *
+ * And the surviving diagnostic is `error.message` alone, which for `execFile`
+ * is `Command failed: <cmd>\n<stderr>` — so the log carried the command back
+ * to the reader and threw away everything that identifies the failure:
+ * `error.code`, `error.killed`, `error.signal`, and how long the call took.
+ * Measured 2026-09-23 on this host, that discarded evidence is decisive:
+ *
+ * - `tasklist` **always** writes `ERROR: <reason>` to stderr when it objects —
+ *   a bad filter, an unreachable host — and exits 1. So a non-zero exit with
+ *   **empty** stderr is not `tasklist` refusing; it is the host killing the
+ *   child, and `crashed` says so.
+ * - The exact spawn the harness makes succeeds 39 times out of 39 from an idle
+ *   Node process (0.6-4.3s, 26 KB, ~530 rows, against a 30s budget and an 8 MB
+ *   ceiling). So "the spawn is wrong" — a missing shell, a PATH the child did
+ *   not inherit, an undersized buffer — is ruled out: each has its **own** message
+ *   (`spawn tasklist ENOENT`, `stdout maxBuffer length exceeded`), and none of
+ *   them is the one observed.
+ * - Under an emulator boot the same call inflates to ~9x its idle cost, which
+ *   is the contention `HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS` is sized
+ *   for and the failure the old line could not distinguish from a crash.
+ *
+ * This is the same fault `avd-probe-verdict.ts` was written for — a probe that
+ * discarded its error, leaving "never answered" indistinguishable from "the
+ * answer is no" — and it is fixed the same way: classify, name the
+ * consequence, and keep the classification pure so it is unit-testable while
+ * the `execFile` glue stays in the integration-only caller.
+ */
+/**
+ * Parameters for {@link buildHostProcessQueryMessage}.
+ */
+export interface BuildHostProcessQueryMessageParams {
+    /**
+    The command that was run, for the reader to try by hand — e.g. `tasklist /FO CSV /NH`.
+     */
+    readonly command: string;
+    /**
+    What the failure costs the caller, closing the line. Defaults to the teardown consequence, which is what the harness's own listing loses; the wedge probe states what *it* loses instead.
+     */
+    readonly consequence?: string | undefined;
+    /**
+    How long the call took before it ended, in milliseconds.
+     */
+    readonly elapsedInMilliseconds: number;
+    /**
+    The child's exit code, when it exited rather than failing to start or being killed.
+     */
+    readonly exitCode: null | number;
+    /**
+    The verdict from {@link resolveHostProcessQueryOutcome}.
+     */
+    readonly outcome: HostProcessQueryOutcome;
+    /**
+    How many processes the output parsed to — the *partial* listing on a failure, which is the evidence that the command was working when it died.
+     */
+    readonly partialRowCount: number;
+    /**
+    The signal the child was killed with, when it was killed.
+     */
+    readonly signal: null | string;
+    /**
+    Whatever the child wrote to stderr — quoted for `refused`, and the emptiness that identifies `crashed`.
+     */
+    readonly standardError: string;
+    /**
+    The budget the call was given, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * How the host process listing ended.
+ *
+ * `listed` is the only success. The rest are distinct failures on purpose: they
+ * need different fixes, and the line they used to share named none of them.
+ */
+export type HostProcessQueryOutcome = 'listed' | 'zero-rows' | HostQueryFailure;
+/**
+ * The ways a host query can fail, shared by every query that classifies its ending.
+ */
+export type HostQueryFailure = 'crashed' | 'not-found' | 'output-overran' | 'refused' | 'timed-out';
+/**
+ * Parameters for {@link resolveHostProcessQueryOutcome}.
+ */
+export interface ResolveHostProcessQueryOutcomeParams {
+    /**
+    `execFile`'s `error.code`: the numeric exit code, or a string like `ENOENT` when the child never ran.
+     */
+    readonly errorCode: null | number | string;
+    /**
+    Whether `execFile` reported an error at all.
+     */
+    readonly hasFailed: boolean;
+    /**
+    Whether a **filtered** query affirmatively reported that nothing matched (`checkIsNoMatchReported`) — the one way an empty answer is an answer.
+     */
+    readonly hasReportedNoMatch: boolean;
+    /**
+    `execFile`'s `error.killed`: whether the budget expired and the child was killed.
+     */
+    readonly isKilled: boolean;
+    /**
+    How many processes the output parsed to.
+     */
+    readonly rowCount: number;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+}
+/**
+ * Parameters for {@link resolveHostQueryFailure}.
+ */
+export type ResolveHostQueryFailureParams = Pick<ResolveHostProcessQueryOutcomeParams, 'errorCode' | 'isKilled' | 'standardError'>;
+/**
+ * Builds the single line the listing logs for an outcome.
+ *
+ * One line, never two: the contradictory pair in this file's header is the
+ * defect this replaces. `listed` has nothing to report, so it returns
+ * `undefined` rather than a cheerful line on the hot path.
+ *
+ * @param params - The outcome plus the command, the budget and what the child left behind.
+ * @returns The warning to log, or `undefined` when the listing succeeded.
+ */
+export declare function buildHostProcessQueryMessage(params: BuildHostProcessQueryMessageParams): string | undefined;
+/**
+ * Renders a millisecond duration for a log line.
+ *
+ * @param durationInMilliseconds - The duration.
+ * @returns Whole milliseconds under a second, and seconds to one decimal above it.
+ */
+export declare function formatDuration(durationInMilliseconds: number): string;
+/**
+ * Renders a child's exit code, in the base a reader can look it up in.
+ *
+ * @param exitCode - The exit code, or `null` when the child was killed before exiting.
+ * @returns The code in hex when it is an `NTSTATUS` failure, in decimal otherwise.
+ */
+export declare function formatExitCode(exitCode: null | number): string;
+/**
+ * Renders what the command said when it refused, as one sentence.
+ *
+ * `tasklist` ends its own `ERROR: …` with a period and a `\r\r\n`, so quoting it
+ * verbatim and adding the sentence break this line needs produced `recognized..`
+ * — the terminator is supplied only when the tool did not supply one.
+ *
+ * @param standardError - Whatever the child wrote to stderr.
+ * @returns The refusal, trimmed, ending in exactly one period.
+ */
+export declare function formatRefusal(standardError: string): string;
+/**
+ * Decides how the listing ended, from what `execFile` reported.
+ *
+ * The order of the branches is the order of specificity: the two failures Node
+ * names itself (`ENOENT`, the buffer ceiling) are recognized before the ones
+ * that have to be inferred from the child's exit, and `crashed` is last
+ * because it is defined by the *absence* of an explanation on stderr.
+ *
+ * @param params - What `execFile` reported, and how many rows the output parsed to.
+ * @returns The outcome.
+ */
+export declare function resolveHostProcessQueryOutcome(params: ResolveHostProcessQueryOutcomeParams): HostProcessQueryOutcome;
+/**
+ * Decides which way a host query that **did** fail failed.
+ *
+ * Split out of {@link resolveHostProcessQueryOutcome} so a sibling query whose
+ * success rules differ — the port-owner query, where zero owners is an answer —
+ * can share one definition of each failure without inheriting `listed` and
+ * `zero-rows`.
+ *
+ * @param params - What `execFile` reported for the failed call.
+ * @returns The failure outcome.
+ */
+export declare function resolveHostQueryFailure(params: ResolveHostQueryFailureParams): HostQueryFailure;

package/dist/lib/esm/host-process-query-verdict.mjs

@@ -0,0 +1,74 @@
+import { assertNever } from "./type-guards.mjs";
+const NTSTATUS_FAILURE_FLOOR = 3221225472;
+const HEXADECIMAL_RADIX = 16;
+const MILLISECONDS_PER_SECOND = 1e3;
+function buildHostProcessQueryMessage(params) {
+  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;
+  const consequence = params.consequence ?? "Teardown falls back to `adb devices` alone and has no PID to escalate to.";
+  switch (params.outcome) {
+    case "crashed": {
+      return `Warning: \`${params.command}\` died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr, ${String(params.partialRowCount)} process(es) listed) \u2014 it did not refuse the request, since it always explains a refusal on stderr. Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;
+    }
+    case "listed": {
+      return void 0;
+    }
+    case "not-found": {
+      return `Warning: \`${params.command}\` could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;
+    }
+    case "output-overran": {
+      return `Warning: \`${params.command}\` produced more output ${cost} than the listing's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;
+    }
+    case "refused": {
+      return `Warning: \`${params.command}\` refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;
+    }
+    case "timed-out": {
+      return `Warning: \`${params.command}\` did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? "" : ` (${params.signal})`}, having listed ${String(params.partialRowCount)} process(es) by then \u2014 so it was working, not refusing, and the budget is what ran out. The partial listing is discarded rather than used: the owned set is a *difference* between two listings, and a truncated one on either side would both miss a process this run owns and claim one it does not. ${consequence}`;
+    }
+    case "zero-rows": {
+      return `Warning: \`${params.command}\` exited cleanly ${cost} but its output parsed to no processes and carried no no-match notice \u2014 a whole-host listing cannot be empty on a running host, and a filtered one says so when nothing matches. Treating it as a failed query. ${consequence}`;
+    }
+    default: {
+      return assertNever(params.outcome);
+    }
+  }
+}
+function formatDuration(durationInMilliseconds) {
+  return durationInMilliseconds < MILLISECONDS_PER_SECOND ? `${String(durationInMilliseconds)}ms` : `${(durationInMilliseconds / MILLISECONDS_PER_SECOND).toFixed(1)}s`;
+}
+function formatExitCode(exitCode) {
+  if (exitCode === null) {
+    return "unknown";
+  }
+  return exitCode >= NTSTATUS_FAILURE_FLOOR ? `0x${exitCode.toString(HEXADECIMAL_RADIX).toUpperCase()}` : String(exitCode);
+}
+function formatRefusal(standardError) {
+  const refusal = standardError.trim();
+  return refusal.endsWith(".") ? refusal : `${refusal}.`;
+}
+function resolveHostProcessQueryOutcome(params) {
+  if (!params.hasFailed) {
+    return params.rowCount === 0 && !params.hasReportedNoMatch ? "zero-rows" : "listed";
+  }
+  return resolveHostQueryFailure(params);
+}
+function resolveHostQueryFailure(params) {
+  if (params.errorCode === "ENOENT") {
+    return "not-found";
+  }
+  if (params.errorCode === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+    return "output-overran";
+  }
+  if (params.isKilled) {
+    return "timed-out";
+  }
+  return params.standardError.trim() === "" ? "crashed" : "refused";
+}
+export {
+  buildHostProcessQueryMessage,
+  formatDuration,
+  formatExitCode,
+  formatRefusal,
+  resolveHostProcessQueryOutcome,
+  resolveHostQueryFailure
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/host-process-query-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the host process listing \u2014 deciding, from how\n * `tasklist` / `ps` ended, *which* way it failed, and saying so in one line.\n *\n * The listing is what names the emulator backend a run owns, and therefore the\n * only PID teardown can escalate to (**L56**). It is best-effort by design: a\n * listing that cannot be produced yields no PIDs rather than failing the run.\n * What it must never be is **unexplained**, and for three weeks it was:\n *\n * ```text\n * Warning: could not list host processes (`tasklist`): Command failed: tasklist /FO CSV /NH\n *\n * Warning: `tasklist` listed no processes.\n * ```\n *\n * Two defects in four lines. The pair is *contradictory* \u2014 the first says the\n * command failed, the second says it ran and found nothing \u2014 and they were\n * emitted together for a single failure, because a failed call resolves `''`\n * and an empty string parses to zero rows. `zero-rows` exists to catch a\n * listing that succeeded and yet returned nothing, which on a real host can\n * only be a failed query; it is not a second opinion on a call that already\n * reported an error.\n *\n * And the surviving diagnostic is `error.message` alone, which for `execFile`\n * is `Command failed: <cmd>\\n<stderr>` \u2014 so the log carried the command back\n * to the reader and threw away everything that identifies the failure:\n * `error.code`, `error.killed`, `error.signal`, and how long the call took.\n * Measured 2026-09-23 on this host, that discarded evidence is decisive:\n *\n * - `tasklist` **always** writes `ERROR: <reason>` to stderr when it objects \u2014\n *   a bad filter, an unreachable host \u2014 and exits 1. So a non-zero exit with\n *   **empty** stderr is not `tasklist` refusing; it is the host killing the\n *   child, and `crashed` says so.\n * - The exact spawn the harness makes succeeds 39 times out of 39 from an idle\n *   Node process (0.6-4.3s, 26 KB, ~530 rows, against a 30s budget and an 8 MB\n *   ceiling). So \"the spawn is wrong\" \u2014 a missing shell, a PATH the child did\n *   not inherit, an undersized buffer \u2014 is ruled out: each has its **own** message\n *   (`spawn tasklist ENOENT`, `stdout maxBuffer length exceeded`), and none of\n *   them is the one observed.\n * - Under an emulator boot the same call inflates to ~9x its idle cost, which\n *   is the contention `HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS` is sized\n *   for and the failure the old line could not distinguish from a crash.\n *\n * This is the same fault `avd-probe-verdict.ts` was written for \u2014 a probe that\n * discarded its error, leaving \"never answered\" indistinguishable from \"the\n * answer is no\" \u2014 and it is fixed the same way: classify, name the\n * consequence, and keep the classification pure so it is unit-testable while\n * the `execFile` glue stays in the integration-only caller.\n */\n\nimport { assertNever } from './type-guards.mjs';\n\n/**\n * The lowest exit code Windows reserves for an `NTSTATUS` failure.\n *\n * A child killed by the OS \u2014 an access violation, a stack overflow \u2014 exits with\n * its `NTSTATUS` as the code, and `0xC0000005` is unreadable in decimal\n * (`3221225477`). Codes at or above this are therefore reported in hex, which\n * is the only form a reader can look up.\n */\nconst NTSTATUS_FAILURE_FLOOR = 0xC0_00_00_00;\n\n/**\n * The base an `NTSTATUS` exit code is rendered in.\n */\nconst HEXADECIMAL_RADIX = 16;\n\n/**\n * Milliseconds in a second, for rendering a duration.\n */\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Parameters for {@link buildHostProcessQueryMessage}.\n */\nexport interface BuildHostProcessQueryMessageParams {\n  /**\n  The command that was run, for the reader to try by hand \u2014 e.g. `tasklist /FO CSV /NH`.\n   */\n  readonly command: string;\n\n  /**\n  What the failure costs the caller, closing the line. Defaults to the teardown consequence, which is what the harness's own listing loses; the wedge probe states what *it* loses instead.\n   */\n  readonly consequence?: string | undefined;\n\n  /**\n  How long the call took before it ended, in milliseconds.\n   */\n  readonly elapsedInMilliseconds: number;\n\n  /**\n  The child's exit code, when it exited rather than failing to start or being killed.\n   */\n  readonly exitCode: null | number;\n\n  /**\n  The verdict from {@link resolveHostProcessQueryOutcome}.\n   */\n  readonly outcome: HostProcessQueryOutcome;\n\n  /**\n  How many processes the output parsed to \u2014 the *partial* listing on a failure, which is the evidence that the command was working when it died.\n   */\n  readonly partialRowCount: number;\n\n  /**\n  The signal the child was killed with, when it was killed.\n   */\n  readonly signal: null | string;\n\n  /**\n  Whatever the child wrote to stderr \u2014 quoted for `refused`, and the emptiness that identifies `crashed`.\n   */\n  readonly standardError: string;\n\n  /**\n  The budget the call was given, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * How the host process listing ended.\n *\n * `listed` is the only success. The rest are distinct failures on purpose: they\n * need different fixes, and the line they used to share named none of them.\n */\nexport type HostProcessQueryOutcome = 'listed' | 'zero-rows' | HostQueryFailure;\n\n/**\n * The ways a host query can fail, shared by every query that classifies its ending.\n */\nexport type HostQueryFailure = 'crashed' | 'not-found' | 'output-overran' | 'refused' | 'timed-out';\n\n/**\n * Parameters for {@link resolveHostProcessQueryOutcome}.\n */\nexport interface ResolveHostProcessQueryOutcomeParams {\n  /**\n  `execFile`'s `error.code`: the numeric exit code, or a string like `ENOENT` when the child never ran.\n   */\n  readonly errorCode: null | number | string;\n\n  /**\n  Whether `execFile` reported an error at all.\n   */\n  readonly hasFailed: boolean;\n\n  /**\n  Whether a **filtered** query affirmatively reported that nothing matched (`checkIsNoMatchReported`) \u2014 the one way an empty answer is an answer.\n   */\n  readonly hasReportedNoMatch: boolean;\n\n  /**\n  `execFile`'s `error.killed`: whether the budget expired and the child was killed.\n   */\n  readonly isKilled: boolean;\n\n  /**\n  How many processes the output parsed to.\n   */\n  readonly rowCount: number;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n}\n\n/**\n * Parameters for {@link resolveHostQueryFailure}.\n */\nexport type ResolveHostQueryFailureParams = Pick<ResolveHostProcessQueryOutcomeParams, 'errorCode' | 'isKilled' | 'standardError'>;\n\n/**\n * Builds the single line the listing logs for an outcome.\n *\n * One line, never two: the contradictory pair in this file's header is the\n * defect this replaces. `listed` has nothing to report, so it returns\n * `undefined` rather than a cheerful line on the hot path.\n *\n * @param params - The outcome plus the command, the budget and what the child left behind.\n * @returns The warning to log, or `undefined` when the listing succeeded.\n */\nexport function buildHostProcessQueryMessage(params: BuildHostProcessQueryMessageParams): string | undefined {\n  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;\n  const consequence = params.consequence ?? 'Teardown falls back to `adb devices` alone and has no PID to escalate to.';\n\n  switch (params.outcome) {\n    case 'crashed': {\n      return `Warning: \\`${params.command}\\` died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr, ${String(params.partialRowCount)} process(es) listed) \u2014 it did not refuse the request, since it always explains a refusal on stderr. Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;\n    }\n    case 'listed': {\n      return undefined;\n    }\n    case 'not-found': {\n      return `Warning: \\`${params.command}\\` could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;\n    }\n    case 'output-overran': {\n      return `Warning: \\`${params.command}\\` produced more output ${cost} than the listing's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;\n    }\n    case 'refused': {\n      return `Warning: \\`${params.command}\\` refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;\n    }\n    case 'timed-out': {\n      return `Warning: \\`${params.command}\\` did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? '' : ` (${params.signal})`}, having listed ${String(params.partialRowCount)} process(es) by then \u2014 so it was working, not refusing, and the budget is what ran out. The partial listing is discarded rather than used: the owned set is a *difference* between two listings, and a truncated one on either side would both miss a process this run owns and claim one it does not. ${consequence}`;\n    }\n    case 'zero-rows': {\n      return `Warning: \\`${params.command}\\` exited cleanly ${cost} but its output parsed to no processes and carried no no-match notice \u2014 a whole-host listing cannot be empty on a running host, and a filtered one says so when nothing matches. Treating it as a failed query. ${consequence}`;\n    }\n    default: {\n      return assertNever(params.outcome);\n    }\n  }\n}\n\n/**\n * Renders a millisecond duration for a log line.\n *\n * @param durationInMilliseconds - The duration.\n * @returns Whole milliseconds under a second, and seconds to one decimal above it.\n */\nexport function formatDuration(durationInMilliseconds: number): string {\n  return durationInMilliseconds < MILLISECONDS_PER_SECOND\n    ? `${String(durationInMilliseconds)}ms`\n    : `${(durationInMilliseconds / MILLISECONDS_PER_SECOND).toFixed(1)}s`;\n}\n\n/**\n * Renders a child's exit code, in the base a reader can look it up in.\n *\n * @param exitCode - The exit code, or `null` when the child was killed before exiting.\n * @returns The code in hex when it is an `NTSTATUS` failure, in decimal otherwise.\n */\nexport function formatExitCode(exitCode: null | number): string {\n  if (exitCode === null) {\n    return 'unknown';\n  }\n\n  return exitCode >= NTSTATUS_FAILURE_FLOOR ? `0x${exitCode.toString(HEXADECIMAL_RADIX).toUpperCase()}` : String(exitCode);\n}\n\n/**\n * Renders what the command said when it refused, as one sentence.\n *\n * `tasklist` ends its own `ERROR: \u2026` with a period and a `\\r\\r\\n`, so quoting it\n * verbatim and adding the sentence break this line needs produced `recognized..`\n * \u2014 the terminator is supplied only when the tool did not supply one.\n *\n * @param standardError - Whatever the child wrote to stderr.\n * @returns The refusal, trimmed, ending in exactly one period.\n */\nexport function formatRefusal(standardError: string): string {\n  const refusal = standardError.trim();\n\n  return refusal.endsWith('.') ? refusal : `${refusal}.`;\n}\n\n/**\n * Decides how the listing ended, from what `execFile` reported.\n *\n * The order of the branches is the order of specificity: the two failures Node\n * names itself (`ENOENT`, the buffer ceiling) are recognized before the ones\n * that have to be inferred from the child's exit, and `crashed` is last\n * because it is defined by the *absence* of an explanation on stderr.\n *\n * @param params - What `execFile` reported, and how many rows the output parsed to.\n * @returns The outcome.\n */\nexport function resolveHostProcessQueryOutcome(params: ResolveHostProcessQueryOutcomeParams): HostProcessQueryOutcome {\n  if (!params.hasFailed) {\n    /*\n     * A host always has processes, so a whole-host listing that parses to nothing is a failed query however it\n     * exited. A filtered one may legitimately match nothing \u2014 but only when it says so; silence is still a failure.\n     */\n    return params.rowCount === 0 && !params.hasReportedNoMatch ? 'zero-rows' : 'listed';\n  }\n\n  return resolveHostQueryFailure(params);\n}\n\n/**\n * Decides which way a host query that **did** fail failed.\n *\n * Split out of {@link resolveHostProcessQueryOutcome} so a sibling query whose\n * success rules differ \u2014 the port-owner query, where zero owners is an answer \u2014\n * can share one definition of each failure without inheriting `listed` and\n * `zero-rows`.\n *\n * @param params - What `execFile` reported for the failed call.\n * @returns The failure outcome.\n */\nexport function resolveHostQueryFailure(params: ResolveHostQueryFailureParams): HostQueryFailure {\n  if (params.errorCode === 'ENOENT') {\n    return 'not-found';\n  }\n\n  if (params.errorCode === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {\n    return 'output-overran';\n  }\n\n  if (params.isKilled) {\n    return 'timed-out';\n  }\n\n  // `tasklist` and `ps` both explain a refusal on stderr, so silence means the child never got to object.\n  return params.standardError.trim() === '' ? 'crashed' : 'refused';\n}\n"],
  "mappings": "AAoDA,SAAS,mBAAmB;AAU5B,MAAM,yBAAyB;AAK/B,MAAM,oBAAoB;AAK1B,MAAM,0BAA0B;AAmHzB,SAAS,6BAA6B,QAAgE;AAC3G,QAAM,OAAO,SAAS,eAAe,OAAO,qBAAqB,CAAC;AAClE,QAAM,cAAc,OAAO,eAAe;AAE1C,UAAQ,OAAO,SAAS;AAAA,IACtB,KAAK,WAAW;AACd,aAAO,cAAc,OAAO,OAAO,WAAW,IAAI,oCAAoC,eAAe,OAAO,QAAQ,CAAC,wBAAwB,OAAO,OAAO,eAAe,CAAC,6LAAwL,WAAW;AAAA,IAChX;AAAA,IACA,KAAK,UAAU;AACb,aAAO;AAAA,IACT;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,cAAc,OAAO,OAAO,8BAA8B,IAAI,2CAA2C,WAAW;AAAA,IAC7H;AAAA,IACA,KAAK,kBAAkB;AACrB,aAAO,cAAc,OAAO,OAAO,2BAA2B,IAAI,qFAAqF,WAAW;AAAA,IACpK;AAAA,IACA,KAAK,WAAW;AACd,aAAO,cAAc,OAAO,OAAO,0BAA0B,IAAI,UAAU,eAAe,OAAO,QAAQ,CAAC,MAAM,cAAc,OAAO,aAAa,CAAC,IAAI,WAAW;AAAA,IACpK;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,cAAc,OAAO,OAAO,gCAAgC,eAAe,OAAO,qBAAqB,CAAC,0BAA0B,IAAI,GAAG,OAAO,WAAW,OAAO,KAAK,KAAK,OAAO,MAAM,GAAG,mBAAmB,OAAO,OAAO,eAAe,CAAC,+SAA0S,WAAW;AAAA,IAC3iB;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,cAAc,OAAO,OAAO,qBAAqB,IAAI,wNAAmN,WAAW;AAAA,IAC5R;AAAA,IACA,SAAS;AACP,aAAO,YAAY,OAAO,OAAO;AAAA,IACnC;AAAA,EACF;AACF;AAQO,SAAS,eAAe,wBAAwC;AACrE,SAAO,yBAAyB,0BAC5B,GAAG,OAAO,sBAAsB,CAAC,OACjC,IAAI,yBAAyB,yBAAyB,QAAQ,CAAC,CAAC;AACtE;AAQO,SAAS,eAAe,UAAiC;AAC9D,MAAI,aAAa,MAAM;AACrB,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,yBAAyB,KAAK,SAAS,SAAS,iBAAiB,EAAE,YAAY,CAAC,KAAK,OAAO,QAAQ;AACzH;AAYO,SAAS,cAAc,eAA+B;AAC3D,QAAM,UAAU,cAAc,KAAK;AAEnC,SAAO,QAAQ,SAAS,GAAG,IAAI,UAAU,GAAG,OAAO;AACrD;AAaO,SAAS,+BAA+B,QAAuE;AACpH,MAAI,CAAC,OAAO,WAAW;AAKrB,WAAO,OAAO,aAAa,KAAK,CAAC,OAAO,qBAAqB,cAAc;AAAA,EAC7E;AAEA,SAAO,wBAAwB,MAAM;AACvC;AAaO,SAAS,wBAAwB,QAAyD;AAC/F,MAAI,OAAO,cAAc,UAAU;AACjC,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,cAAc,qCAAqC;AAC5D,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,UAAU;AACnB,WAAO;AAAA,EACT;AAGA,SAAO,OAAO,cAAc,KAAK,MAAM,KAAK,YAAY;AAC1D;",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -69,6 +69,8 @@ export type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab
 export { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';
 export type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';
 export { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';
+export type { BuildStatusBarBandFailureMessageParams, PaintOutStatusBarOptions, ResolveStatusBarBandParams, StatusBarBandColor, StatusBarBandVerdict } from './paint-out-status-bar.mjs';
+export { buildStatusBarBandFailureMessage, DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS, DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS, paintOutStatusBar, resolveStatusBarBand } from './paint-out-status-bar.mjs';
 export type { PollInObsidianParams } from './poll-in-obsidian.mjs';
 export { pollInObsidian } from './poll-in-obsidian.mjs';
 export { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';
@@ -79,7 +81,7 @@ export { runObsidianVersionMatrix } from './run-version-matrix.mjs';
 export type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';
 export { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';
 export type { BuildSoftKeyboardDiagnosticMessageParams, CheckIsSoftKeyboardUpParams, ElementRect, ResolveSoftKeyboardTapPointsParams, SoftKeyboardTapPoint, SoftKeyboardViewportSnapshot } from './soft-keyboard-geometry.mjs';
-export { buildSoftKeyboardDiagnosticMessage, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.mjs';
+export { buildSoftKeyboardDiagnosticMessage, checkIsInputMethodShown, checkIsSoftKeyboardUp, DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS, parseInputMethodState, resolveSoftKeyboardTapPoints } from './soft-keyboard-geometry.mjs';
 export type { RaiseSoftKeyboardParams, TapDeviceParams } from './soft-keyboard.mjs';
 export { raiseSoftKeyboard, tapDevice } from './soft-keyboard.mjs';
 export type { StaleBuildErrorConstructorParams } from './stale-build-error.mjs';

package/dist/lib/esm/index.mjs

@@ -87,6 +87,13 @@ import {
 } from "./obsidian-version.mjs";
 import { openObsidianSettingsTab } from "./open-obsidian-settings-tab.mjs";
 import { OwnedInstanceExitedError } from "./owned-instance-exited-error.mjs";
+import {
+  buildStatusBarBandFailureMessage,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
+  paintOutStatusBar,
+  resolveStatusBarBand
+} from "./paint-out-status-bar.mjs";
 import { pollInObsidian } from "./poll-in-obsidian.mjs";
 import { RendererFailedToInitializeError } from "./renderer-failed-to-initialize-error.mjs";
 import { resolveEmulatorDeviceId } from "./resolve-emulator-device-id.mjs";
@@ -94,6 +101,7 @@ import { runObsidianVersionMatrix } from "./run-version-matrix.mjs";
 import { SilentAsarFallbackError } from "./silent-asar-fallback-error.mjs";
 import {
   buildSoftKeyboardDiagnosticMessage,
+  checkIsInputMethodShown,
   checkIsSoftKeyboardUp,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   parseInputMethodState,
@@ -124,6 +132,8 @@ export {
   DEFAULT_EVAL_CAP_IN_MILLISECONDS,
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   DEFAULT_OBSIDIAN_VERSION_SPECS,
+  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,
+  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
   DeviceSettingNamespace,
@@ -146,8 +156,10 @@ export {
   buildDeviceSettingsCommandArguments,
   buildLabelSvg,
   buildSoftKeyboardDiagnosticMessage,
+  buildStatusBarBandFailureMessage,
   captureDeviceScreenshot,
   captureObsidianScreenshot,
+  checkIsInputMethodShown,
   checkIsMobileTransport,
   checkIsSoftKeyboardUp,
   computeFitToCanvas,
@@ -167,6 +179,7 @@ export {
   labelScreenshot,
   measureLabelCaption,
   openObsidianSettingsTab,
+  paintOutStatusBar,
   parseInputMethodState,
   pollInObsidian,
   raiseSoftKeyboard,
@@ -182,6 +195,7 @@ export {
   resolveInstallerCompatibility,
   resolveMissingInjectedPlugins,
   resolveSoftKeyboardTapPoints,
+  resolveStatusBarBand,
   restoreAppConfig,
   runAdbBinary,
   runAdbText,
@@ -198,4 +212,4 @@ export {
   withSoftKeyboardEnabled,
   writeDeviceSetting
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.mjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.mjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.mjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.mjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.mjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.mjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.mjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.mjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.mjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.mjs';\nexport { connectToCdp } from './connect-to-cdp.mjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.mjs';\nexport { ContextId } from './context-id.mjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.mjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.mjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';\nexport { readDemoVaultTree } from './demo-vault-tree.mjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';\nexport { captureDeviceScreenshot } from './device-screenshot.mjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.mjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.mjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.mjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.mjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.mjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.mjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.mjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.mjs';\nexport { evalInObsidian } from './eval-in-obsidian.mjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.mjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.mjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.mjs';\nexport { hideVaultName } from './hide-vault-name.mjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.mjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.mjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.mjs';\nexport type { LibResolver } from './lib-registry.mjs';\nexport { registerLibResolver } from './lib-registry.mjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.mjs';\nexport { getVersionMetadata } from './obsidian-metadata.mjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.mjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.mjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.mjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.mjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.mjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.mjs';\nexport { StaleBuildError } from './stale-build-error.mjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.mjs';\nexport { TemporaryVault } from './temporary-vault.mjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.mjs';\nexport { AppiumTransport } from './transport-appium.mjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.mjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nexport { createTransportFromOptions } from './transport-factory.mjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nexport { checkIsMobileTransport } from './transport-options.mjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.mjs';\n"],
  "mappings": "AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,8BAA8B;AAEvC,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAE3C,SAAS,+BAA+B;AAMxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,oCAAoC;AAK7C,SAAS,8BAA8B;AAEvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,wCAAwC;AAkBjD,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,qBAAqB;AAE9B,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAE9C,SAAS,mCAAmC;AAQ5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,2BAA2B;AAOpC,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AASxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,uBAAuB;AAMhC,SAAS,sBAAsB;AAK/B,SAAS,uBAAuB;AAOhC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAM3C,SAAS,8BAA8B;AAMvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sCAAsC;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type { RunAdbParams } from './adb.mjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.mjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.mjs';\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.mjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.mjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.mjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.mjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.mjs';\nexport type { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.mjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.mjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.mjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.mjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.mjs';\nexport { connectToCdp } from './connect-to-cdp.mjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.mjs';\nexport { ContextId } from './context-id.mjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.mjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.mjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  BuildDemoVaultPopulateAsyncParams,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.mjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.mjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.mjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.mjs';\nexport { readDemoVaultTree } from './demo-vault-tree.mjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.mjs';\nexport type { CaptureDeviceScreenshotParams } from './device-screenshot.mjs';\nexport { captureDeviceScreenshot } from './device-screenshot.mjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.mjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.mjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.mjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.mjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.mjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.mjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.mjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.mjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.mjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.mjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.mjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.mjs';\nexport { evalInObsidian } from './eval-in-obsidian.mjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.mjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.mjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.mjs';\nexport { hideVaultName } from './hide-vault-name.mjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.mjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.mjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\n} from './label-screenshot.mjs';\nexport type { LibResolver } from './lib-registry.mjs';\nexport { registerLibResolver } from './lib-registry.mjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.mjs';\nexport { getVersionMetadata } from './obsidian-metadata.mjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.mjs';\nexport type { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.mjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.mjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.mjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.mjs';\nexport type {\n  BuildStatusBarBandFailureMessageParams,\n  PaintOutStatusBarOptions,\n  ResolveStatusBarBandParams,\n  StatusBarBandColor,\n  StatusBarBandVerdict\n} from './paint-out-status-bar.mjs';\nexport {\n  buildStatusBarBandFailureMessage,\n  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,\n  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,\n  paintOutStatusBar,\n  resolveStatusBarBand\n} from './paint-out-status-bar.mjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.mjs';\nexport { pollInObsidian } from './poll-in-obsidian.mjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nexport type { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.mjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.mjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.mjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.mjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.mjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nexport type {\n  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.mjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.mjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.mjs';\nexport { StaleBuildError } from './stale-build-error.mjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\n} from './temporary-vault.mjs';\nexport { TemporaryVault } from './temporary-vault.mjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.mjs';\nexport { AppiumTransport } from './transport-appium.mjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.mjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nexport { createTransportFromOptions } from './transport-factory.mjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nexport { checkIsMobileTransport } from './transport-options.mjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.mjs';\n"],
  "mappings": "AAOA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,2BAA2B;AAEpC,SAAS,iCAAiC;AAK1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,8BAA8B;AAEvC,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB;AAK7B,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAE3C,SAAS,+BAA+B;AAMxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,oCAAoC;AAK7C,SAAS,8BAA8B;AAEvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,wCAAwC;AAkBjD,SAAS,sBAAsB;AAM/B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,qBAAqB;AAE9B,SAAS,yCAAyC;AAMlD,SAAS,qCAAqC;AAE9C,SAAS,mCAAmC;AAQ5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,2BAA2B;AAOpC,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAQzC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sBAAsB;AAC/B,SAAS,uCAAuC;AAEhD,SAAS,+BAA+B;AAExC,SAAS,gCAAgC;AAEzC,SAAS,+BAA+B;AASxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,uBAAuB;AAMhC,SAAS,sBAAsB;AAK/B,SAAS,uBAAuB;AAOhC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAM3C,SAAS,8BAA8B;AAMvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sCAAsC;",
  "names": []
}


package/dist/lib/esm/label-screenshot.mjs

@@ -2,7 +2,7 @@ import { readPngDimensions } from "./capture-screenshot.mjs";
 import { importSharp } from "./sharp-loader.mjs";
 const FONT_SIZE_RATIO = 0.034;
 const BAND_HEIGHT_RATIO = 2.2;
-const BAND_OPACITY = 0.94;
+const BAND_OPACITY = 1;
 const MINIMUM_FONT_SIZE_IN_PIXELS = 18;
 const MINIMUM_HEIGHT_RATIO = 0.075;
 const SIDE_MARGIN_RATIO = 0.04;
@@ -112,4 +112,4 @@ export {
   labelScreenshot,
   measureLabelCaption
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/label-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Adds a caption band to an already-captured screenshot.\n *\n * A store listing shows screenshots ONE AT A TIME, in a carousel, with no\n * caption of its own \u2014 so an image has to say what it is showing. Without that,\n * a shot of the state a plugin removes reads as a shot of the state the plugin\n * causes, which is the opposite of the message.\n *\n * The band is drawn over the BOTTOM of the frame, for two reasons: the top is\n * where the content being demonstrated usually starts, and the bottom of an\n * Obsidian frame is chrome \u2014 status bar, word count, sync indicator \u2014 which the\n * band then covers rather than competing with.\n *\n * This is post-processing, deliberately. The capture stays an untouched device\n * frame, and rewording a label needs no re-shoot.\n *\n * A caption that is too long for its frame is MEASURED and rejected rather than\n * drawn. An SVG `<text>` is clipped by its viewport at both ends with no\n * ellipsis and no error, so an overlong caption ships as a sentence fragment\n * that looks deliberate \u2014 `nabled in Settings - a listening plugin is told` \u2014\n * and the frame is still exactly the size it should be, so every dimension\n * assertion downstream still passes. The only feedback anyone ever got was\n * looking at the PNG. See {@link measureLabelCaption}.\n */\n\nimport type { SharpCompositeLayer } from './sharp-loader.mjs';\n\nimport { readPngDimensions } from './capture-screenshot.mjs';\nimport { importSharp } from './sharp-loader.mjs';\n\n/**\n * Parameters for {@link computeLabelBand}.\n */\nexport interface ComputeLabelBandParams {\n  /**\n   * Height of the image being labeled, in pixels.\n   */\n  readonly imageHeightInPixels: number;\n\n  /**\n   * Width of the image being labeled, in pixels.\n   */\n  readonly imageWidthInPixels: number;\n}\n\n/**\n * The geometry of the caption band.\n */\nexport interface LabelBandGeometry {\n  /**\n   * How much horizontal room the caption has, in pixels: the image width less\n   * the margin held clear at each end, so a caption that fits does not read as\n   * though it were about to touch the edge of the frame.\n   */\n  readonly captionRoomInPixels: number;\n\n  /**\n   * Font size for the caption, in pixels.\n   */\n  readonly fontSizeInPixels: number;\n\n  /**\n   * Height of the band, in pixels.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * Distance from the top of the image to the top of the band, in pixels.\n   */\n  readonly topInPixels: number;\n}\n\n/**\n * What a caption measures against the frame it is destined for.\n */\nexport interface LabelCaptionMeasurement {\n  /**\n   * The room available, in pixels \u2014 {@link LabelBandGeometry.captionRoomInPixels}.\n   */\n  readonly captionRoomInPixels: number;\n\n  /**\n   * Whether the caption fits that room.\n   */\n  readonly doesFit: boolean;\n\n  /**\n   * How wide the caption actually renders, in pixels, at the size the band\n   * would draw it.\n   */\n  readonly textWidthInPixels: number;\n}\n\n/**\n * Options for {@link labelScreenshot}.\n */\nexport interface LabelScreenshotOptions {\n  /**\n   * The caption. Keep it to a handful of words: it is read at listing-thumbnail\n   * size, and it is neither wrapped nor shrunk to fit \u2014 one that does not fit\n   * is REJECTED, with the measured width and the room available. Check a\n   * candidate with {@link measureLabelCaption} before committing to it.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link measureLabelCaption}.\n */\nexport interface MeasureLabelCaptionParams {\n  /**\n   * Height of the image the caption is destined for, in pixels.\n   */\n  readonly imageHeightInPixels: number;\n\n  /**\n   * Width of the image the caption is destined for, in pixels.\n   */\n  readonly imageWidthInPixels: number;\n\n  /**\n   * The caption to measure.\n   */\n  readonly text: string;\n}\n\n/**\n * Caption size as a fraction of image WIDTH, not height.\n *\n * Width is what governs legibility here: a 900x1600 phone frame and a 1200x800\n * desktop frame are read at similar on-screen widths in a listing, so sizing by\n * width keeps the caption visually consistent across the two.\n */\nconst FONT_SIZE_RATIO = 0.034;\n\n/**\n * Band height as a multiple of the font size \u2014 enough to sit the text on with\n * clear space above and below.\n */\nconst BAND_HEIGHT_RATIO = 2.2;\n\n/**\n * Opacity of the band. Near-opaque on purpose: the band exists partly to COVER\n * the chrome along the bottom of the frame, and at 0.82 a status bar legibly\n * bled through behind the caption, which looked like a mistake rather than a\n * design.\n */\nconst BAND_OPACITY = 0.94;\n\nconst MINIMUM_FONT_SIZE_IN_PIXELS = 18;\n\n/**\n * Floor on band height as a fraction of image HEIGHT.\n *\n * Height derived from the caption alone is too shallow on a tall frame: on a\n * 900x1600 phone it came to 68px and sliced through the status row it was meant\n * to cover, clipping the text mid-line. This floor makes the band deep enough to\n * swallow that row whole (120px on a 900x1600 phone), and is inert on a wide frame where the caption-derived\n * height is already the larger of the two.\n */\nconst MINIMUM_HEIGHT_RATIO = 0.075;\n\n/**\n * Margin held clear at EACH end of the caption, as a fraction of image width.\n *\n * A caption that ends a pixel inside the frame is legally un-clipped and still\n * looks wrong, so the room a caption is measured against is the frame less this\n * at both ends \u2014 48px each side on a 1200px frame.\n */\nconst SIDE_MARGIN_RATIO = 0.04;\n\n/**\n * Divisor that turns a span into its midpoint, for centering the caption.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * The caption's typeface and weight, in one place because the band and the\n * measurement canvas MUST draw with the same ones: a measurement taken in a\n * different face is not a measurement of the thing that ships.\n */\nconst FONT_FAMILY = 'Segoe UI, Helvetica, Arial, sans-serif';\n\nconst FONT_WEIGHT = '600';\n\nconst CAPTION_FILL = '#ffffff';\n\n/**\n * Upper bound on one glyph's advance width, as a multiple of the font size.\n *\n * It sizes the off-screen canvas the caption is measured on, and it only ever\n * needs to be an over-estimate: a canvas too narrow would clip the text being\n * measured, under-report its width, and reintroduce the exact silent clipping\n * the measurement exists to catch. No Latin glyph in a proportional sans\n * advances a full em \u2014 an em dash, the widest, is 1.0 \u2014 so 1.1 is headroom at\n * negligible cost (measured prose runs about 0.45 em per character, so the\n * canvas comes out roughly 2.5x the text).\n */\nconst MAXIMUM_GLYPH_ADVANCE_RATIO = 1.1;\n\n/**\n * Height of the measurement canvas as a multiple of the font size, so ascenders\n * and descenders have room and the trim reads the glyphs rather than the edge.\n */\nconst MEASUREMENT_CANVAS_HEIGHT_RATIO = 3;\n\n/**\n * How far a pixel may differ from the transparent surround before `trim` counts\n * it as text. Deliberately far lower than `sharp`'s default of 10: the outermost\n * pixels of an antialiased glyph are very faint, and the default discards them,\n * under-measuring a caption by a pixel or two at each end.\n */\nconst TRIM_THRESHOLD = 1;\n\n/**\n * Parameters for {@link buildCaptionTextElement}.\n */\ninterface CaptionTextElementParams {\n  readonly fontSizeInPixels: number;\n  readonly text: string;\n  readonly textAnchor: 'middle' | 'start';\n  readonly xInPixels: number;\n  readonly yInPixels: number;\n}\n\n/**\n * Builds the SVG for the caption band.\n *\n * @param text - The caption.\n * @param geometry - The band geometry.\n * @param imageWidthInPixels - Width of the image, so the band spans it.\n * @returns The SVG markup.\n */\nexport function buildLabelSvg(text: string, geometry: LabelBandGeometry, imageWidthInPixels: number): string {\n  const { fontSizeInPixels, heightInPixels } = geometry;\n  const captionElement = buildCaptionTextElement({\n    fontSizeInPixels,\n    text,\n    textAnchor: 'middle',\n    xInPixels: imageWidthInPixels / CENTER_DIVISOR,\n    yInPixels: heightInPixels / CENTER_DIVISOR\n  });\n\n  return `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${String(imageWidthInPixels)}\" height=\"${String(heightInPixels)}\">`\n    + `<rect x=\"0\" y=\"0\" width=\"${String(imageWidthInPixels)}\" height=\"${String(heightInPixels)}\" `\n    + `fill=\"#000000\" fill-opacity=\"${String(BAND_OPACITY)}\"/>`\n    + `${captionElement}</svg>`;\n}\n\n/**\n * Computes the caption band's size and position for a given image.\n *\n * @param params - The image dimensions.\n * @returns The band geometry.\n * @throws Error if either dimension is not a positive number.\n */\nexport function computeLabelBand(params: ComputeLabelBandParams): LabelBandGeometry {\n  const { imageHeightInPixels, imageWidthInPixels } = params;\n\n  if (!Number.isFinite(imageWidthInPixels) || imageWidthInPixels <= 0) {\n    throw new Error(`computeLabelBand: imageWidthInPixels must be a positive number, got ${String(imageWidthInPixels)}.`);\n  }\n\n  if (!Number.isFinite(imageHeightInPixels) || imageHeightInPixels <= 0) {\n    throw new Error(`computeLabelBand: imageHeightInPixels must be a positive number, got ${String(imageHeightInPixels)}.`);\n  }\n\n  const fontSizeInPixels = Math.max(MINIMUM_FONT_SIZE_IN_PIXELS, Math.round(imageWidthInPixels * FONT_SIZE_RATIO));\n  const captionHeightInPixels = Math.round(fontSizeInPixels * BAND_HEIGHT_RATIO);\n  const flooredHeightInPixels = Math.max(captionHeightInPixels, Math.round(imageHeightInPixels * MINIMUM_HEIGHT_RATIO));\n  const heightInPixels = Math.min(imageHeightInPixels, flooredHeightInPixels);\n  const sideMarginInPixels = Math.round(imageWidthInPixels * SIDE_MARGIN_RATIO);\n\n  return {\n    captionRoomInPixels: imageWidthInPixels - (sideMarginInPixels * CENTER_DIVISOR),\n    fontSizeInPixels,\n    heightInPixels,\n    topInPixels: imageHeightInPixels - heightInPixels\n  };\n}\n\n/**\n * Escapes text for inclusion in SVG character data.\n *\n * A caption is authored per screenshot and can legitimately contain `&` or the\n * angle brackets Obsidian uses in link syntax; unescaped, those make the SVG\n * impossible to parse and `sharp` fails on a caption rather than on an image.\n *\n * @param text - The raw caption.\n * @returns The caption, safe to embed in SVG.\n */\nexport function escapeSvgText(text: string): string {\n  return text\n    .replaceAll('&', '&amp;')\n    .replaceAll('<', '&lt;')\n    .replaceAll('>', '&gt;')\n    .replaceAll('\"', '&quot;')\n    .replaceAll('\\'', '&apos;');\n}\n\n/**\n * Draws a caption band across the bottom of a screenshot.\n *\n * The image keeps its dimensions exactly: the band is composited OVER the\n * frame, never appended to it, because the store expects a specific size.\n *\n * @param bytes - The captured PNG.\n * @param options - The caption.\n * @returns A {@link Promise} that resolves to the labeled PNG, the same size as the input.\n * @throws Error if `sharp` is not installed, the image dimensions cannot be read, or the caption is too wide for the frame.\n */\nexport async function labelScreenshot(bytes: Uint8Array, options: LabelScreenshotOptions): Promise<Uint8Array> {\n  const sharp = await importSharp('labelScreenshot');\n  const metadata = await sharp(bytes).metadata();\n  const imageWidthInPixels = metadata.width;\n  const imageHeightInPixels = metadata.height;\n\n  /* v8 ignore next 3 -- Defensive: `sharp` rejects a non-image before it can report metadata without dimensions, so this branch is unreachable from a test. */\n  if (imageWidthInPixels === undefined || imageHeightInPixels === undefined) {\n    throw new Error('labelScreenshot: could not read the source image dimensions.');\n  }\n\n  const geometry = computeLabelBand({ imageHeightInPixels, imageWidthInPixels });\n  const textWidthInPixels = await measureCaptionWidth(options.text, geometry.fontSizeInPixels);\n\n  if (textWidthInPixels > geometry.captionRoomInPixels) {\n    const overflowInPixels = textWidthInPixels - geometry.captionRoomInPixels;\n    throw new Error(\n      `labelScreenshot: the caption is ${String(overflowInPixels)}px too wide for the frame. `\n        + `It renders ${String(textWidthInPixels)}px at font-size ${String(geometry.fontSizeInPixels)}, and a `\n        + `${String(imageWidthInPixels)}px frame has room for ${String(geometry.captionRoomInPixels)}px. `\n        + 'Shorten it: a caption that does not fit is clipped at BOTH ends, with no ellipsis to show it happened. '\n        + `Caption: ${JSON.stringify(options.text)}`\n    );\n  }\n\n  const svg = buildLabelSvg(options.text, geometry, imageWidthInPixels);\n  const layer: SharpCompositeLayer = {\n    input: Buffer.from(svg),\n    left: 0,\n    top: geometry.topInPixels\n  };\n\n  const labeled = await sharp(bytes)\n    .composite([layer])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(labeled);\n}\n\n/**\n * Measures a caption against the frame it is destined for, without drawing\n * anything.\n *\n * This is what {@link labelScreenshot} rejects an overlong caption with, exposed\n * so a caption can be chosen with the number in hand instead of by capturing a\n * frame and looking at it.\n *\n * @param params - The caption and the dimensions of the image it is for.\n * @returns A {@link Promise} that resolves to the measurement.\n * @throws Error if `sharp` is not installed, or either dimension is not a positive number.\n */\nexport async function measureLabelCaption(params: MeasureLabelCaptionParams): Promise<LabelCaptionMeasurement> {\n  const { imageHeightInPixels, imageWidthInPixels, text } = params;\n  const geometry = computeLabelBand({ imageHeightInPixels, imageWidthInPixels });\n  const textWidthInPixels = await measureCaptionWidth(text, geometry.fontSizeInPixels);\n\n  return {\n    captionRoomInPixels: geometry.captionRoomInPixels,\n    doesFit: textWidthInPixels <= geometry.captionRoomInPixels,\n    textWidthInPixels\n  };\n}\n\n/**\n * Builds the caption's SVG `<text>` element.\n *\n * Both the band and the measurement canvas go through here, so the thing that\n * is measured is drawn with the same face, weight and size as the thing that\n * ships. Two hand-written copies would be free to drift, and a measurement that\n * has drifted from the drawing is worse than no measurement at all.\n *\n * @param params - The caption, its size, and where to anchor it.\n * @returns The `<text>` markup.\n */\nfunction buildCaptionTextElement(params: CaptionTextElementParams): string {\n  const { fontSizeInPixels, text, textAnchor, xInPixels, yInPixels } = params;\n\n  return `<text x=\"${String(xInPixels)}\" y=\"${String(yInPixels)}\" `\n    + `font-family=\"${FONT_FAMILY}\" font-size=\"${String(fontSizeInPixels)}\" `\n    + `font-weight=\"${FONT_WEIGHT}\" fill=\"${CAPTION_FILL}\" text-anchor=\"${textAnchor}\" dominant-baseline=\"central\">`\n    + `${escapeSvgText(text)}</text>`;\n}\n\n/**\n * Measures how wide a caption renders at a given size.\n *\n * The text is drawn alone on a transparent canvas deliberately wider than it can\n * possibly need, then `trim`med back to its own ink \u2014 the same measurement that\n * was previously done by hand, once, per caption, by whoever thought to doubt\n * one. The renderer doing the measuring is the renderer that draws the band, so\n * the two cannot disagree about a font the host does or does not have.\n *\n * @param text - The caption.\n * @param fontSizeInPixels - The size the band would draw it at.\n * @returns A {@link Promise} that resolves to the rendered width in pixels.\n */\nasync function measureCaptionWidth(text: string, fontSizeInPixels: number): Promise<number> {\n  // A caption with no ink leaves the canvas uniformly transparent, and `trim`\n  // returns such an image untouched \u2014 i.e. reports the whole canvas as text.\n  if (text.trim() === '') {\n    return 0;\n  }\n\n  const sharp = await importSharp('measureLabelCaption');\n  const paddingInPixels = fontSizeInPixels * CENTER_DIVISOR;\n  const canvasWidthInPixels = Math.ceil(fontSizeInPixels * MAXIMUM_GLYPH_ADVANCE_RATIO * text.length) + paddingInPixels;\n  const canvasHeightInPixels = Math.ceil(fontSizeInPixels * MEASUREMENT_CANVAS_HEIGHT_RATIO);\n  const captionElement = buildCaptionTextElement({\n    fontSizeInPixels,\n    text,\n    textAnchor: 'start',\n    xInPixels: fontSizeInPixels,\n    yInPixels: canvasHeightInPixels / CENTER_DIVISOR\n  });\n  const svg = `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${String(canvasWidthInPixels)}\" height=\"${String(canvasHeightInPixels)}\">`\n    + `${captionElement}</svg>`;\n\n  const trimmed = await sharp(new Uint8Array(Buffer.from(svg)))\n    .trim({ threshold: TRIM_THRESHOLD })\n    .png()\n    .toBuffer();\n\n  return readPngDimensions(new Uint8Array(trimmed)).widthInPixels;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/label-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Adds a caption band to an already-captured screenshot.\n *\n * A store listing shows screenshots ONE AT A TIME, in a carousel, with no\n * caption of its own \u2014 so an image has to say what it is showing. Without that,\n * a shot of the state a plugin removes reads as a shot of the state the plugin\n * causes, which is the opposite of the message.\n *\n * The band is drawn over the BOTTOM of the frame, for two reasons: the top is\n * where the content being demonstrated usually starts, and the bottom of an\n * Obsidian frame is chrome \u2014 status bar, word count, sync indicator \u2014 which the\n * band then covers rather than competing with.\n *\n * This is post-processing, deliberately. The capture stays an untouched device\n * frame, and rewording a label needs no re-shoot.\n *\n * A caption that is too long for its frame is MEASURED and rejected rather than\n * drawn. An SVG `<text>` is clipped by its viewport at both ends with no\n * ellipsis and no error, so an overlong caption ships as a sentence fragment\n * that looks deliberate \u2014 `nabled in Settings - a listening plugin is told` \u2014\n * and the frame is still exactly the size it should be, so every dimension\n * assertion downstream still passes. The only feedback anyone ever got was\n * looking at the PNG. See {@link measureLabelCaption}.\n */\n\nimport type { SharpCompositeLayer } from './sharp-loader.mjs';\n\nimport { readPngDimensions } from './capture-screenshot.mjs';\nimport { importSharp } from './sharp-loader.mjs';\n\n/**\n * Parameters for {@link computeLabelBand}.\n */\nexport interface ComputeLabelBandParams {\n  /**\n   * Height of the image being labeled, in pixels.\n   */\n  readonly imageHeightInPixels: number;\n\n  /**\n   * Width of the image being labeled, in pixels.\n   */\n  readonly imageWidthInPixels: number;\n}\n\n/**\n * The geometry of the caption band.\n */\nexport interface LabelBandGeometry {\n  /**\n   * How much horizontal room the caption has, in pixels: the image width less\n   * the margin held clear at each end, so a caption that fits does not read as\n   * though it were about to touch the edge of the frame.\n   */\n  readonly captionRoomInPixels: number;\n\n  /**\n   * Font size for the caption, in pixels.\n   */\n  readonly fontSizeInPixels: number;\n\n  /**\n   * Height of the band, in pixels.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * Distance from the top of the image to the top of the band, in pixels.\n   */\n  readonly topInPixels: number;\n}\n\n/**\n * What a caption measures against the frame it is destined for.\n */\nexport interface LabelCaptionMeasurement {\n  /**\n   * The room available, in pixels \u2014 {@link LabelBandGeometry.captionRoomInPixels}.\n   */\n  readonly captionRoomInPixels: number;\n\n  /**\n   * Whether the caption fits that room.\n   */\n  readonly doesFit: boolean;\n\n  /**\n   * How wide the caption actually renders, in pixels, at the size the band\n   * would draw it.\n   */\n  readonly textWidthInPixels: number;\n}\n\n/**\n * Options for {@link labelScreenshot}.\n */\nexport interface LabelScreenshotOptions {\n  /**\n   * The caption. Keep it to a handful of words: it is read at listing-thumbnail\n   * size, and it is neither wrapped nor shrunk to fit \u2014 one that does not fit\n   * is REJECTED, with the measured width and the room available. Check a\n   * candidate with {@link measureLabelCaption} before committing to it.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link measureLabelCaption}.\n */\nexport interface MeasureLabelCaptionParams {\n  /**\n   * Height of the image the caption is destined for, in pixels.\n   */\n  readonly imageHeightInPixels: number;\n\n  /**\n   * Width of the image the caption is destined for, in pixels.\n   */\n  readonly imageWidthInPixels: number;\n\n  /**\n   * The caption to measure.\n   */\n  readonly text: string;\n}\n\n/**\n * Caption size as a fraction of image WIDTH, not height.\n *\n * Width is what governs legibility here: a 900x1600 phone frame and a 1200x800\n * desktop frame are read at similar on-screen widths in a listing, so sizing by\n * width keeps the caption visually consistent across the two.\n */\nconst FONT_SIZE_RATIO = 0.034;\n\n/**\n * Band height as a multiple of the font size \u2014 enough to sit the text on with\n * clear space above and below.\n */\nconst BAND_HEIGHT_RATIO = 2.2;\n\n/**\n * Opacity of the band. Fully opaque, and that is a decision rather than a\n * default: the band's job is to COVER the chrome along the bottom of the frame,\n * so nothing underneath it may reach the captured frame at all.\n *\n * It was 0.94, a value chosen only because 0.82 let a status bar legibly bleed\n * through behind the caption and look like a mistake rather than a design.\n * Nothing in that argued for 0.94 over full opacity. What 0.94 does is attenuate\n * whatever is under the band to about 6 % brightness \u2014 invisible to a reader,\n * and still 349 differing pixels to a diff, measured on a temporary vault's name\n * rendering under the band of a 1200x800 desktop frame. Any value below 1 holds\n * that channel open for every varying thing the bottom chrome can carry \u2014 a\n * clock, a word count, a sync indicator \u2014 on a frame nobody has captured yet.\n *\n * Written into the emitted SVG explicitly, even though 1 is what `fill-opacity`\n * defaults to. Dropping the attribute would leave this constant unused and take\n * the decision away with it: the band would then be opaque by accident of the\n * format rather than on purpose, with nothing named to read and nothing to\n * assert on.\n */\nconst BAND_OPACITY = 1;\n\nconst MINIMUM_FONT_SIZE_IN_PIXELS = 18;\n\n/**\n * Floor on band height as a fraction of image HEIGHT.\n *\n * Height derived from the caption alone is too shallow on a tall frame: on a\n * 900x1600 phone it came to 68px and sliced through the status row it was meant\n * to cover, clipping the text mid-line. This floor makes the band deep enough to\n * swallow that row whole (120px on a 900x1600 phone), and is inert on a wide frame where the caption-derived\n * height is already the larger of the two.\n */\nconst MINIMUM_HEIGHT_RATIO = 0.075;\n\n/**\n * Margin held clear at EACH end of the caption, as a fraction of image width.\n *\n * A caption that ends a pixel inside the frame is legally un-clipped and still\n * looks wrong, so the room a caption is measured against is the frame less this\n * at both ends \u2014 48px each side on a 1200px frame.\n */\nconst SIDE_MARGIN_RATIO = 0.04;\n\n/**\n * Divisor that turns a span into its midpoint, for centering the caption.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * The caption's typeface and weight, in one place because the band and the\n * measurement canvas MUST draw with the same ones: a measurement taken in a\n * different face is not a measurement of the thing that ships.\n */\nconst FONT_FAMILY = 'Segoe UI, Helvetica, Arial, sans-serif';\n\nconst FONT_WEIGHT = '600';\n\nconst CAPTION_FILL = '#ffffff';\n\n/**\n * Upper bound on one glyph's advance width, as a multiple of the font size.\n *\n * It sizes the off-screen canvas the caption is measured on, and it only ever\n * needs to be an over-estimate: a canvas too narrow would clip the text being\n * measured, under-report its width, and reintroduce the exact silent clipping\n * the measurement exists to catch. No Latin glyph in a proportional sans\n * advances a full em \u2014 an em dash, the widest, is 1.0 \u2014 so 1.1 is headroom at\n * negligible cost (measured prose runs about 0.45 em per character, so the\n * canvas comes out roughly 2.5x the text).\n */\nconst MAXIMUM_GLYPH_ADVANCE_RATIO = 1.1;\n\n/**\n * Height of the measurement canvas as a multiple of the font size, so ascenders\n * and descenders have room and the trim reads the glyphs rather than the edge.\n */\nconst MEASUREMENT_CANVAS_HEIGHT_RATIO = 3;\n\n/**\n * How far a pixel may differ from the transparent surround before `trim` counts\n * it as text. Deliberately far lower than `sharp`'s default of 10: the outermost\n * pixels of an antialiased glyph are very faint, and the default discards them,\n * under-measuring a caption by a pixel or two at each end.\n */\nconst TRIM_THRESHOLD = 1;\n\n/**\n * Parameters for {@link buildCaptionTextElement}.\n */\ninterface CaptionTextElementParams {\n  readonly fontSizeInPixels: number;\n  readonly text: string;\n  readonly textAnchor: 'middle' | 'start';\n  readonly xInPixels: number;\n  readonly yInPixels: number;\n}\n\n/**\n * Builds the SVG for the caption band.\n *\n * @param text - The caption.\n * @param geometry - The band geometry.\n * @param imageWidthInPixels - Width of the image, so the band spans it.\n * @returns The SVG markup.\n */\nexport function buildLabelSvg(text: string, geometry: LabelBandGeometry, imageWidthInPixels: number): string {\n  const { fontSizeInPixels, heightInPixels } = geometry;\n  const captionElement = buildCaptionTextElement({\n    fontSizeInPixels,\n    text,\n    textAnchor: 'middle',\n    xInPixels: imageWidthInPixels / CENTER_DIVISOR,\n    yInPixels: heightInPixels / CENTER_DIVISOR\n  });\n\n  return `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${String(imageWidthInPixels)}\" height=\"${String(heightInPixels)}\">`\n    + `<rect x=\"0\" y=\"0\" width=\"${String(imageWidthInPixels)}\" height=\"${String(heightInPixels)}\" `\n    + `fill=\"#000000\" fill-opacity=\"${String(BAND_OPACITY)}\"/>`\n    + `${captionElement}</svg>`;\n}\n\n/**\n * Computes the caption band's size and position for a given image.\n *\n * @param params - The image dimensions.\n * @returns The band geometry.\n * @throws Error if either dimension is not a positive number.\n */\nexport function computeLabelBand(params: ComputeLabelBandParams): LabelBandGeometry {\n  const { imageHeightInPixels, imageWidthInPixels } = params;\n\n  if (!Number.isFinite(imageWidthInPixels) || imageWidthInPixels <= 0) {\n    throw new Error(`computeLabelBand: imageWidthInPixels must be a positive number, got ${String(imageWidthInPixels)}.`);\n  }\n\n  if (!Number.isFinite(imageHeightInPixels) || imageHeightInPixels <= 0) {\n    throw new Error(`computeLabelBand: imageHeightInPixels must be a positive number, got ${String(imageHeightInPixels)}.`);\n  }\n\n  const fontSizeInPixels = Math.max(MINIMUM_FONT_SIZE_IN_PIXELS, Math.round(imageWidthInPixels * FONT_SIZE_RATIO));\n  const captionHeightInPixels = Math.round(fontSizeInPixels * BAND_HEIGHT_RATIO);\n  const flooredHeightInPixels = Math.max(captionHeightInPixels, Math.round(imageHeightInPixels * MINIMUM_HEIGHT_RATIO));\n  const heightInPixels = Math.min(imageHeightInPixels, flooredHeightInPixels);\n  const sideMarginInPixels = Math.round(imageWidthInPixels * SIDE_MARGIN_RATIO);\n\n  return {\n    captionRoomInPixels: imageWidthInPixels - (sideMarginInPixels * CENTER_DIVISOR),\n    fontSizeInPixels,\n    heightInPixels,\n    topInPixels: imageHeightInPixels - heightInPixels\n  };\n}\n\n/**\n * Escapes text for inclusion in SVG character data.\n *\n * A caption is authored per screenshot and can legitimately contain `&` or the\n * angle brackets Obsidian uses in link syntax; unescaped, those make the SVG\n * impossible to parse and `sharp` fails on a caption rather than on an image.\n *\n * @param text - The raw caption.\n * @returns The caption, safe to embed in SVG.\n */\nexport function escapeSvgText(text: string): string {\n  return text\n    .replaceAll('&', '&amp;')\n    .replaceAll('<', '&lt;')\n    .replaceAll('>', '&gt;')\n    .replaceAll('\"', '&quot;')\n    .replaceAll('\\'', '&apos;');\n}\n\n/**\n * Draws a caption band across the bottom of a screenshot.\n *\n * The image keeps its dimensions exactly: the band is composited OVER the\n * frame, never appended to it, because the store expects a specific size.\n *\n * @param bytes - The captured PNG.\n * @param options - The caption.\n * @returns A {@link Promise} that resolves to the labeled PNG, the same size as the input.\n * @throws Error if `sharp` is not installed, the image dimensions cannot be read, or the caption is too wide for the frame.\n */\nexport async function labelScreenshot(bytes: Uint8Array, options: LabelScreenshotOptions): Promise<Uint8Array> {\n  const sharp = await importSharp('labelScreenshot');\n  const metadata = await sharp(bytes).metadata();\n  const imageWidthInPixels = metadata.width;\n  const imageHeightInPixels = metadata.height;\n\n  /* v8 ignore next 3 -- Defensive: `sharp` rejects a non-image before it can report metadata without dimensions, so this branch is unreachable from a test. */\n  if (imageWidthInPixels === undefined || imageHeightInPixels === undefined) {\n    throw new Error('labelScreenshot: could not read the source image dimensions.');\n  }\n\n  const geometry = computeLabelBand({ imageHeightInPixels, imageWidthInPixels });\n  const textWidthInPixels = await measureCaptionWidth(options.text, geometry.fontSizeInPixels);\n\n  if (textWidthInPixels > geometry.captionRoomInPixels) {\n    const overflowInPixels = textWidthInPixels - geometry.captionRoomInPixels;\n    throw new Error(\n      `labelScreenshot: the caption is ${String(overflowInPixels)}px too wide for the frame. `\n        + `It renders ${String(textWidthInPixels)}px at font-size ${String(geometry.fontSizeInPixels)}, and a `\n        + `${String(imageWidthInPixels)}px frame has room for ${String(geometry.captionRoomInPixels)}px. `\n        + 'Shorten it: a caption that does not fit is clipped at BOTH ends, with no ellipsis to show it happened. '\n        + `Caption: ${JSON.stringify(options.text)}`\n    );\n  }\n\n  const svg = buildLabelSvg(options.text, geometry, imageWidthInPixels);\n  const layer: SharpCompositeLayer = {\n    input: Buffer.from(svg),\n    left: 0,\n    top: geometry.topInPixels\n  };\n\n  const labeled = await sharp(bytes)\n    .composite([layer])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(labeled);\n}\n\n/**\n * Measures a caption against the frame it is destined for, without drawing\n * anything.\n *\n * This is what {@link labelScreenshot} rejects an overlong caption with, exposed\n * so a caption can be chosen with the number in hand instead of by capturing a\n * frame and looking at it.\n *\n * @param params - The caption and the dimensions of the image it is for.\n * @returns A {@link Promise} that resolves to the measurement.\n * @throws Error if `sharp` is not installed, or either dimension is not a positive number.\n */\nexport async function measureLabelCaption(params: MeasureLabelCaptionParams): Promise<LabelCaptionMeasurement> {\n  const { imageHeightInPixels, imageWidthInPixels, text } = params;\n  const geometry = computeLabelBand({ imageHeightInPixels, imageWidthInPixels });\n  const textWidthInPixels = await measureCaptionWidth(text, geometry.fontSizeInPixels);\n\n  return {\n    captionRoomInPixels: geometry.captionRoomInPixels,\n    doesFit: textWidthInPixels <= geometry.captionRoomInPixels,\n    textWidthInPixels\n  };\n}\n\n/**\n * Builds the caption's SVG `<text>` element.\n *\n * Both the band and the measurement canvas go through here, so the thing that\n * is measured is drawn with the same face, weight and size as the thing that\n * ships. Two hand-written copies would be free to drift, and a measurement that\n * has drifted from the drawing is worse than no measurement at all.\n *\n * @param params - The caption, its size, and where to anchor it.\n * @returns The `<text>` markup.\n */\nfunction buildCaptionTextElement(params: CaptionTextElementParams): string {\n  const { fontSizeInPixels, text, textAnchor, xInPixels, yInPixels } = params;\n\n  return `<text x=\"${String(xInPixels)}\" y=\"${String(yInPixels)}\" `\n    + `font-family=\"${FONT_FAMILY}\" font-size=\"${String(fontSizeInPixels)}\" `\n    + `font-weight=\"${FONT_WEIGHT}\" fill=\"${CAPTION_FILL}\" text-anchor=\"${textAnchor}\" dominant-baseline=\"central\">`\n    + `${escapeSvgText(text)}</text>`;\n}\n\n/**\n * Measures how wide a caption renders at a given size.\n *\n * The text is drawn alone on a transparent canvas deliberately wider than it can\n * possibly need, then `trim`med back to its own ink \u2014 the same measurement that\n * was previously done by hand, once, per caption, by whoever thought to doubt\n * one. The renderer doing the measuring is the renderer that draws the band, so\n * the two cannot disagree about a font the host does or does not have.\n *\n * @param text - The caption.\n * @param fontSizeInPixels - The size the band would draw it at.\n * @returns A {@link Promise} that resolves to the rendered width in pixels.\n */\nasync function measureCaptionWidth(text: string, fontSizeInPixels: number): Promise<number> {\n  // A caption with no ink leaves the canvas uniformly transparent, and `trim`\n  // returns such an image untouched \u2014 i.e. reports the whole canvas as text.\n  if (text.trim() === '') {\n    return 0;\n  }\n\n  const sharp = await importSharp('measureLabelCaption');\n  const paddingInPixels = fontSizeInPixels * CENTER_DIVISOR;\n  const canvasWidthInPixels = Math.ceil(fontSizeInPixels * MAXIMUM_GLYPH_ADVANCE_RATIO * text.length) + paddingInPixels;\n  const canvasHeightInPixels = Math.ceil(fontSizeInPixels * MEASUREMENT_CANVAS_HEIGHT_RATIO);\n  const captionElement = buildCaptionTextElement({\n    fontSizeInPixels,\n    text,\n    textAnchor: 'start',\n    xInPixels: fontSizeInPixels,\n    yInPixels: canvasHeightInPixels / CENTER_DIVISOR\n  });\n  const svg = `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${String(canvasWidthInPixels)}\" height=\"${String(canvasHeightInPixels)}\">`\n    + `${captionElement}</svg>`;\n\n  const trimmed = await sharp(new Uint8Array(Buffer.from(svg)))\n    .trim({ threshold: TRIM_THRESHOLD })\n    .png()\n    .toBuffer();\n\n  return readPngDimensions(new Uint8Array(trimmed)).widthInPixels;\n}\n"],
  "mappings": "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",
  "names": []
}
