Open History to see the last commit
1import { requestGuarded, runStreamGuarded } from "../rpc/client.ts";
2import { EnvironmentSupervisor } from "../connection/supervisor.ts";
3import * as SubscriptionRef from "effect/SubscriptionRef";
4import * as Option from "effect/Option";
5import * as Stream from "effect/Stream";
6import type { RpcSession } from "../rpc/session.ts";
7import { describe, expect, it } from "@effect/vitest";
8import { vi } from "vite-plus/test";
9import {
10 AuthAccessReadScope,
11 AuthAccessWriteScope,
12 AuthEnvironmentMaintainScope,
13 AuthOrchestrationOperateScope,
14 AuthOrchestrationReadScope,
15 AuthPreviewOperateScope,
16 AuthProvidersManageScope,
17 AuthSettingsWriteScope,
18 AuthSourceControlWriteScope,
19 ThreadId,
20 EnvironmentId,
21 ORCHESTRATION_V2_WS_METHODS,
22 ScheduledTaskId,
23 WS_METHODS,
24 type AuthSessionState,
25 type PeerLinkSummary,
26} from "@t3tools/contracts";
27import * as Cause from "effect/Cause";
28import * as DateTime from "effect/DateTime";
29import * as Effect from "effect/Effect";
30import * as Fiber from "effect/Fiber";
31import * as Layer from "effect/Layer";
32import { Atom, AtomRegistry, AsyncResult } from "effect/reactivity";
33import { EnvironmentRegistry } from "../connection/registry.ts";
34import { createCommandPermissions } from "./commandPermissions.ts";
35import { createEnvironmentRpcCommand } from "./runtime.ts";
36import { AVAILABLE_CONNECTION_STATE, BearerConnectionTarget } from "../connection/model.ts";
37import { createPeerLinkEnvironmentAtoms } from "./peerLinks.ts";
38
39vi.mock("./session.ts", () => ({
40 createEnvironmentSessionAtoms: () => ({ sessionStateAtom: sessions }),
41}));
42const sessions = Atom.family((_id: EnvironmentId) =>
43 Atom.make<AsyncResult.AsyncResult<AuthSessionState, string>>(AsyncResult.initial()),
44);
45const env = EnvironmentId.make("target");
46const other = EnvironmentId.make("other");
47const grant = (allowed: boolean): AuthSessionState => ({
48 authenticated: true,
49 auth: {
50 policy: "remote-reachable",
51 bootstrapMethods: [],
52 sessionMethods: [],
53 sessionCookieName: "test",
54 },
55 scopes: allowed ? [AuthOrchestrationOperateScope] : [],
56 permissions: allowed ? [AuthOrchestrationOperateScope] : [],
57});
58const runtime = Atom.runtime(
59 Layer.succeed(EnvironmentRegistry, {
60 run: (_id: EnvironmentId, effect: Effect.Effect<unknown>) => effect,
61 } as unknown as EnvironmentRegistry["Service"]),
62);
63const permissions = createCommandPermissions(runtime, WS_METHODS.scheduledTasksDelete);
64const setup = Effect.gen(function* () {
65 const registry = AtomRegistry.make();
66 registry.mount(sessions(env));
67 yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose()));
68 return registry;
69});
70
71describe("command permissions", () => {
72 it.effect("requires the destination read grant to refresh providers", () =>
73 Effect.scoped(
74 Effect.gen(function* () {
75 const registry = yield* setup;
76 const refresh = createCommandPermissions(runtime, WS_METHODS.serverRefreshProviders);
77 registry.set(sessions(env), AsyncResult.success(grant(true)));
78 expect(registry.get(refresh.permissionAtom(env))).toBe(false);
79 expect((yield* refresh.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
80 "EnvironmentAuthorizationError",
81 );
82 registry.set(
83 sessions(env),
84 AsyncResult.success({
85 ...grant(false),
86 scopes: [AuthOrchestrationReadScope],
87 permissions: [AuthOrchestrationReadScope],
88 }),
89 );
90 expect(registry.get(refresh.permissionAtom(env))).toBe(true);
91 yield* refresh.authorize(registry, env);
92 registry.set(sessions(other), AsyncResult.success(grant(false)));
93 expect(registry.get(refresh.permissionAtom(other))).toBe(false);
94 expect((yield* refresh.authorize(registry, other).pipe(Effect.flip))._tag).toBe(
95 "EnvironmentAuthorizationError",
96 );
97 registry.set(sessions(env), AsyncResult.success(grant(false)));
98 expect(registry.get(refresh.permissionAtom(env))).toBe(false);
99 expect((yield* refresh.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
100 "EnvironmentAuthorizationError",
101 );
102 }),
103 ),
104 );
105
106 it.effect("requires the destination preview grant to close a browser tab", () =>
107 Effect.scoped(
108 Effect.gen(function* () {
109 const registry = yield* setup;
110 const close = createCommandPermissions(runtime, WS_METHODS.previewClose);
111 registry.set(sessions(env), AsyncResult.success(grant(true)));
112 expect(registry.get(close.permissionAtom(env))).toBe(false);
113 expect((yield* close.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
114 "EnvironmentAuthorizationError",
115 );
116 registry.set(
117 sessions(env),
118 AsyncResult.success({
119 ...grant(false),
120 scopes: [AuthPreviewOperateScope],
121 permissions: [AuthPreviewOperateScope],
122 }),
123 );
124 expect(registry.get(close.permissionAtom(env))).toBe(true);
125 yield* close.authorize(registry, env);
126 registry.set(sessions(other), AsyncResult.success(grant(false)));
127 expect(registry.get(close.permissionAtom(other))).toBe(false);
128 expect((yield* close.authorize(registry, other).pipe(Effect.flip))._tag).toBe(
129 "EnvironmentAuthorizationError",
130 );
131 }),
132 ),
133 );
134
135 it.effect("requires the destination provider grant to remove an incomplete connection", () =>
136 Effect.scoped(
137 Effect.gen(function* () {
138 const registry = yield* setup;
139 const remove = createCommandPermissions(runtime, WS_METHODS.providerAuthRemoveMethod);
140 registry.set(sessions(env), AsyncResult.success(grant(true)));
141 expect(registry.get(remove.permissionAtom(env))).toBe(false);
142 expect((yield* remove.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
143 "EnvironmentAuthorizationError",
144 );
145 registry.set(
146 sessions(env),
147 AsyncResult.success({
148 ...grant(false),
149 scopes: [AuthProvidersManageScope],
150 permissions: [AuthProvidersManageScope],
151 }),
152 );
153 expect(registry.get(remove.permissionAtom(env))).toBe(true);
154 yield* remove.authorize(registry, env);
155 registry.set(sessions(other), AsyncResult.success(grant(false)));
156 expect(registry.get(remove.permissionAtom(other))).toBe(false);
157 }),
158 ),
159 );
160
161 it.effect.each([
162 { method: WS_METHODS.serverRunStorageCleanup, scope: AuthSettingsWriteScope },
163 { method: WS_METHODS.serverReclaimDatabaseSpace, scope: AuthEnvironmentMaintainScope },
164 ])("requires the destination $scope grant for $method", ({ method, scope }) =>
165 Effect.scoped(
166 Effect.gen(function* () {
167 const registry = yield* setup;
168 const command = createCommandPermissions(runtime, method);
169 registry.set(sessions(env), AsyncResult.success(grant(true)));
170 expect(registry.get(command.permissionAtom(env))).toBe(false);
171 expect((yield* command.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
172 "EnvironmentAuthorizationError",
173 );
174 registry.set(
175 sessions(env),
176 AsyncResult.success({ ...grant(true), scopes: [scope], permissions: [scope] }),
177 );
178 expect(registry.get(command.permissionAtom(env))).toBe(true);
179 yield* command.authorize(registry, env);
180 registry.set(sessions(other), AsyncResult.success(grant(false)));
181 expect(registry.get(command.permissionAtom(other))).toBe(false);
182 }),
183 ),
184 );
185
186 it.effect("requires the destination settings grant to check OTLP endpoints", () =>
187 Effect.scoped(
188 Effect.gen(function* () {
189 const registry = yield* setup;
190 const check = createCommandPermissions(runtime, WS_METHODS.serverCheckOtlpEndpoint);
191 registry.set(sessions(env), AsyncResult.success(grant(true)));
192 expect(registry.get(check.permissionAtom(env))).toBe(false);
193 registry.set(
194 sessions(env),
195 AsyncResult.success({
196 ...grant(false),
197 scopes: [AuthSettingsWriteScope],
198 permissions: [AuthSettingsWriteScope],
199 }),
200 );
201 expect(registry.get(check.permissionAtom(env))).toBe(true);
202 yield* check.authorize(registry, env);
203 }),
204 ),
205 );
206
207 it.effect.each([WS_METHODS.scheduledTasksDelete, ORCHESTRATION_V2_WS_METHODS.stopWorkflow])(
208 "uses the target grant for both availability and execution of %s",
209 (method) =>
210 Effect.scoped(
211 Effect.gen(function* () {
212 const registry = yield* setup;
213 const permissions = createCommandPermissions(runtime, method);
214 registry.set(sessions(env), AsyncResult.success(grant(true)));
215 expect(registry.get(permissions.permissionAtom(env))).toBe(true);
216 expect(permissions.permissionAtom(env)).toBe(permissions.permissionAtom(env));
217 yield* permissions.authorize(registry, env);
218 registry.set(sessions(other), AsyncResult.success(grant(false)));
219 expect(registry.get(permissions.permissionAtom(other))).toBe(false);
220 const denied = yield* permissions.authorize(registry, other).pipe(Effect.flip);
221 expect(denied._tag).toBe("EnvironmentAuthorizationError");
222 }),
223 ),
224 );
225 it.effect("waits for an initial grant", () =>
226 Effect.scoped(
227 Effect.gen(function* () {
228 const registry = yield* setup;
229 const fiber = yield* permissions.authorize(registry, env).pipe(Effect.forkChild);
230 yield* Effect.yieldNow;
231 registry.set(sessions(env), AsyncResult.success(grant(true)));
232 yield* Fiber.join(fiber);
233 }),
234 ),
235 );
236 it.effect(
237 "denies failed and unauthenticated sessions, but accepts a cached refreshing grant",
238 () =>
239 Effect.scoped(
240 Effect.gen(function* () {
241 const registry = yield* setup;
242 registry.set(sessions(env), AsyncResult.failure(Cause.fail("offline")));
243 expect((yield* permissions.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
244 "EnvironmentAuthorizationError",
245 );
246 registry.set(
247 sessions(env),
248 AsyncResult.success({ ...grant(true), authenticated: false }),
249 );
250 expect((yield* permissions.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
251 "EnvironmentAuthorizationError",
252 );
253 registry.set(sessions(env), AsyncResult.waiting(AsyncResult.success(grant(true))));
254 yield* permissions.authorize(registry, env);
255 }),
256 ),
257 );
258 it("rechecks permission after waiting in a serial command lane", async () => {
259 const registry = AtomRegistry.make();
260 const unmount = registry.mount(sessions(env));
261 registry.set(sessions(env), AsyncResult.success(grant(true)));
262 let release!: () => void;
263 let started!: () => void;
264 const entered = new Promise<void>((resolve) => {
265 started = resolve;
266 });
267 const gate = new Promise<void>((resolve) => {
268 release = resolve;
269 });
270 let calls = 0;
271 const command = createEnvironmentRpcCommand(runtime, {
272 label: "test.delete",
273 tag: WS_METHODS.scheduledTasksDelete,
274 concurrency: { mode: "serial", key: () => "target" },
275 execute: () =>
276 Effect.promise(async () => {
277 calls++;
278 started();
279 await gate;
280 return { id: ScheduledTaskId.make("task") };
281 }),
282 });
283 const target = { environmentId: env, input: { id: ScheduledTaskId.make("task") } };
284 try {
285 const first = command.run(registry, target);
286 await entered;
287 const second = command.run(registry, target);
288 registry.set(sessions(env), AsyncResult.success(grant(false)));
289 release();
290 expect((await first)._tag).toBe("Success");
291 expect((await second)._tag).toBe("Failure");
292 expect(calls).toBe(1);
293 } finally {
294 unmount();
295 registry.dispose();
296 }
297 });
298});
299
300it.effect(
301 "requires source control alone for git, and both grants when attaching a worktree to a thread",
302 () =>
303 Effect.scoped(
304 Effect.gen(function* () {
305 const registry = yield* setup;
306 registry.set(sessions(env), AsyncResult.success(grant(true)));
307 const git = createCommandPermissions(runtime, WS_METHODS.vcsInit);
308 expect((yield* git.authorize(registry, env).pipe(Effect.flip)).requiredPermission).toBe(
309 AuthSourceControlWriteScope,
310 );
311 registry.set(
312 sessions(env),
313 AsyncResult.success({
314 ...grant(false),
315 scopes: [AuthSourceControlWriteScope],
316 permissions: [AuthSourceControlWriteScope],
317 }),
318 );
319 yield* git.authorize(registry, env);
320 const prepare = createCommandPermissions(runtime, WS_METHODS.gitPreparePullRequestThread);
321 const input = {
322 cwd: "/repo",
323 reference: "123",
324 mode: "worktree",
325 threadId: ThreadId.make("thread"),
326 };
327 expect(registry.get(prepare.permissionAtom(env, input))).toBe(false);
328 expect(
329 (yield* prepare.authorize(registry, env, input).pipe(Effect.flip)).requiredScope,
330 ).toBe(AuthOrchestrationOperateScope);
331 yield* prepare.authorize(registry, env, { ...input, threadId: undefined });
332 registry.set(
333 sessions(env),
334 AsyncResult.success({
335 ...grant(true),
336 scopes: [AuthSourceControlWriteScope, AuthOrchestrationOperateScope],
337 permissions: [AuthSourceControlWriteScope, AuthOrchestrationOperateScope],
338 }),
339 );
340 expect(registry.get(prepare.permissionAtom(env, input))).toBe(true);
341 yield* prepare.authorize(registry, env, input);
342 }),
343 ),
344);
345
346it.effect.each(["commit", "push", "commit_push", "create_pr", "commit_push_pr"] as const)(
347 "%s needs thread read permission only when generating a PR from a thread",
348 (action) =>
349 Effect.scoped(
350 Effect.gen(function* () {
351 const registry = yield* setup;
352 const command = createCommandPermissions(runtime, WS_METHODS.gitRunStackedAction);
353 const input = { actionId: "action", cwd: "/repo", action };
354 const withThread = { ...input, threadId: ThreadId.make("thread") };
355 const session = {
356 ...grant(false),
357 scopes: [AuthSourceControlWriteScope],
358 permissions: [AuthSourceControlWriteScope],
359 };
360 registry.set(sessions(env), AsyncResult.success(session));
361 expect(registry.get(command.permissionAtom(env, input))).toBe(true);
362 yield* command.authorize(registry, env, input);
363 const readsThread = action === "create_pr" || action === "commit_push_pr";
364 expect(registry.get(command.permissionAtom(env, withThread))).toBe(!readsThread);
365 if (readsThread) {
366 expect(
367 yield* command.authorize(registry, env, withThread).pipe(Effect.flip),
368 ).toMatchObject({ requiredPermission: AuthOrchestrationReadScope });
369 } else {
370 yield* command.authorize(registry, env, withThread);
371 }
372 registry.set(
373 sessions(env),
374 AsyncResult.success({
375 ...session,
376 scopes: [AuthSourceControlWriteScope, AuthOrchestrationReadScope],
377 permissions: [AuthSourceControlWriteScope, AuthOrchestrationReadScope],
378 }),
379 );
380 expect(registry.get(command.permissionAtom(env, withThread))).toBe(true);
381 yield* command.authorize(registry, env, withThread);
382 }),
383 ),
384);
385
386it.effect(
387 "refreshes linked environments after permitted writes and blocks a read-only session",
388 () =>
389 Effect.scoped(
390 Effect.gen(function* () {
391 const registry = yield* setup;
392 const peer: PeerLinkSummary = {
393 environmentId: EnvironmentId.make("peer"),
394 label: "Box",
395 urls: ["https://box.example.test"],
396 access: "auto",
397 linkedAt: DateTime.makeUnsafe("2026-10-01T12:00:00Z"),
398 expiresAt: DateTime.makeUnsafe("2026-10-31T12:00:00Z"),
399 lastReachedAt: null,
400 lastError: null,
401 status: "reachable",
402 };
403 let links: ReadonlyArray<PeerLinkSummary> = [];
404 const client = {
405 [WS_METHODS.peerLinksList]: () => Effect.sync(() => ({ links })),
406 [WS_METHODS.peerLinksLink]: vi.fn(() =>
407 Effect.sync(() => {
408 links = [peer];
409 return peer;
410 }),
411 ),
412 [WS_METHODS.peerLinksUnlink]: vi.fn(() =>
413 Effect.sync(() => {
414 links = [];
415 return { removed: true };
416 }),
417 ),
418 };
419 const supervisor = {
420 target: new BearerConnectionTarget({
421 environmentId: env,
422 label: "Test",
423 connectionId: "test",
424 }),
425 session: yield* SubscriptionRef.make(Option.some({ client } as unknown as RpcSession)),
426 state: yield* SubscriptionRef.make({
427 ...AVAILABLE_CONNECTION_STATE,
428 phase: "connected" as const,
429 }),
430 } as EnvironmentSupervisor["Service"];
431 const peerRuntime = Atom.runtime(
432 Layer.succeed(EnvironmentRegistry, {
433 run: (id, effect) => {
434 expect(id).toBe(env);
435 return Effect.provideService(effect, EnvironmentSupervisor, supervisor);
436 },
437 followStream: (id, stream) => {
438 expect(id).toBe(env);
439 return Stream.provideService(stream, EnvironmentSupervisor, supervisor);
440 },
441 } as EnvironmentRegistry["Service"]),
442 );
443 const peerLinks = createPeerLinkEnvironmentAtoms(peerRuntime);
444 const list = peerLinks.list({ environmentId: env, input: {} });
445 registry.mount(list);
446 const readLinks = AtomRegistry.getResult(registry, list, { suspendOnWaiting: true });
447 const setAccess = (writable: boolean) =>
448 registry.set(
449 sessions(env),
450 AsyncResult.success({
451 ...grant(false),
452 scopes: [AuthAccessReadScope, ...(writable ? [AuthAccessWriteScope] : [])],
453 permissions: [AuthAccessReadScope, ...(writable ? [AuthAccessWriteScope] : [])],
454 }),
455 );
456 registry.mount(sessions(other));
457 registry.set(
458 sessions(other),
459 AsyncResult.success({
460 ...grant(false),
461 scopes: [AuthAccessWriteScope],
462 permissions: [AuthAccessWriteScope],
463 }),
464 );
465 setAccess(false);
466 expect(yield* readLinks).toEqual({ links: [] });
467 const linkInput = { url: peer.urls[0]!, pairingCode: "test-code", access: peer.access };
468 const link = Effect.promise(() =>
469 peerLinks.link.run(registry, { environmentId: env, input: linkInput }),
470 );
471 const unlink = Effect.promise(() =>
472 peerLinks.unlink.run(registry, {
473 environmentId: env,
474 input: { environmentId: peer.environmentId },
475 }),
476 );
477 expect(registry.get(peerLinks.link.permissionAtom(env))).toBe(false);
478 const deniedLink = yield* link;
479 expect(deniedLink._tag).toBe("Failure");
480 if (deniedLink._tag === "Failure") {
481 expect(Cause.squash(deniedLink.cause)).toMatchObject({
482 _tag: "EnvironmentAuthorizationError",
483 requiredPermission: AuthAccessWriteScope,
484 });
485 }
486 expect(client[WS_METHODS.peerLinksLink]).not.toHaveBeenCalled();
487 setAccess(true);
488 expect(registry.get(peerLinks.link.permissionAtom(env))).toBe(true);
489 expect((yield* link)._tag).toBe("Success");
490 expect(client[WS_METHODS.peerLinksLink]).toHaveBeenCalledExactlyOnceWith(linkInput);
491 expect(yield* readLinks).toEqual({ links: [peer] });
492
493 setAccess(false);
494 expect(registry.get(peerLinks.unlink.permissionAtom(env))).toBe(false);
495 const deniedUnlink = yield* unlink;
496 expect(deniedUnlink._tag).toBe("Failure");
497 if (deniedUnlink._tag === "Failure") {
498 expect(Cause.squash(deniedUnlink.cause)).toMatchObject({
499 _tag: "EnvironmentAuthorizationError",
500 requiredPermission: AuthAccessWriteScope,
501 });
502 }
503 expect(client[WS_METHODS.peerLinksUnlink]).not.toHaveBeenCalled();
504 expect(yield* readLinks).toEqual({ links: [peer] });
505 setAccess(true);
506 expect(registry.get(peerLinks.unlink.permissionAtom(env))).toBe(true);
507 expect((yield* unlink)._tag).toBe("Success");
508 expect(client[WS_METHODS.peerLinksUnlink]).toHaveBeenCalledExactlyOnceWith({
509 environmentId: peer.environmentId,
510 });
511 expect(yield* readLinks).toEqual({ links: [] });
512 }),
513 ),
514);
515
516it.effect("requires access management to answer a link request", () =>
517 Effect.scoped(
518 Effect.gen(function* () {
519 const registry = yield* setup;
520 registry.set(sessions(env), AsyncResult.success(grant(true)));
521 const answer = createCommandPermissions(runtime, WS_METHODS.peerLinksAnswerRequest);
522 expect(registry.get(answer.permissionAtom(env))).toBe(false);
523 expect((yield* answer.authorize(registry, env).pipe(Effect.flip)).requiredPermission).toBe(
524 AuthAccessWriteScope,
525 );
526 registry.set(
527 sessions(env),
528 AsyncResult.success({
529 ...grant(false),
530 scopes: [AuthAccessWriteScope],
531 permissions: [AuthAccessWriteScope],
532 }),
533 );
534 expect(registry.get(answer.permissionAtom(env))).toBe(true);
535 yield* answer.authorize(registry, env);
536 }),
537 ),
538);
539
540it.effect("honors exact empty permissions and preserves legacy parent grants", () =>
541 Effect.scoped(
542 Effect.gen(function* () {
543 const registry = yield* setup;
544 const git = createCommandPermissions(runtime, WS_METHODS.vcsInit);
545 registry.set(sessions(env), AsyncResult.success({ ...grant(true), permissions: [] }));
546 expect(registry.get(git.permissionAtom(env))).toBe(false);
547 const denied = yield* git.authorize(registry, env).pipe(Effect.flip);
548 expect(denied).toMatchObject({
549 requiredPermission: AuthSourceControlWriteScope,
550 requiredScope: AuthOrchestrationOperateScope,
551 });
552 const { permissions: _exact, ...legacy } = grant(true);
553 registry.set(sessions(env), AsyncResult.success(legacy));
554 expect(registry.get(git.permissionAtom(env))).toBe(true);
555 yield* git.authorize(registry, env);
556 }),
557 ),
558);
559
560it.effect("rejects protected unary and streamed RPCs outside a guarded command", () =>
561 Effect.gen(function* () {
562 let writes = 0;
563 const session = {
564 client: {
565 [WS_METHODS.scheduledTasksDelete]: () =>
566 Effect.sync(() => {
567 writes++;
568 return { id: ScheduledTaskId.make("task") };
569 }),
570 [WS_METHODS.gitRunStackedAction]: () =>
571 Stream.fromEffect(
572 Effect.sync(() => {
573 writes++;
574 }),
575 ),
576 },
577 } as unknown as RpcSession;
578 const supervisor = {
579 target: { environmentId: env, label: "target" },
580 session: yield* SubscriptionRef.make(Option.some(session)),
581 } as unknown as EnvironmentSupervisor["Service"];
582 const unary = yield* requestGuarded(WS_METHODS.scheduledTasksDelete, {
583 id: ScheduledTaskId.make("task"),
584 }).pipe(Effect.provideService(EnvironmentSupervisor, supervisor), Effect.flip);
585 expect(unary._tag).toBe("EnvironmentAuthorizationError");
586 const streamed = yield* runStreamGuarded(WS_METHODS.gitRunStackedAction, {
587 actionId: "test-action",
588 cwd: "/repo",
589 action: "commit",
590 }).pipe(Stream.runDrain, Effect.provideService(EnvironmentSupervisor, supervisor), Effect.flip);
591 expect(streamed._tag).toBe("EnvironmentAuthorizationError");
592 expect(writes).toBe(0);
593 }),
594);