@antprofuse/saddle-islands-tools 0.0.0-stage → 0.1.4

package/tools/modules/minifish/harness/host-native-ui.mjs

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import {expect} from '@playwright/test';
+const selectors={alert:'.adm-dialog-body,.adm-modal-body',showLoading:'.adm-toast-loading',showToast:'.adm-toast-wrap:not(:has(.adm-toast-loading))'};
+const visibleSelector=api=>selectors[api].split(',').map(s=>s+':visible').join(',');
+export function validateHostUiPaint(evidence,{content,title,buttonText}={}){
+ assert.equal(evidence.count,1,'Unique actual host carrier required');
+ const r=evidence.box;assert(r&&r.width>0&&r.height>0&&evidence.visible,'Actual host carrier must paint');
+ assert(r.x+r.width>0&&r.y+r.height>0&&r.x<evidence.viewport.width&&r.y<evidence.viewport.height,'Host carrier must intersect viewport');
+ if(content!==undefined)assert(evidence.text.includes(content),'Native host content must match source');
+ if(title!==undefined)assert(evidence.text.includes(title),'Native host title must match source');
+ if(buttonText!==undefined)assert.deepEqual(evidence.buttons,[buttonText],'Native host action and cardinality');
+ if(title!==undefined&&content!==undefined&&buttonText!==undefined)assert.equal(evidence.text.replace(/\s/g,''),(title+content+buttonText).replace(/\s/g,''),'No extra or incorrect native alert content');
+ return evidence;
+}
+export async function assertHostNativeUi(page,app,a){
+ assert(['alert','showLoading','showToast','addToHomeWithGuideDialog'].includes(a.api),'Finite native UI observation');
+ if(a.api==='addToHomeWithGuideDialog')throw Error('PUBLIC CAPABILITY UNAVAILABLE: official shortcut guide has no verified Web host carrier');
+ const host=page.frameLocator('iframe[name="lyra-integration-web-sdk"]');
+ const nodes=host.locator(visibleSelector(a.api));
+ if(a.state==='hidden'){await expect(nodes).toHaveCount(0);return {state:'hidden',api:a.api,carrierCount:0,level:'actual-host'};}
+ assert.equal(a.state,'visible');
+ const row=app.evidence().expectations.find(r=>r.id===a.boundaryId);assert(row&&row.execution==='official-ui','Actual official UI request required');assert.equal(row.received,1);
+ assert.equal(row.request.operation,'jsapi:'+a.api);
+ await expect(nodes).toHaveCount(1);
+ const evidence=await nodes.evaluate(el=>{
+  const r=el.getBoundingClientRect(),s=getComputedStyle(el);return {count:1,text:el.innerText,buttons:[...el.querySelectorAll('button,[role="button"]')].map(n=>n.innerText),box:{x:r.x,y:r.y,width:r.width,height:r.height},viewport:{width:innerWidth,height:innerHeight},visible:s.visibility==='visible'&&s.display!=='none'&&Number(s.opacity)>0,styles:{fontSize:s.fontSize,color:s.color,backgroundColor:s.backgroundColor,borderRadius:s.borderRadius},documentUrl:location.href};
+ });
+ validateHostUiPaint(evidence,a);
+ if(a.observation==='visual')throw Error('SOURCE PROJECTION REQUIRED: native host styles captured, but prototype-to-official-host visual equivalence is not approved');
+ return {api:a.api,boundaryId:a.boundaryId,request:row.request,carrier:evidence,officialResult:row.officialResult??null,resultPending:row.delivered===0,level:'actual-host-not-Mock'};
+}
+export async function dismissHostAlert(page,app,boundaryId){
+ const row=app.evidence().expectations.find(r=>r.id===boundaryId);assert(row?.execution==='official-ui'&&row.request.operation==='jsapi:alert'&&row.received===1,'Declared actual alert required');
+ const host=page.frameLocator('iframe[name="lyra-integration-web-sdk"]'),body=host.locator(visibleSelector('alert'));await expect(body).toHaveCount(1);
+ const buttons=body.locator('button,[role="button"]');await expect(buttons).toHaveCount(1);await expect(buttons).toHaveText(row.request.params.buttonText);await buttons.click();
+ await expect.poll(()=>app.evidence().expectations.find(r=>r.id===boundaryId).delivered).toBe(1);
+ if(row.requireConsumption)await expect.poll(()=>app.evidence().expectations.find(r=>r.id===boundaryId).consumed).toBe(1);
+ await expect(body).toHaveCount(0);
+}

