@deeeed/metamask-harness 0.47.4 → 0.49.0

package/library/actions/extension/performance/_navigation-memory.mjs

@@ -1,9 +1,40 @@
+// Runs navigation and idle memory measurements with forced GC, CDP metrics, and heap snapshots.
+// Checks configured growth bounds and writes diagnostic artifacts for failed measurements.
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
 const DEFAULT_SCREEN_TIMEOUT_MS = 15_000;
 const DEFAULT_SETTLE_MS = 1_500;
 const DEFAULT_GC_SETTLE_MS = 300;
 const DEFAULT_ACTION_TIMEOUT_MS = 400_000;
 const DEFAULT_ROUND_DURATION_MS = 10_000;
 
+export async function withMemoryFailureReport(input, measure) {
+  try {
+    return await measure();
+  } catch (error) {
+    if (!error?.memoryMeasurement) throw error;
+    const directory = await mkdtemp(path.join(input.context.artifactsDir, 'navigation-memory-'));
+    const report = path.join(directory, 'measurement.json');
+    await writeFile(report, `${JSON.stringify({
+      nodeId: input.context.nodeId,
+      action: input.action,
+      ...error.memoryMeasurement,
+    }, null, 2)}\n`, { mode: 0o600 });
+    await writeFile(input.outputPath, `${JSON.stringify({ artifacts: [{
+      path: path.relative(input.context.artifactsDir, report),
+      type: 'report',
+      nodeId: input.context.nodeId,
+      label: 'Failed memory measurement',
+      category: 'diagnostic',
+      mimeType: 'application/json',
+    }] })}\n`, { mode: 0o600 });
+    delete error.memoryMeasurement;
+    error.message += `\nNext: jq . ${JSON.stringify(report)}`;
+    throw error;
+  }
+}
+
 function finiteNumber(value, fallback, label) {
   const parsed = value ?? fallback;
   if (!Number.isFinite(parsed)) throw new Error(`${label} must be a finite number.`);
@@ -217,9 +248,9 @@ export async function measureNavigationSlope(page, options, bounds) {
     passed,
   };
   if (!passed.nodes || !passed.listeners) {
-    throw new Error(
+    throw Object.assign(new Error(
       `Navigation memory bounds exceeded: nodes ${slopes.nodes.toFixed(2)}/${bounds.maxNodesPerCycle} per cycle; listeners ${slopes.listeners.toFixed(2)}/${bounds.maxListenersPerCycle} per cycle.`,
-    );
+    ), { memoryMeasurement: result });
   }
   return result;
 }
@@ -282,9 +313,9 @@ export async function measureDetachedDom(page, options, maxDetachedGrowth) {
     passed: after - before <= maxDetachedGrowth,
   };
   if (!result.passed) {
-    throw new Error(
+    throw Object.assign(new Error(
       `Detached DOM bound exceeded: growth ${result.growth}/${maxDetachedGrowth} nodes.`,
-    );
+    ), { memoryMeasurement: result });
   }
   return result;
 }
@@ -333,9 +364,9 @@ export async function compareIdleNavigation(page, options, maxAttributableListen
     passed: attributableListenersPerCycle <= maxAttributableListenersPerCycle,
   };
   if (!result.passed) {
-    throw new Error(
+    throw Object.assign(new Error(
       `Idle-control bound exceeded: attributable listeners ${attributableListenersPerCycle.toFixed(2)}/${maxAttributableListenersPerCycle} per cycle (navigation ${navigation.slopes.listeners.toFixed(2)}, idle ${idleListenersPerCycle.toFixed(2)}).`,
-    );
+    ), { memoryMeasurement: result });
   }
   return result;
 }

package/library/actions/extension/performance/compare_idle_navigation_memory.mjs

@@ -1,12 +1,15 @@
+// Compares post-GC listener growth across equal-duration idle and navigation rounds against a configured bound.
+// Writes a diagnostic report when the measurement exceeds that bound.
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
   compareIdleNavigation,
   idleControlBound,
   navigationMemoryOptions,
