Skip to content

Commit 5f6481c

Browse files
authored
fix(interaction): refuse taps whose target sits behind the visible keyboard (#2602)
* fix(interaction): refuse taps whose target sits behind the visible keyboard An acting target whose rect center lands inside the visible keyboard's band is refused with `tap_keyboard_occludes_target`, because the touch activates a key instead of the named element (#2589). Neither sibling guarantee reached it: the keyboard is a separate system surface, so it is never a covering sibling for `occlusion`, and a covered tab bar stays inside the app's own window rect for `offscreen`. The guard runs at the shared pipeline door, so selector, `@ref`, the native-ref preflight, and both drag endpoints read one decision, and a backend that "succeeds" cannot do so on a target the shared rules refuse. Raw coordinates keep their escape hatch and disclose the same reason in the response warning instead: they name a point rather than an element, they are how a keyboard's own control is tapped, and that path never captures the tree the band is measured against. The keyboard's own keys and dock items stay tappable, an element whose center stays above the key plane keeps pressing, and an unmeasurable keyboard fails open. Versioned help and the iOS runner hint no longer claim the keyboard usually does not block interactions. Closes #2589 * chore(gates): prove the keyboard-occlusion cells on the four acting paths * fix(interaction): guard the aim point the tap dispatches, not a second guess at it The guard measured the target's rect center while the acting paths dispatch whatever `resolveNodeTouchPoint` resolves, and those two points are not the same node geometry: a parent whose interactive descendants own its center has its aim pushed into a child-free region. Center-first could wave through a tap whose real aim had moved into the key plane, and refuse one whose real aim had moved clear of it. The stage owner now resolves the aim once, measures that, and returns it for the dispatch, so one point is in play per acting tap. The native-ref fast path keeps the rect center and says why: it hands the element to the backend and dispatches by ref, so there is no coordinate to re-derive. The coordinate path's two disclosures shared their viewport lookup, which the keyboard warning had been resolving a second time for the same point. The runtime cases now build on the ADR 0011 fixture's #2589 tree instead of restating its rects, and one case pins the point rule from both sides: a target whose center stays above the key plane while its dispatched aim falls below it is refused, and the same tree with the keypad lifted off the bottom edge shows the tap aiming under the key plane. * refactor(interaction): say which tap point a path has in its resolver's type The stage door carried two overload declarations and two parameter aliases to say that a path handing in a resolver returning `Point` gets a `Point` back and a path without one gets `null`. One constrained generic — `TPoint extends Point | null` on a resolver every path must pass — says exactly that, and the native-ref fast path reads its nullability off the rect center it asks for rather than into a signature above the function it calls. No cast, no branch that cannot be reached. Also removes ceremony the previous commit left behind: a session-lookup helper with one caller, a guard that rebound `params.tapPoint` to a local for one use, and runtime cases that lifted the keyboard off the bottom edge twice, once through a translation knob with one caller and once inline with the offset spelled out again. * chore(tests): drop runner payloads no test consumes Five of the runner-side snapshot payloads here have no consumer anywhere in the tree, and fallow reports them as dead exports because this stack changes the file. Deleted rather than suppressed or de-exported into unused locals: the two that remain are the ones the provider-transcript scenarios actually read.
1 parent 31385da commit 5f6481c

17 files changed

Lines changed: 642 additions & 164 deletions

File tree

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2187,7 +2187,7 @@ extension RunnerTests {
21872187
code: "UNSUPPORTED_OPERATION",
21882188
message: "Unable to dismiss the iOS keyboard: the keyboard exposes no dismiss key, and background taps are never attempted (no tap outside the keyboard can be proven side-effect-free)",
21892189
hint:
2190-
"The on-screen keyboard usually does not block agent-device interactions: press the next target directly instead of retrying dismiss. If that press fails or reports no visible effect, scroll the target into view, or use keyboard enter to press the return key when submission is wanted."
2190+
"An element whose center sits behind the on-screen keyboard is refused with tap_keyboard_occludes_target; one whose center stays above the keys presses normally. To end editing, tap the app's own Done/Cancel control, or use keyboard enter to press the return key when submission is wanted."
21912191
)
21922192
)
21932193
}