package/tools/modules/minifish/harness/host-navigation.mjs

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict';
+import {expect} from '@playwright/test';
+import {activeShellSelector} from './browser.mjs';
+
+// Official Lyra 2.40.1 shell, outside the business page iframe. Select the
+// current non-exiting shell before observing its title; no expected-word filter.
+export function hostNavigationCarriers(page){
+ const host=page.frameLocator('iframe[name="lyra-integration-web-sdk"]');
+ const shell=host.locator(activeShellSelector);
+ return {shell,bar:shell.locator('.lyra-page-title .titlebar'),title:shell.locator('.lyra-page-title .titlebar .titlebar-center > .title')};
+}
+export function validateHostNavigation(observed,expected){
+ assert.equal(observed.title,expected.title,'Actual host title');
+ assert.equal(observed.backgroundColor,expected.backgroundColor,'Actual host navigation background');
+ assert(observed.box.width>0&&observed.box.height>0,'Host navigation must have a painted box');
+ assert(observed.opacity>0&&observed.hit,'Actual host navigation must be painted and unobstructed');
+ return observed;
+}
+export function validateDarkForeground(items){
+ for(const role of ['time','network','batteryText','batteryFill','batteryOutline','title','capsuleMore','capsuleClose']){
+  const item=items[role];assert(item?.visible,`Painted host foreground required: ${role}`);
+  assert(item.colors?.length,`Foreground paint evidence required: ${role}`);
+  for(const color of item.colors){
+   const match=/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)$/.exec(color);
+   assert(match&&Number(match[4]??1)>0,`Opaque foreground color: ${role}`);
+   assert(Math.max(...match.slice(1,4).map(Number))<128,`Approved dark foreground: ${role} (${color})`);
+  }
+ }
+ return items;
+}
+// Read actual CSS text, SVG icon paint and embedded capsule image paint. The
+// SVG comes from this carrier's computed background, not a separate URL probe.
+export async function observeHostForeground(shell){
+ const selectors={time:'.statusbar .time-info',network:'.statusbar .network-wifi',batteryText:'.statusbar .battery-level-text',batteryFill:'.statusbar .surplus-battery-level-process',title:'.titlebar-center > .title',capsuleMore:'.titlebar .actions .more-action',capsuleClose:'.titlebar .actions .close-action'};
+ const result={};
+ for(const [role,selector] of Object.entries(selectors)){
+  const node=shell.locator('.lyra-page-title '+selector);await expect(node).toHaveCount(1);await expect(node).toBeVisible();
+  result[role]=await node.evaluate((el,role)=>{
+   const style=getComputedStyle(el),box=el.getBoundingClientRect();
+   const norm=value=>{const c=document.createElement('canvas').getContext('2d');c.fillStyle=value;const hex=c.fillStyle;if(/^#[\da-f]{6}$/i.test(hex))return `rgb(${parseInt(hex.slice(1,3),16)}, ${parseInt(hex.slice(3,5),16)}, ${parseInt(hex.slice(5,7),16)})`;return hex;};
+   let colors=[];
+   if(role.startsWith('capsule')){
+    const m=/url\(["']?(data:image\/svg\+xml[^"')]+)["']?\)/.exec(style.backgroundImage);
+    if(!m)throw Error('Expected actual SDK embedded capsule SVG');
+    const [header,data]=m[1].split(',');const xml=header.includes(';base64')?atob(data):decodeURIComponent(data);
+    const doc=new DOMParser().parseFromString(xml,'image/svg+xml');
+    for(const p of doc.querySelectorAll('path,circle,rect,ellipse,polygon')){
+     const fill=p.getAttribute('fill')??p.parentElement?.getAttribute('fill')??'black';if(fill!=='none')colors.push(norm(fill));
+     const stroke=p.getAttribute('stroke');if(stroke&&stroke!=='none')colors.push(norm(stroke));
+    }
+   }else if(role==='network'){
+    for(const p of el.querySelectorAll('svg path')){const s=getComputedStyle(p);if(s.fill!=='none')colors.push(s.fill);if(s.stroke!=='none')colors.push(s.stroke);}
+   }else colors=[role==='batteryFill'?style.backgroundColor:style.color];
+   let opacity=1;for(let p=el;p;p=p.parentElement)opacity*=Number(getComputedStyle(p).opacity);
+   return {visible:box.width>0&&box.height>0&&opacity>0,computedColor:style.color,backgroundColor:style.backgroundColor,backgroundImage:style.backgroundImage,colors:[...new Set(colors)],box:{x:box.x,y:box.y,width:box.width,height:box.height},opacity};
+  },role);
+ }
+ // Battery outline uses an SDK raster background; record the exact computed
+ // carrier in addition to its independently checked actual fill and text.
+ const outline=shell.locator('.lyra-page-title .battery-level-icon');await expect(outline).toHaveCount(1);await expect(outline).toBeVisible();
+ result.batteryOutline=await outline.evaluate(async el=>{
+  const s=getComputedStyle(el),box=el.getBoundingClientRect(),match=/url\(["']?(data:image\/[^"')]+)["']?\)/.exec(s.backgroundImage);
+  if(!match)throw Error('Expected actual embedded SDK battery image');
+  const img=new Image();img.src=match[1];await img.decode();const c=document.createElement('canvas');c.width=img.naturalWidth;c.height=img.naturalHeight;
+  const ctx=c.getContext('2d');ctx.drawImage(img,0,0);const pixels=ctx.getImageData(0,0,c.width,c.height).data,colors=new Set();
+  for(let i=0;i<pixels.length;i+=4)if(pixels[i+3]>200)colors.add(`rgb(${pixels[i]}, ${pixels[i+1]}, ${pixels[i+2]})`);
+  return {visible:box.width>0&&box.height>0,computedColor:s.color,backgroundImage:s.backgroundImage,colors:[...colors],imageSize:{width:c.width,height:c.height},method:'decode actual computed embedded raster; opaque foreground pixels'};
+ });
+ return result;
+}
+export async function observeHostNavigation(page){
+ const {shell,bar,title}=hostNavigationCarriers(page);
+ for(const node of [shell,bar,title]){await expect(node).toHaveCount(1);await expect(node).toBeVisible();}
+ const paint=await bar.evaluate(el=>{
+  const s=getComputedStyle(el),r=el.getBoundingClientRect();let opacity=1;for(let p=el;p;p=p.parentElement)opacity*=Number(getComputedStyle(p).opacity);
+  const hit=el.ownerDocument.elementFromPoint(r.x+r.width/2,r.y+r.height/2);
+  return {backgroundColor:s.backgroundColor,opacity,hit:!!hit&&(hit===el||el.contains(hit)),box:{x:r.x,y:r.y,width:r.width,height:r.height}};
+ });
+ return {layer:'official-sdk-host',adapter:'lyra-2.40.1-titlebar-v1',title:await title.innerText(),...paint};
+}
+export async function assertHostNavigation(page,app,a,systemPlan){
+ await expect.poll(()=>app.evidence().hostLanguage.navigation.filter(r=>r.stage==='request').length,{message:'Product consumes system response then delegates actual navigation API'}).toBe(1);
+ const host=app.evidence().hostLanguage;
+ assert.equal(host.observations.length,systemPlan.times,'Exact public system response count');
+ assert.equal(host.systemRequests.length,systemPlan.times,'Exact public system request count');
+ assert.deepEqual(host.systemRequests[0].params,systemPlan.request.params,'Actual getSystemInfo parameters');
+ assert.equal(host.observations[0].mocked.language,systemPlan.outcome.value.language,'Declared public system response');
+ const navigation=host.navigation.filter(r=>r.stage==='request');
+ assert.equal(navigation[0].afterSystemResponse,systemPlan.times,'Navigation follows delivered system response');
+ assert.deepEqual(navigation[0].params,{title:a.title},'Actual delegated setNavigationBar parameters');
+ await expect.poll(()=>app.evidence().hostLanguage.navigation.filter(r=>r.stage==='success').length,{message:'Actual host setNavigationBar success callback'}).toBe(1);
+ const carriers=hostNavigationCarriers(page);await expect(carriers.title).toHaveText(a.title);
+ const observed=await observeHostNavigation(page);validateHostNavigation(observed,a);
+ const foreground=await observeHostForeground(carriers.shell);validateDarkForeground(foreground);
+ return {...observed,foreground,foregroundStandard:'user-approved official black theme; prototype #000 mapped, actual colors retained',system:app.evidence().hostLanguage,consumption:'delivered public system result -> product setNavigationBar -> actual host title'};
+}

package/tools/modules/minifish/harness/image-loading.mjs

@@ -0,0 +1,35 @@
+import {expect} from '@playwright/test';
+
+// Official native image can use a single background on a role=img DIV.
+export async function loadedImage(locator, expectedUrl, {pseudo}={}) {
+  await expect(locator).toHaveCount(1);
+  await expect(locator).toBeVisible();
+  return locator.evaluate(async (element, {expected,pseudo}) => {
+    const native = Boolean(pseudo)||element.tagName !== 'IMG';
+    const standard = !pseudo&&element.tagName === 'IMG';
+    if (!native && !standard) throw new Error('Unsupported image representation');
+    let actual;
+    if (standard) actual = element.currentSrc || element.getAttribute('src');
+    else {
+      const match = /^url\((["']?)(.*?)\1\)$/.exec(getComputedStyle(element,pseudo?'::'+pseudo:null).backgroundImage);
+      if (!match) throw new Error('Native image must have one material URL');
+      actual = match[2];
+    }
+    const resolve = url => new URL(url, element.ownerDocument.baseURI).href;
+    if (!actual || (expected!==undefined&&resolve(actual) !== resolve(expected))) throw new Error('Image material URL mismatch');
+    const image = standard ? element : new element.ownerDocument.defaultView.Image();
+    if (native) image.src = actual;
+    let timer;
+    try {
+      await Promise.race([image.decode(), new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('Image decode timed out')), 5000);
+      })]);
+      if (!image.complete || image.naturalWidth <= 0 || image.naturalHeight <= 0) throw new Error('Image did not load real pixels');
+      return {representation: standard ? 'img' : 'native-image', url: resolve(actual), width: image.naturalWidth, height: image.naturalHeight};
+    } finally { clearTimeout(timer); }
+  }, {expected:expectedUrl,pseudo});
+}
+
+export async function imageResourceURL(locator,{pseudo}={}){
+ return locator.evaluate((e,pseudo)=>{let url;if(!pseudo&&e.tagName==='IMG')url=e.currentSrc||e.getAttribute('src');else{const m=/^url\((["']?)(.*?)\1\)$/.exec(getComputedStyle(e,pseudo?'::'+pseudo:null).backgroundImage);url=m?.[2];}if(!url)throw Error('Missing public material URL');return new URL(url,e.ownerDocument.baseURI).href;},pseudo);
+}

package/tools/modules/minifish/harness/independent-case-runner.mjs

@@ -0,0 +1,175 @@
+import {hostPolicy} from '@minifish/project-host';
+import {prepareHeldNativeInput,executeHeldSnapshot} from './held-snapshot.mjs';
+import {prepareHeldSnapshot,independentBoundary,assertNativeState,projectAssert,locateProject,queryBoundaryIds,validateReleasedPaymentRows} from '@minifish/project-runtime';
+import {installInputLifecycleEvidence} from './input-lifecycle-evidence.mjs';
+import {executionRole,executionEvidence,capturePolicy,needsFailureCapture} from './execution-evidence.mjs';
+import {assertHostNavigation} from './host-navigation.mjs';
+import {waitNativeEnabled} from './native-enabled.mjs';
+import {targetActions} from './target-actions.mjs';
+import {semanticLocator,synchronizeAnchors,closeAnchors} from './semantic-anchor.mjs';
+import assert from 'node:assert/strict';
+import {readFile, writeFile, unlink} from 'node:fs/promises';
+import { expect } from '@playwright/test';
+import { openMinifish } from './browser.mjs';
+import { zeroBusinessPlan } from './zero-business-plan.mjs';
+import { assertNativeVisual, nativeMetrics, near, geometryNear } from './independent-visual.mjs';
+import { installRendererImageEvidence } from './renderer-image-evidence.mjs';
+import { waitForNativeInput } from './loading-input.mjs';
+import {assertHostNativeUi,dismissHostAlert} from './host-native-ui.mjs';
+import {observeCarousel} from './carousel-observation.mjs';
+import {retainedPageRoundTrip} from './retained-page-lifecycle.mjs';
+import { assertSkeletonAppearance } from './skeleton-appearance.mjs';
+import { prepareMiniappCapture, captureMiniappScreenshot } from './miniapp-screenshot.mjs';
+
+export const screenshotPolicyVersion = 1;
+
+function target(root, name) { return semanticLocator(root, name); }
+
+export async function runMiniappCase({page, plan, testInfo}) {
+  assert.equal(plan.resources.length, 0, 'resource handling is not implemented in this runner yet');
+  const boundary = plan.boundaries.length ? independentBoundary(plan.boundaries) : zeroBusinessPlan();
+  const images = installRendererImageEvidence(page);
+  const result = { caseId: plan.case.id, preparation: 'not-run', target: 'not-run', boundary: 'not-run', cleanup: 'not-run', errors: [], assertions:[], observations:{} };
+  const screenshotMode = process.env.MINIFISH_SCREENSHOTS ?? (process.env.MINIFISH_FINAL_SCREENSHOTS === '1' ? 'all' : 'none');
+  assert(['none','failed','all'].includes(screenshotMode), 'Invalid screenshot policy');
+  result.screenshots = []; result.artifactErrors = [];
+  const role=executionRole(plan,process.env.MINIFISH_EXECUTION_ROLE??'behavior');
+  const artifactOnly=role==='held-artifact';
+  const policy=capturePolicy(plan,role,screenshotMode);
+  Object.assign(result,executionEvidence(plan,role));
+  if(policy.independentRequired)result.screenshotDisposition='independent-held-capture-required';
+  const capture = async phase => {
+    await trace?.sample('before-capture:'+phase,app?.root,boundary.evidence());
+    try { const shot = await captureMiniappScreenshot(page, testInfo, phase,phase==='target'?capturePreparation:undefined); result.screenshots.push({...shot,...(heldSpec?{inputState:'released',heldSnapshotImage:false}:{})}); }
+    catch(error) { result.artifactErrors.push(`Screenshot ${phase}: ${error.message}`); }
+    await trace?.sample('after-capture:'+phase,app?.root,boundary.evidence());
+  };
+  const trace=process.env.MINIFISH_INPUT_TRACE==='1'?await installInputLifecycleEvidence(page):null;
+  let app;
+  let input;
+  let capturePreparation;
+  result.actions=[];
+  let observation;
+  let heldSpec;
+  const locate=(root,name,options)=>locateProject(root,name,options,observation);
+  try {
+    result.preparation = 'running';
+    if(!artifactOnly&&(plan.beforeTarget??[]).some(a=>a.kind==='press'))heldSpec=prepareHeldSnapshot(plan);
+    if(plan.plugin){
+      assert(process.env.MINIFISH_PLUGIN_PACKAGE_URL&&process.env.MINIFISH_PLUGIN_ARTIFACT_MANIFEST,'Explicit compiled plugin artifact required');
+      const artifact=JSON.parse(await readFile(process.env.MINIFISH_PLUGIN_ARTIFACT_MANIFEST,'utf8'));
+      assert.deepEqual(artifact.plan,plan.plugin.events,'Case plugin plan must match compiled artifact');
+    }
+    if(plan.observationModule){observation=await import('./'+plan.observationModule);assert.equal(typeof observation.locate,'function');assert.equal(typeof observation.assertTarget,'function');}
+    for (const action of plan.actions) {
+      if (action.kind === 'open-page') {
+        assert(!app, 'duplicate page open');
+        app = await openMinifish({page, hostPolicy, plan:boundary, query:plan.inputs.query,
+          hostLanguage:plan.inputs.hostLanguage, requireHostLanguage:!!plan.hostSystemPlan, hostSystemPlan:plan.hostSystemPlan, simulatorUrl:process.env.MINIFISH_SIMULATOR_URL,
+          pageRoute:process.env.MINIFISH_PAGE_ROUTE,
+          plugin:plan.plugin?{provider:plan.plugin.provider,version:plan.plugin.version,events:plan.plugin.events,packageBaseUrl:process.env.MINIFISH_PLUGIN_PACKAGE_URL}:null,
+          nativeApis:[...plan.boundaries.filter(b=>b.execution!=='official-scroll').map(b=>b.request.operation).filter(o=>o.startsWith('jsapi:')).map(o=>o.slice(6)),'getGradeInfo','getBackgroundFetchData','pushWindow','redirectTo','alert','showToast','addToHomeWithGuideDialog']});
+        await synchronizeAnchors(app.root);
+      } else if (action.kind === 'wait-request') {
+        await expect.poll(()=>boundary.evidence().expectations.find(r=>r.id===action.boundaryId)?.received).toBe(1);
+      } else if(action.kind==='wait-response'){
+        await expect.poll(()=>boundary.evidence().expectations.find(r=>r.id===action.boundaryId)?.delivered).toBe(1);
+        const row=boundary.evidence().expectations.find(r=>r.id===action.boundaryId);
+        if(row.requireConsumption)await expect.poll(()=>boundary.evidence().expectations.find(r=>r.id===action.boundaryId)?.consumed).toBe(1);
+      } else if(action.kind==='wait-packet-complete'){
+        for(const id of action.boundaryIds){const row=()=>boundary.evidence().expectations.find(r=>r.id===id);assert(row(),'Declared packet boundary');await expect.poll(()=>row().received).toBe(row().times);await expect.poll(()=>row().delivered).toBe(row().times);if(row().requireConsumption)await expect.poll(()=>row().consumed).toBe(row().times);}
+        boundary.assertPacketComplete();
+      } else if(action.kind==='wait-loading-exit'){
+        const host=page.frameLocator('iframe[name="lyra-integration-web-sdk"]');
+        await expect(host.locator('.adm-toast-loading:visible')).toHaveCount(0);
+      } else if (action.kind === 'arrive') {
+        assert(app, 'page must open before arrival checks');
+        await synchronizeAnchors(app.root);
+        await expect(locate(app.root, action.target)).toHaveCount(1);
+        await expect(locate(app.root, action.target)).toBeVisible();
+      } else throw Error(`Unimplemented preparation action: ${action.kind}`);
+    }
+    assert(app, 'missing real page opening');
+    await trace?.attach();
+    input=targetActions({page,locate:(name,instance)=>locate(app.root,name,{instance}),synchronize:()=>synchronizeAnchors(app.root),boundary,receipts:result.actions,beforePress:async()=>{if(artifactOnly)capturePreparation=await prepareMiniappCapture(page);},observeInput:async(stage,action)=>trace?.sample(stage,app.root,boundary.evidence(),action)});
+    if(heldSpec)await prepareHeldNativeInput(app.root,heldSpec,locate(app.root,heldSpec.press.target,{instance:heldSpec.press.instance}));
+    for(const action of plan.beforeTarget??[]){
+      if(action.kind==='leave-return'){
+        const receipt={id:action.id,kind:action.kind,status:'running'};result.actions.push(receipt);
+        try{receipt.lifecycle=await retainedPageRoundTrip({page,app,boundary,action,queryBoundaryIds});receipt.status='passed';}catch(error){receipt.status='failed';receipt.error=error.message;throw error;}
+      }else await input.run(action);
+    }
+    result.preparation = 'passed';
+    result.target = 'running';
+    if(heldSpec){
+      const held=await executeHeldSnapshot({root:app.root,spec:heldSpec,release:action=>input.releaseHeldSnapshot(action),validators:observation});
+      result.heldSnapshot={version:heldSpec.version,snapshot:held.snapshot,timing:held.timing,imageStage:'released-independent-from-held-semantic-snapshot'};
+      result.assertions.push(...held.assertions);Object.assign(result.observations,held.observations);
+      for(const assertion of held.assertions)if(assertion.status!=='passed')result.errors.push(assertion.id+': '+assertion.error);
+      if(!held.timing.eligible){result.inputValidity='invalid';result.target='invalidated';}
+    }else for (const assertion of plan.assertions) {
+      await synchronizeAnchors(app.root);
+      const locator=assertion.kind==='host-navigation'?undefined:locate(app.root, assertion.target,{instance:assertion.instance});
+      try {
+        if(assertion.kind==='host-native-ui'){result.observations[assertion.id]=await assertHostNativeUi(page,app,assertion);
+        }else if(assertion.kind==='carousel-frame'){result.observations[assertion.id]=await observeCarousel(app.root,assertion.contract,{urls:assertion.images,records:images.records});
+        }else if(assertion.kind==='host-navigation'){result.observations[assertion.id]=await assertHostNavigation(page,app,assertion,plan.hostSystemPlan);
+        }else if(assertion.kind==='region'){result.observations[assertion.id]=await observation.assertTarget({app,page,assertion,images});
+        }else if(await projectAssert({root:app.root,assertion,locator,locate,images,result})){
+        }else if(['hidden','visible'].includes(assertion.kind)){await assertNativeState(locator,assertion);
+        }else if(assertion.kind==='text'){
+          await expect(locator).toHaveCount(assertion.count);await expect(locator).toBeVisible();await expect(locator).toHaveText(assertion.expected);
+        } else result.observations[assertion.id]=await assertNativeVisual(locator,assertion,images);
+        result.assertions.push({id:assertion.id,sourceCaseIds:assertion.sourceCaseIds,status:'passed'});
+      }catch(error){result.assertions.push({id:assertion.id,sourceCaseIds:assertion.sourceCaseIds,status:'failed',error:error.message});result.errors.push(error.message);}
+    }
+    if(result.target!=='invalidated')result.target = result.errors.length ? 'failed':'passed';
+    if (policy.target) await capture('target');
+    if(artifactOnly){
+      result.notExecutedActions=(plan.afterTarget??[]).map(action=>({...action,status:'not-executed-artifact-only'}));
+      await input.cancelForArtifact(capturePreparation.clip);
+    }else if(heldSpec){if(result.inputValidity!=='invalid')await input.completeHeldRelease(heldSpec.release);}
+    else for(const action of plan.afterTarget??[])await input.run(action);
+    for(const action of plan.completion){
+      if(action.kind==='wait-boundaries'){for(const id of action.boundaryIds){const row=()=>boundary.evidence().expectations.find(r=>r.id===id);assert(row(),'Declared completion boundary required');await expect.poll(()=>row().received).toBe(row().times);await expect.poll(()=>row().delivered).toBe(row().times);if(row().requireConsumption)await expect.poll(()=>row().consumed).toBe(row().times);}if(action.receiptPhase!==undefined){assert.equal(action.receiptPhase,'released-payment','Finite completion payment phase');validateReleasedPaymentRows(boundary.evidence().expectations,action.boundaryIds);}continue;}
+      if(action.kind==='dismiss-host-alert'){await dismissHostAlert(page,app,action.boundaryId);result.assertions.push({id:action.id,sourceCaseIds:action.sourceCaseIds,status:'passed'});continue;}
+      assert.equal(action.kind,'click-and-request');
+      const locator=locate(app.root,action.target,{instance:action.instance});await expect(locator).toHaveCount(1);await expect(locator).toBeVisible();await waitNativeEnabled(locator,true);
+      await locator.scrollIntoViewIfNeeded();await waitForNativeInput(page,locator);await locator.click();
+      await expect.poll(()=>boundary.evidence().expectations.find(r=>r.id===action.boundaryId)?.delivered).toBe(1);
+      const row=boundary.evidence().expectations.find(r=>r.id===action.boundaryId);
+      if(row.requireConsumption)await expect.poll(()=>boundary.evidence().expectations.find(r=>r.id===action.boundaryId)?.consumed).toBe(1);
+      result.assertions.push({id:action.id,sourceCaseIds:action.sourceCaseIds,status:'passed'});
+    }
+  } catch (error) {
+    if (result.preparation === 'running') result.preparation = 'failed';
+    if (result.target === 'running') result.target = 'failed';
+    result.errors.push(error.message);
+  } finally {
+    try{await app?.capturePayGuide('runner-finally');await app?.flushPayGuide();}catch{}
+    try{await input?.cleanup();}catch(error){result.errors.push('Input release: '+error.message);}
+    try { if (app) { result.anchors = await app.root.locator(':root').evaluate(el => Array.from(el.ownerDocument.querySelectorAll('[data-anchor-id]')).map(n => ({path:n.getAttribute('data-anchor-id'),tag:n.tagName,text:n.textContent?.slice(0,160)}))); await closeAnchors(app.root); } }
+    catch (error) { result.errors.push('Anchor cleanup: '+error.message); }
+    try { if(artifactOnly){assert(app,'Artifact requires real page');result.artifactAudit=app.assertArtifactComplete(plan.afterTarget.map(a=>a.boundaryId));result.boundary='not-executed-artifact-only';}else{if (app) app.assertComplete(); else boundary.assertComplete(); result.boundary = 'passed';} }
+    catch (error) { result.boundary = 'failed'; result.errors.push(error.message); }
+    if (needsFailureCapture(policy,screenshotMode,result)) await capture('failure');
+    if(trace)result.inputLifecycle=await trace.evidence(page);
+    try { if (app) await app.close(); else { await boundary.close(); await page.close(); } result.cleanup = 'passed'; }
+    catch (error) { result.cleanup = 'failed'; result.errors.push(error.message); }
+    if (screenshotMode === 'failed' && !result.errors.length && !result.artifactErrors.length) {
+      for (const shot of result.screenshots) {
+        await unlink(testInfo.outputPath(shot.file));
+        await unlink(testInfo.outputPath(`miniapp-${shot.phase}.json`));
+      }
+      result.screenshots = [];
+    }
+    result.images=await images.snapshot();images.close();
+    result.finishedAt=new Date().toISOString();
+    result.outcome=result.inputValidity==='invalid'?'invalid-input':result.errors.length||result.artifactErrors.length?'failed':artifactOnly?'artifact-only':'passed';
+    const evidenceFile = testInfo.outputPath('case-result.json');
+    await writeFile(evidenceFile, JSON.stringify({...result, evidence:app?.evidence() ?? boundary.evidence()}, null, 2));
+    await testInfo.attach('case-result', {path:evidenceFile, contentType:'application/json'});
+  }
+  if (result.artifactErrors.length) throw Error(result.artifactErrors.join("\n"));
+  if (result.errors.length) throw Error(result.errors.join('\n'));
+}

package/tools/modules/minifish/harness/independent-visual.mjs

@@ -0,0 +1,107 @@
+import {sampleNativeMetrics} from './native-dom-sampling.mjs';
+import {rendererImageFrameId} from './renderer-image-evidence.mjs';
+import assert from 'node:assert/strict';
+import {expect} from '@playwright/test';
+export async function nativeMetricsFrameIdentity(locator) {
+ const handle=await locator.elementHandle();let frameId;
+ try{const frame=await handle?.ownerFrame();if(frame)frameId=rendererImageFrameId(locator.page(),frame);}finally{await handle?.dispose();}
+ return frameId;
+}
+export async function nativeMetrics(locator) {
+ const frameId=await nativeMetricsFrameIdentity(locator);
+ const metrics=await locator.evaluate(sampleNativeMetrics);
+ metrics.frameId=frameId;for(const paint of [...metrics.imagePaints,...metrics.imagePaintInventory])paint.frameId=frameId;return metrics;
+}
+export function near(actual,expected,label,tolerance=.02){assert(Math.abs(actual-expected)<=tolerance,`${label}: ${actual} != ${expected}`);}
+export function imagePaintCarrier(m){
+ if(m.styles.backgroundImage!=='none')return m; // Existing background policy stays on its painted root.
+ const paints=(m.imagePaints??[]).filter(p=>p.visible);
+ assert.equal(paints.length,1,'One visible actual image paint carrier inside semantic root required');
+ const paint=paints[0];assert(paint.owned,'Image cannot belong to a different semantic child');
+ assert(paint.visible,'Actual image paint carrier must be visible');
+ assert(paint.box.width>0&&paint.box.height>0,'Nonzero actual image paint required');
+ for(const b of [...paint.clipping,{x:0,y:0,...paint.viewport,clipX:true,clipY:true}]){
+  const r=paint.box;if(b.clipX)assert(r.x>=b.x-.25&&r.x+r.width<=b.x+b.width+.25,'Image horizontal paint clipping');if(b.clipY)assert(r.y>=b.y-.25&&r.y+r.height<=b.y+b.height+.25,'Image vertical paint clipping');
+ }
+ return paint;
+}
+export function validateNativeImage(m,expected,records){
+ m=imagePaintCarrier(m);
+ const urls=[...m.styles.backgroundImage.matchAll(/url\(["']?(.*?)["']?\)/g)].map(v=>v[1]);
+ if(urls.length)assert.deepEqual(urls,[expected],'Exact background image on this carrier');
+ else assert(m.images.some(i=>i.src===expected),'Exact source image on this carrier');
+ assert(records.some(r=>r.url===expected&&r.frame===m.frame&&(r.frameId===undefined||r.frameId===m.frameId)&&r.status===200&&r.bytes>0&&r.decoded?.width>0&&r.decoded?.height>0),'Actual same-frame renderer response and original bytes decode');
+}
+export function validateImageFit(m,fit,expected,records){
+ const inventory=m.imagePaintInventory;
+ validateNativeImage(m,expected,records);
+ m=imagePaintCarrier(m);
+ if(m.styles.backgroundImage==='none'){assert.equal(m.styles.objectFit,fit,'Source image fit');return;}
+ if(m.styles.backgroundSize===fit)return;
+ if(fit==='fill'){
+  assert.equal(m.styles.backgroundSize,'contain','Finite source fill/native contain equivalence only');
+  const paints=inventory?.filter(p=>p.visible&&p.box.width>0&&p.box.height>0);assert.equal(paints?.length,1,'One actual visible image paint for fill equivalence');
+  assert(paints[0].owned&&paints[0].paintIndex===(m.paintIndex??0),'Equivalence belongs to the same semantic image paint');
+ }else{
+ assert.equal(fit,'contain','Only source contain has a finite native stretch equivalence');
+ assert.equal(m.styles.backgroundSize,'100% 100%','Native background fit');
+ }
+ assert.equal(m.styles.backgroundRepeat,'no-repeat','One nonrepeated image paint');
+ assert(['50% 50%','center center'].includes(m.styles.backgroundPosition),'Centered image paint');
+ const receipts=records.filter(r=>r.url===expected&&r.frame===m.frame&&(r.frameId===undefined||r.frameId===m.frameId)&&r.status===200&&r.bytes>0&&r.decoded?.width>0&&r.decoded?.height>0);
+ assert(receipts.length,'Same-frame original image decode required');
+ for(const r of receipts){geometryNear(m.box.height,m.box.width*r.decoded.height/r.decoded.width,'Equal source/carrier aspect projected height');geometryNear(m.box.width,m.box.height*r.decoded.width/r.decoded.height,'Equal source/carrier aspect projected width');}
+}
+export async function assertNativeImage(locator,a,images){
+ await expect(locator).toHaveCount(1);await expect(locator).toBeVisible();await locator.scrollIntoViewIfNeeded();
+ let m=await nativeMetrics(locator);const u=m.viewport.width/a.designWidth;
+ if(a.fit)await expect.poll(async()=>imageValidationStatus(m=await nativeMetrics(locator),metrics=>validateImageFit(metrics,a.fit,a.expected,images?.records??[])),{message:'Strict source contain/native image aspect and decoded receipt'}).toEqual({status:'matched'});
+ if(a.width!==undefined)geometryNear(m.box.width,a.width*u,'image width');
+ if(a.height!==undefined)geometryNear(m.box.height,a.height*u,'image height');
+ for(const b of [...m.clipping,{x:0,y:0,...m.viewport}])assert(m.box.x>=b.x-.1&&m.box.y>=b.y-.1&&m.box.x+m.box.width<=b.x+b.width+.1&&m.box.y+m.box.height<=b.y+b.height+.1,'Visible image carrier clipping');
+ await expect.poll(async()=>imageValidationStatus(m=await nativeMetrics(locator),metrics=>validateNativeImage(metrics,a.expected,images?.records??[])),{message:'Actual carrier URL and same-frame decoded renderer receipt'}).toEqual({status:'matched'});
+ return m;
+}
+// User-approved absolute budget in logical CSS pixels, independent of DPR/size.
+export const GEOMETRY_TOLERANCE = 0.25;
+export function geometryNear(actual,expected,label){
+ assert(Number.isFinite(actual)&&Number.isFinite(expected),`${label}: finite geometry required`);
+ near(actual,expected,label,GEOMETRY_TOLERANCE);
+}
+export async function assertNativeVisual(locator,a,images) {
+ await expect(locator).toHaveCount(1);await expect(locator).toBeVisible();
+ const m=await nativeMetrics(locator),u=m.viewport.width/a.designWidth;
+ const css=(key,n)=>(['fontSize','lineHeight','letterSpacing'].includes(key)?near:geometryNear)(parseFloat(m.styles[key]),n*u,key);
+ if(a.kind==='image') {
+  return assertNativeImage(locator,a,images);
+ } else {
+  await expect(locator).toHaveText(a.expected);
+  css('fontSize',a.fontSize);assert.equal(Number(m.styles.fontWeight),a.fontWeight);assert.equal(m.styles.color,a.color);
+  assert(/PingFang SC|sans-serif/.test(m.styles.fontFamily),'Source native/system font family');
+  if(a.kind==='text-visual') {
+   near(parseFloat(m.styles.lineHeight),a.fontSize*u*a.lineHeightRatio,'line height');css('marginTop',a.marginTop);css('marginBottom',a.marginBottom);
+  } else {
+   await expect(locator).toBeEnabled();geometryNear(m.box.height,a.height*u,'button height');assert(m.box.width+.02>=a.minWidth*u,'button minimum width');
+   css('borderRadius',a.radius);css('paddingLeft',a.horizontalPadding);css('paddingRight',a.horizontalPadding);assert.equal(m.styles.backgroundColor,a.backgroundColor);
+  }
+  assert(m.texts.length,'Actual rendered text geometry required');
+  for(const t of m.texts){assert(t.y>=m.box.y-.02&&t.y+t.height<=m.box.y+m.box.height+.02,'Text vertically clipped');assert(t.x>=m.box.x-.02&&t.x+t.width<=m.box.x+m.box.width+.02,'Text horizontally clipped');}
+  if(a.kind==='button-visual') {const top=Math.min(...m.texts.map(t=>t.y)),bottom=Math.max(...m.texts.map(t=>t.y+t.height));near((top+bottom)/2,m.box.y+m.box.height/2,'button text vertical center',1);}
+ }
+ return m;
+}
+// Exact resource enumeration stays inside an already resolved semantic root.
+export function nativeImageIndex(metrics,url){
+ const matches=metrics.flatMap((m,index)=>{
+  const urls=[...m.styles.backgroundImage.matchAll(/url\(["']?(.*?)["']?\)/g)].map(v=>v[1]);
+  return (urls.includes(url)||m.images.some(i=>i.src===url))?[index]:[];
+ });
+ assert.equal(matches.length,1,'Unique exact source image in semantic root');return matches[0];
+}
+export async function nativeImageBySource(root,url){
+ const images=root.locator('[role="img"]');const metrics=[];
+ for(let i=0;i<await images.count();i++)metrics.push(await nativeMetrics(images.nth(i)));
+ return images.nth(nativeImageIndex(metrics,url));
+}
+
+export function imageValidationStatus(metrics,validate){try{validate(metrics);return {status:'matched'};}catch(error){return {status:'mismatch',error:error.message,metrics};}}

package/tools/modules/minifish/harness/inline-svg.mjs

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import {expect,nativePart} from './semantic-observation.mjs';
+import {nativeMetrics,geometryNear} from './independent-visual.mjs';
+export function normalizeSvg(svg){return svg.trim().replace(/>\s+</g,'><');}
+export function decodeInlineSvg(uri){
+ const m=/^data:image\/svg\+xml;base64,([A-Za-z0-9+/]+={0,2})$/.exec(uri);assert(m,'Only base64 image/svg+xml resource');
+ const bytes=Buffer.from(m[1],'base64');assert.equal(bytes.toString('base64'),m[1],'Canonical base64 bytes required');return bytes.toString('utf8');
+}
+export function validateInlineSvg(observed,expected){
+ assert.equal(normalizeSvg(decodeInlineSvg(observed.src)),normalizeSvg(expected),'Frozen SVG bytes');
+ assert(observed.decoded&&observed.naturalWidth>0&&observed.naturalHeight>0,'Actual browser SVG decode');return observed;
+}
+export function validateClearGeometry(button,image){
+ const u=button.viewport.width/375;for(const k of ['width','height']){geometryNear(button.box[k],34*u,'clear button '+k);geometryNear(image.box[k],18*u,'clear image '+k);}
+ for(const k of ['paddingLeft','paddingRight','paddingTop','paddingBottom'])geometryNear(parseFloat(button.styles[k]),8*u,k);
+ geometryNear(parseFloat(button.styles.marginRight),-8*u,'clear negative margin');
+ assert.equal(button.styles.backgroundColor,'rgba(0, 0, 0, 0)');assert.equal(button.borderWidth,0,'Borderless clear button');assert.equal(button.afterBorderWidth,0,'No native button after border');
+ assert.equal(image.styles.backgroundImage==='none'?image.styles.objectFit:image.styles.backgroundSize,'contain');
+ geometryNear(image.box.x+image.box.width/2,button.box.x+button.box.width/2,'clear image center x');geometryNear(image.box.y+image.box.height/2,button.box.y+button.box.height/2,'clear image center y');
+}
+export async function assertInlineClear(node,a){
+ await expect(node).toHaveCount(1);await expect(node).toBeVisible();
+ const nested=nativePart(node,{role:'button'});assert((await nested.count())<=1,'Duplicate native clear button');const button=await nested.count()?nested:node;
+ await expect(button).toBeVisible();await button.scrollIntoViewIfNeeded();const image=nativePart(button,{role:'img'});await expect(image).toHaveCount(1);await expect(image).toBeVisible();
+ const observed=await image.evaluate(async el=>{
+  const background=getComputedStyle(el).backgroundImage;const urls=[...background.matchAll(/url\(["']?(.*?)["']?\)/g)].map(m=>m[1]);
+  if(urls.length>1)throw Error('Duplicate image backgrounds');const src=urls.length?urls[0]:el.currentSrc||el.src||el.getAttribute('src');if(!src)throw Error('Actual image source missing');
+  const img=el instanceof HTMLImageElement?el:new Image();if(img!==el)img.src=src;await img.decode();return {src,decoded:true,naturalWidth:img.naturalWidth,naturalHeight:img.naturalHeight,method:img===el?'actual image decode':'actual carrier background bytes decode'};
+ });validateInlineSvg(observed,a.svg);
+ const b=await nativeMetrics(button),im=await nativeMetrics(image);const border=await button.evaluate(el=>{const s=getComputedStyle(el),p=getComputedStyle(el,'::after');return {borderWidth:Math.max(...['Top','Right','Bottom','Left'].map(k=>parseFloat(s['border'+k+'Width'])||0)),afterBorderWidth:Math.max(...['Top','Right','Bottom','Left'].map(k=>parseFloat(p['border'+k+'Width'])||0))};});Object.assign(b,border);
+ if(a.visual)validateClearGeometry(b,im);return {resource:observed,svg:normalizeSvg(a.svg),button:b,image:im};
+}

package/tools/modules/minifish/harness/input-lifecycle-evidence.mjs

@@ -0,0 +1,16 @@
+// Optional public, read-only input/capture diagnostics. No dispatched events,
+// scrolling, handlers, product memory or retries; listeners are passive.
+export async function installInputLifecycleEvidence(page){
+ const key='__seeleInputLifecycleEvidence';
+ const attach=async()=>{for(const frame of page.frames())try{await frame.evaluate(({key})=>{
+  if(globalThis[key])return;const events=[];globalThis[key]=events;
+  for(const type of ['pointerdown','pointerup','pointercancel','mousedown','mouseup','click','touchstart','touchend','touchcancel','scroll'])document.addEventListener(type,e=>{const n=e.target?.closest?.('[data-anchor-id]');events.push({type,time:performance.timeOrigin+performance.now(),trusted:e.isTrusted,buttons:e.buttons,button:e.button,x:e.clientX,y:e.clientY,path:n?.getAttribute('data-anchor-id')??null,box:n?(()=>{const r=n.getBoundingClientRect();return {x:r.x,y:r.y,width:r.width,height:r.height};})():null,scrollX,scrollY});if(events.length>160)events.shift();},{capture:true,passive:true});
+ },{key});}catch{}};
+ const records=[];
+ return {attach,sample(stage,root,boundary,action){
+  records.push({stage,time:Date.now(),action,requests:boundary.expectations.map(r=>({id:r.id,received:r.received,delivered:r.delivered,consumed:r.consumed}))});
+ },async evidence(){
+  const frames=[];for(const frame of page.frames())try{frames.push(await frame.evaluate(({key})=>({url:location.href,events:globalThis[key]??[],viewport:{width:innerWidth,height:innerHeight,dpr:devicePixelRatio}}),{key}));}catch(e){frames.push({detached:true,error:e.message});}
+  return {samples:records,frames};
+ }};
+}

package/tools/modules/minifish/harness/jsapi.mjs

@@ -0,0 +1,92 @@
+import {hostDeviceFixture,configureHostDeviceMount,hostDeviceMountEvidence} from './host-device-fixture.mjs';
+import assert from 'node:assert/strict';
+import {nativeUiResultPath,nativeUiApis} from './native-ui-contract.mjs';
+// Official Minifish rendererExtend -> beforeMount -> beforeBridgeInvokeAsync.
+// Captures native calls without reading or altering product business state.
+export const bridgePath = '/__bill_tests__/bridge.js';
+export const jsapiPath = '/__bill_tests__/jsapi';
+export function bridgeScript(origin, additionalApis = [], observeLoading = false, officialUi = [], observeCorrelation = false) {
+  assert(!additionalApis.includes('pageScrollTo'),'Official scroll cannot enter renderer Mock list');
+  assert(officialUi.every(api=>nativeUiApis.includes(api)),'Finite official UI delegation list');
+  const mockedApis = ['makePhoneCall','tradePay','getAuthCode','startApp','exitMiniProgram','exitApp', ...additionalApis,...(additionalApis.includes('getStorage')?['getTinyLocalStorage']:[]),...(additionalApis.includes('setStorage')?['setTinyLocalStorage']:[])];
+  return `window.lyraRendererExtendBridge.beforeMount(params => {
+    const hostFixture=${JSON.stringify(hostDeviceFixture)};
+    const mounted=(${configureHostDeviceMount.toString()})(params,hostFixture);
+    const hostEvidence=(${hostDeviceMountEvidence.toString()})(params,mounted,hostFixture);
+    const hostObserver=window.top?.__billHostDeviceFixture;
+    if(typeof hostObserver==='function')Promise.resolve(hostObserver(hostEvidence));
+    const officialRequests=new WeakMap(),bridgeIds=new WeakMap();let bridgeSequence=0;
+    const traceBridge=(kind,api,option,target)=>{if(!${observeCorrelation})return;try{
+      const observer=window.top.__billPublicApiTrace;if(typeof observer!=='function')return;
+      if(option&&typeof option==='object'&&!bridgeIds.has(option))bridgeIds.set(option,++bridgeSequence);
+      Promise.resolve(observer({kind,bridgeId:bridgeIds.get(option)??null,at:Date.now(),api,option,officialTarget:{pageUrl:target?.pageUrl,trAppId:target?.trAppId,trPageId:target?.trPageId,contextType:target?.contextType}})).catch(()=>{});
+    }catch{}};
+    return ({
+    ...mounted,
+    afterBridgeInvokeAsync: async (api, option, target, result) => {
+      traceBridge('bridge-after',api,option,target);
+      if(${JSON.stringify(officialUi)}.includes(api)){
+        const requestOption=officialRequests.get(option);
+        if(!requestOption)throw Error('Official UI result lost original invocation identity');
+        officialRequests.delete(option);
+        const response=await fetch(${JSON.stringify(origin+nativeUiResultPath)},{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({api,option:requestOption,actualResultOption:option,officialTarget:{pageUrl:target?.pageUrl,trAppId:target?.trAppId,trPageId:target?.trPageId,contextType:target?.contextType},resultPresent:result!==undefined,...(result!==undefined?{result}:{}),at:Date.now()})});
+        if(!response.ok)throw Error('Official UI result rejected');
+      }
+      ${observeLoading ? `
+      if(['showLoading','hideLoading'].includes(api))console.log('LOADING-OBS '+JSON.stringify({at:Date.now(),frame:location.href,kind:'api-after',api,option,target,result}));
+      ` : ''}
+      return result;
+    },
+    beforeBridgeInvokeAsync: async (api, option, target) => {
+      traceBridge('bridge-before',api,option,target);
+      ${observeLoading ? "if(['showLoading','hideLoading'].includes(api))console.log('LOADING-OBS '+JSON.stringify({at:Date.now(),frame:location.href,kind:'api-before',api,option,target}));" : ''}
+      if (!${JSON.stringify(mockedApis)}.includes(api)&&!${JSON.stringify(officialUi)}.includes(api)) return undefined;
+      const response = await fetch(${JSON.stringify(origin + jsapiPath)}, {
+        method:'POST', headers:{'content-type':'application/json'},
+        body:JSON.stringify({api,option,officialTarget:{pageUrl:target?.pageUrl,trAppId:target?.trAppId,trPageId:target?.trPageId,contextType:target?.contextType}})
+      });
+      if(response.status===204&&(api==='pushWindow'||${JSON.stringify(officialUi)}.includes(api))){
+        if(${JSON.stringify(officialUi)}.includes(api))officialRequests.set(option,JSON.parse(JSON.stringify(option)));
+        return undefined;
+      }
+      if (!response.ok) return {error:99999,errorMessage:'test boundary rejected native call'};
+      return await response.json();
+    }
+  });});`;
+}
+// Official dynamic-component fixture proves the SDK adds this app scope.
+// Keep the raw option in wire evidence; all business keys remain exact.
+export function businessJsapiOption(option) {
+  if (option && typeof option === 'object' && !Array.isArray(option)
+    && Object.hasOwn(option, '__appxDomain') && option.__appxDomain === 'app') {
+    const {__appxDomain, ...business} = option;
+    return business;
+  }
+  return option;
+}
+export async function fulfillJsapi(route, plan) {
+  const request = route.request();
+  const wire = request.postDataJSON();
+  const call=decodeNativeStorage(wire.api,businessJsapiOption(wire.option));
+  let result = await plan.receive(`jsapi:${call.api}`, call.params, wire);
+  if(wire.api==='getTinyLocalStorage'&&Object.hasOwn(result??{},'data'))result={...result,data:JSON.stringify({APDataStorage:result.data})};
+  await route.fulfill({json:result});
+  plan.markDelivered(`jsapi:${call.api}`,call.params);
+}
+
+// Official @ali/antcube-appx-bridge-my root/storage/boost/impl.js maps
+// public storage methods to native TinyLocalStorage and adds scope metadata.
+export function decodeNativeStorage(api,params){
+ if(!['getTinyLocalStorage','setTinyLocalStorage'].includes(api))return {api,params};
+ assert.equal(params.type,'user','Native storage user scope');
+ if(api==='getTinyLocalStorage'){
+  assert.deepEqual(Object.keys(params).sort(),['isAppFirstPage','key','type']);
+  assert.equal(typeof params.isAppFirstPage,'boolean');
+  return {api:'getStorage',params:{key:params.key}};
+ }
+ assert(Object.keys(params).every(k=>['key','type','data','value'].includes(k)),'Unexpected native storage fields');
+ assert.equal(typeof params.data,'string');
+ if(Object.hasOwn(params,'value'))assert.equal(params.value,params.data,'Native storage duplicate encoding mismatch');
+ const parsed=JSON.parse(params.data);assert.deepEqual(Object.keys(parsed),['APDataStorage']);
+ return {api:'setStorage',params:{key:params.key,data:parsed.APDataStorage}};
+}