+  withMemoryFailureReport,
 } from './_navigation-memory.mjs';
 
 runAdapter((input) =>
-  withExtensionPage(input, async (page) => ({
+  withMemoryFailureReport(input, () => withExtensionPage(input, async (page) => ({
     action: input.action,
     status: 'pass',
     ...(await compareIdleNavigation(
@@ -14,5 +17,5 @@ runAdapter((input) =>
       navigationMemoryOptions(input.node, 'rounds', 8),
       idleControlBound(input.node),
     )),
-  })),
+  }))),
 );

package/library/actions/extension/performance/measure_detached_dom.mjs

@@ -1,12 +1,15 @@
+// Checks detached-node growth between post-GC heap snapshots before and after repeated screen navigation.
+// Writes a diagnostic report when growth exceeds the configured bound.
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
   detachedDomBound,
   measureDetachedDom,
   navigationMemoryOptions,
+  withMemoryFailureReport,
 } from './_navigation-memory.mjs';
 
 runAdapter((input) =>
-  withExtensionPage(input, async (page) => ({
+  withMemoryFailureReport(input, () => withExtensionPage(input, async (page) => ({
     action: input.action,
     status: 'pass',
     ...(await measureDetachedDom(
@@ -14,5 +17,5 @@ runAdapter((input) =>
       navigationMemoryOptions(input.node, 'cycles', 5),
       detachedDomBound(input.node),
     )),
-  })),
+  }))),
 );

package/library/actions/extension/performance/measure_navigation_memory.mjs

@@ -1,12 +1,15 @@
+// Repeatedly navigates a screen and measures post-GC DOM-node, listener, and heap growth slopes.
+// Enforces node and listener slope bounds and writes a diagnostic report when either fails.
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
   measureNavigationSlope,
   navigationMemoryOptions,
   navigationSlopeBounds,
+  withMemoryFailureReport,
 } from './_navigation-memory.mjs';
 
 runAdapter((input) =>
-  withExtensionPage(input, async (page) => ({
+  withMemoryFailureReport(input, () => withExtensionPage(input, async (page) => ({
     action: input.action,
     status: 'pass',
     ...(await measureNavigationSlope(
@@ -14,5 +17,5 @@ runAdapter((input) =>
       navigationMemoryOptions(input.node),
       navigationSlopeBounds(input.node),
     )),
-  })),
+  }))),
 );

package/library/actions/extension/perps/assert_orders.mjs

@@ -1,3 +1,4 @@
+// Assert that explicitly selected Perps orders are present or absent in live order state.
 import { runAdapter } from '../platform/cdp.mjs';
 import { assertOrders } from './perps.mjs';
 

package/library/actions/extension/perps/assert_positions.mjs

@@ -1,3 +1,4 @@
+// Assert that explicitly selected Perps positions are present or absent in runtime position state.
 import { runAdapter } from '../platform/cdp.mjs';
 import { assertPositions } from './perps.mjs';
 

package/library/actions/extension/perps/assert_visible_consistency.mjs

@@ -1,3 +1,5 @@
+// Sample changing Perps UI values or check recent activity containment across filters.
+// Some modes navigate lists, select filters, or open watchlist market details.
 import { pathToFileURL } from 'node:url';
 
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
@@ -86,7 +88,8 @@ async function visiblePrice(page, surface, market) {
       if (!element) return false;
       const style = getComputedStyle(element);
       const rect = element.getBoundingClientRect();
-      return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+      return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0
+        && rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth;
     };
     const root = document.querySelector('[data-testid=${JSON.stringify(rootTestId)}]');
     const price = ${priceTestId
@@ -111,7 +114,8 @@ async function marketRows(page, maxItems) {
     if (testId.startsWith('market-row-ticker-') || /-(?:token-logo|asset-label)$/u.test(testId)) return false;
     const style = getComputedStyle(element);
     const rect = element.getBoundingClientRect();
-    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0
+        && rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth;
   }).slice(0, ${JSON.stringify(maxItems)}).map((element) => ({
     testId: String(element.getAttribute('data-testid') || '').slice(0, 500),
     label: String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500),
@@ -124,7 +128,8 @@ async function watchlistRows(page, maxItems) {
   ].filter((element) => {
     const style = getComputedStyle(element);
     const rect = element.getBoundingClientRect();
-    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0
+        && rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth;
   }).slice(0, ${JSON.stringify(maxItems)}).map((element) => ({
     testId: String(element.getAttribute('data-testid') || '').slice(0, 500),
     label: String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500),
@@ -138,6 +143,7 @@ function changedRows(first, last) {
     .map((entry) => entry.testId);
 }
 
+// Containment checks loaded full-list rows, including rows below the viewport.
 async function activityIds(page, maxItems) {
   const selector = '[data-testid^="transaction-card-"]';
   return page.evaluate(`[
@@ -155,7 +161,8 @@ async function recentActivityState(page, maxItems) {
       if (!element) return false;
       const style = getComputedStyle(element);
       const rect = element.getBoundingClientRect();
-      return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+      return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0
+        && rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth;
     };
     return {
       ids: [...document.querySelectorAll('[data-testid^="transaction-card-"]')]

package/library/actions/extension/perps/close_orders.mjs

@@ -1,3 +1,4 @@
+// Cancel selected Perps orders through guarded mutation helpers and verify their absence.
 import { runAdapter } from '../platform/cdp.mjs';
 import { assertOrders, closeOrders } from './perps.mjs';
 
@@ -5,5 +6,7 @@ runAdapter(async (input) => {
   const close = await closeOrders(input);
   if (close.proofPath === 'visible-product-controls') return close;
   const assertion = await assertOrders(input, false);
-  return { ...assertion, close };
+  return close.proofPath === 'accepted-order-status'
+    ? { ...assertion, ...close }
+    : { ...assertion, close };
 });

package/library/actions/extension/perps/close_positions.mjs

@@ -1,3 +1,4 @@
+// Verify selected Perps positions are already absent; reject positions that need live closure.
 import { runAdapter } from '../platform/cdp.mjs';
 import { assertPositions, closePositions } from './perps.mjs';
 

package/library/actions/extension/perps/close_visible_position.mjs

@@ -1,3 +1,6 @@
+// Close visible Perps positions with funding checks and receipt-bound identity.
+// Accepted fills require lineage checks; full closes retain their own venue identity.
+
 import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
   assertTrustedExternalMutationTarget,
@@ -10,7 +13,7 @@ import {
   trustedExternalMutationPlanIsExact,
   withExternalMutationRecovery,
 } from './mutation-receipt.mjs';
-import { requireCurrentVisibleFundingBalance, requirePerpsTradingContext } from './perps.mjs';
+import { observeHyperliquidSubmission, placementReceiptSelection, requireCurrentVisibleFundingBalance, requirePerpsTradingContext } from './perps.mjs';
 import {
   absoluteDelta,
   parsePositionDetail,
@@ -58,6 +61,97 @@ async function readVisibleClosePosition(page, market) {
   })()`);
 }
 
+async function readAcceptedFill(page, placement, market, side, visibleSize) {
+  const accepted = placement.record?.acceptance;
+  if (!accepted?.venueOrderId) throw new Error('Position cleanup requires the exact accepted venue order ID.');
+  const deadline = Date.now() + 10_000;
+  let startTime = null;
+  // Explicit end windows read current fills instead of the controller's recent-history cache.
+  while (Date.now() < deadline) {
+    const result = await page.session.call('Runtime.evaluate', {
+      expression: `(async () => {
+        const request = globalThis.stateHooks?.submitRequestToBackground;
+        if (typeof request !== 'function') throw new Error('Read-only Perps fill API is unavailable.');
+        const recent = await request('perpsGetOrderFills', [{ aggregateByTime: false, endTime: ${JSON.stringify(Date.now())} }]);
+        if (!Array.isArray(recent) || recent.some(fill => !fill || typeof fill !== 'object'
+          || Array.isArray(fill) || !['string', 'number'].includes(typeof fill.orderId))) {
+          throw new Error('Read-only Perps fill history is malformed.');
+        }
+        const owned = recent.filter(fill => String(fill?.orderId) === ${JSON.stringify(accepted.venueOrderId)});
+        if (owned.some(fill => !Number.isSafeInteger(fill.timestamp) || fill.timestamp <= 0)) {
+          throw new Error('Accepted order has malformed fill timestamps.');
+        }
+        return owned.length ? Math.min(...owned.map(fill => fill.timestamp)) : null;
+      })()`,
+      awaitPromise: true, returnByValue: true,
+    }, { timeoutMs: Math.max(1, deadline - Date.now()) });
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.exception?.description ?? result.exceptionDetails.text ?? 'Perps fill observation failed.');
+    }
+    startTime = result.result?.value;
+    if (startTime !== null) {
+      if (!Number.isSafeInteger(startTime) || startTime <= 0) throw new Error('Accepted fill observation returned an invalid timestamp.');
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(250, Math.max(1, deadline - Date.now()))));
+  }
+  if (startTime === null) throw new Error('Accepted order did not reach fill history before the cleanup observation deadline.');
+  const data = await page.evaluate(`(async () => {
+    const request = globalThis.stateHooks?.submitRequestToBackground;
+    if (typeof request !== 'function') throw new Error('Read-only Perps fill API is unavailable.');
+    const startTime = ${JSON.stringify(startTime)};
+    const [fills, orders] = await Promise.all([
+      request('perpsGetOrderFills', [{ aggregateByTime: false, startTime, endTime: ${JSON.stringify(Date.now())} }]),
+      request('perpsGetOpenOrders', []),
+    ]);
+    if (!Array.isArray(fills) || !Array.isArray(orders) || fills.length >= 2000) {
+      throw new Error('Read-only Perps fill coverage is incomplete.');
+    }
+    const market = ${JSON.stringify(market)};
+    return {
+      openOrderCount: orders.filter(order => String(order.symbol ?? order.coin).toUpperCase() === market).length,
+      fills: fills.filter(fill => String(fill.symbol).toUpperCase() === market).map(fill => ({
+        orderId: String(fill.orderId), side: fill.side, size: fill.size,
+        startPosition: fill.startPosition, timestamp: fill.timestamp,
+      })),
+    };
+  })()`);
+  if (data.openOrderCount !== 0) throw new Error('Cancel the exact accepted order remainder before closing its filled position.');
+  const decimal = (value) => {
+    const match = /^(-?)(0|[1-9][0-9]{0,19})(?:\.([0-9]{1,8}))?$/u.exec(String(value));
+    if (!match) throw new Error('Perps fill size identity is invalid.');
+    return BigInt(`${match[1]}${match[2]}${String(match[3] ?? '').padEnd(8, '0')}`);
+  };
+  const owned = data.fills.filter((fill) => fill.orderId === accepted.venueOrderId);
+  if (!owned.length || data.fills.some((fill) => !Number.isSafeInteger(fill.timestamp) || fill.timestamp <= 0)) {
+    throw new Error('Accepted venue order has no independently observed complete fill identity.');
+  }
+  const firstTimestamp = Math.min(...owned.map((fill) => fill.timestamp));
+  if (data.fills.some((fill) => fill.timestamp >= firstTimestamp && fill.orderId !== accepted.venueOrderId)) {
+    throw new Error('Another order changed this market after the accepted fill; refusing shared-position cleanup.');
+  }
+  const sign = side === 'long' ? 1n : -1n;
+  owned.sort((left, right) => {
+    const difference = sign * (decimal(left.startPosition) - decimal(right.startPosition));
+    return difference < 0n ? -1 : difference > 0n ? 1 : 0;
+  });
+  let position = 0n;
+  for (const fill of owned) {
+    const size = decimal(fill.size);
+    if (fill.side !== (side === 'long' ? 'buy' : 'sell') || size <= 0n || decimal(fill.startPosition) !== position) {
+      throw new Error('Accepted order fills do not prove an exclusively owned position starting from zero.');
+    }
+    position += sign * size;
+  }
+  const sizeMatch = /^([0-9.,]+) ([A-Z0-9:_-]{2,20})$/u.exec(visibleSize);
+  if (!sizeMatch || sizeMatch[2] !== market || decimal(sizeMatch[1].replace(/,/gu, '')) !== sign * position
+    || sign * position > decimal(accepted.size)) {
+    throw new Error('Visible position size does not equal the exact accepted-order fills.');
+  }
+  return { venueOrderId: accepted.venueOrderId, fillCount: owned.length, size: visibleSize,
+    firstFillTimestamp: firstTimestamp, lastFillTimestamp: Math.max(...owned.map((fill) => fill.timestamp)) };
+}
+
 async function prepareCloseModal(page, partialAmount) {
   let confirmation;
   for (let attempt = 0; attempt < 3 && !confirmation; attempt += 1) {
@@ -75,6 +169,7 @@ async function prepareCloseModal(page, partialAmount) {
         return {
           amount: String(document.querySelector('[data-testid="close-amount-value"] input')?.value || read('close-amount-value')),
           fullSizeSelected: Boolean(document.querySelector('[data-testid="close-amount-slider-pct-100"]')),
+          marketOrder: !modal.querySelector('[data-testid="limit-price-input"]'),
           margin: read('perps-close-summary-margin-value'),
           fees: read('perps-close-summary-fees-value'),
           receive: read('perps-close-summary-receive-value'),
@@ -129,6 +224,20 @@ async function proveGlobalCleanup(page, balanceBeforeBaseUnits, toleranceBaseUni
   };
 }
 
+function requireCloseAcceptance(receipt, maximumBaseUnits) {
+  const accepted = receipt?.acceptance;
+  const size = receipt?.facts?.closeSizing?.size;
+  if (!accepted?.venueOrderId || accepted.status !== 'filled' || Number(accepted.filledSize) !== Number(size)
+    || accepted.venueOrderId === receipt?.facts?.acceptedFill?.venueOrderId) {
+    throw new Error('Full close has no distinct accepted full-fill identity.');
+  }
+  const notional = Math.ceil(Number(accepted.filledSize) * Number(accepted.averagePrice) * 1_000_000);
+  if (!Number.isSafeInteger(notional) || notional <= 0 || BigInt(notional) > BigInt(maximumBaseUnits)) {
+    throw new Error('Accepted close fill exceeds the trusted operation cap.');
+  }
+  return { venueOrderId: accepted.venueOrderId, filledSize: accepted.filledSize, averagePrice: accepted.averagePrice };
+}
+
 export async function closeVisiblePosition(input) {
   return withExtensionPage(input, async (page) => {
   const market = marketSymbol(input.node?.market);
@@ -176,6 +285,7 @@ export async function closeVisiblePosition(input) {
     roundingToleranceBaseUnits,
     ...(cleanupOnly ? { positionSize: fundingPositionSize, cleanupOnly: true } : {}),
   });
+  const closeBudget = trustedExternalMutationBudget(input, 'perps-close-position');
   const existingReceipt = await readExternalMutationReceipt(input, identity);
   if (existingReceipt) {
     return withExternalMutationRecovery(existingReceipt, async () => {
@@ -187,7 +297,8 @@ export async function closeVisiblePosition(input) {
         dispatch: async () => {
           throw new Error('resumed close must not dispatch');
         },
-        observe: async () => {
+        observe: async ({ receipt }) => {
+          const acceptedClose = partialAmount == null ? requireCloseAcceptance(receipt, closeBudget.maxBaseUnits) : null;
           const deadline = Date.now() + 45_000;
           let finalState;
           let absentSince = null;
@@ -218,6 +329,7 @@ export async function closeVisiblePosition(input) {
                 );
                 return {
                   success: true,
+                  ...acceptedClose,
                   finalState,
                   cleanup,
                 };
@@ -238,6 +350,8 @@ export async function closeVisiblePosition(input) {
         receipt: mutation.receipt,
         resumed: true,
         recovery: mutation.recovery,
+        ...(partialAmount == null ? { venueOrderId: mutation.observation.venueOrderId,
+          filledSize: mutation.observation.filledSize, averagePrice: mutation.observation.averagePrice } : {}),
         finalState: mutation.observation.finalState,
         cleanup: mutation.observation.cleanup ?? null,
         proofPath: 'trusted-pointer-visible-ui',
@@ -275,20 +389,30 @@ export async function closeVisiblePosition(input) {
   const observedNotionalBaseUnits = sizeMatch && sizeMatch[2] === market && priceBaseUnits != null
     ? `${Math.round(Number(sizeMatch[1]) * Number(priceBaseUnits))}`
     : null;
-  const closeBudget = trustedExternalMutationBudget(input, 'perps-close-position');
   if (!/^[1-9][0-9]{0,29}$/u.test(String(observedNotionalBaseUnits ?? ''))
     || BigInt(observedNotionalBaseUnits) > BigInt(closeBudget.maxBaseUnits)) {
     throw new Error('Visible Perps position notional is unavailable or exceeds the authorized close cap.');
   }
-  if (!cleanupOnly) {
-    await readPriorMutationReceipt(input, identity, 'metamask.perps.place_order');
+  const placement = cleanupOnly ? null
+    : await readPriorMutationReceipt(input, identity, 'metamask.perps.place_order', placementReceiptSelection(input));
+  let acceptedFill = null;
+  if (['limit', 'market'].includes(placement?.record?.identity?.orderType)) {
+    if (partialAmount != null) throw new Error('Accepted-fill cleanup requires a full owned-size close.');
+    acceptedFill = await readAcceptedFill(page, placement, market, fundingSide, exactBefore.size);
   }
-  const balanceBeforeBaseUnits = fundingBalance.observedBaseUnits;
+  const balanceBeforeBaseUnits = String(placement?.record?.facts?.balanceBeforeBaseUnits ?? fundingBalance.observedBaseUnits);
   if (!/^(?:0|[1-9][0-9]{0,29})$/u.test(balanceBeforeBaseUnits)) {
     throw new Error('Prior order receipt has no valid visible pre-order balance.');
   }
   const confirmation = await prepareCloseModal(page, partialAmount);
-  const mutation = await runGuardedExternalMutation({
+  if (partialAmount == null && (!confirmation.fullSizeSelected || !confirmation.marketOrder)) {
+    throw new Error('Receipt-bound full close requires the visible 100% market-close form.');
+  }
+  const closeSizing = partialAmount == null ? { size: sizeMatch[1], side: fundingSide === 'long' ? 'short' : 'long' } : null;
+  let submissionObserver = null;
+  let mutation;
+  try {
+    mutation = await runGuardedExternalMutation({
     input,
     identity,
     publicationFacts: {
@@ -298,12 +422,13 @@ export async function closeVisiblePosition(input) {
       cleanupOnly,
       fundingBalance,
       tradingContext,
+      ...(acceptedFill ? { acceptedFill } : {}),
+      ...(closeSizing ? { closeSizing } : {}),
     },
     dispatch: async () => {
       let dispatchTarget;
       try {
         await requireCurrentVisibleFundingBalance(input, page, timeoutMs, fundingBalance.observedBaseUnits);
-        await requirePerpsTradingContext(input, page);
         assertTrustedExternalMutationTarget(input, page, identity);
         const current = await readVisibleClosePosition(page, market);
         const currentPosition = parsePositionDetail({ pair: `${market}-USD`, ...current });
@@ -313,7 +438,20 @@ export async function closeVisiblePosition(input) {
         }) || currentPosition.size !== exactBefore.size) {
           throw new Error('Visible Perps position changed before close dispatch.');
         }
-        await prepareCloseModal(page, partialAmount);
+        if (acceptedFill && JSON.stringify(await readAcceptedFill(page, placement, market, fundingSide, currentPosition.size))
+          !== JSON.stringify(acceptedFill)) {
+          throw new Error('Accepted-order fill identity changed before close dispatch.');
+        }
+        const currentConfirmation = await prepareCloseModal(page, partialAmount);
+        if (closeSizing) {
+          if (!currentConfirmation.fullSizeSelected || !currentConfirmation.marketOrder) {
+            throw new Error('Full market-close selection changed before dispatch.');
+          }
+          submissionObserver = await observeHyperliquidSubmission(page, { ...tradingContext, market,
+            side: closeSizing.side, size: closeSizing.size, orderType: 'market', reduceOnly: true,
+            leverage, maximumNotionalBaseUnits: closeBudget.maxBaseUnits });
+          await submissionObserver.checkSizing();
+        }
         dispatchTarget = await page.evaluate(`(() => {
           const element = document.querySelector('[data-testid="perps-close-position-modal-submit"]');
           if (!element || element.disabled || element.getAttribute('aria-disabled') === 'true') {
@@ -322,10 +460,12 @@ export async function closeVisiblePosition(input) {
           const rect = element.getBoundingClientRect();
           return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
         })()`);
+        await requirePerpsTradingContext(input, page);
         assertTrustedExternalMutationTarget(input, page, identity);
       } catch (error) {
         throw externalMutationNotDispatched(error instanceof Error ? error.message : String(error));
       }
+      submissionObserver?.arm();
       await page.session.call('Input.dispatchMouseEvent', {
         type: 'mousePressed', x: dispatchTarget.x, y: dispatchTarget.y,
         button: 'left', buttons: 1, clickCount: 1,
@@ -334,8 +474,10 @@ export async function closeVisiblePosition(input) {
         type: 'mouseReleased', x: dispatchTarget.x, y: dispatchTarget.y,
         button: 'left', buttons: 0, clickCount: 1,
       });
+      return submissionObserver ? submissionObserver.accepted(timeoutMs) : undefined;
     },
-    observe: async () => {
+    observe: async ({ receipt }) => {
+      const acceptedClose = closeSizing ? requireCloseAcceptance(receipt, closeBudget.maxBaseUnits) : null;
       const closeDeadline = Date.now() + 45_000;
       let finalState;
       while (Date.now() <= closeDeadline) {
@@ -364,6 +506,7 @@ export async function closeVisiblePosition(input) {
             );
             return {
               success: true,
+              ...acceptedClose,
               finalState,
               cleanup,
             };
@@ -373,7 +516,10 @@ export async function closeVisiblePosition(input) {
       }
       throw new Error('matching closed-position postcondition was not visible before timeout');
     },
-  });
+    });
+  } finally {
+    submissionObserver?.close();
+  }
   return {
     action: input.action,
     market,
@@ -387,6 +533,9 @@ export async function closeVisiblePosition(input) {
     receipt: mutation.receipt,
     resumed: mutation.resumed,
     recovery: mutation.recovery,
+    ...(closeSizing ? { venueOrderId: mutation.observation.venueOrderId,
+      filledSize: mutation.observation.filledSize, averagePrice: mutation.observation.averagePrice,
+      closeSizing: submissionObserver?.sizing } : {}),
     proofPath: 'trusted-pointer-visible-ui',
   };
   });

package/library/actions/extension/perps/compare_provider_market.mjs

@@ -1,3 +1,5 @@
+// Fetch production Hyperliquid data and compare it with the opened market's displayed values.
+// Also check the funding countdown and nonblank chart canvases.
 import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 
 function numeric(value) {

package/library/actions/extension/perps/edit_margin.mjs

@@ -1,3 +1,5 @@
+// Submit live margin changes through visible controls with mutation receipts and position identity checks.
+// Observe the resulting margin and balance; removal requires a prior successful add receipt.
 import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
   assertTrustedExternalMutationTarget,
@@ -266,7 +268,6 @@ export async function editMargin(input) {
       let dispatchTarget;
       try {
         await requireCurrentVisibleFundingBalance(input, page, timeoutMs, fundingBalance.observedBaseUnits);
-        await requirePerpsTradingContext(input, page);
         assertTrustedExternalMutationTarget(input, page, identity);
         const current = await readPosition(page, market);
         if (current.marginBaseUnits !== before.marginBaseUnits || current.size !== before.size
@@ -284,6 +285,7 @@ export async function editMargin(input) {
           const rect = element.getBoundingClientRect();
           return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
         })()`);
+        await requirePerpsTradingContext(input, page);
         assertTrustedExternalMutationTarget(input, page, identity);
       } catch (error) {
         throw externalMutationNotDispatched(error instanceof Error ? error.message : String(error));

package/library/actions/extension/perps/ensure_orders.mjs

@@ -1,3 +1,4 @@
+// Require selected Perps orders to match the requested state without placing or cancelling orders.
 import { runAdapter } from '../platform/cdp.mjs';
 import { ensureOrders } from './perps.mjs';
 

package/library/actions/extension/perps/ensure_positions.mjs

@@ -1,3 +1,4 @@
+// Require selected Perps positions to match the requested state without opening or closing positions.
 import { runAdapter } from '../platform/cdp.mjs';
 import { ensurePositions } from './perps.mjs';