@niwa-labs/harness 0.0.0-stage → 0.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +12 -2
- package/package.json +12 -4
- package/src/bundled.ts +61 -0
- package/src/capabilities.ts +267 -0
- package/src/conformance/control.ts +375 -0
- package/src/conformance/fixtures.ts +44 -0
- package/src/conformance/insert.ts +136 -0
- package/src/conformance/profile.ts +93 -0
- package/src/conformance/reading.ts +339 -0
- package/src/control.ts +448 -0
- package/src/declaration.ts +224 -0
- package/src/delivery.ts +75 -0
- package/src/discover.ts +291 -0
- package/src/index.ts +560 -0
- package/src/insert-report.ts +72 -0
- package/src/insert.ts +171 -0
- package/src/instance.ts +66 -0
- package/src/options.ts +83 -0
- package/src/reading.ts +415 -0
- package/src/reverse.ts +32 -0
- package/src/skills.ts +32 -0
- package/src/tools.ts +106 -0
- package/test/conformance.test.ts +512 -0
- package/test/declaration.test.ts +271 -0
- package/test/delivery.test.ts +30 -0
- package/test/life-event.test.ts +11 -0
- package/test/profile-conformance.test.ts +20 -0
- package/test/record-fields.test.ts +57 -0
- package/test/session-mode.test.ts +39 -0
- package/test/title.test.ts +38 -0
- package/test/tools-mode.test.ts +107 -0
- package/test/tools.test.ts +42 -0
- package/test/unknown-variant.test.ts +28 -0
- package/tsconfig.json +6 -0
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Niwa Labs contributors
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
CHANGED
|
@@ -1,3 +1,13 @@
|
|
|
1
|
-
#
|
|
1
|
+
# @niwa-labs/harness
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
The shared session model and the contract every harness kind implements: reading transcripts, controlling a session, injection and an explicit declaration of capabilities. Each harness protocol is translated into this model, and all other logic works only on it.
|
|
4
|
+
|
|
5
|
+
## Profiles
|
|
6
|
+
|
|
7
|
+
Every kind declares the profile of its installations (`profile: { status, of(options) }`): the paths a
|
|
8
|
+
session needs inside a box, computed from the installation's options (its program, its home with the
|
|
9
|
+
sign-in, sessions, configuration and caches) and the hosts of its model. A kind without one does not
|
|
10
|
+
register. `bind` gives each installation its profile, with the hosts the owner names in `net` added.
|
|
11
|
+
`profileConformance(binding, { cwd })` runs a session of an installation in a nono box closed to reading
|
|
12
|
+
with nothing but that profile; a kind whose installations pass declares its profile `verified`, the others
|
|
13
|
+
`admitted`.
|
package/package.json
CHANGED
|
@@ -1,6 +1,14 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@niwa-labs/harness",
|
|
3
|
-
"version": "0.0.0
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.0.0",
|
|
4
|
+
"license": "MIT",
|
|
5
|
+
"type": "module",
|
|
6
|
+
"exports": {
|
|
7
|
+
".": "./src/index.ts"
|
|
8
|
+
},
|
|
9
|
+
"dependencies": {
|
|
10
|
+
"@niwa-labs/core": "0.0.0",
|
|
11
|
+
"@niwa-labs/sandbox": "0.0.0",
|
|
12
|
+
"zod": "^4.6.7"
|
|
13
|
+
}
|
|
14
|
+
}
|
package/src/bundled.ts
ADDED
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A program niwa ships as the dependency of a kind: the ACP adapter of Claude Code is one. It is
|
|
3
|
+
* run by the runtime that runs niwa, so finding it and starting it are the same resolution and
|
|
4
|
+
* neither wants anything on the `PATH`. The kind that depends on the program finds it and hands
|
|
5
|
+
* the result to discovery.
|
|
6
|
+
*/
|
|
7
|
+
|
|
8
|
+
import { readFileSync } from "node:fs";
|
|
9
|
+
import { createRequire } from "node:module";
|
|
10
|
+
|
|
11
|
+
import { z } from "zod";
|
|
12
|
+
|
|
13
|
+
/**
|
|
14
|
+
* A bundled program as the kind that ships it found it: the package that holds it, the script
|
|
15
|
+
* inside the package as an absolute path, and the version the package says.
|
|
16
|
+
*
|
|
17
|
+
* The kind finds it because the kind declares the dependency: a package manager that keeps each
|
|
18
|
+
* package's dependencies apart shows them to that package alone. `path` is absent when the
|
|
19
|
+
* package is not installed where the kind looks.
|
|
20
|
+
*/
|
|
21
|
+
export const BundledProgramSchema = z.object({
|
|
22
|
+
/** The package that holds the program. */
|
|
23
|
+
package: z.string().min(1),
|
|
24
|
+
/** The script, as an absolute path. */
|
|
25
|
+
path: z.string().min(1).optional(),
|
|
26
|
+
/** The version the package says in its `package.json`, when it says one. */
|
|
27
|
+
version: z.string().min(1).optional(),
|
|
28
|
+
});
|
|
29
|
+
export type BundledProgram = z.output<typeof BundledProgramSchema>;
|
|
30
|
+
|
|
31
|
+
/** What of a `package.json` niwa reads: the version, when the package says one. */
|
|
32
|
+
const PackageManifestSchema = z.object({ version: z.string().min(1) });
|
|
33
|
+
|
|
34
|
+
/** The version a `package.json` says, when it says one: a version that is not a non-empty text is none. */
|
|
35
|
+
export function manifestVersion(manifest: unknown): string | undefined {
|
|
36
|
+
const parsed = PackageManifestSchema.safeParse(manifest);
|
|
37
|
+
return parsed.success ? parsed.data.version : undefined;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* Find a bundled program from the package that depends on it.
|
|
42
|
+
*
|
|
43
|
+
* `from` is the `import.meta.url` of a file of that package, and the program is looked for the
|
|
44
|
+
* way that file would import it. A program that is not installed there comes back without a path.
|
|
45
|
+
*/
|
|
46
|
+
export function findBundled(from: string, program: { readonly package: string; readonly entry: string }): BundledProgram {
|
|
47
|
+
const require = createRequire(from);
|
|
48
|
+
let path: string;
|
|
49
|
+
try {
|
|
50
|
+
path = require.resolve(`${program.package}/${program.entry}`);
|
|
51
|
+
} catch {
|
|
52
|
+
return { package: program.package };
|
|
53
|
+
}
|
|
54
|
+
let version: string | undefined;
|
|
55
|
+
try {
|
|
56
|
+
version = manifestVersion(JSON.parse(readFileSync(require.resolve(`${program.package}/package.json`), "utf8")));
|
|
57
|
+
} catch {
|
|
58
|
+
// A package that does not let its manifest be read has no version to say.
|
|
59
|
+
}
|
|
60
|
+
return version === undefined ? { package: program.package, path } : { package: program.package, path, version };
|
|
61
|
+
}
|
|
@@ -0,0 +1,267 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* What each side of a harness declares it can do, and how niwa refuses the rest
|
|
3
|
+
*.
|
|
4
|
+
*
|
|
5
|
+
* - `Unsupported`: the ability is not declared. A fact about the kind, known before the call.
|
|
6
|
+
* - `Unavailable`: the ability is declared, but this installation cannot serve it right now.
|
|
7
|
+
*
|
|
8
|
+
* An undeclared ability is never emulated: a side that cannot list sessions refuses, it does not
|
|
9
|
+
* return an empty list.
|
|
10
|
+
*/
|
|
11
|
+
|
|
12
|
+
import { NotSent } from "@niwa-labs/core";
|
|
13
|
+
import { z } from "zod";
|
|
14
|
+
|
|
15
|
+
import type { Harness } from "./instance.ts";
|
|
16
|
+
import type { KindOptions, OptionBlocks } from "./options.ts";
|
|
17
|
+
import { describeToolsMode } from "./control.ts";
|
|
18
|
+
import type { ToolsMode } from "./control.ts";
|
|
19
|
+
|
|
20
|
+
/** The three sides of a harness. */
|
|
21
|
+
export type HarnessSide = "reading" | "control" | "insert";
|
|
22
|
+
|
|
23
|
+
export const ReadingCapabilitiesSchema = z.object({
|
|
24
|
+
list: z.boolean(),
|
|
25
|
+
read: z.boolean(),
|
|
26
|
+
/** Following a session while it grows. */
|
|
27
|
+
watch: z.boolean(),
|
|
28
|
+
});
|
|
29
|
+
export type ReadingCapabilities = z.output<typeof ReadingCapabilitiesSchema>;
|
|
30
|
+
|
|
31
|
+
/**
|
|
32
|
+
* The working mode of a session, chosen once at its start: `ask` asks before file changes, `auto`
|
|
33
|
+
* works freely in its working folder and leaves the rest to the harness's own mechanism, `full`
|
|
34
|
+
* has full access and is never asked.
|
|
35
|
+
*/
|
|
36
|
+
export const SessionModeSchema = z.enum(["ask", "auto", "full"]);
|
|
37
|
+
export type SessionMode = z.output<typeof SessionModeSchema>;
|
|
38
|
+
|
|
39
|
+
/** The mode of a session started with none chosen, by the call or by the instance. */
|
|
40
|
+
export const DEFAULT_SESSION_MODE: SessionMode = "auto";
|
|
41
|
+
|
|
42
|
+
export const LaunchCapabilitiesSchema = z.object({
|
|
43
|
+
model: z.boolean(),
|
|
44
|
+
effort: z.array(z.string()),
|
|
45
|
+
/** The modes the kind can give a session. */
|
|
46
|
+
modes: z.array(SessionModeSchema).default([]),
|
|
47
|
+
});
|
|
48
|
+
export type LaunchCapabilities = z.output<typeof LaunchCapabilitiesSchema>;
|
|
49
|
+
|
|
50
|
+
export const ControlCapabilitiesSchema = z.object({
|
|
51
|
+
start: z.boolean(),
|
|
52
|
+
resume: z.boolean(),
|
|
53
|
+
send: z.boolean(),
|
|
54
|
+
interrupt: z.boolean(),
|
|
55
|
+
/** An answer by schema, natively or through "submit answer". */
|
|
56
|
+
ask: z.boolean(),
|
|
57
|
+
/**
|
|
58
|
+
* The control side's `ask` returns a value that already passed the schema.
|
|
59
|
+
*
|
|
60
|
+
* Without it the control side has no such `ask`: niwa gives the session the action to submit an
|
|
61
|
+
* answer, and the session calls it. A kind declares it in the sides it offers by default; the
|
|
62
|
+
* instance inherits it from there.
|
|
63
|
+
*/
|
|
64
|
+
structuredOutput: z.boolean().default(false),
|
|
65
|
+
/**
|
|
66
|
+
* What the control side applies to a session when it starts it: the session keeps it for its
|
|
67
|
+
* whole life, and no start with another value is made up for it.
|
|
68
|
+
*
|
|
69
|
+
* `model` says whether a model can be chosen; `effort` lists the levels it accepts, none when
|
|
70
|
+
* it accepts no effort; `modes` lists the working modes it can give. A request outside this is
|
|
71
|
+
* refused before the session is started.
|
|
72
|
+
*/
|
|
73
|
+
launch: LaunchCapabilitiesSchema.default({ model: false, effort: [], modes: [] }),
|
|
74
|
+
/**
|
|
75
|
+
* The tool modes the control side can hold a session to, beyond `all`, which every side can:
|
|
76
|
+
* only niwa's tools, and an allow-list of the harness's own. A mode outside this is refused
|
|
77
|
+
* before the session is started; an installation that says nothing of them holds neither.
|
|
78
|
+
*/
|
|
79
|
+
tools: z.object({ niwaOnly: z.boolean(), allow: z.boolean() }).optional(),
|
|
80
|
+
});
|
|
81
|
+
export type ControlCapabilities = z.output<typeof ControlCapabilitiesSchema>;
|
|
82
|
+
|
|
83
|
+
export const InsertCapabilitiesSchema = z.object({
|
|
84
|
+
/** Reports that a nested session was spawned. */
|
|
85
|
+
nested: z.boolean(),
|
|
86
|
+
/** Reports that the context was compacted. */
|
|
87
|
+
compaction: z.boolean(),
|
|
88
|
+
/** Reports that the owner opened a session by hand. */
|
|
89
|
+
manualOpen: z.boolean(),
|
|
90
|
+
/** Reports that a tool asks for permission. */
|
|
91
|
+
permission: z.boolean(),
|
|
92
|
+
/** Reports that the harness ended a session. */
|
|
93
|
+
end: z.boolean(),
|
|
94
|
+
});
|
|
95
|
+
export type InsertCapabilities = z.output<typeof InsertCapabilitiesSchema>;
|
|
96
|
+
|
|
97
|
+
/**
|
|
98
|
+
* Which sides an installation has and what each can do. An absent side does not exist; every call
|
|
99
|
+
* to it is refused.
|
|
100
|
+
*/
|
|
101
|
+
export const SideCapabilitiesSchema = z.object({
|
|
102
|
+
reading: ReadingCapabilitiesSchema.optional(),
|
|
103
|
+
control: ControlCapabilitiesSchema.optional(),
|
|
104
|
+
insert: InsertCapabilitiesSchema.optional(),
|
|
105
|
+
});
|
|
106
|
+
export type SideCapabilities = z.output<typeof SideCapabilitiesSchema>;
|
|
107
|
+
|
|
108
|
+
/** The ability names of each side. */
|
|
109
|
+
export interface SideAbilities {
|
|
110
|
+
reading: keyof ReadingCapabilities;
|
|
111
|
+
control: Exclude<keyof ControlCapabilities, "launch" | "tools">;
|
|
112
|
+
insert: keyof InsertCapabilities;
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
/** The ability is not declared for that side. Refused by name, before anything is sent. */
|
|
116
|
+
export class Unsupported extends NotSent {
|
|
117
|
+
override name = "Unsupported";
|
|
118
|
+
override readonly code = "Unsupported";
|
|
119
|
+
|
|
120
|
+
constructor(
|
|
121
|
+
readonly harness: Harness["id"],
|
|
122
|
+
readonly side: HarnessSide,
|
|
123
|
+
readonly ability: string,
|
|
124
|
+
detail?: string,
|
|
125
|
+
) {
|
|
126
|
+
super(
|
|
127
|
+
`harness "${harness}" does not support ${side}.${ability}` + (detail ? `: ${detail}` : ""),
|
|
128
|
+
);
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
/** The ability is declared, but this installation cannot serve it right now. */
|
|
133
|
+
export class Unavailable extends Error {
|
|
134
|
+
override name = "Unavailable";
|
|
135
|
+
readonly code = "Unavailable";
|
|
136
|
+
|
|
137
|
+
constructor(
|
|
138
|
+
readonly harness: Harness["id"],
|
|
139
|
+
readonly side: HarnessSide,
|
|
140
|
+
readonly ability: string,
|
|
141
|
+
detail?: string,
|
|
142
|
+
) {
|
|
143
|
+
super(
|
|
144
|
+
`harness "${harness}" cannot serve ${side}.${ability} right now` +
|
|
145
|
+
(detail ? `: ${detail}` : ""),
|
|
146
|
+
);
|
|
147
|
+
}
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
/** Whether the instance declares the ability. */
|
|
151
|
+
export function supports<S extends HarnessSide>(
|
|
152
|
+
instance: Harness,
|
|
153
|
+
side: S,
|
|
154
|
+
ability: SideAbilities[S],
|
|
155
|
+
): boolean {
|
|
156
|
+
const declared: Partial<Record<string, unknown>> | undefined = instance.sides[side];
|
|
157
|
+
return declared?.[ability] === true;
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
/** Refuse with `Unsupported`, before anything is attempted, when the ability is not declared. */
|
|
161
|
+
export function requireAbility<S extends HarnessSide>(
|
|
162
|
+
instance: Harness,
|
|
163
|
+
side: S,
|
|
164
|
+
ability: SideAbilities[S],
|
|
165
|
+
): void {
|
|
166
|
+
if (!supports(instance, side, ability)) {
|
|
167
|
+
throw new Unsupported(
|
|
168
|
+
instance.id,
|
|
169
|
+
side,
|
|
170
|
+
ability,
|
|
171
|
+
instance.sides[side] === undefined ? `the ${side} side does not exist` : undefined,
|
|
172
|
+
);
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
/**
|
|
177
|
+
* The mode a session starts in: the call's, else the instance's, else the default of the kind.
|
|
178
|
+
*
|
|
179
|
+
* The default is `auto` when the kind can give it, else the first mode the kind declares, so a
|
|
180
|
+
* kind is never given a default it does not support. A kind that declares no modes gets `auto`,
|
|
181
|
+
* which `requireLaunch` then refuses if a mode is asked for.
|
|
182
|
+
*/
|
|
183
|
+
export function modeOf(
|
|
184
|
+
requested: SessionMode | undefined,
|
|
185
|
+
instance: SessionMode | undefined,
|
|
186
|
+
launch: LaunchCapabilities,
|
|
187
|
+
): SessionMode {
|
|
188
|
+
const supported = launch.modes.includes(DEFAULT_SESSION_MODE) ? undefined : launch.modes[0];
|
|
189
|
+
return requested ?? instance ?? supported ?? DEFAULT_SESSION_MODE;
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
/**
|
|
193
|
+
* Refuse with `Unsupported`, before a session is started, a model, an effort or a mode the kind
|
|
194
|
+
* cannot apply at launch. The error says what the kind does support; nothing is dropped.
|
|
195
|
+
*/
|
|
196
|
+
export function requireLaunch(
|
|
197
|
+
harness: Harness["id"],
|
|
198
|
+
launch: LaunchCapabilities,
|
|
199
|
+
requested: {
|
|
200
|
+
readonly model?: string | undefined;
|
|
201
|
+
readonly effort?: string | undefined;
|
|
202
|
+
readonly mode?: SessionMode | undefined;
|
|
203
|
+
},
|
|
204
|
+
): void {
|
|
205
|
+
if (requested.mode !== undefined && !launch.modes.includes(requested.mode)) {
|
|
206
|
+
throw new Unsupported(
|
|
207
|
+
harness,
|
|
208
|
+
"control",
|
|
209
|
+
"start",
|
|
210
|
+
launch.modes.length === 0
|
|
211
|
+
? `it has no working modes (asked for "${requested.mode}")`
|
|
212
|
+
: `the mode "${requested.mode}" is not one of ${launch.modes.join(", ")}; ` +
|
|
213
|
+
"choose one of them for the session, or set `control.mode` on the instance",
|
|
214
|
+
);
|
|
215
|
+
}
|
|
216
|
+
if (requested.model !== undefined && requested.model !== "" && !launch.model) {
|
|
217
|
+
throw new Unsupported(harness, "control", "start", `it cannot choose a model per session (asked for "${requested.model}")`);
|
|
218
|
+
}
|
|
219
|
+
if (requested.effort !== undefined && requested.effort !== "" && !launch.effort.includes(requested.effort)) {
|
|
220
|
+
throw new Unsupported(
|
|
221
|
+
harness,
|
|
222
|
+
"control",
|
|
223
|
+
"start",
|
|
224
|
+
launch.effort.length === 0
|
|
225
|
+
? `it accepts no effort (asked for "${requested.effort}")`
|
|
226
|
+
: `effort "${requested.effort}" is not one of ${launch.effort.join(", ")}`,
|
|
227
|
+
);
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
/**
|
|
232
|
+
* Refuse with `Unsupported`, before a session is started, an options block that is not the one of
|
|
233
|
+
* the kind: a kind takes the block it declares and no other, and nothing is ignored. The kind's own
|
|
234
|
+
* block is checked by its schema, and is what is returned: the blocks the session is given.
|
|
235
|
+
*/
|
|
236
|
+
export function requireOwnBlocks(harness: Harness["id"], kind: KindOptions | undefined, given: OptionBlocks): OptionBlocks {
|
|
237
|
+
const foreign = Object.entries(given).flatMap(([name, value]) => (value !== undefined && name !== kind?.block ? [name] : []));
|
|
238
|
+
if (foreign.length > 0) {
|
|
239
|
+
throw new Unsupported(
|
|
240
|
+
harness,
|
|
241
|
+
"control",
|
|
242
|
+
"start",
|
|
243
|
+
kind === undefined
|
|
244
|
+
? `it takes no options (asked for "${foreign.join('", "')}")`
|
|
245
|
+
: `it takes the "${kind.block}" options block only (asked for "${foreign.join('", "')}")`,
|
|
246
|
+
);
|
|
247
|
+
}
|
|
248
|
+
const own = kind === undefined ? undefined : given[kind.block];
|
|
249
|
+
if (kind === undefined || own === undefined) return {};
|
|
250
|
+
const checked = kind.schema.safeParse(own);
|
|
251
|
+
if (!checked.success) throw new Error(`the "${kind.block}" options block of harness "${harness}" is refused: ${z.prettifyError(checked.error)}`);
|
|
252
|
+
return { [kind.block]: checked.data };
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
/**
|
|
256
|
+
* Refuse with `Unsupported`, before a session is started, a tool mode the side cannot hold the
|
|
257
|
+
* session to. `all` is never refused.
|
|
258
|
+
*/
|
|
259
|
+
export function requireTools(
|
|
260
|
+
harness: Harness["id"],
|
|
261
|
+
tools: ControlCapabilities["tools"] | undefined,
|
|
262
|
+
mode: ToolsMode | undefined,
|
|
263
|
+
): void {
|
|
264
|
+
if (mode === undefined || mode === "all") return;
|
|
265
|
+
const held = mode === "niwa-only" ? tools?.niwaOnly === true : tools?.allow === true;
|
|
266
|
+
if (!held) throw new Unsupported(harness, "control", "start", describeToolsMode(mode));
|
|
267
|
+
}
|