obsidian-integration-testing 14.0.0 → 15.0.0

package/dist/lib/esm/sharp-loader.d.mts

@@ -32,6 +32,7 @@ export interface SharpInstance {
     png: (this: void) => SharpInstance;
     resize: (this: void, width: number, height: number, options?: SharpResizeOptions) => SharpInstance;
     toBuffer: (this: void) => Promise<Buffer>;
+    trim: (this: void, options: SharpTrimOptions) => SharpInstance;
 }
 /**
  * The subset of `sharp`'s metadata the image helpers read.
@@ -46,6 +47,16 @@ export interface SharpMetadata {
 export interface SharpResizeOptions {
     readonly fit: 'cover' | 'fill';
 }
+/**
+ * The subset of `sharp`'s trim options the image helpers set.
+ */
+export interface SharpTrimOptions {
+    /**
+     * How far a pixel may differ from the trimmed-away color before it counts as
+     * content.
+     */
+    readonly threshold: number;
+}
 /**
  * Loads `sharp` on demand.
  *

package/dist/lib/esm/sharp-loader.mjs

@@ -13,4 +13,4 @@ async function importSharp(caller) {
 export {
   importSharp
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3NoYXJwLWxvYWRlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIExhemlseSBsb2FkcyBgc2hhcnBgLCB0aGUgT1BUSU9OQUwgcGVlciBkZXBlbmRlbmN5IHRoZSBpbWFnZSBoZWxwZXJzIG5lZWQsIGFuZFxuICogZGVzY3JpYmVzIHRoZSBzbGljZSBvZiBpdHMgc3VyZmFjZSB0aGV5IHVzZS5cbiAqXG4gKiBUaGUgbG9hZCBpcyBkZWZlcnJlZCBiZWNhdXNlIGEgc3RhdGljIGltcG9ydCB3b3VsZCBkcmFnIGBzaGFycGAnc1xuICogcGxhdGZvcm0tc3BlY2lmaWMgbmF0aXZlIGJpbmFyaWVzIGludG8gZXZlcnkgY29uc3VtZXIgb2YgdGhpcyBwYWNrYWdlJ3MgaW5kZXgsXG4gKiB3aGVuIG9ubHkgc2NyZWVuc2hvdCBwb3N0LXByb2Nlc3NpbmcgbmVlZHMgdGhlbS4gVGhlIHR5cGUgaXMgc3RydWN0dXJhbCBmb3JcbiAqIHRoZSBzYW1lIHJlYXNvbjogdGhpcyBtb2R1bGUgdHlwZS1jaGVja3Mgd2l0aG91dCBgc2hhcnBgJ3Mgb3duIHR5cGVzIGJlaW5nXG4gKiByZXNvbHZhYmxlLlxuICovXG5cbi8qKlxuICogQSBsYXllciBwYXNzZWQgdG8gYHNoYXJwYCdzIGBjb21wb3NpdGVgLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNoYXJwQ29tcG9zaXRlTGF5ZXIge1xuICByZWFkb25seSBpbnB1dDogQnVmZmVyO1xuICByZWFkb25seSBsZWZ0OiBudW1iZXI7XG4gIHJlYWRvbmx5IHRvcDogbnVtYmVyO1xufVxuXG4vKipcbiAqIFRoZSBgc2hhcnBgIGVudHJ5IHBvaW50IHRoZSBpbWFnZSBoZWxwZXJzIHVzZS5cbiAqL1xuZXhwb3J0IHR5cGUgU2hhcnBGYWN0b3J5ID0gKGlucHV0OiBVaW50OEFycmF5KSA9PiBTaGFycEluc3RhbmNlO1xuXG4vKipcbiAqIE9uZSBgc2hhcnBgIHBpcGVsaW5lLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNoYXJwSW5zdGFuY2Uge1xuICBibHVyOiAodGhpczogdm9pZCwgc2lnbWE6IG51bWJlcikgPT4gU2hhcnBJbnN0YW5jZTtcbiAgY29tcG9zaXRlOiAodGhpczogdm9pZCwgbGF5ZXJzOiBTaGFycENvbXBvc2l0ZUxheWVyW10pID0+IFNoYXJwSW5zdGFuY2U7XG4gIG1ldGFkYXRhOiAodGhpczogdm9pZCkgPT4gUHJvbWlzZTxTaGFycE1ldGFkYXRhPjtcbiAgcG5nOiAodGhpczogdm9pZCkgPT4gU2hhcnBJbnN0YW5jZTtcbiAgcmVzaXplOiAodGhpczogdm9pZCwgd2lkdGg6IG51bWJlciwgaGVpZ2h0OiBudW1iZXIsIG9wdGlvbnM/OiBTaGFycFJlc2l6ZU9wdGlvbnMpID0+IFNoYXJwSW5zdGFuY2U7XG4gIHRvQnVmZmVyOiAodGhpczogdm9pZCkgPT4gUHJvbWlzZTxCdWZmZXI+O1xuICB0cmltOiAodGhpczogdm9pZCwgb3B0aW9uczogU2hhcnBUcmltT3B0aW9ucykgPT4gU2hhcnBJbnN0YW5jZTtcbn1cblxuLyoqXG4gKiBUaGUgc3Vic2V0IG9mIGBzaGFycGAncyBtZXRhZGF0YSB0aGUgaW1hZ2UgaGVscGVycyByZWFkLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNoYXJwTWV0YWRhdGEge1xuICByZWFkb25seSBoZWlnaHQ/OiBudW1iZXIgfCB1bmRlZmluZWQ7XG4gIHJlYWRvbmx5IHdpZHRoPzogbnVtYmVyIHwgdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIFRoZSBzdWJzZXQgb2YgYHNoYXJwYCdzIHJlc2l6ZSBvcHRpb25zIHRoZSBpbWFnZSBoZWxwZXJzIHNldC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTaGFycFJlc2l6ZU9wdGlvbnMge1xuICByZWFkb25seSBmaXQ6ICdjb3ZlcicgfCAnZmlsbCc7XG59XG5cbi8qKlxuICogVGhlIHN1YnNldCBvZiBgc2hhcnBgJ3MgdHJpbSBvcHRpb25zIHRoZSBpbWFnZSBoZWxwZXJzIHNldC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTaGFycFRyaW1PcHRpb25zIHtcbiAgLyoqXG4gICAqIEhvdyBmYXIgYSBwaXhlbCBtYXkgZGlmZmVyIGZyb20gdGhlIHRyaW1tZWQtYXdheSBjb2xvciBiZWZvcmUgaXQgY291bnRzIGFzXG4gICAqIGNvbnRlbnQuXG4gICAqL1xuICByZWFkb25seSB0aHJlc2hvbGQ6IG51bWJlcjtcbn1cblxuLyoqXG4gKiBMb2FkcyBgc2hhcnBgIG9uIGRlbWFuZC5cbiAqXG4gKiBAcGFyYW0gY2FsbGVyIC0gTmFtZSBvZiB0aGUgY2FsbGluZyBoZWxwZXIsIHNvIHRoZSBlcnJvciBzYXlzIHdoaWNoIG9uZSBuZWVkcyBpdC5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gdGhlIGBzaGFycGAgZmFjdG9yeS5cbiAqIEB0aHJvd3MgRXJyb3IgbmFtaW5nIHRoZSBtaXNzaW5nIG9wdGlvbmFsIHBlZXIgZGVwZW5kZW5jeS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGltcG9ydFNoYXJwKGNhbGxlcjogc3RyaW5nKTogUHJvbWlzZTxTaGFycEZhY3Rvcnk+IHtcbiAgdHJ5IHtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tcmVzdHJpY3RlZC1zeW50YXggLS0gYHNoYXJwYCBpcyBhbiBPUFRJT05BTCBwZWVyLCBzbyBpdCBtdXN0IGJlIGxvYWRlZCBsYXppbHk6IGEgc3RhdGljIGltcG9ydCB3b3VsZCBkcmFnIGl0cyBuYXRpdmUgYmluYXJpZXMgaW50byBldmVyeSBjb25zdW1lciBvZiB0aGlzIHBhY2thZ2UncyBpbmRleC5cbiAgICBjb25zdCBzaGFycE1vZHVsZSA9IGF3YWl0IGltcG9ydCgnc2hhcnAnKTtcbiAgICBjb25zdCBmYWN0b3J5OiB1bmtub3duID0gc2hhcnBNb2R1bGUuZGVmYXVsdDtcbiAgICByZXR1cm4gZmFjdG9yeSBhcyBTaGFycEZhY3Rvcnk7XG4gIH0gY2F0Y2ggKGVycm9yOiB1bmtub3duKSB7XG4gICAgLyogdjggaWdub3JlIHN0YXJ0IC0tIFJlYWNoZWQgb25seSB3aGVuIHRoZSBvcHRpb25hbCBwZWVyIGlzIGFic2VudCwgd2hpY2ggaXQgbmV2ZXIgaXMgaW4gdGhpcyBwYWNrYWdlJ3Mgb3duIHRlc3QgcnVuLiAqL1xuICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgIGAke2NhbGxlcn0gbmVlZHMgdGhlIG9wdGlvbmFsIHBlZXIgZGVwZW5kZW5jeSBcInNoYXJwXCIuIGBcbiAgICAgICAgKyAnSW5zdGFsbCBpdCBpbiB0aGUgY29uc3VtaW5nIHByb2plY3QgKG5wbSBpIC1EIHNoYXJwKS4nLFxuICAgICAgeyBjYXVzZTogZXJyb3IgfVxuICAgICk7XG4gICAgLyogdjggaWdub3JlIHN0b3AgKi9cbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBeUVBLGVBQXNCLFlBQVksUUFBdUM7QUFDdkUsTUFBSTtBQUVGLFVBQU0sY0FBYyxNQUFNLE9BQU8sT0FBTztBQUN4QyxVQUFNLFVBQW1CLFlBQVk7QUFDckMsV0FBTztBQUFBLEVBQ1QsU0FBUyxPQUFnQjtBQUV2QixVQUFNLElBQUk7QUFBQSxNQUNSLEdBQUcsTUFBTTtBQUFBLE1BRVQsRUFBRSxPQUFPLE1BQU07QUFBQSxJQUNqQjtBQUFBLEVBRUY7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/soft-keyboard-geometry.mjs

@@ -8,11 +8,9 @@ function buildSoftKeyboardDiagnosticMessage(params) {
   const lines = [
     `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,
     `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,
-    `device: ${params.inputMethodState || "(no input_method state reported)"}`
+    `device: ${params.inputMethodState || "(no input_method state reported)"}`,
+    ...lift === 0 ? ["The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts."] : []
   ];
-  if (lift === 0) {
-    lines.push("The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts.");
-  }
   return lines.join("\n");
 }
 function checkIsSoftKeyboardUp(params) {
@@ -35,10 +33,7 @@ function resolveSoftKeyboardTapPoints(params) {
   const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);
   const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);
   const topOffsetInPixels = Math.round(screenY * devicePixelRatio);
-  if (topOffsetInPixels === 0) {
-    return [{ xInPixels, yInPixels: centerYInPixels }];
-  }
-  return [
+  return topOffsetInPixels === 0 ? [{ xInPixels, yInPixels: centerYInPixels }] : [
     { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },
     { xInPixels, yInPixels: centerYInPixels }
   ];
@@ -53,4 +48,4 @@ export {
   parseInputMethodState,
   resolveSoftKeyboardTapPoints
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * that the field *moves*, which is why the detection here is geometric rather\n * than an API call. Two runs failed on that before a framebuffer dump said so,\n * which is also why the diagnostic below exists.\n *\n * **The signal is a DELTA against a baseline read before the touch, not the\n * field's absolute offset from the bottom.** The absolute offset was the original\n * test and it is right only for a **bottom-anchored** field \u2014 a suggester, a\n * command palette \u2014 where \"clear of the bottom\" and \"lifted\" are the same\n * sentence. For a **centred modal** the condition is already true with no\n * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned\n * success having dispatched no touch (measured 2026-09-12 against a centred\n * prompt modal: the field's `top` read `352.4453125` before and after real taps\n * and the check said the keyboard was up both times). A delta is the same public\n * API for both shapes, and it costs a field that cannot move its verdict \u2014 see\n * {@link checkIsSoftKeyboardUp} for the one case that trades away.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The geometry read before the first touch, which is what the verdict is measured against.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The geometry read **before** the first touch, with the keyboard still down.\n   *\n   * Required, and deliberately not optional: an absent baseline could only mean falling back to the\n   * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge, read after the touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is\n * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of\n * its own, being the one reading that an already-up keyboard also produces.\n *\n * @param params - The evidence gathered before the first touch and after the last one.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;\n  const currentTop = params.snapshot.inputRect?.top ?? null;\n  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;\n\n  const lines = [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`\n  ];\n\n  if (lift === 0) {\n    lines.push('The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts.');\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Decides whether the IME is up, from how far the field moved.\n *\n * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least\n * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,\n * so a field that has not moved has had no keyboard arrive under it \u2014 whether it is a bottom-anchored\n * suggester or a centred modal.\n *\n * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was\n * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates\n * that from a centred modal with no keyboard \u2014 both read as \"clear of the bottom and not moving\" \u2014 and of\n * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than\n * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard\n * down, which is what `raiseSoftKeyboard` does.\n *\n * @param params - The geometry before and after the touch, and how far the field must have lifted.\n * @returns Whether the field lifted far enough to have made room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const baselineRect = params.baselineSnapshot.inputRect;\n  const { inputRect } = params.snapshot;\n  if (!baselineRect || !inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  if (topOffsetInPixels === 0) {\n    return [{ xInPixels, yInPixels: centerYInPixels }];\n  }\n\n  return [\n    { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n    { xInPixels, yInPixels: centerYInPixels }\n  ];\n}\n\n/**\n * Formats a measurement for the diagnostic, saying so rather than printing a number when there was none.\n *\n * @param value - The measurement, or `null` when the field was not on screen to measure.\n * @returns The number as text, or `(no input)`.\n */\nfunction formatMeasurement(value: null | number): string {\n  return value === null ? '(no input)' : String(value);\n}\n"],
  "mappings": "AAkKO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAKnC,MAAM,iBAAiB;AAahB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,cAAc,OAAO,iBAAiB,WAAW,OAAO;AAC9D,QAAM,aAAa,OAAO,SAAS,WAAW,OAAO;AACrD,QAAM,OAAO,gBAAgB,QAAQ,eAAe,OAAO,OAAO,cAAc;AAEhF,QAAM,QAAQ;AAAA,IACZ,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,qBAAqB,kBAAkB,WAAW,CAAC,aAAa,kBAAkB,UAAU,CAAC,SAAS,kBAAkB,IAAI,CAAC;AAAA,IACrL,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,EAC1E;AAEA,MAAI,SAAS,GAAG;AACd,UAAM,KAAK,uLAAkL;AAAA,EAC/L;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAoBO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,eAAe,OAAO,iBAAiB;AAC7C,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,gBAAgB,CAAC,WAAW;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,aAAa,MAAM,UAAU,MAAM;AAC5C;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,MAAI,sBAAsB,GAAG;AAC3B,WAAO,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC;AAAA,EACnD;AAEA,SAAO;AAAA,IACL,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACF;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * that the field *moves*, which is why the detection here is geometric rather\n * than an API call. Two runs failed on that before a framebuffer dump said so,\n * which is also why the diagnostic below exists.\n *\n * **The signal is a DELTA against a baseline read before the touch, not the\n * field's absolute offset from the bottom.** The absolute offset was the original\n * test and it is right only for a **bottom-anchored** field \u2014 a suggester, a\n * command palette \u2014 where \"clear of the bottom\" and \"lifted\" are the same\n * sentence. For a **centred modal** the condition is already true with no\n * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned\n * success having dispatched no touch (measured 2026-09-12 against a centred\n * prompt modal: the field's `top` read `352.4453125` before and after real taps\n * and the check said the keyboard was up both times). A delta is the same public\n * API for both shapes, and it costs a field that cannot move its verdict \u2014 see\n * {@link checkIsSoftKeyboardUp} for the one case that trades away.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The geometry read before the first touch, which is what the verdict is measured against.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The geometry read **before** the first touch, with the keyboard still down.\n   *\n   * Required, and deliberately not optional: an absent baseline could only mean falling back to the\n   * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge, read after the touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is\n * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of\n * its own, being the one reading that an already-up keyboard also produces.\n *\n * @param params - The evidence gathered before the first touch and after the last one.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;\n  const currentTop = params.snapshot.inputRect?.top ?? null;\n  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;\n\n  const lines = [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`,\n    ...(lift === 0 ? ['The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts.'] : [])\n  ];\n\n  return lines.join('\\n');\n}\n\n/**\n * Decides whether the IME is up, from how far the field moved.\n *\n * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least\n * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,\n * so a field that has not moved has had no keyboard arrive under it \u2014 whether it is a bottom-anchored\n * suggester or a centred modal.\n *\n * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was\n * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates\n * that from a centred modal with no keyboard \u2014 both read as \"clear of the bottom and not moving\" \u2014 and of\n * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than\n * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard\n * down, which is what `raiseSoftKeyboard` does.\n *\n * @param params - The geometry before and after the touch, and how far the field must have lifted.\n * @returns Whether the field lifted far enough to have made room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const baselineRect = params.baselineSnapshot.inputRect;\n  const { inputRect } = params.snapshot;\n  if (!baselineRect || !inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  return topOffsetInPixels === 0\n    ? [{ xInPixels, yInPixels: centerYInPixels }]\n    : [\n      { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n      { xInPixels, yInPixels: centerYInPixels }\n    ];\n}\n\n/**\n * Formats a measurement for the diagnostic, saying so rather than printing a number when there was none.\n *\n * @param value - The measurement, or `null` when the field was not on screen to measure.\n * @returns The number as text, or `(no input)`.\n */\nfunction formatMeasurement(value: null | number): string {\n  return value === null ? '(no input)' : String(value);\n}\n"],
  "mappings": "AAkKO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAKnC,MAAM,iBAAiB;AAahB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,cAAc,OAAO,iBAAiB,WAAW,OAAO;AAC9D,QAAM,aAAa,OAAO,SAAS,WAAW,OAAO;AACrD,QAAM,OAAO,gBAAgB,QAAQ,eAAe,OAAO,OAAO,cAAc;AAEhF,QAAM,QAAQ;AAAA,IACZ,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,qBAAqB,kBAAkB,WAAW,CAAC,aAAa,kBAAkB,UAAU,CAAC,SAAS,kBAAkB,IAAI,CAAC;AAAA,IACrL,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,IACxE,GAAI,SAAS,IAAI,CAAC,uLAAkL,IAAI,CAAC;AAAA,EAC3M;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAoBO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,eAAe,OAAO,iBAAiB;AAC7C,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,gBAAgB,CAAC,WAAW;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,aAAa,MAAM,UAAU,MAAM;AAC5C;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,SAAO,sBAAsB,IACzB,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC,IAC1C;AAAA,IACA,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACJ;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}