‎packages/contracts/src/interaction-guarantees.ts‎

Lines changed: 43 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,9 @@ export const INTERACTION_GUARANTEES = [
3434
'disambiguation',
3535
// Targets covered by another visible element are refused.
3636
'occlusion',
37+
// Targets whose tap point sits behind the visible software keyboard are refused. The keyboard is
38+
// its own system surface, so `occlusion` cannot see it and `offscreen` passes it (#2589).
39+
'keyboardOcclusion',
3740
// Element-targeted coordinate paths keep the resolved parent identity while
3841
// choosing a point outside independently interactive descendants. A parent
3942
// whose safe region is fully tiled fails closed instead of activating a child.
@@ -161,6 +164,15 @@ const RUNTIME_TREE_SHARED_GUARANTEES = {
161164
kind: 'runtime',
162165
via: 'packages/selectors/src/interaction-touch-point.ts#resolveInteractionTouchPoint',
163166
},
167+
// #2589: one guard for every acting node path, run at the shared pipeline door
168+
// (`runInteractionPipelineStages`), so the native-ref fast path cannot succeed on a target the
169+
// shared rule refuses. Its band is derived from the tree the path already holds: the keyboard is
170+
// never a covering sibling of app content and never leaves the app window rect, so neither
171+
// `occlusion` nor `offscreen` can reach it.
172+
keyboardOcclusion: {
173+
kind: 'runtime',
174+
via: 'src/commands/interaction/runtime/keyboard-occlusion.ts#assertTapTargetClearOfVisibleKeyboard',
175+
},
164176
// #1542: the base decision is the contracts-owned snapshot visibility resolver (bulk accessibility
165177
// tree), but throwIfOffscreenInteractionTarget is the actual end-to-end
166178
// enforcement point — on iOS (local, non-provider sessions only) a would-be
@@ -269,14 +281,18 @@ export const INTERACTION_DISPATCH_PATHS: Record<InteractionPathId, InteractionPa
269281
kind: 'runtime',
270282
via: 'packages/selectors/src/interaction-touch-point.ts#resolveInteractionTouchPoint',
271283
},
284+
keyboardOcclusion: {
285+
kind: 'runtime',
286+
via: 'src/commands/interaction/runtime/keyboard-occlusion.ts#assertTapTargetClearOfVisibleKeyboard',
287+
},
272288
offscreen: {
273289
kind: 'runtime',
274290
via: 'src/commands/interaction/runtime/resolution.ts#throwIfOffscreenInteractionTarget',
275291
},
276292
nonHittable: {
277293
kind: 'inapplicable',
278294
reason:
279-
'Drag endpoints name contact coordinates and intentionally need not be independently tappable controls; covered and off-screen endpoints are still refused.',
295+
'Drag endpoints name contact coordinates and intentionally need not be independently tappable controls; covered, keyboard-occluded, and off-screen endpoints are still refused.',
280296
},
281297
responseConstruction: {
282298
kind: 'runtime',
@@ -323,6 +339,13 @@ export const INTERACTION_DISPATCH_PATHS: Record<InteractionPathId, InteractionPa
323339
kind: 'runtime',
324340
via: 'packages/selectors/src/selector-pipeline.ts#runNodePipelineStages',
325341
},
342+
// Same door as the runtime tree paths: the preflight IS `runInteractionPipelineStages`, so
343+
// the keyboard guard runs before the backend call even though `occlusion` above is served by
344+
// the snapshot annotation the pipeline reads.
345+
keyboardOcclusion: {
346+
kind: 'runtime',
347+
via: 'src/commands/interaction/runtime/keyboard-occlusion.ts#assertTapTargetClearOfVisibleKeyboard',
348+
},
326349
parentOwnedTouchPoint: {
327350
kind: 'inapplicable',
328351
reason:
@@ -388,6 +411,15 @@ export const INTERACTION_DISPATCH_PATHS: Record<InteractionPathId, InteractionPa
388411
kind: 'inapplicable',
389412
reason: 'Coordinates name the exact point to activate; no parent element is resolved.',
390413
},
414+
// The classifier runs, and the refusal reason reaches the response as a warning instead of an
415+
// error: coordinates are the escape hatch that still reaches a keyboard's own control, and
416+
// this path never captures the tree the band is measured against, so a refusal would trust an
417+
// arbitrarily stale snapshot. See `describeKeyboardOccludedPointWarning`.
418+
keyboardOcclusion: {
419+
kind: 'waived',
420+
reason:
421+
'Intentional: a raw point carries no element identity to excuse a deliberate keyboard tap, and the point is checked against the last-known tree rather than one captured for this action. The shared decision still runs and publishes `tap_keyboard_occludes_target` in the response warning.',
422+
},
391423
offscreen: {
392424
kind: 'runtime',
393425
via: 'src/commands/interaction/runtime/resolution.ts#resolveInteractionTarget',
@@ -435,6 +467,11 @@ export const INTERACTION_DISPATCH_PATHS: Record<InteractionPathId, InteractionPa
435467
reason:
436468
'Intentional: the direct element-tap outcome relies on XCTest hittability instead of the daemon snapshot occlusion classifier.',
437469
},
470+
keyboardOcclusion: {
471+
kind: 'waived',
472+
reason:
473+
'Intentional: the fused runner element tap never sees a daemon tree, so no band can be derived; the daemon-resolved sibling paths refuse the same target.',
474+
},
438475
parentOwnedTouchPoint: {
439476
kind: 'waived',
440477
reason:
@@ -491,6 +528,11 @@ export const INTERACTION_DISPATCH_PATHS: Record<InteractionPathId, InteractionPa
491528
kind: 'waived',
492529
reason: 'Intentional: Maestro taps resolved bounds regardless of overlay state.',
493530
},
531+
keyboardOcclusion: {
532+
kind: 'waived',
533+
reason:
534+
'Intentional: shares the occlusion waiver above — Maestro taps resolved bounds regardless of what overlays them.',
535+
},
494536
parentOwnedTouchPoint: {
495537
kind: 'waived',
496538
reason:

‎packages/platform-apple/src/runner/__tests__/runner-client.test.ts‎

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -510,9 +510,9 @@ test('parseRunnerResponse preserves runner unsupported-operation codes', async (
510510
);
511511
});
512512

