Skip to content

Commit 181a0f9

Browse files
authored
refactor(ios): declare runner screen-capture facts at the owning contract (#2813)
* refactor(ios): declare runner screen-capture facts at the owning contract #2728 asked for the runner's display facts at the owning cross-language contract, not by per-consumer casts. The wire key was a TypeScript literal and the shape a Swift struct pinned only by two hand-written Swift encode tests, so every consumer restated a shape it did not own. Move the read to packages/contracts/src/screen-capture-contract.ts and record the wire key plus two measured Duo poses in the golden table contracts/fixtures/screen-capture-metadata.json. The table names no field of its own: this module's reader and ScreenshotMetadataPayload stay the only two declarations of the shape, and each language decodes the table through its own, so a renamed or dropped fact fails both lanes. The vitest twin asserts the host reads exactly the facts a capture recorded and refuses anything that cannot describe one. Negative control on a booted iPhone Duo: renaming pixelsPerPoint in the table alone turns both lanes red, Swift with DecodingError.keyNotFound at captures[0].metadata and vitest by refusing the payload. * docs(adr-0025): record what the shipped capture encoder owes The capture-surface section still said a normalization "owes a rotation and a crop". The redraw that landed pays the rotation at the image's own logical size and scale and deliberately takes no crop, so the one-pixel difference between a runner capture and a simctl export stays rather than being stretched away. Narrow the sampling-path evidence gap to what was never exercised: keyboard settling and the navigation fallback each have a recorded lit-panel observation from #2741, so only a pose change under the sampler, and screen recording at all, remain open. Drop the Device Hub and host Accessibility requirement from the Duo fixture docs. `fold` drives the hinge through simulator HID, and device-hub-window-missing is named by no production code any more. * chore(gates): put the screen-capture contract on the per-PR lane Declare the new contracts subpath in the exports map and regenerate the R11 contracts-exports snapshot from it. Add the golden-table encode test and its no-facts sibling to the ios.yml -only-testing list, so cross-language drift on this key fails a pull request instead of waiting for nightly; the PR list now selects 101 methods with no dark tests.
1 parent efd2108 commit 181a0f9

12 files changed

Lines changed: 283 additions & 146 deletions

File tree

‎.github/workflows/ios.yml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -181,6 +181,8 @@ jobs:
181181
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testApplicationStateRawValuesMatchTheActivationDecoder \
182182
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testMissingBundleCommandInvalidatesCompleteCachedTargetState \
183183
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testCachedTargetInvalidationClearsProcessBoundState \
184+
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testScreenshotDisplayFactsReEncodeEveryGoldenTableRowUnderTheTablesKey \
185+
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testScreenshotResultCarriesNoDisplayFactsWhenNothingResolved \
184186
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testAlertResolutionCannotBypassRequestedDeadline \
185187
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testAlertAcceptTreatsOpenAsAffirmative \
186188
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testAlertAcceptDoesNotActivateAReplacementWithASharedButton \

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/UnitTests/RunnerTests+AppScreenCaptureTests.swift‎

Lines changed: 57 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,37 @@
11
import XCTest
22

33
#if AGENT_DEVICE_RUNNER_UNIT_TESTS
4+
/// One read of contracts/fixtures/screen-capture-metadata.json. The capture decodes through the
5+
/// production `ScreenshotMetadataPayload`, so the table cannot describe a shape this encoder does
6+
/// not write, and this file's re-encode cannot write a shape the table does not describe. The table
7+
/// names no field of its own: this struct and the host's reader in
8+
/// `packages/contracts/src/screen-capture-contract.ts` are the only declarations of the shape, and
9+
/// `packages/contracts/src/screen-capture-contract.test.ts` is the vitest twin (#2728).
10+
private struct ScreenCaptureMetadataTable: Decodable {
11+
struct Capture: Decodable {
12+
let name: String
13+
let metadata: ScreenshotMetadataPayload
14+
}
15+
16+
let key: String
17+
let captures: [Capture]
18+
}
19+
20+
private func loadScreenCaptureMetadataTable() throws -> ScreenCaptureMetadataTable {
21+
let fixtureURL = URL(fileURLWithPath: #filePath)
22+
.deletingLastPathComponent() // UnitTests
23+
.deletingLastPathComponent() // AgentDeviceRunnerUITests
24+
.deletingLastPathComponent() // AgentDeviceRunner
25+
.deletingLastPathComponent() // runner
26+
.deletingLastPathComponent() // apple
27+
.deletingLastPathComponent() // repo root
28+
.appendingPathComponent("contracts/fixtures/screen-capture-metadata.json")
29+
return try JSONDecoder().decode(
30+
ScreenCaptureMetadataTable.self,
31+
from: Data(contentsOf: fixtureURL)
32+
)
33+
}
34+
435
extension RunnerTests {
536
func testScreenCaptureFailureCarriesTheBridgeReasonAsItsOwnCode() {
637
XCTAssertEqual(
@@ -26,34 +57,39 @@ extension RunnerTests {
2657
)
2758
}
2859

29-
func testScreenshotResultEncodesDisplayFactsUnderTheKeyTheHostReads() throws {
30-
// The measured open-Duo inner panel: 2852x2006 at scale 3 on display 3. The host reads these to
31-
// rescale an image it did not measure, so the key and the shape are a cross-language contract.
32-
let payload = DataPayload(
33-
message: "tmp/screenshot-1.png",
34-
screenshotMetadata: ScreenshotMetadataPayload(
35-
displayID: 3,
36-
pixelWidth: 2852,
37-
pixelHeight: 2006,
38-
pixelsPerPoint: 3
60+
func testScreenshotDisplayFactsReEncodeEveryGoldenTableRowUnderTheTablesKey() throws {
61+
let table = try loadScreenCaptureMetadataTable()
62+
XCTAssertFalse(table.captures.isEmpty, "the table must record at least one measured capture")
63+
for capture in table.captures {
64+
let payload = DataPayload(
65+
message: "tmp/screenshot-1.png",
66+
screenshotMetadata: capture.metadata
3967
)
40-
)
41-
let encoded = try JSONSerialization.jsonObject(
42-
with: JSONEncoder().encode(payload)
43-
) as? [String: Any]
44-
XCTAssertEqual(encoded?["message"] as? String, "tmp/screenshot-1.png")
45-
let metadata = encoded?["screenshotMetadata"] as? [String: Any]
46-
XCTAssertEqual(metadata?["displayID"] as? UInt, 3)
47-
XCTAssertEqual(metadata?["pixelWidth"] as? Int, 2852)
48-
XCTAssertEqual(metadata?["pixelHeight"] as? Int, 2006)
49-
XCTAssertEqual(metadata?["pixelsPerPoint"] as? Double, 3)
68+
let encoded = try JSONSerialization.jsonObject(
69+
with: JSONEncoder().encode(payload)
70+
) as? [String: Any]
71+
XCTAssertEqual(encoded?["message"] as? String, "tmp/screenshot-1.png", capture.name)
72+
// The host reads these facts under the key the table spells, which neither language restates.
73+
guard let metadata = encoded?[table.key] as? [String: Any] else {
74+
return XCTFail("\(capture.name): no display facts under the table's key '\(table.key)'")
75+
}
76+
XCTAssertEqual(metadata["displayID"] as? UInt, capture.metadata.displayID, capture.name)
77+
XCTAssertEqual(metadata["pixelWidth"] as? Int, capture.metadata.pixelWidth, capture.name)
78+
XCTAssertEqual(metadata["pixelHeight"] as? Int, capture.metadata.pixelHeight, capture.name)
79+
XCTAssertEqual(
80+
metadata["pixelsPerPoint"] as? Double,
81+
capture.metadata.pixelsPerPoint,
82+
capture.name
83+
)
84+
}
5085
}
5186

5287
func testScreenshotResultCarriesNoDisplayFactsWhenNothingResolved() throws {
88+
let key = try loadScreenCaptureMetadataTable().key
5389
let encoded = try JSONSerialization.jsonObject(
5490
with: JSONEncoder().encode(DataPayload(message: "tmp/screenshot-1.png"))
5591
) as? [String: Any]
56-
XCTAssertNil(encoded?["screenshotMetadata"])
92+
XCTAssertNil(encoded?[key], "a capture that resolved nothing owes no facts either")
5793
}
5894
}
5995
#endif
Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
{
2+
"comment": "Cross-language golden table for the display facts one Apple runner capture reports about the image it encoded (#2728). The vitest twin is packages/contracts/src/screen-capture-contract.test.ts and the Swift twin is UnitTests/RunnerTests+AppScreenCaptureTests.swift, which decodes and re-encodes every capture through the production ScreenshotMetadataPayload — so a renamed or dropped fact fails both lanes. This table deliberately records no field list: the Swift struct and the TypeScript reader are the only declarations of the shape. Add a measured capture here, never to one suite.",
3+
"key": "screenshotMetadata",
4+
"captures": [
5+
{
6+
"name": "Open Duo, resolved inner panel LCD-1: the window is 951x669 pt on display 3 and the upright encoding is one pixel per axis under the 2853x2007 CoreDevice calls the panel",
7+
"metadata": {
8+
"displayID": 3,
9+
"pixelWidth": 2852,
10+
"pixelHeight": 2006,
11+
"pixelsPerPoint": 3
12+
}
13+
},
14+
{
15+
"name": "Closed Duo, outer panel LCD: the same command following the app onto the other panel, reported by the window that moved with it",
16+
"metadata": {
17+
"displayID": 1,
18+
"pixelWidth": 1398,
19+
"pixelHeight": 2034,
20+
"pixelsPerPoint": 3
21+
}
22+
}
23+
]
24+
}

‎docs/adr/0025-foldable-apple-panels.md‎

Lines changed: 21 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,12 @@ the system presents turned has its buffer sideways.
9999
The capture reports the display ID it used, the pixel size it encoded, and the pixels-per-point of
100100
that image, so density normalization reads the source it captured instead of applying a scale the
101101
host inferred. A runner that reports nothing measured nothing, and normalization keeps the pre-panel
102-
answer rather than borrowing a scale from a panel nobody captured.
102+
answer rather than borrowing a scale from a panel nobody captured. That payload is a cross-language
103+
contract, not a per-consumer cast: `packages/contracts/src/screen-capture-contract.ts` owns the read,
104+
the Swift struct owns the write, and those two types are the only declarations of the shape. The
105+
golden table `contracts/fixtures/screen-capture-metadata.json` carries the wire key and two measured
106+
poses for the vitest twin and the runner unit-test lane to decode through, so drift fails CI on both
107+
sides at once.
103108

104109
A capture asks the target app's window first and the system surface's window second. The home screen
105110
is SpringBoard's window, so a capture with no session app — or with one that is not running — still
@@ -432,11 +437,14 @@ Four facts the capture path cannot read off the image:
432437
whose display size transposes the panel, where `simctl` exports the same panel `2853x2007`
433438
upright. The runner's production encoder and `XCUIScreenshot`'s produce 0 differing pixels for
434439
one capture from `358,402` and `328,181` encoded bytes, so the turn belongs to the capture and
435-
not to an encoder. Rotating is not enough to compare the two: the runner's canvas is `2006x2852`
436-
and `simctl`'s `2853x2007`, a pixel apart on each axis, so #2729's normalization owes a rotation
437-
and a crop. - **Overlays.** A screen capture and a window capture are both display captures — the
438-
second cropped to the window — so the software keyboard, a SpringBoard-hosted permission alert,
439-
and the status bar all appear in either. It cuts the other way as well: that alert's own window
440+
not to an encoder. Rotating is not enough to compare the two: the raw canvas is `2006x2852` and
441+
`simctl`'s `2853x2007`, a pixel apart on each axis. The shipped encoder draws the capture upright
442+
at that image's own logical size and scale, which pays the rotation and takes no crop: the one-pixel
443+
difference stays, because stretching it to CoreDevice's nominal panel box would invent pixels the
444+
capture never held (#2741). - **Overlays.** A screen capture and a window capture are both display
445+
captures — the second cropped to the window — so the software keyboard, a SpringBoard-hosted
446+
permission alert, and the status bar all appear in either. It cuts the other way as well: that
447+
alert's own window
440448
resolved to `displayID` `3`, the dark panel in the closed pose, and capturing it yielded a black
441449
`668x950` crop indistinguishable from any capture of a dark panel. Whether a system window on the
442450
*lit* panel captures was not measured, so a system surface is verified on the app's panel, not
@@ -483,9 +491,13 @@ incorrect viewport, not an inner-panel delivery prohibition.
483491
physical foldable was never exercised.
484492
- **Runner observation paths that sample a frame.** Keyboard settling, screen recording, and the
485493
navigation fallback now take their frame from the display owning a window and each states in
486-
`runner.log` what it looked at, but none was watched on a device that changes panel under it. A
487-
pose change mid-recording still changes the captured display under a writer sized from the first
488-
frame, and that mismatch was never exercised.
494+
`runner.log` what it looked at. Keyboard settling and the navigation fallback were each watched
495+
once while serving a lit panel — `AGENT_DEVICE_RUNNER_KEYBOARD_STABILITY samples=3 captured=3
496+
settled=yes` behind a `returnKeyType="done"` field, and
497+
`AGENT_DEVICE_RUNNER_IN_APP_BACK_VISUAL_VERIFICATION ... changed=no` as the no-change control
498+
(#2741) — and neither was watched while the pose changed underneath it. Screen recording was never
499+
watched: a pose change mid-recording still changes the captured display under a writer sized from
500+
the first frame, and that mismatch was never exercised.
489501
- **Desktop capture paths.** The two `#if os(macOS)` siblings of the `screenshot` capture in
490502
`RunnerTests+CommandExecution.swift` keep capturing the desktop screen, which also reaches the
491503
screen through Screen Capture Kit in `AgentDeviceMacOSHelper`; only the iOS branches changed

‎examples/test-app/README.md‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -313,9 +313,9 @@ gate and does not change the ordinary iPhone lane.
313313

314314
Requirements: `DEVELOPER_DIR` pinned to a Duo-capable Xcode (iOS 27.1 ships only with Xcode 27.1+);
315315
exactly one booted iPhone Duo not shared with a concurrent run (concurrent runs rebuild the shared
316-
Apple runner and race capture/pose state); Xcode Device Hub reachable with Accessibility permission
317-
(`fold` presses its pose control — a Device Hub window on a secondary display makes the control
318-
unreachable and reports `device-hub-window-missing`; move it to the main display); the Agent Device
316+
Apple runner and race capture/pose state); nothing else for pose control, because `fold` drives the
317+
hinge through simulator HID — a helper compiled and dispatched inside the simulator with `simctl
318+
spawn`, so no Device Hub window and no host Accessibility permission is involved; the Agent Device
319319
Tester app installed on that simulator.
320320

321321
```bash

‎examples/test-app/foldable/duo-pose-semantic.mjs‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -20,9 +20,10 @@
2020
// * DEVELOPER_DIR pinned to a Duo-capable Xcode (the iOS 27.1 runtime ships only with Xcode 27.1+).
2121
// * An iPhone Duo simulator already booted on that toolchain, not shared with a concurrent run
2222
// (concurrent runs rebuild the shared Apple runner and race the pose/capture state).
23-
// * Xcode Device Hub reachable with Accessibility permission, because `fold` presses the Device
24-
// Hub pose control. If Device Hub's window is on a secondary display, pose control is
25-
// unreachable and `fold` reports `device-hub-window-missing`; move it to the main display.
23+
// * Nothing else for pose control: `fold` drives the hinge through simulator HID, compiling a
24+
// helper and dispatching it inside the simulator with `simctl spawn`, so no Device Hub window
25+
// and no host Accessibility permission is involved. It refuses a single-panel simulator as
26+
// `single-panel-device` and a pose the hinge read-back does not confirm as `fold-pose-unverified`.
2627
// * The Agent Device Tester fixture app installed on that simulator.
2728
//
2829
// Usage (from the repository root):

‎packages/contracts/package.json‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -396,6 +396,10 @@
396396
"types": "./src/runner-lease-context.ts",
397397
"default": "./src/runner-lease-context.ts"
398398
},
399+
"./screen-capture-contract": {
400+
"types": "./src/screen-capture-contract.ts",
401+
"default": "./src/screen-capture-contract.ts"
402+
},
399403
"./screen-recording-runtime": {
400404
"types": "./src/screen-recording-runtime.ts",
401405
"default": "./src/screen-recording-runtime.ts"
Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,82 @@
1+
import { test } from 'vitest';
2+
import assert from 'node:assert/strict';
3+
import fs from 'node:fs';
4+
import path from 'node:path';
5+
import {
6+
readRunnerScreenCaptureMetadata,
7+
type RunnerScreenCaptureMetadata,
8+
} from './screen-capture-contract.ts';
9+
10+
// Cross-language golden table: the display facts a runner capture reports about its own image are
11+
// written by the Swift encoder (`ScreenshotMetadataPayload`) and read here. Every capture in
12+
// contracts/fixtures/screen-capture-metadata.json is asserted by this file AND by
13+
// `UnitTests/RunnerTests+AppScreenCaptureTests.swift`, which decodes and re-encodes each one through
14+
// the production struct, so a renamed or dropped fact turns both suites red without a simulator. The
15+
// table names no field of its own: the two production types are the only declarations of the shape.
16+
type ScreenCaptureMetadataTable = {
17+
key: string;
18+
captures: Array<{ name: string; metadata: RunnerScreenCaptureMetadata }>;
19+
};
20+
21+
const TABLE = JSON.parse(
22+
fs.readFileSync(
23+
path.resolve(
24+
import.meta.dirname,
25+
'..',
26+
'..',
27+
'..',
28+
'contracts',
29+
'fixtures',
30+
'screen-capture-metadata.json',
31+
),
32+
'utf8',
33+
),
34+
) as ScreenCaptureMetadataTable;
35+
36+
const [MEASURED] = TABLE.captures;
37+
assert(MEASURED, 'the golden table must record at least one measured capture');
38+
39+
/** A runner `data` payload, as the native side answers a file-path screenshot. */
40+
function runnerPayload(metadata: unknown): Record<string, unknown> {
41+
return { message: 'tmp/screenshot-1.png', [TABLE.key]: metadata };
42+
}
43+
44+
test('reads every measured capture the golden table records', () => {
45+
for (const capture of TABLE.captures) {
46+
// deepEqual pins the key set as well as the values, so a reader that gained or renamed a fact
47+
// stops matching the capture the encoder produced.
48+
assert.deepEqual(
49+
readRunnerScreenCaptureMetadata(runnerPayload(capture.metadata)),
50+
capture.metadata,
51+
capture.name,
52+
);
53+
}
54+
});
55+
56+
test('refuses a payload missing any fact the golden table records', () => {
57+
for (const field of Object.keys(MEASURED.metadata)) {
58+
const partial: Record<string, number> = { ...MEASURED.metadata };
59+
delete partial[field];
60+
assert.equal(
61+
readRunnerScreenCaptureMetadata(runnerPayload(partial)),
62+
undefined,
63+
`missing ${field}`,
64+
);
65+
}
66+
});
67+
68+
test('reports no source fact when the runner carried no metadata', () => {
69+
assert.equal(readRunnerScreenCaptureMetadata({ message: 'tmp/screenshot-1.png' }), undefined);
70+
});
71+
72+
test.each([
73+
['a non-object payload', 'not-an-object'],
74+
['an array payload', [MEASURED.metadata]],
75+
['the pre-panel scale probe leaking in as zero', { ...MEASURED.metadata, displayID: 0 }],
76+
['a zero-scale image', { ...MEASURED.metadata, pixelsPerPoint: 0 }],
77+
['a non-integer pixel box', { ...MEASURED.metadata, pixelWidth: 2852.5 }],
78+
['a negative scale', { ...MEASURED.metadata, pixelsPerPoint: -3 }],
79+
['a non-numeric scale', { ...MEASURED.metadata, pixelsPerPoint: '3' }],
80+
])('refuses %s rather than guessing a capture', (_case, metadata) => {
81+
assert.equal(readRunnerScreenCaptureMetadata(runnerPayload(metadata)), undefined);
82+
});
Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
/**
2+
* The display facts an Apple runner capture reports about the image it encoded (#2728).
3+
*
4+
* A foldable lights one panel at a time and the dark panel still answers with a valid all-black PNG
5+
* at exit zero, so a capture has to carry its own proof of what it looked at: the display it
6+
* captured, the box it encoded, and how many pixels make one point. Swift owns the encoder
7+
* (`ScreenshotMetadataPayload` in `RunnerTests+Models.swift`) and this module owns the reader; those
8+
* two types are the only declarations of the shape. The golden table
9+
* `contracts/fixtures/screen-capture-metadata.json` carries the wire key and two real measured
10+
* captures, and each language decodes it through its own production type — this file's test and
11+
* `UnitTests/RunnerTests+AppScreenCaptureTests.swift` — so a renamed or dropped fact turns both
12+
* lanes red without a simulator. A consumer may not restate this shape as a local literal or read it
13+
* through an unchecked cast.
14+
*/
15+
16+
/** The `data` key a runner screenshot result carries its display facts under. */
17+
const RUNNER_SCREEN_CAPTURE_METADATA_KEY = 'screenshotMetadata';
18+
19+
/**
20+
* What one runner capture measured about itself. `pixelsPerPoint` is the scale of the image the
21+
* runner encoded, `pixelWidth`/`pixelHeight` are that encoded image's own box after the runner drew
22+
* it upright, and `displayID` is the screen the window reported — never a screen chosen by number
23+
* or by position in a screen list.
24+
*/
25+
export type RunnerScreenCaptureMetadata = Readonly<{
26+
displayID: number;
27+
pixelWidth: number;
28+
pixelHeight: number;
29+
pixelsPerPoint: number;
30+
}>;
31+
32+
/**
33+
* Reads the display facts out of a runner `data` payload. Returns undefined when the payload carries
34+
* none or carries a value that cannot describe a real capture, which leaves the consumer with no
35+
* source fact — the honest pre-panel state — rather than a number invented from a panel nobody
36+
* measured. The Swift encoder refuses to report a scale that is not finite and positive, so these
37+
* refusals are the host's defence against a payload that did not come from that encoder.
38+
*/
39+
export function readRunnerScreenCaptureMetadata(
40+
data: Record<string, unknown>,
41+
): RunnerScreenCaptureMetadata | undefined {
42+
const raw = data[RUNNER_SCREEN_CAPTURE_METADATA_KEY];
43+
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
44+
const payload = raw as Record<string, unknown>;
45+
const displayID = readPositiveInteger(payload.displayID);
46+
const pixelWidth = readPositiveInteger(payload.pixelWidth);
47+
const pixelHeight = readPositiveInteger(payload.pixelHeight);
48+
const pixelsPerPoint = readPositiveFinite(payload.pixelsPerPoint);
49+
if (
50+
displayID === undefined ||
51+
pixelWidth === undefined ||
52+
pixelHeight === undefined ||
53+
pixelsPerPoint === undefined
54+
) {
55+
return undefined;
56+
}
57+
return Object.freeze({ displayID, pixelWidth, pixelHeight, pixelsPerPoint });
58+
}
59+
60+
function readPositiveInteger(value: unknown): number | undefined {
61+
return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : undefined;
62+
}
63+
64+
function readPositiveFinite(value: unknown): number | undefined {
65+
return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
66+
}

0 commit comments

Comments
 (0)