package/dist/lib/esm/stale-build-detection.d.mts

@@ -0,0 +1,108 @@
+/**
+ * @file
+ *
+ * Decides whether the `dist/` folder the global setup is about to install
+ * predates the sources it was built from, so a run cannot silently test an old
+ * plugin. See {@link StaleBuildError} for why this is an error rather than a
+ * warning.
+ *
+ * **What counts as a source.** Everything under `<projectRoot>/src/` that is not
+ * a test file, plus `manifest.json` and `styles.css` at the root when they exist.
+ * Test files are excluded because they are not build inputs — the bundler's entry
+ * graph starts at `src/main.ts` and never reaches a `*.test.ts` — and a guard
+ * that fires when editing a test, where rebuilding would change nothing, is a
+ * guard people learn to switch off. `package.json` is excluded for the same
+ * reason from the other side: it is edited for scripts and dependency ranges far
+ * more often than for anything that reaches the bundle, and the one field of it
+ * that ships is read back out of `manifest.json` anyway.
+ *
+ * **mtime, not content.** A `git switch` rewrites mtimes without changing
+ * content, so a branch switch can report a stale build against a `dist/` that
+ * would hash identically. That direction is deliberate: the remedy is a rebuild,
+ * which is what the reader wanted after switching branches anyway, and the
+ * alternative — hashing the entry graph — needs the bundler's own input list,
+ * which the harness does not have and cannot get from `main.js` in both the
+ * `dev` and `build` shapes.
+ */
+import type { ObsidianTransportOptions } from './transport-options.mjs';
+/**
+ * The environment variable that downgrades a stale-build failure to a warning
+ * for a single run.
+ *
+ * The {@link ObsidianTransportOptions.shouldFailOnStaleBuild} option cannot serve
+ * that case on its own: it lives in a tracked config file, so a one-off
+ * "test what is in `dist/` right now" run would need an edit and a revert — which
+ * is how a guard ends up switched off permanently by accident.
+ */
+export declare const ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME = "OBSIDIAN_TEST_ALLOW_STALE_BUILD";
+/**
+ * Parameters for {@link checkIsBuildStale}.
+ */
+export interface CheckIsBuildStaleParams {
+    /**
+    When `main.js` in the chosen dist folder was last written, in epoch milliseconds.
+     */
+    readonly buildModifiedAtInMilliseconds: number;
+    /**
+    The newest source found, or `undefined` when the project has none to compare against.
+     */
+    readonly newestSource: SourceModification | undefined;
+}
+/**
+ * One source file and when it last changed.
+ */
+export interface SourceModification {
+    /**
+    When the file was last written, in epoch milliseconds.
+     */
+    readonly modifiedAtInMilliseconds: number;
+    /**
+    The file's path relative to the project root, with `/` separators.
+     */
+    readonly path: string;
+}
+/**
+ * Decides whether a build predates its sources.
+ *
+ * `false` when there is no source to compare against: a project whose sources do
+ * not live under `src/` is not a project whose build is provably old, and
+ * claiming staleness there would fail every run of it.
+ *
+ * Strictly newer, so a source written in the same millisecond as the build — or
+ * by the build itself — is not stale.
+ *
+ * @param params - The build's modification time and the newest source.
+ * @returns `true` when the newest source is newer than the build.
+ */
+export declare function checkIsBuildStale(params: CheckIsBuildStaleParams): boolean;
+/**
+ * Whether a file name is one the build reads.
+ *
+ * @param fileName - The bare file name, without a directory.
+ * @returns `true` unless it is a test file.
+ */
+export declare function checkIsSourceFileName(fileName: string): boolean;
+/**
+ * Finds the most recently modified source of the plugin at `projectRoot`.
+ *
+ * Walks `src/` recursively and adds the root-level files the build also reads.
+ * Anything unreadable is skipped rather than thrown: a file that vanished
+ * mid-walk cannot make a build stale, and this check must never be the reason a
+ * run fails.
+ *
+ * @param projectRoot - The absolute path to the project root.
+ * @returns The newest source, or `undefined` when the project has none.
+ */
+export declare function findNewestSourceModification(projectRoot: string): Promise<SourceModification | undefined>;
+/**
+ * Resolves whether a stale build fails the run, applying the default when
+ * neither escape hatch is used.
+ *
+ * The environment variable wins over the option, because it is the narrower
+ * statement: a project that sets the option has decided permanently, while the
+ * variable is set for one command line.
+ *
+ * @param options - The transport options.
+ * @returns `true` when a stale build should throw.
+ */
+export declare function willFailOnStaleBuild(options: ObsidianTransportOptions | undefined): boolean;