513-
test('parseRunnerResponse surfaces the keyboard-dismiss hint to press the next target directly', async () => {
513+
test('parseRunnerResponse surfaces the keyboard-dismiss hint naming the occlusion reason', async () => {
514514
const hint =
515-
'The on-screen keyboard usually does not block agent-device interactions: press the next target directly instead of retrying dismiss. If that press fails or reports no visible effect, scroll the target into view, or use keyboard enter to press the return key when submission is wanted.';
515+
"An element whose center sits behind the on-screen keyboard is refused with tap_keyboard_occludes_target; one whose center stays above the keys presses normally. To end editing, tap the app's own Done/Cancel control, or use keyboard enter to press the return key when submission is wanted.";
516516
const response = new Response(
517517
JSON.stringify({
518518
ok: false,
@@ -531,12 +531,8 @@ test('parseRunnerResponse surfaces the keyboard-dismiss hint to press the next t
531531
assert.ok(error instanceof AppError);
532532
assert.equal(error.code, 'UNSUPPORTED_OPERATION');
533533
assert.equal(error.details?.hint, hint);
534-
assert.match(
535-
String(error.details?.hint),
536-
/usually does not block agent-device interactions/i,
537-
);
538-
assert.match(String(error.details?.hint), /press the next target directly/i);
539-
assert.match(String(error.details?.hint), /scroll the target into view/i);
534+
assert.match(String(error.details?.hint), /tap_keyboard_occludes_target/);
535+
assert.match(String(error.details?.hint), /center stays above the keys/i);
540536
assert.match(String(error.details?.hint), /keyboard enter/i);
541537
return true;
542538
},

‎src/cli-schema/cli-help.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ Targets:
110110
Recovery:
111111
Network/typeahead result missing: wait text "Expected result" or wait <selector>.
112112
A target that should be gone/disappear: use wait absent <selector>; wait exists ... is rejected in favor of the plain selector wait.
113-
Keyboard visible over the next target: the on-screen keyboard usually does not block presses, so press the target directly instead of dismissing. If the press fails or reports no visible effect, scroll the target into view or use keyboard enter when submission is wanted.
113+
Keyboard visible over the next target: an element whose center sits behind the keyboard is refused with tap_keyboard_occludes_target, because the touch would activate a key instead of the target. End editing first -- the app's own Done/Cancel control, or keyboard enter when submission is wanted -- then retry. A target whose center stays above the keys still presses; a raw coordinate behind the keyboard taps anyway and reports the reason in warning.
114114
Sparse or recovered accessibility snapshot: use screenshot as visual truth, leave the bad screen if needed, then retry snapshot -i.
115115
Non-hittable success hint: verify with the settled diff or snapshot; retarget by a better ref/selector if the UI did not change.
116116
@@ -162,7 +162,7 @@ Text entry:
162162
fill replaces; type appends to an already-focused field: fill 'id="field-email"' "[email protected]"; type "Handle with care" --delay-ms 80
163163
fill <target> "" clears the field (replace with nothing); the empty argument must be present -- fill <target> alone is a missing argument.
164164
Plain fill/type first; if an iOS debounced/search-as-you-type field drops characters, retry with --delay-ms before clipboard paste.
165-
The keyboard usually does not block interactions -- press the next target directly. keyboard dismiss taps its own dismiss key when one exists, else UNSUPPORTED_OPERATION. Android: try dismiss before back. iOS: when both fail, do not tap a static text/heading hoping it is safe; prefer type "\\n" to submit.
165+
Element presses behind the keyboard are refused with tap_keyboard_occludes_target. keyboard dismiss taps its own dismiss key when one exists, else UNSUPPORTED_OPERATION. Android: try dismiss before back. iOS: when both fail, do not tap a static text/heading hoping it is safe; prefer type "\\n" to submit.
166166
iOS paste-prompt limits and Android IME/handwriting capture quirks: help debugging.
167167
168168
Session ordering:
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
import type { InteractionAction } from './resolution.ts';
2+
3+
/**
4+
* The passive verb a refusal uses for the action it declined, so every acting guard that refuses
5+
* before dispatch describes the failure in the caller's own words.
6+
*/
7+
export function interactionVerb(action: InteractionAction): string {
8+
switch (action) {
9+
case 'fill':
10+
return 'be filled';
11+
case 'focus':
12+
return 'be focused';
13+
case 'longPress':
14+
return 'be long-pressed';
15+
case 'hover':
16+
return 'be hovered';
17+
default:
18+
return 'be tapped';
19+
}
20+
}
Lines changed: 218 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,218 @@
1+
import assert from 'node:assert/strict';
2+
import { test } from 'vitest';
3+
import type { Point, Rect, SnapshotState } from '@agent-device/kernel/snapshot';
4+
import { makeSnapshotState } from '@agent-device/selectors/snapshot-geometry-fixtures';
5+
import { keyboardCoveredTabBarSnapshot } from '../../../../test/integration/interaction-contract/fixtures.ts';
6+
import { ref, selector } from './selector-read-utils.ts';
7+
import { createInteractionDevice } from './__tests__/test-utils/index.ts';
8+
9+
// #2589: the keyboard is its own system surface, so neither `occlusion` nor `offscreen` refuses a
10+
// tap whose point belongs to it. These cover the consequences the shared classifier cannot express:
11+
// which paths refuse, which disclose, and which stay silent. The tree itself is the contract
12+
// fixtures' #2589 shape, so the refusal and the disclosure are measured on the same geometry the
13+
// ADR 0011 cells claim.
14+
15+
const TAB_BAR_RECT: Rect = { x: 148, y: 791, width: 104, height: 83 };
16+
17+
/** The contract fixture with its app-owned button moved, so the variants stay one tree, not copies. */
18+
function keyboardTree(params: { tabRect?: Rect } = {}): SnapshotState {
19+
const tabRect = params.tabRect;
20+
if (!tabRect) return keyboardCoveredTabBarSnapshot();
21+
return makeSnapshotState(
22+
keyboardCoveredTabBarSnapshot().nodes.map((node) =>
23+
node.index === 1 ? { ...node, rect: tabRect } : node,
24+
),
25+
);
26+
}
27+
28+
/**
29+
* Keyboard-owned rects hauled above the docking budget: the tree stops describing a keyboard the
30+
* bottom of the screen belongs to, which is what the app-drawn-keypad and aim cases measure against.
31+
*/
32+
function liftKeyboardOffBottomEdge(nodes: SnapshotState['nodes']): SnapshotState['nodes'] {
33+
return nodes.map((node) =>
34+
node.rect && (node.type === 'Keyboard' || node.type === 'Key')
35+
? { ...node, rect: { ...node.rect, y: node.rect.y - 560 } }
36+
: node,
37+
);
38+
}
39+
40+
function tappedDevice(snapshot: SnapshotState, calls: Point[]) {
41+
return createInteractionDevice(snapshot, {
42+
tap: async (_context, point) => {
43+
calls.push(point);
44+
return { ok: true };
45+
},
46+
});
47+
}
48+
49+
test('press @ref refuses a target whose center sits behind the visible keyboard', async () => {
50+
const calls: Point[] = [];
51+
const device = tappedDevice(keyboardTree(), calls);
52+
53+
await assert.rejects(
54+
() => device.interactions.click(ref('@e2'), { session: 'default' }),
55+
(error: unknown) => {
56+
assert.ok(error instanceof Error);
57+
assert.equal((error as { code?: string }).code, 'COMMAND_FAILED');
58+
assert.match(error.message, /Ref @e2 is behind the visible keyboard/);
59+
const details = (error as { details?: Record<string, unknown> }).details;
60+
assert.equal(details?.reason, 'tap_keyboard_occludes_target');
61+
assert.equal(details?.ref, '@e2');
62+
assert.deepEqual(details?.rect, TAB_BAR_RECT);
63+
assert.deepEqual(details?.keyboardFrame, { x: 0, y: 583, width: 402, height: 291 });
64+
assert.match(String(details?.hint), /End editing first/);
65+
return true;
66+
},
67+
);
68+
assert.deepEqual(calls, []);
69+
});
70+
71+
test('fill refuses with the verb matching the action', async () => {
72+
const device = tappedDevice(keyboardTree(), []);
73+
await assert.rejects(
74+
() => device.interactions.fill(ref('@e2'), 'hello', { session: 'default' }),
75+
/cannot be filled safely/,
76+
);
77+
});
78+
79+
test('press selector refuses the same node the ref path refuses', async () => {
80+
const calls: Point[] = [];
81+
const device = tappedDevice(keyboardTree(), calls);
82+
83+
await assert.rejects(
84+
() => device.interactions.press(selector('label=Form'), { session: 'default' }),
85+
(error: unknown) => {
86+
assert.ok(error instanceof Error);
87+
assert.match(error.message, /Selector label=Form is behind the visible keyboard/);
88+
const details = (error as { details?: Record<string, unknown> }).details;
89+
assert.equal(details?.reason, 'tap_keyboard_occludes_target');
90+
return true;
91+
},
92+
);
93+
assert.deepEqual(calls, []);
94+
});
95+
96+
test('a keyboard key is a legitimate target: pressing one still taps', async () => {
97+
const calls: Point[] = [];
98+
const device = tappedDevice(keyboardTree(), calls);
99+
100+
await device.interactions.click(ref('@e6'), { session: 'default' });
101+
102+
assert.deepEqual(calls, [{ x: 202, y: 779 }]);
103+
});
104+
105+
test('an element whose center stays above the key plane still taps', async () => {
106+
const calls: Point[] = [];
107+
const peeking = { x: 148, y: 470, width: 104, height: 110 };
108+
const device = tappedDevice(keyboardTree({ tabRect: peeking }), calls);
109+
110+
await device.interactions.click(ref('@e2'), { session: 'default' });
111+
112+
assert.deepEqual(calls, [{ x: 200, y: 525 }]);
113+
});
114+
115+
test('no keyboard in the tree means nothing to refuse', async () => {
116+
const calls: Point[] = [];
117+
const withoutKeyboard = makeSnapshotState(
118+
keyboardTree().nodes.filter((node) => node.type !== 'Keyboard' && node.type !== 'Key'),
119+
);
120+
const device = tappedDevice(withoutKeyboard, calls);
121+
122+
await device.interactions.click(ref('@e2'), { session: 'default' });
123+
124+
assert.deepEqual(calls, [{ x: 200, y: 833 }]);
125+
});
126+
127+
test('an app-drawn keypad that stops short of the bottom edge is not the system keyboard', async () => {
128+
const calls: Point[] = [];
129+
const appOwnedKeypad = makeSnapshotState(liftKeyboardOffBottomEdge(keyboardTree().nodes));
130+
const device = tappedDevice(appOwnedKeypad, calls);
131+
132+
await device.interactions.click(ref('@e2'), { session: 'default' });
133+
134+
assert.deepEqual(calls, [{ x: 200, y: 833 }]);
135+
});
136+
137+
test('a coordinate behind the keyboard taps anyway and discloses the reason', async () => {
138+
const calls: Point[] = [];
139+
const device = tappedDevice(keyboardTree(), calls);
140+
141+
const result = await device.interactions.press(
142+
{ kind: 'point', x: 200, y: 810 },
143+
{
144+
session: 'default',
145+
},
146+
);
147+
148+
assert.deepEqual(calls, [{ x: 200, y: 810 }]);
149+
assert.match(result.warning ?? '', /behind the visible keyboard/);
150+
assert.match(result.warning ?? '', /tap_keyboard_occludes_target/);
151+
});
152+
153+
test('the guard reads the point the interaction dispatches, not the rect center', async () => {
154+
// The Form button's own center sits 3 pt above the key plane, and its interactive child owns that
155+
// upper region, so the point the tap dispatches is pushed down into the keyboard's band.
156+
const aimShifted = makeSnapshotState([
157+
...keyboardCoveredTabBarSnapshot().nodes,
158+
{
159+
index: 5,
160+
depth: 3,
161+
parentIndex: 1,
162+
type: 'Button',
163+
label: 'Send',
164+
rect: { x: 148, y: 500, width: 104, height: 83 },
165+
hittable: true,
166+
},
167+
]).nodes.map((node) =>
168+
node.index === 1 ? { ...node, rect: { x: 148, y: 500, width: 104, height: 160 } } : node,
169+
);
170+
171+
const calls: Point[] = [];
172+
await assert.rejects(
173+
() =>
174+
tappedDevice(makeSnapshotState(aimShifted), calls).interactions.click(ref('@e2'), {
175+
session: 'default',
176+
}),
177+
/Ref @e2 is behind the visible keyboard/,
178+
);
179+
assert.deepEqual(calls, []);
180+
181+
// The same tree with its keyboard hauled off the bottom edge shows where that tap was aiming: below
182+
// the key plane, which is what makes this the dispatched point's refusal rather than the center's.
183+
const aim: Point[] = [];
184+
await tappedDevice(
185+
makeSnapshotState(liftKeyboardOffBottomEdge(aimShifted)),
186+
aim,
187+
).interactions.click(ref('@e2'), { session: 'default' });
188+
assert.equal(aim.length, 1);
189+
assert.ok((aim[0]?.y ?? 0) > 583, `expected the dispatched point below 583, got ${aim[0]?.y}`);
190+
});
191+
192+
test('a coordinate on a reported key is the keyboard the caller asked for', async () => {
193+
const calls: Point[] = [];
194+
const device = tappedDevice(keyboardTree(), calls);
195+
196+
const result = await device.interactions.press(
197+
{ kind: 'point', x: 160, y: 760 },
198+
{
199+
session: 'default',
200+
},
201+
);
202+
203+
assert.deepEqual(calls, [{ x: 160, y: 760 }]);
204+
assert.equal(result.warning, undefined);
205+
});
206+
207+
test('the out-of-viewport disclosure still wins on a stale-tree coordinate', async () => {
208+
const device = tappedDevice(keyboardTree(), []);
209+
210+
const result = await device.interactions.press(
211+
{ kind: 'point', x: 900, y: 810 },
212+
{
213+
session: 'default',
214+
},
215+
);
216+
217+
assert.match(result.warning ?? '', /outside the last-known viewport/);
218+
});

0 commit comments

Comments
 (0)