Open History to see the last commit
1// @effect-diagnostics nodeBuiltinImport:off - resume coverage writes, appends
2// to, and truncates real transcript files byte-exactly, mirroring the reader's
3// own deliberate node:fs usage.
4import * as NodeFSP from "node:fs/promises";
5import * as NodeOS from "node:os";
6import * as NodePath from "node:path";
7import * as NodeZlib from "node:zlib";
8
9import { afterEach, assert, beforeEach, describe, it } from "@effect/vitest";
10import { totalTokens, type TranscriptUsageFormat } from "@t3tools/provider-core/server/usage";
11import * as Schema from "effect/Schema";
12
13import { TEST_FORMATS } from "./usageTestFormats.ts";
14import {
15 listTranscriptFiles,
16 readTranscriptRecords,
17 transcriptLineGate,
18} from "./usageTranscriptReader.ts";
19
20let dir: string;
21
22beforeEach(async () => {
23 dir = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "usage-reader-test-"));
24});
25
26afterEach(async () => {
27 await NodeFSP.rm(dir, { recursive: true, force: true });
28});
29
30function claudeLine(id: number, outputTokens: number): string {
31 return `${JSON.stringify({
32 type: "assistant",
33 timestamp: "2026-08-01T10:00:00Z",
34 requestId: `req_${id}`,
35 sessionId: "session-1",
36 message: {
37 id: `msg_${id}`,
38 model: "claude-fable-5",
39 usage: { input_tokens: 10, output_tokens: outputTokens },
40 },
41 })}\n`;
42}
43
44function codexMetaLine(): string {
45 return `${JSON.stringify({
46 type: "session_meta",
47 timestamp: "2026-08-01T10:00:00Z",
48 payload: { type: "session_meta", id: "codex-session-1" },
49 })}\n`;
50}
51
52function codexModelLine(model: string): string {
53 return `${JSON.stringify({
54 type: "turn_context",
55 timestamp: "2026-08-01T10:00:01Z",
56 payload: { type: "turn_context", model },
57 })}\n`;
58}
59
60function codexTierLine(serviceTier: string): string {
61 return `${JSON.stringify({
62 type: "event_msg",
63 timestamp: "2026-08-01T10:00:01Z",
64 payload: { type: "thread_settings_applied", thread_settings: { service_tier: serviceTier } },
65 })}\n`;
66}
67
68function codexUsageLine(outputTokens: number, secondsOffset: number): string {
69 return `${JSON.stringify({
70 type: "event_msg",
71 timestamp: `2026-08-01T10:00:${String(secondsOffset).padStart(2, "0")}Z`,
72 payload: {
73 type: "token_count",
74 info: { last_token_usage: { input_tokens: 100, output_tokens: outputTokens } },
75 },
76 })}\n`;
77}
78
79describe("compressed transcripts", () => {
80 it("discovers nested plain and zstd JSONL files within the requested window", async () => {
81 const nested = NodePath.join(dir, "nested");
82 await NodeFSP.mkdir(nested);
83 const plain = NodePath.join(dir, "active.jsonl");
84 const compressed = NodePath.join(nested, "archived.jsonl.zst");
85 const old = NodePath.join(nested, "old.jsonl.zst");
86 await NodeFSP.writeFile(plain, claudeLine(1, 5));
87 await NodeFSP.writeFile(compressed, NodeZlib.zstdCompressSync(claudeLine(2, 7)));
88 await NodeFSP.writeFile(old, NodeZlib.zstdCompressSync(claudeLine(3, 11)));
89 await NodeFSP.writeFile(NodePath.join(nested, "unrelated.zst"), "ignored");
90 await NodeFSP.writeFile(NodePath.join(nested, "partial.jsonl.zst.tmp"), "ignored");
91 await NodeFSP.utimes(old, 1, 1);
92
93 const listed = await listTranscriptFiles(dir, Date.parse("2026-01-01T00:00:00Z"));
94 assert.deepStrictEqual(
95 listed.files.map((file) => file.path).sort(),
96 [plain, compressed].sort(),
97 );
98 assert.strictEqual(listed.failedPaths, 0);
99 assert.isAbove(listed.files.find((file) => file.path === compressed)?.size ?? 0, 0);
100 });
101
102 it.each([
103 { parser: "native", streamingThresholdBytes: undefined },
104 { parser: "projected", streamingThresholdBytes: 1024 },
105 ])(
106 "matches plain Codex records and unfinished tails through long lines ($parser)",
107 async ({ streamingThresholdBytes }) => {
108 const plain = NodePath.join(dir, "rollout.jsonl");
109 const compressed = plain + ".zst";
110 const large = codexUsageLine(9, 5).replace(
111 '"payload":',
112 '"padding":' + JSON.stringify("日本語 é".repeat(128 * 1024)) + ',"payload":',
113 );
114 const content =
115 codexMetaLine() +
116 codexModelLine("gpt-6-astra") +
117 codexTierLine("ultrafast") +
118 large +
119 codexUsageLine(13, 6).replace('"output_tokens":13', '"output_tokens":"invalid"') +
120 codexUsageLine(21, 8).trimEnd();
121 await NodeFSP.writeFile(plain, content);
122 await NodeFSP.writeFile(compressed, NodeZlib.zstdCompressSync(content));
123
124 const options =
125 streamingThresholdBytes === undefined ? undefined : { streamingThresholdBytes };
126 const expected = await readTranscriptRecords(plain, TEST_FORMATS.codex, undefined, options);
127 const actual = await readTranscriptRecords(
128 compressed,
129 TEST_FORMATS.codex,
130 undefined,
131 options,
132 );
133 assert.isNotNull(expected);
134 assert.isNotNull(actual);
135 assert.strictEqual(expected.records.length, 1);
136 assert.strictEqual(expected.tailRecords.length, 1);
137 assert.deepStrictEqual(actual.records, expected.records);
138 assert.deepStrictEqual(actual.tailRecords, expected.tailRecords);
139 assert.strictEqual(expected.malformedRecords, 1);
140 assert.strictEqual(actual.malformedRecords, expected.malformedRecords);
141 assert.strictEqual(actual.records[0]?.speed, "ultrafast");
142 assert.isFalse(actual.resumed);
143 assert.strictEqual(actual.position.resumeOffset, 0);
144 },
145 );
146
147 it("ignores a prior resume position and rereads compressed rollouts from their start", async () => {
148 const plain = NodePath.join(dir, "rollout.jsonl");
149 const content = codexMetaLine() + codexModelLine("gpt-6-astra") + codexUsageLine(9, 5);
150 await NodeFSP.writeFile(plain, content);
151 const first = await readTranscriptRecords(plain, TEST_FORMATS.codex);
152 assert.isNotNull(first);
153
154 const compressed = plain + ".zst";
155 await NodeFSP.writeFile(compressed, NodeZlib.zstdCompressSync(content + codexUsageLine(21, 8)));
156 const actual = await readTranscriptRecords(compressed, TEST_FORMATS.codex, first.position);
157 assert.isNotNull(actual);
158 assert.isFalse(actual.resumed);
159 assert.deepStrictEqual(
160 actual.records.map((record) => record.totals.outputTokens),
161 [9, 21],
162 );
163 const repeated = await readTranscriptRecords(compressed, TEST_FORMATS.codex, actual.position);
164 assert.isNotNull(repeated);
165 assert.isFalse(repeated.resumed);
166 assert.deepStrictEqual(repeated.records, actual.records);
167 });
168
169 it("returns null for zstd decoder errors rather than caching an empty parse", async () => {
170 const path = NodePath.join(dir, "corrupt.jsonl.zst");
171 await NodeFSP.writeFile(path, "not a zstd frame");
172 assert.isNull(await readTranscriptRecords(path, TEST_FORMATS.claude));
173 });
174});
175
176describe("readTranscriptRecords resume", () => {
177 it.each([
178 { mode: "buffered", streamingThresholdBytes: Infinity },
179 { mode: "streaming", streamingThresholdBytes: 0 },
180 ])("counts malformed tails once across $mode reads and resume", async (options) => {
181 const format: TranscriptUsageFormat<{ errors: number }> = {
182 ...TEST_FORMATS.claude,
183 selectFields: { ...TEST_FORMATS.claude.selectFields, usage: true },
184 state: {
185 initial: () => ({ errors: 0 }),
186 schema: Schema.Struct({ errors: Schema.Number }),
187 },
188 parseLine(line, state) {
189 return this.parseProjected(JSON.parse(line), state);
190 },
191 parseProjected(value, state) {
192 if (
193 typeof value === "object" &&
194 value !== null &&
195 "usage" in value &&
196 value.usage === "malformed"
197 ) {
198 state.errors += 1;
199 return [];
200 }
201 return TEST_FORMATS.claude.parseProjected(value, undefined);
202 },
203 readMalformedRecords: (state: { errors: number }) => state.errors,
204 };
205 const path = NodePath.join(dir, "diagnostics.jsonl");
206 const malformed = JSON.stringify({ usage: "malformed" });
207 // Completed lines enter the projected parser only when they cross a stream chunk.
208 const committed = `${JSON.stringify({ usage: "malformed", padding: "x".repeat(256 * 1024) })}\n${claudeLine(1, 5)}`;
209 await NodeFSP.writeFile(path, committed + malformed);
210
211 const first = await readTranscriptRecords(path, format, undefined, options);
212 assert.isNotNull(first);
213 assert.deepStrictEqual(
214 first.records.map((record) => record.totals.outputTokens),
215 [5],
216 );
217 assert.deepStrictEqual(first.tailRecords, []);
218 assert.strictEqual(first.position.resumeOffset, Buffer.byteLength(committed));
219 assert.deepStrictEqual(first.position.state, { errors: 1 });
220 assert.strictEqual(first.malformedRecords, 2);
221
222 const savedPosition = JSON.parse(JSON.stringify(first.position));
223 await NodeFSP.appendFile(path, `\n${claudeLine(2, 7)}${malformed}\n`);
224 const resumed = await readTranscriptRecords(path, format, savedPosition, options);
225 assert.isNotNull(resumed);
226 assert.isTrue(resumed.resumed);
227 assert.deepStrictEqual(
228 resumed.records.map((record) => record.totals.outputTokens),
229 [7],
230 );
231 assert.deepStrictEqual(resumed.position.state, { errors: 3 });
232 assert.strictEqual(resumed.malformedRecords, 3);
233
234 const full = await readTranscriptRecords(path, format, undefined, options);
235 assert.isNotNull(full);
236 assert.deepStrictEqual([...first.records, ...resumed.records], full.records);
237 assert.deepStrictEqual(resumed.tailRecords, full.tailRecords);
238 assert.deepStrictEqual(resumed.position, full.position);
239 assert.strictEqual(resumed.malformedRecords, full.malformedRecords);
240 });
241
242 it("parses only appended lines when resuming a grown file", async () => {
243 const path = NodePath.join(dir, "claude.jsonl");
244 await NodeFSP.writeFile(path, claudeLine(1, 5) + claudeLine(2, 7));
245 const first = await readTranscriptRecords(path, TEST_FORMATS.claude);
246 assert.isNotNull(first);
247 assert.strictEqual(first.records.length, 2);
248 assert.isFalse(first.resumed);
249 assert.strictEqual(first.malformedRecords, 0);
250
251 await NodeFSP.appendFile(path, claudeLine(3, 11));
252 const second = await readTranscriptRecords(path, TEST_FORMATS.claude, first.position);
253 assert.isNotNull(second);
254 assert.isTrue(second.resumed);
255 assert.strictEqual(second.records.length, 1);
256 assert.strictEqual(second.records[0]?.totals.outputTokens, 11);
257
258 const full = await readTranscriptRecords(path, TEST_FORMATS.claude);
259 assert.isNotNull(full);
260 assert.deepStrictEqual([...first.records, ...second.records], [...full.records]);
261 });
262
263 it("carries the Codex reducer state across the resume boundary", async () => {
264 const path = NodePath.join(dir, "rollout.jsonl");
265 await NodeFSP.writeFile(
266 path,
267 codexMetaLine() + codexModelLine("gpt-5.2-codex") + codexTierLine("ultrafast"),
268 );
269 const first = await readTranscriptRecords(path, TEST_FORMATS.codex);
270 assert.isNotNull(first);
271 assert.strictEqual(first.records.length, 0);
272
273 await NodeFSP.appendFile(path, codexUsageLine(9, 5));
274 const second = await readTranscriptRecords(path, TEST_FORMATS.codex, first.position);
275 assert.isNotNull(second);
276 assert.isTrue(second.resumed);
277 assert.strictEqual(second.records.length, 1);
278 assert.strictEqual(second.records[0]?.model, "gpt-5.2-codex");
279 assert.strictEqual(second.records[0]?.speed, "ultrafast");
280 assert.strictEqual(second.records[0]?.sessionId, "codex-session-1");
281 });
282
283 it("suppresses a Codex duplicate usage event that straddles the boundary", async () => {
284 const path = NodePath.join(dir, "rollout.jsonl");
285 await NodeFSP.writeFile(
286 path,
287 codexMetaLine() + codexModelLine("gpt-5.2-codex") + codexUsageLine(9, 5),
288 );
289 const first = await readTranscriptRecords(path, TEST_FORMATS.codex);
290 assert.isNotNull(first);
291 assert.strictEqual(first.records.length, 1);
292
293 // Codex duplicates token_count at stream boundaries, including after resume points.
294 await NodeFSP.appendFile(path, codexUsageLine(9, 5) + codexUsageLine(21, 8));
295 const second = await readTranscriptRecords(path, TEST_FORMATS.codex, first.position);
296 assert.isNotNull(second);
297 assert.isTrue(second.resumed);
298 assert.deepStrictEqual(
299 second.records.map((record) => record.totals.outputTokens),
300 [21],
301 );
302 });
303
304 it("defers an unterminated trailing line to tailRecords, then consumes it once terminated", async () => {
305 const path = NodePath.join(dir, "claude.jsonl");
306 const unterminated = claudeLine(2, 7).trimEnd();
307 await NodeFSP.writeFile(path, claudeLine(1, 5) + unterminated);
308 const first = await readTranscriptRecords(path, TEST_FORMATS.claude);
309 assert.isNotNull(first);
310 assert.strictEqual(first.records.length, 1);
311 assert.strictEqual(first.tailRecords.length, 1);
312 assert.strictEqual(first.tailRecords[0]?.totals.outputTokens, 7);
313
314 await NodeFSP.appendFile(path, `\n${claudeLine(3, 11)}`);
315 const second = await readTranscriptRecords(path, TEST_FORMATS.claude, first.position);
316 assert.isNotNull(second);
317 assert.isTrue(second.resumed);
318 assert.deepStrictEqual(
319 second.records.map((record) => record.totals.outputTokens),
320 [7, 11],
321 );
322 assert.strictEqual(second.tailRecords.length, 0);
323 });
324
325 it.each([
326 { mode: "buffered", streamingThresholdBytes: Infinity },
327 { mode: "streaming", streamingThresholdBytes: 0 },
328 ])(
329 "resumes an initial Codex carried-total tail without rebilling it ($mode)",
330 async (options) => {
331 const path = NodePath.join(dir, "continuation.jsonl");
332 const usage = (input: number, output: number) => ({
333 input_tokens: input,
334 output_tokens: output,
335 });
336 const event = (last: unknown, cumulative: unknown) =>
337 JSON.stringify({
338 type: "event_msg",
339 timestamp: "2026-08-01T10:00:05Z",
340 payload: {
341 type: "token_count",
342 info: { last_token_usage: last, total_token_usage: cumulative },
343 },
344 });
345 const firstLine = event(usage(100, 20), usage(500, 60));
346 await NodeFSP.writeFile(
347 path,
348 codexMetaLine() + codexModelLine("gpt-6-astra") + codexTierLine("ultrafast") + firstLine,
349 );
350 const first = await readTranscriptRecords(path, TEST_FORMATS.codex, undefined, options);
351 assert.isNotNull(first);
352 assert.strictEqual(first.records.length, 0);
353 assert.deepStrictEqual(
354 first.tailRecords.map((r) => [r.totals.outputTokens, r.speed]),
355 [[20, "ultrafast"]],
356 );
357 assert.strictEqual(first.malformedRecords, 0);
358
359 await NodeFSP.appendFile(path, `\n${firstLine}\n${event(usage(10, 2), usage(510, 62))}\n`);
360 const resumed = await readTranscriptRecords(
361 path,
362 TEST_FORMATS.codex,
363 JSON.parse(JSON.stringify(first.position)),
364 options,
365 );
366 const full = await readTranscriptRecords(path, TEST_FORMATS.codex, undefined, options);
367 assert.isNotNull(resumed);
368 assert.isNotNull(full);
369 assert.isTrue(resumed.resumed);
370 assert.deepStrictEqual(resumed.records, full.records);
371 assert.deepStrictEqual(
372 resumed.records.map((r) => [r.totals.outputTokens, r.speed]),
373 [
374 [20, "ultrafast"],
375 [2, "ultrafast"],
376 ],
377 );
378 assert.deepStrictEqual(resumed.tailRecords, []);
379 assert.strictEqual(resumed.malformedRecords, 0);
380 assert.deepStrictEqual(resumed.position, full.position);
381 },
382 );
383
384 it.each([
385 { mode: "buffered", streamingThresholdBytes: Infinity },
386 { mode: "streaming", streamingThresholdBytes: 0 },
387 ])(
388 "bills a Codex request whose turn was interrupted before its token_count ($mode)",
389 async (options) => {
390 const path = NodePath.join(dir, "rollout.jsonl");
391 const usage = (input: number, output: number) => ({
392 input_tokens: input,
393 cached_input_tokens: 0,
394 cache_write_input_tokens: 0,
395 output_tokens: output,
396 reasoning_output_tokens: 0,
397 total_tokens: input + output,
398 });
399 const context = (turn: number) => ({
400 type: "turn_context",
401 timestamp: `2026-11-02T10:00:0${turn * 4 - 4}.000Z`,
402 payload: { turn_id: `turn-${turn}`, model: "gpt-6-sol" },
403 });
404 const request = (turn: number, id: number, timestamp: string, last: unknown) => ({
405 type: "token_usage_record",
406 timestamp,
407 payload: { turn_id: `turn-${turn}`, response_id: `resp_${id}`, usage: last },
408 });
409 const tokenCount = (timestamp: string, last: unknown, total: unknown) => ({
410 type: "event_msg",
411 timestamp,
412 payload: {
413 type: "token_count",
414 info: { last_token_usage: last, total_token_usage: total },
415 },
416 });
417 const lines = [
418 {
419 type: "session_meta",
420 timestamp: "2026-11-02T10:00:00.000Z",
421 payload: { id: "aborted-turn-repro", model_provider: "openai" },
422 },
423 context(1),
424 request(1, 1, "2026-11-02T10:00:01.000Z", usage(100, 20)),
425 tokenCount("2026-11-02T10:00:01.001Z", usage(100, 20), usage(100, 20)),
426 // Interrupted after this request finished: no token_count reports it.
427 request(1, 2, "2026-11-02T10:00:02.000Z", usage(150, 10)),
428 {
429 type: "event_msg",
430 timestamp: "2026-11-02T10:00:03.000Z",
431 payload: { type: "turn_aborted", turn_id: "turn-1", reason: "interrupted" },
432 },
433 context(2),
434 request(2, 3, "2026-11-02T10:00:05.000Z", usage(200, 30)),
435 tokenCount("2026-11-02T10:00:05.001Z", usage(200, 30), usage(450, 60)),
436 ];
437 // Lines longer than a read chunk take the projected path when streaming.
438 const padding = "x".repeat(256 * 1024);
439 await NodeFSP.writeFile(
440 path,
441 lines.map((line) => `${JSON.stringify({ padding, ...line })}\n`).join(""),
442 );
443
444 const result = await readTranscriptRecords(path, TEST_FORMATS.codex, undefined, options);
445 assert.isNotNull(result);
446 const requests = [...result.records, ...result.tailRecords]
447 .map((record) => totalTokens(record.totals))
448 .toSorted((a, b) => a - b);
449 assert.deepStrictEqual(
450 {
451 billedTokens: requests.reduce((sum, tokens) => sum + tokens, 0),
452 requests,
453 malformedRecords: result.malformedRecords,
454 },
455 { billedTokens: 510, requests: [120, 160, 230], malformedRecords: 0 },
456 );
457 },
458 );
459
460 it("re-parses from the start when the guard bytes no longer match", async () => {
461 const path = NodePath.join(dir, "claude.jsonl");
462 await NodeFSP.writeFile(path, claudeLine(1, 5));
463 const first = await readTranscriptRecords(path, TEST_FORMATS.claude);
464 assert.isNotNull(first);
465
466 await NodeFSP.writeFile(path, claudeLine(4, 13) + claudeLine(5, 17));
467 const second = await readTranscriptRecords(path, TEST_FORMATS.claude, first.position);
468 assert.isNotNull(second);
469 assert.isFalse(second.resumed);
470 assert.deepStrictEqual(
471 second.records.map((record) => record.totals.outputTokens),
472 [13, 17],
473 );
474 });
475
476 it("re-parses from the start when the file shrank below the resume point", async () => {
477 const path = NodePath.join(dir, "claude.jsonl");
478 await NodeFSP.writeFile(path, claudeLine(1, 5) + claudeLine(2, 7));
479 const first = await readTranscriptRecords(path, TEST_FORMATS.claude);
480 assert.isNotNull(first);
481
482 await NodeFSP.writeFile(path, claudeLine(3, 11));
483 const second = await readTranscriptRecords(path, TEST_FORMATS.claude, first.position);
484 assert.isNotNull(second);
485 assert.isFalse(second.resumed);
486 assert.deepStrictEqual(
487 second.records.map((record) => record.totals.outputTokens),
488 [11],
489 );
490 });
491
492 it("parses a line larger than one stream chunk", async () => {
493 const path = NodePath.join(dir, "claude.jsonl");
494 const bigLine = `${JSON.stringify({
495 type: "assistant",
496 timestamp: "2026-08-01T10:00:00Z",
497 requestId: "req_big",
498 sessionId: "session-1",
499 padding: "x".repeat(512 * 1024),
500 message: {
501 id: "msg_big",
502 model: "claude-fable-5",
503 usage: { input_tokens: 10, output_tokens: 42 },
504 },
505 })}\n`;
506 await NodeFSP.writeFile(path, bigLine + claudeLine(2, 7));
507
508 const parsed = await readTranscriptRecords(path, TEST_FORMATS.claude);
509 assert.isNotNull(parsed);
510 assert.deepStrictEqual(
511 parsed.records.map((record) => record.totals.outputTokens),
512 [42, 7],
513 );
514 });
515
516 it("keeps a CRLF Codex reducer line whose marker straddles a stream chunk", async () => {
517 const path = NodePath.join(dir, "rollout.jsonl");
518 const crlf = (line: string) => line.replace("\n", "\r\n");
519 const modelLine = crlf(codexModelLine("gpt-5.2-codex"));
520 const head = crlf(codexMetaLine());
521 const fillerBytes =
522 256 * 1024 - Buffer.byteLength(head) - modelLine.indexOf("turn_context") - 4;
523 const fillerEnvelope = crlf(`${JSON.stringify({ type: "response_item", output: "" })}\n`);
524 const padding = "é".repeat((fillerBytes - Buffer.byteLength(fillerEnvelope)) / 2);
525 const filler = crlf(`${JSON.stringify({ type: "response_item", output: padding })}\n`);
526 const content = head + filler + modelLine + crlf(codexUsageLine(40, 2));
527 await NodeFSP.writeFile(path, content);
528
529 const result = await readTranscriptRecords(path, TEST_FORMATS.codex);
530 assert.isNotNull(result);
531 assert.strictEqual(result.records.length, 1);
532 assert.strictEqual(result.records[0]?.model, "gpt-5.2-codex");
533 assert.strictEqual(result.records[0]?.sessionId, "codex-session-1");
534 assert.strictEqual(result.position.resumeOffset, Buffer.byteLength(content));
535 });
536});
537
538describe("transcriptLineGate", () => {
539 const gates = {
540 one: transcriptLineGate(['"usage"']),
541 several: transcriptLineGate(['"token_count"', '"session_meta"', '"a.b(c)"']),
542 };
543 const markers = { one: ['"usage"'], several: ['"token_count"', '"session_meta"', '"a.b(c)"'] };
544
545 it("matches markers beside multi-byte and malformed UTF-8", () => {
546 const invalid = Buffer.from([0xff, 0xc3]);
547 for (const kind of ["one", "several"] as const) {
548 for (const marker of markers[kind]) {
549 assert.isTrue(gates[kind](Buffer.from(`{"text":"日本語 é",${marker}:1}`)));
550 assert.isTrue(gates[kind](Buffer.concat([invalid, Buffer.from(marker), invalid])));
551 assert.isFalse(gates[kind](Buffer.from(`{"text":"日本語 é ${marker.slice(1, -1)}"}`)));
552 }
553 }
554 });
555});