package/dist/lib/esm/stale-build-detection.mjs

@@ -0,0 +1,84 @@
+import {
+  readdir,
+  stat
+} from "node:fs/promises";
+import {
+  join,
+  relative,
+  sep
+} from "node:path";
+import process from "node:process";
+const ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME = "OBSIDIAN_TEST_ALLOW_STALE_BUILD";
+const ROOT_SOURCE_FILE_NAMES = ["manifest.json", "styles.css"];
+const SOURCE_DIRECTORY_NAME = "src";
+const EXCLUDED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function checkIsBuildStale(params) {
+  const { buildModifiedAtInMilliseconds, newestSource } = params;
+  return newestSource ? newestSource.modifiedAtInMilliseconds > buildModifiedAtInMilliseconds : false;
+}
+function checkIsSourceFileName(fileName) {
+  return !fileName.includes(".test.");
+}
+async function findNewestSourceModification(projectRoot) {
+  const paths = [
+    ...await listSourcePaths(join(projectRoot, SOURCE_DIRECTORY_NAME)),
+    ...ROOT_SOURCE_FILE_NAMES.map((fileName) => join(projectRoot, fileName))
+  ];
+  let newestSource;
+  for (const path of paths) {
+    const modifiedAtInMilliseconds = await readModifiedAtInMilliseconds(path);
+    if (modifiedAtInMilliseconds === void 0 || newestSource && newestSource.modifiedAtInMilliseconds >= modifiedAtInMilliseconds) {
+      continue;
+    }
+    newestSource = {
+      modifiedAtInMilliseconds,
+      path: relative(projectRoot, path).split(sep).join("/")
+    };
+  }
+  return newestSource;
+}
+function willFailOnStaleBuild(options) {
+  return checkIsStaleBuildAllowedByEnvironment() ? false : options?.shouldFailOnStaleBuild ?? true;
+}
+function checkIsStaleBuildAllowedByEnvironment() {
+  const value = process.env[ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME]?.trim().toLowerCase() ?? "";
+  return value !== "" && value !== "0" && value !== "false";
+}
+async function listSourcePaths(directory) {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const paths = [];
+  for (const entry of entries) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!EXCLUDED_DIRECTORY_NAMES.has(entry.name)) {
+        paths.push(...await listSourcePaths(path));
+      }
+      continue;
+    }
+    if (checkIsSourceFileName(entry.name)) {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+async function readModifiedAtInMilliseconds(path) {
+  try {
+    const stats = await stat(path);
+    return stats.mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME,
+  checkIsBuildStale,
+  checkIsSourceFileName,
+  findNewestSourceModification,
+  willFailOnStaleBuild
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/stale-build-detection.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the `dist/` folder the global setup is about to install\n * predates the sources it was built from, so a run cannot silently test an old\n * plugin. See {@link StaleBuildError} for why this is an error rather than a\n * warning.\n *\n * **What counts as a source.** Everything under `<projectRoot>/src/` that is not\n * a test file, plus `manifest.json` and `styles.css` at the root when they exist.\n * Test files are excluded because they are not build inputs \u2014 the bundler's entry\n * graph starts at `src/main.ts` and never reaches a `*.test.ts` \u2014 and a guard\n * that fires when editing a test, where rebuilding would change nothing, is a\n * guard people learn to switch off. `package.json` is excluded for the same\n * reason from the other side: it is edited for scripts and dependency ranges far\n * more often than for anything that reaches the bundle, and the one field of it\n * that ships is read back out of `manifest.json` anyway.\n *\n * **mtime, not content.** A `git switch` rewrites mtimes without changing\n * content, so a branch switch can report a stale build against a `dist/` that\n * would hash identically. That direction is deliberate: the remedy is a rebuild,\n * which is what the reader wanted after switching branches anyway, and the\n * alternative \u2014 hashing the entry graph \u2014 needs the bundler's own input list,\n * which the harness does not have and cannot get from `main.js` in both the\n * `dev` and `build` shapes.\n */\n\nimport type { Dirent } from 'node:fs';\n\nimport {\n  readdir,\n  stat\n} from 'node:fs/promises';\nimport {\n  join,\n  relative,\n  sep\n} from 'node:path';\nimport process from 'node:process';\n\nimport type { ObsidianTransportOptions } from './transport-options.mjs';\n\n/**\n * The environment variable that downgrades a stale-build failure to a warning\n * for a single run.\n *\n * The {@link ObsidianTransportOptions.shouldFailOnStaleBuild} option cannot serve\n * that case on its own: it lives in a tracked config file, so a one-off\n * \"test what is in `dist/` right now\" run would need an edit and a revert \u2014 which\n * is how a guard ends up switched off permanently by accident.\n */\nexport const ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME = 'OBSIDIAN_TEST_ALLOW_STALE_BUILD';\n\n/**\n * Root-level files the plugin build reads besides `src/`.\n */\nconst ROOT_SOURCE_FILE_NAMES = ['manifest.json', 'styles.css'];\n\n/**\n * The directory holding the plugin's sources, relative to the project root.\n */\nconst SOURCE_DIRECTORY_NAME = 'src';\n\n/**\n * Directory names never descended into while looking for sources. Neither\n * belongs to a plugin's own `src/`, but both turn up in repos that vendor or\n * generate into it, and either would make the walk arbitrarily expensive.\n */\nconst EXCLUDED_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);\n\n/**\n * Parameters for {@link checkIsBuildStale}.\n */\nexport interface CheckIsBuildStaleParams {\n  /**\n  When `main.js` in the chosen dist folder was last written, in epoch milliseconds.\n   */\n  readonly buildModifiedAtInMilliseconds: number;\n\n  /**\n  The newest source found, or `undefined` when the project has none to compare against.\n   */\n  readonly newestSource: SourceModification | undefined;\n}\n\n/**\n * One source file and when it last changed.\n */\nexport interface SourceModification {\n  /**\n  When the file was last written, in epoch milliseconds.\n   */\n  readonly modifiedAtInMilliseconds: number;\n\n  /**\n  The file's path relative to the project root, with `/` separators.\n   */\n  readonly path: string;\n}\n\n/**\n * Decides whether a build predates its sources.\n *\n * `false` when there is no source to compare against: a project whose sources do\n * not live under `src/` is not a project whose build is provably old, and\n * claiming staleness there would fail every run of it.\n *\n * Strictly newer, so a source written in the same millisecond as the build \u2014 or\n * by the build itself \u2014 is not stale.\n *\n * @param params - The build's modification time and the newest source.\n * @returns `true` when the newest source is newer than the build.\n */\nexport function checkIsBuildStale(params: CheckIsBuildStaleParams): boolean {\n  const { buildModifiedAtInMilliseconds, newestSource } = params;\n  return newestSource ? newestSource.modifiedAtInMilliseconds > buildModifiedAtInMilliseconds : false;\n}\n\n/**\n * Whether a file name is one the build reads.\n *\n * @param fileName - The bare file name, without a directory.\n * @returns `true` unless it is a test file.\n */\nexport function checkIsSourceFileName(fileName: string): boolean {\n  return !fileName.includes('.test.');\n}\n\n/**\n * Finds the most recently modified source of the plugin at `projectRoot`.\n *\n * Walks `src/` recursively and adds the root-level files the build also reads.\n * Anything unreadable is skipped rather than thrown: a file that vanished\n * mid-walk cannot make a build stale, and this check must never be the reason a\n * run fails.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The newest source, or `undefined` when the project has none.\n */\nexport async function findNewestSourceModification(projectRoot: string): Promise<SourceModification | undefined> {\n  const paths = [\n    ...await listSourcePaths(join(projectRoot, SOURCE_DIRECTORY_NAME)),\n    ...ROOT_SOURCE_FILE_NAMES.map((fileName) => join(projectRoot, fileName))\n  ];\n\n  let newestSource: SourceModification | undefined;\n  for (const path of paths) {\n    const modifiedAtInMilliseconds = await readModifiedAtInMilliseconds(path);\n    if ((modifiedAtInMilliseconds === undefined) || (newestSource && newestSource.modifiedAtInMilliseconds >= modifiedAtInMilliseconds)) {\n      continue;\n    }\n\n    newestSource = {\n      modifiedAtInMilliseconds,\n      path: relative(projectRoot, path).split(sep).join('/')\n    };\n  }\n\n  return newestSource;\n}\n\n/**\n * Resolves whether a stale build fails the run, applying the default when\n * neither escape hatch is used.\n *\n * The environment variable wins over the option, because it is the narrower\n * statement: a project that sets the option has decided permanently, while the\n * variable is set for one command line.\n *\n * @param options - The transport options.\n * @returns `true` when a stale build should throw.\n */\nexport function willFailOnStaleBuild(options: ObsidianTransportOptions | undefined): boolean {\n  return checkIsStaleBuildAllowedByEnvironment() ? false : options?.shouldFailOnStaleBuild ?? true;\n}\n\n/**\n * Whether {@link ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME} is set to something\n * meaning \"yes\".\n *\n * An empty value and a literal `0` / `false` count as unset, so a `.env` line\n * left behind as `OBSIDIAN_TEST_ALLOW_STALE_BUILD=0` does not silently keep the\n * guard off.\n *\n * @returns `true` when the variable asks for the guard to be downgraded.\n */\nfunction checkIsStaleBuildAllowedByEnvironment(): boolean {\n  const value = process.env[ALLOW_STALE_BUILD_ENVIRONMENT_VARIABLE_NAME]?.trim().toLowerCase() ?? '';\n  return value !== '' && value !== '0' && value !== 'false';\n}\n\n/**\n * Lists every source file under a directory, recursively.\n *\n * A missing or unreadable directory yields nothing \u2014 a project whose sources are\n * elsewhere is not an error here.\n *\n * @param directory - The absolute path to walk.\n * @returns The absolute paths of the source files found.\n */\nasync function listSourcePaths(directory: string): Promise<string[]> {\n  let entries: Dirent[];\n  try {\n    entries = await readdir(directory, { withFileTypes: true });\n  } catch {\n    return [];\n  }\n\n  const paths: string[] = [];\n  for (const entry of entries) {\n    const path = join(directory, entry.name);\n    if (entry.isDirectory()) {\n      if (!EXCLUDED_DIRECTORY_NAMES.has(entry.name)) {\n        paths.push(...await listSourcePaths(path));\n      }\n\n      continue;\n    }\n\n    if (checkIsSourceFileName(entry.name)) {\n      paths.push(path);\n    }\n  }\n\n  return paths;\n}\n\n/**\n * Reads one file's modification time.\n *\n * @param path - The absolute path to stat.\n * @returns The epoch milliseconds, or `undefined` when the file is missing or unreadable.\n */\nasync function readModifiedAtInMilliseconds(path: string): Promise<number | undefined> {\n  try {\n    const stats = await stat(path);\n    return stats.mtimeMs;\n  } catch {\n    return undefined;\n  }\n}\n"],
  "mappings": "AA6BA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,OAAO,aAAa;AAab,MAAM,8CAA8C;AAK3D,MAAM,yBAAyB,CAAC,iBAAiB,YAAY;AAK7D,MAAM,wBAAwB;AAO9B,MAAM,2BAA2B,oBAAI,IAAI,CAAC,QAAQ,cAAc,CAAC;AA6C1D,SAAS,kBAAkB,QAA0C;AAC1E,QAAM,EAAE,+BAA+B,aAAa,IAAI;AACxD,SAAO,eAAe,aAAa,2BAA2B,gCAAgC;AAChG;AAQO,SAAS,sBAAsB,UAA2B;AAC/D,SAAO,CAAC,SAAS,SAAS,QAAQ;AACpC;AAaA,eAAsB,6BAA6B,aAA8D;AAC/G,QAAM,QAAQ;AAAA,IACZ,GAAG,MAAM,gBAAgB,KAAK,aAAa,qBAAqB,CAAC;AAAA,IACjE,GAAG,uBAAuB,IAAI,CAAC,aAAa,KAAK,aAAa,QAAQ,CAAC;AAAA,EACzE;AAEA,MAAI;AACJ,aAAW,QAAQ,OAAO;AACxB,UAAM,2BAA2B,MAAM,6BAA6B,IAAI;AACxE,QAAK,6BAA6B,UAAe,gBAAgB,aAAa,4BAA4B,0BAA2B;AACnI;AAAA,IACF;AAEA,mBAAe;AAAA,MACb;AAAA,MACA,MAAM,SAAS,aAAa,IAAI,EAAE,MAAM,GAAG,EAAE,KAAK,GAAG;AAAA,IACvD;AAAA,EACF;AAEA,SAAO;AACT;AAaO,SAAS,qBAAqB,SAAwD;AAC3F,SAAO,sCAAsC,IAAI,QAAQ,SAAS,0BAA0B;AAC9F;AAYA,SAAS,wCAAiD;AACxD,QAAM,QAAQ,QAAQ,IAAI,2CAA2C,GAAG,KAAK,EAAE,YAAY,KAAK;AAChG,SAAO,UAAU,MAAM,UAAU,OAAO,UAAU;AACpD;AAWA,eAAe,gBAAgB,WAAsC;AACnE,MAAI;AACJ,MAAI;AACF,cAAU,MAAM,QAAQ,WAAW,EAAE,eAAe,KAAK,CAAC;AAAA,EAC5D,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,QAAkB,CAAC;AACzB,aAAW,SAAS,SAAS;AAC3B,UAAM,OAAO,KAAK,WAAW,MAAM,IAAI;AACvC,QAAI,MAAM,YAAY,GAAG;AACvB,UAAI,CAAC,yBAAyB,IAAI,MAAM,IAAI,GAAG;AAC7C,cAAM,KAAK,GAAG,MAAM,gBAAgB,IAAI,CAAC;AAAA,MAC3C;AAEA;AAAA,IACF;AAEA,QAAI,sBAAsB,MAAM,IAAI,GAAG;AACrC,YAAM,KAAK,IAAI;AAAA,IACjB;AAAA,EACF;AAEA,SAAO;AACT;AAQA,eAAe,6BAA6B,MAA2C;AACrF,MAAI;AACF,UAAM,QAAQ,MAAM,KAAK,IAAI;AAC7B,WAAO,MAAM;AAAA,EACf,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
  "names": []
}


package/dist/lib/esm/stale-build-error.d.mts

@@ -0,0 +1,81 @@
+/**
+ * @file
+ *
+ * The distinct error thrown when the `dist/` the harness is about to install is
+ * **older than the sources it was built from** — the plugin in the vault is not
+ * the plugin in the working tree.
+ *
+ * The failure it prevents has two directions and the cheap one is not the reason
+ * this exists. A suite that FAILS against a stale build costs one confusing run:
+ * the symptom is whatever the missing code would have provided, so it reads as a
+ * defect in the code under test (observed 2026-09-19: a `waitUntil timed out: the
+ * enabled event to arrive` against a build five hours old, with the plugin
+ * loading and registering perfectly — it simply had no component to publish the
+ * event). A suite that PASSES against a stale build costs nothing visible and
+ * proves nothing: an integration suite exists to be the one test that can fail
+ * for the right reason, and a stale artifact silently converts it into a test of
+ * last week's code. Nothing at all reports that direction, which is why the
+ * verdict is an error rather than a warning.
+ *
+ * Exported so a consumer can `instanceof`-match this specific setup failure —
+ * the same reason `ConfigDirectoryFallbackError` is.
+ */
+/**
+ * Parameters for the {@link StaleBuildError} constructor.
+ */
+export interface StaleBuildErrorConstructorParams {
+    /**
+    When `main.js` in the chosen dist folder was last written, in epoch milliseconds.
+     */
+    readonly buildModifiedAtInMilliseconds: number;
+    /**
+    Absolute path to the dist folder the run was about to install from.
+     */
+    readonly distPath: string;
+    /**
+    When the newest source was last written, in epoch milliseconds.
+     */
+    readonly sourceModifiedAtInMilliseconds: number;
+    /**
+    Path to the newest source found, relative to the project root.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * Thrown by the global setup when the built plugin predates its sources.
+ *
+ * Carries both timestamps and the newest source's path, so the message names the
+ * file that makes the build stale rather than leaving the reader to find it.
+ */
+export declare class StaleBuildError extends Error {
+    /**
+    When `main.js` in the chosen dist folder was last written, in epoch milliseconds.
+     */
+    readonly buildModifiedAtInMilliseconds: number;
+    /**
+    Which build is stale and what outdated it, with **no remedy attached** — the opening of
+    {@link StaleBuildError.message}, and what the warning path logs when the failure is switched off. The two
+    readers need different halves: somebody whose run just FAILED needs the remedy, while somebody who
+    deliberately escaped the failure has already applied it, and repeating *"set `shouldFailOnStaleBuild:
+    false`"* at a reader who just did exactly that is the noise that teaches people to skim the line.
+     */
+    readonly description: string;
+    /**
+    Absolute path to the dist folder the run was about to install from.
+     */
+    readonly distPath: string;
+    /**
+    When the newest source was last written, in epoch milliseconds.
+     */
+    readonly sourceModifiedAtInMilliseconds: number;
+    /**
+    Path to the newest source found, relative to the project root.
+     */
+    readonly sourcePath: string;
+    /**
+     * Creates the error from the dist folder and the newest source that outdates it.
+     *
+     * @param params - The dist path, both modification times, and the newest source's path.
+     */
+    constructor(params: StaleBuildErrorConstructorParams);
+}

package/dist/lib/esm/stale-build-error.mjs

@@ -0,0 +1,50 @@
+const MINUTE_IN_MILLISECONDS = 6e4;
+class StaleBuildError extends Error {
+  /**
+  When `main.js` in the chosen dist folder was last written, in epoch milliseconds.
+   */
+  buildModifiedAtInMilliseconds;
+  /**
+  Which build is stale and what outdated it, with **no remedy attached** — the opening of
+  {@link StaleBuildError.message}, and what the warning path logs when the failure is switched off. The two
+  readers need different halves: somebody whose run just FAILED needs the remedy, while somebody who
+  deliberately escaped the failure has already applied it, and repeating *"set `shouldFailOnStaleBuild:
+  false`"* at a reader who just did exactly that is the noise that teaches people to skim the line.
+   */
+  description;
+  /**
+  Absolute path to the dist folder the run was about to install from.
+   */
+  distPath;
+  /**
+  When the newest source was last written, in epoch milliseconds.
+   */
+  sourceModifiedAtInMilliseconds;
+  /**
+  Path to the newest source found, relative to the project root.
+   */
+  sourcePath;
+  /**
+   * Creates the error from the dist folder and the newest source that outdates it.
+   *
+   * @param params - The dist path, both modification times, and the newest source's path.
+   */
+  constructor(params) {
+    const { buildModifiedAtInMilliseconds, distPath, sourceModifiedAtInMilliseconds, sourcePath } = params;
+    const ageInMinutes = Math.round((sourceModifiedAtInMilliseconds - buildModifiedAtInMilliseconds) / MINUTE_IN_MILLISECONDS);
+    const description = `The build is stale: ${distPath}/main.js was written at ${new Date(buildModifiedAtInMilliseconds).toISOString()}, but ${sourcePath} changed at ${new Date(sourceModifiedAtInMilliseconds).toISOString()} \u2014 ${String(ageInMinutes)} minute(s) later. The vault would be given a plugin built before that change, so this run tests code that is not in the working tree.`;
+    super(
+      `${description} Run \`npm run build\` (or \`npm run dev\`) and try again. To test the built artifact deliberately, set \`shouldFailOnStaleBuild: false\` in the transport options, or \`OBSIDIAN_TEST_ALLOW_STALE_BUILD=1\` for a single run.`
+    );
+    this.name = "StaleBuildError";
+    this.description = description;
+    this.buildModifiedAtInMilliseconds = buildModifiedAtInMilliseconds;
+    this.distPath = distPath;
+    this.sourceModifiedAtInMilliseconds = sourceModifiedAtInMilliseconds;
+    this.sourcePath = sourcePath;
+  }
+}
+export {
+  StaleBuildError
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/strict-proxy.mjs

@@ -11,10 +11,7 @@ function bypassStrictProxy(object) {
   if (!isObjectLike(object)) {
     return object;
   }
-  if (!(STRICT_PROXY_TARGET_SYMBOL in object)) {
-    return object;
-  }
-  return object[STRICT_PROXY_TARGET_SYMBOL];
+  return STRICT_PROXY_TARGET_SYMBOL in object ? object[STRICT_PROXY_TARGET_SYMBOL] : object;
 }
 function strictProxy(value, mockClass) {
   return wrapProxy(value, mockClass);
@@ -53,10 +50,7 @@ function wrapProxy(value, mockClass) {
       }
       if (mockPrototype && typeof property === "string" && property.endsWith("__") && property in mockPrototype) {
         const value_ = mockPrototype[property];
-        if (typeof value_ === "function") {
-          return value_.bind(receiver);
-        }
-        return value_;
+        return typeof value_ === "function" ? value_.bind(receiver) : value_;
       }
       if (typeof property === "symbol" || PASSTHROUGH_PROPS.has(property)) {
         return Reflect.get(target, property, receiver);
@@ -69,4 +63,4 @@ export {
   bypassStrictProxy,
   strictProxy
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/strict-proxy.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Strict proxy for mock objects.\n *\n * Wraps an object in a `Proxy` that throws a descriptive error when any\n * unmocked property is accessed, instead of silently returning `undefined`.\n *\n * - Idempotent (double-wrapping is a no-op).\n * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).\n * - Class-name-aware error messages for class instances.\n * - Recursive proxying of nested plain objects (for partial mocks only).\n *\n * Overloads:\n * 1. `strictProxy(value, MockClass)` \u2014 infers `T` from `MockClass.prototype`,\n *    overlays `__`-suffixed methods via the proxy.\n * 2. `strictProxy(value: T)` \u2014 infers `T` from the argument.\n * 3. `strictProxy<T>(partial)` \u2014 test mocking: typed via `PartialDeep<T>`.\n * 4. `strictProxy<T>(value)` \u2014 explicit `T`, unchecked value (cross-type cast).\n */\n\nimport type { PartialDeep } from 'type-fest';\n\nimport type { GenericObject } from './type-guards.mjs';\n\nimport { ensureGenericObject } from './type-guards.mjs';\n\nconst STRICT_PROXY_TARGET_SYMBOL = Symbol.for('strictProxyTarget');\n\nconst PASSTHROUGH_PROPS = new Set<string | symbol>([\n  Symbol.iterator,\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  'then',\n  'toJSON'\n]);\n\ntype MockClassLike<T> = MockClassPrototypeRef<T> & MockClassRef;\n\ninterface MockClassPrototypeRef<T> {\n  prototype: T;\n}\n\ninterface MockClassRef {\n  name: string;\n  prototype: object;\n}\n\n/**\n * Unwraps a strict-proxied object, returning the underlying target.\n *\n * Accessing unmocked properties on the returned object yields `undefined`\n * instead of throwing. Non-proxied values are returned as-is.\n *\n * @typeParam T - The type of the object.\n * @param object - The object to unwrap.\n * @returns The underlying target, or `object` if it is not a strict proxy.\n */\nexport function bypassStrictProxy<T>(object: T): T {\n  if (!isObjectLike(object)) {\n    return object;\n  }\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `in` is required, not a shorthand: `object` may be a strict proxy, and only `in` routes through its `has` trap. `Object.hasOwn` would ask the target for an own descriptor and miss the marker.\n  if (!(STRICT_PROXY_TARGET_SYMBOL in object)) {\n    return object;\n  }\n  return object[STRICT_PROXY_TARGET_SYMBOL] as T;\n}\n\n// eslint-disable-next-line @typescript-eslint/unified-signatures -- This overload infers T from mockClass; the `unknown` overload below requires explicit T. They cannot be combined.\nexport function strictProxy<T>(value: unknown, mockClass: MockClassLike<T>): T;\nexport function strictProxy<T extends object>(value: T): T;\nexport function strictProxy<T>(value: PartialDeep<T>): T;\n// eslint-disable-next-line @typescript-eslint/unified-signatures, @typescript-eslint/no-unnecessary-type-parameters -- PartialDeep<T> above gives type safety for partial mocks; this overload accepts an explicit T with an unchecked value for cross-type casts.\nexport function strictProxy<T>(value: unknown): T;\n/**\n * Wraps a mock object in a strict {@link Proxy} that throws on unmocked access.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object (or partial mock) to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\nexport function strictProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  return wrapProxy<T>(value, mockClass);\n}\n\n/**\n * Checks whether a value is a non-`null` object.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a non-`null` object.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Checks whether a value is a plain object (prototype is `Object.prototype`).\n *\n * @param value - The value to check.\n * @returns `true` if the value is a plain object.\n */\nfunction isPlainObject(value: unknown): value is GenericObject {\n  return value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;\n}\n\n/**\n * Implements the strict-proxy wrapping logic shared by all overloads.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T provides return-type inference at the call sites.\nfunction wrapProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  if (!isObjectLike(value)) {\n    return value as T;\n  }\n\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `in` is required, not a shorthand: `value` may already be a strict proxy, and only `in` routes through its `has` trap. `Object.hasOwn` would ask the target for an own descriptor and re-wrap an already-wrapped value.\n  if (STRICT_PROXY_TARGET_SYMBOL in value) {\n    return value as T;\n  }\n  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });\n\n  const isClass = !isPlainObject(value);\n  const className = mockClass?.name ?? (isClass ? value.constructor.name : '');\n  const mockPrototype = mockClass ? ensureGenericObject(mockClass.prototype) : null;\n  const proxiedChildren = isClass ? null : new Map<string | symbol>();\n\n  return new Proxy(value, {\n    get(target, property, receiver): unknown {\n      // 1. Own properties and prototype chain of the original object.\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- Walking the PROTOTYPE CHAIN is the point, as the comment above says: inherited methods must resolve through the proxy. `Object.hasOwn` would see only own properties and send every inherited member down the \"not mocked\" path.\n      if (property in target) {\n        if (proxiedChildren?.has(property)) {\n          return proxiedChildren.get(property);\n        }\n\n        const value_: unknown = Reflect.get(target, property, receiver);\n        if (proxiedChildren && isPlainObject(value_)) {\n          const result = wrapProxy<unknown>(value_);\n          proxiedChildren.set(property, result);\n          return result;\n        }\n        return value_;\n      }\n\n      // 2. Mock prototype chain (for __ methods on the mock class).\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- Walking the mock's PROTOTYPE CHAIN is the point: a `__` method inherited from a mock base class has to resolve here, and `Object.hasOwn` would only see the leaf class's own members.\n      if (mockPrototype && typeof property === 'string' && property.endsWith('__') && property in mockPrototype) {\n        const value_: unknown = mockPrototype[property];\n        if (typeof value_ === 'function') {\n          return value_.bind(receiver);\n        }\n        return value_;\n      }\n\n      // 3. Passthrough props (symbols, then, toJSON, etc.).\n      if (typeof property === 'symbol' || PASSTHROUGH_PROPS.has(property)) {\n        return Reflect.get(target, property, receiver);\n      }\n\n      throw new Error(`Property \"${property}\" is not mocked in ${className}. To override, assign a value first: mock.${property} = ...`);\n    }\n  }) as T;\n}\n"],
  "mappings": "AAyBA,SAAS,2BAA2B;AAEpC,MAAM,6BAA6B,uBAAO,IAAI,mBAAmB;AAEjE,MAAM,oBAAoB,oBAAI,IAAqB;AAAA,EACjD,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP;AAAA,EACA;AACF,CAAC;AAuBM,SAAS,kBAAqB,QAAc;AACjD,MAAI,CAAC,aAAa,MAAM,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,8BAA8B,SAAS;AAC3C,WAAO;AAAA,EACT;AACA,SAAO,OAAO,0BAA0B;AAC1C;AAgBO,SAAS,YAAe,OAAgB,WAA6B;AAC1E,SAAO,UAAa,OAAO,SAAS;AACtC;AAQA,SAAS,aAAa,OAAiC;AACrD,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AAQA,SAAS,cAAc,OAAwC;AAC7D,SAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO;AAChG;AAWA,SAAS,UAAa,OAAgB,WAA6B;AACjE,MAAI,CAAC,aAAa,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAGA,MAAI,8BAA8B,OAAO;AACvC,WAAO;AAAA,EACT;AACA,SAAO,eAAe,OAAO,4BAA4B,EAAE,MAAM,CAAC;AAElE,QAAM,UAAU,CAAC,cAAc,KAAK;AACpC,QAAM,YAAY,WAAW,SAAS,UAAU,MAAM,YAAY,OAAO;AACzE,QAAM,gBAAgB,YAAY,oBAAoB,UAAU,SAAS,IAAI;AAC7E,QAAM,kBAAkB,UAAU,OAAO,oBAAI,IAAqB;AAElE,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,UAAU,UAAmB;AAGvC,UAAI,YAAY,QAAQ;AACtB,YAAI,iBAAiB,IAAI,QAAQ,GAAG;AAClC,iBAAO,gBAAgB,IAAI,QAAQ;AAAA,QACrC;AAEA,cAAM,SAAkB,QAAQ,IAAI,QAAQ,UAAU,QAAQ;AAC9D,YAAI,mBAAmB,cAAc,MAAM,GAAG;AAC5C,gBAAM,SAAS,UAAmB,MAAM;AACxC,0BAAgB,IAAI,UAAU,MAAM;AACpC,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAIA,UAAI,iBAAiB,OAAO,aAAa,YAAY,SAAS,SAAS,IAAI,KAAK,YAAY,eAAe;AACzG,cAAM,SAAkB,cAAc,QAAQ;AAC9C,YAAI,OAAO,WAAW,YAAY;AAChC,iBAAO,OAAO,KAAK,QAAQ;AAAA,QAC7B;AACA,eAAO;AAAA,MACT;AAGA,UAAI,OAAO,aAAa,YAAY,kBAAkB,IAAI,QAAQ,GAAG;AACnE,eAAO,QAAQ,IAAI,QAAQ,UAAU,QAAQ;AAAA,MAC/C;AAEA,YAAM,IAAI,MAAM,aAAa,QAAQ,sBAAsB,SAAS,6CAA6C,QAAQ,QAAQ;AAAA,IACnI;AAAA,EACF,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/strict-proxy.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Strict proxy for mock objects.\n *\n * Wraps an object in a `Proxy` that throws a descriptive error when any\n * unmocked property is accessed, instead of silently returning `undefined`.\n *\n * - Idempotent (double-wrapping is a no-op).\n * - Passthrough for well-known props (`then`, `toJSON`, `Symbol.iterator`, etc.).\n * - Class-name-aware error messages for class instances.\n * - Recursive proxying of nested plain objects (for partial mocks only).\n *\n * Overloads:\n * 1. `strictProxy(value, MockClass)` \u2014 infers `T` from `MockClass.prototype`,\n *    overlays `__`-suffixed methods via the proxy.\n * 2. `strictProxy(value: T)` \u2014 infers `T` from the argument.\n * 3. `strictProxy<T>(partial)` \u2014 test mocking: typed via `PartialDeep<T>`.\n * 4. `strictProxy<T>(value)` \u2014 explicit `T`, unchecked value (cross-type cast).\n */\n\nimport type { PartialDeep } from 'type-fest';\n\nimport type { GenericObject } from './type-guards.mjs';\n\nimport { ensureGenericObject } from './type-guards.mjs';\n\nconst STRICT_PROXY_TARGET_SYMBOL = Symbol.for('strictProxyTarget');\n\nconst PASSTHROUGH_PROPS = new Set<string | symbol>([\n  Symbol.iterator,\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  'then',\n  'toJSON'\n]);\n\ntype MockClassLike<T> = MockClassPrototypeRef<T> & MockClassRef;\n\ninterface MockClassPrototypeRef<T> {\n  prototype: T;\n}\n\ninterface MockClassRef {\n  name: string;\n  prototype: object;\n}\n\n/**\n * Unwraps a strict-proxied object, returning the underlying target.\n *\n * Accessing unmocked properties on the returned object yields `undefined`\n * instead of throwing. Non-proxied values are returned as-is.\n *\n * @typeParam T - The type of the object.\n * @param object - The object to unwrap.\n * @returns The underlying target, or `object` if it is not a strict proxy.\n */\nexport function bypassStrictProxy<T>(object: T): T {\n  if (!isObjectLike(object)) {\n    return object;\n  }\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `in` is required, not a shorthand: `object` may be a strict proxy, and only `in` routes through its `has` trap. `Object.hasOwn` would ask the target for an own descriptor and miss the marker.\n  return (STRICT_PROXY_TARGET_SYMBOL in object) ? (object[STRICT_PROXY_TARGET_SYMBOL] as T) : object;\n}\n\n// eslint-disable-next-line @typescript-eslint/unified-signatures -- This overload infers T from mockClass; the `unknown` overload below requires explicit T. They cannot be combined.\nexport function strictProxy<T>(value: unknown, mockClass: MockClassLike<T>): T;\nexport function strictProxy<T extends object>(value: T): T;\nexport function strictProxy<T>(value: PartialDeep<T>): T;\n// eslint-disable-next-line @typescript-eslint/unified-signatures, @typescript-eslint/no-unnecessary-type-parameters -- PartialDeep<T> above gives type safety for partial mocks; this overload accepts an explicit T with an unchecked value for cross-type casts.\nexport function strictProxy<T>(value: unknown): T;\n/**\n * Wraps a mock object in a strict {@link Proxy} that throws on unmocked access.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object (or partial mock) to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\nexport function strictProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  return wrapProxy<T>(value, mockClass);\n}\n\n/**\n * Checks whether a value is a non-`null` object.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a non-`null` object.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return value !== null && typeof value === 'object';\n}\n\n/**\n * Checks whether a value is a plain object (prototype is `Object.prototype`).\n *\n * @param value - The value to check.\n * @returns `true` if the value is a plain object.\n */\nfunction isPlainObject(value: unknown): value is GenericObject {\n  return value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;\n}\n\n/**\n * Implements the strict-proxy wrapping logic shared by all overloads.\n *\n * @typeParam T - The type the proxy presents.\n * @param value - The object to wrap.\n * @param mockClass - Optional mock class providing `__`-suffixed overlay methods.\n * @returns The wrapped value typed as `T`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T provides return-type inference at the call sites.\nfunction wrapProxy<T>(value: unknown, mockClass?: MockClassRef): T {\n  if (!isObjectLike(value)) {\n    return value as T;\n  }\n\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `in` is required, not a shorthand: `value` may already be a strict proxy, and only `in` routes through its `has` trap. `Object.hasOwn` would ask the target for an own descriptor and re-wrap an already-wrapped value.\n  if (STRICT_PROXY_TARGET_SYMBOL in value) {\n    return value as T;\n  }\n  Object.defineProperty(value, STRICT_PROXY_TARGET_SYMBOL, { value });\n\n  const isClass = !isPlainObject(value);\n  const className = mockClass?.name ?? (isClass ? value.constructor.name : '');\n  const mockPrototype = mockClass ? ensureGenericObject(mockClass.prototype) : null;\n  const proxiedChildren = isClass ? null : new Map<string | symbol>();\n\n  return new Proxy(value, {\n    get(target, property, receiver): unknown {\n      // 1. Own properties and prototype chain of the original object.\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- Walking the PROTOTYPE CHAIN is the point, as the comment above says: inherited methods must resolve through the proxy. `Object.hasOwn` would see only own properties and send every inherited member down the \"not mocked\" path.\n      if (property in target) {\n        if (proxiedChildren?.has(property)) {\n          return proxiedChildren.get(property);\n        }\n\n        const value_: unknown = Reflect.get(target, property, receiver);\n        if (proxiedChildren && isPlainObject(value_)) {\n          const result = wrapProxy<unknown>(value_);\n          proxiedChildren.set(property, result);\n          return result;\n        }\n        return value_;\n      }\n\n      // 2. Mock prototype chain (for __ methods on the mock class).\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- Walking the mock's PROTOTYPE CHAIN is the point: a `__` method inherited from a mock base class has to resolve here, and `Object.hasOwn` would only see the leaf class's own members.\n      if (mockPrototype && typeof property === 'string' && property.endsWith('__') && property in mockPrototype) {\n        const value_: unknown = mockPrototype[property];\n        return typeof value_ === 'function' ? value_.bind(receiver) : value_;\n      }\n\n      // 3. Passthrough props (symbols, then, toJSON, etc.).\n      if (typeof property === 'symbol' || PASSTHROUGH_PROPS.has(property)) {\n        return Reflect.get(target, property, receiver);\n      }\n\n      throw new Error(`Property \"${property}\" is not mocked in ${className}. To override, assign a value first: mock.${property} = ...`);\n    }\n  }) as T;\n}\n"],
  "mappings": "AAyBA,SAAS,2BAA2B;AAEpC,MAAM,6BAA6B,uBAAO,IAAI,mBAAmB;AAEjE,MAAM,oBAAoB,oBAAI,IAAqB;AAAA,EACjD,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP;AAAA,EACA;AACF,CAAC;AAuBM,SAAS,kBAAqB,QAAc;AACjD,MAAI,CAAC,aAAa,MAAM,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,SAAQ,8BAA8B,SAAW,OAAO,0BAA0B,IAAU;AAC9F;AAgBO,SAAS,YAAe,OAAgB,WAA6B;AAC1E,SAAO,UAAa,OAAO,SAAS;AACtC;AAQA,SAAS,aAAa,OAAiC;AACrD,SAAO,UAAU,QAAQ,OAAO,UAAU;AAC5C;AAQA,SAAS,cAAc,OAAwC;AAC7D,SAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO;AAChG;AAWA,SAAS,UAAa,OAAgB,WAA6B;AACjE,MAAI,CAAC,aAAa,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAGA,MAAI,8BAA8B,OAAO;AACvC,WAAO;AAAA,EACT;AACA,SAAO,eAAe,OAAO,4BAA4B,EAAE,MAAM,CAAC;AAElE,QAAM,UAAU,CAAC,cAAc,KAAK;AACpC,QAAM,YAAY,WAAW,SAAS,UAAU,MAAM,YAAY,OAAO;AACzE,QAAM,gBAAgB,YAAY,oBAAoB,UAAU,SAAS,IAAI;AAC7E,QAAM,kBAAkB,UAAU,OAAO,oBAAI,IAAqB;AAElE,SAAO,IAAI,MAAM,OAAO;AAAA,IACtB,IAAI,QAAQ,UAAU,UAAmB;AAGvC,UAAI,YAAY,QAAQ;AACtB,YAAI,iBAAiB,IAAI,QAAQ,GAAG;AAClC,iBAAO,gBAAgB,IAAI,QAAQ;AAAA,QACrC;AAEA,cAAM,SAAkB,QAAQ,IAAI,QAAQ,UAAU,QAAQ;AAC9D,YAAI,mBAAmB,cAAc,MAAM,GAAG;AAC5C,gBAAM,SAAS,UAAmB,MAAM;AACxC,0BAAgB,IAAI,UAAU,MAAM;AACpC,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAIA,UAAI,iBAAiB,OAAO,aAAa,YAAY,SAAS,SAAS,IAAI,KAAK,YAAY,eAAe;AACzG,cAAM,SAAkB,cAAc,QAAQ;AAC9C,eAAO,OAAO,WAAW,aAAa,OAAO,KAAK,QAAQ,IAAI;AAAA,MAChE;AAGA,UAAI,OAAO,aAAa,YAAY,kBAAkB,IAAI,QAAQ,GAAG;AACnE,eAAO,QAAQ,IAAI,QAAQ,UAAU,QAAQ;AAAA,MAC/C;AAEA,YAAM,IAAI,MAAM,aAAa,QAAQ,sBAAsB,SAAS,6CAA6C,QAAQ,QAAQ;AAAA,IACnI;AAAA,EACF,CAAC;AACH;",
  "names": []
}
