@fuzdev/fuz_app 0.147.0 → 0.149.0

package/dist/testing/rpc_round_trip.js

@@ -9,38 +9,72 @@ import './assert_dev_env.js';
  * fixture-producing callback.
  *
  * Cadence: per-describe `setup_test()` call (see `testing/round_trip.ts` module
- * docstring). RPC round-trip tests fire one JSON-RPC envelope per
- * method-direction and don't mutate state in a way that contaminates the
- * next case.
+ * docstring). The generic POST and GET cases fire one JSON-RPC envelope per
+ * method-direction against shared principals (an authed account, an admin
+ * account, the keeper). A side-effecting method called as the authed account
+ * runs on a fresh account of its own (`round_trip_uses_fresh_account`):
+ * the generated params of a self-targeting method act on the caller — an
+ * `account_delete` with no `account_id` deletes it, an
+ * `account_session_revoke_all` ends its session — and on the shared account
+ * that would leave every later call refused as unauthenticated. A 401 to any
+ * non-public call fails (`assert_rpc_authenticated`), so a credential lost
+ * some other way goes red rather than vacuous. The `success_fixtures` case
+ * also mutates — each fixture builds a row and the call revokes, deletes, or
+ * decides it — so it runs last on the describe's fixture, and each factory
+ * seeds its own rows.
  *
  * @module
  */
 import { describe, test, beforeAll, assert } from 'vitest';
 import { ROLE_ADMIN } from '../auth/role_schema.js';
-import { JSONRPC_METHOD_NOT_FOUND, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import { JSONRPC_INTERNAL_ERROR, JSONRPC_METHOD_NOT_FOUND, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import { jsonrpc_error_code_to_http_status } from '../http/jsonrpc_errors.js';
 import { generate_valid_body } from './schema_generators.js';
-import { is_public_auth } from '../http/auth_shape.js';
 import { create_rpc_post_init, create_rpc_get_url, assert_jsonrpc_error_response, assert_jsonrpc_success_response, resolve_rpc_endpoints_for_setup, find_rpc_action, find_rpc_method } from './rpc_helpers.js';
+import { is_unauthenticated_refusal, pick_auth_principal, round_trip_uses_fresh_account, to_principal_headers } from './integration_helpers.js';
 /**
- * Pick auth headers matching an RPC method's auth requirement. Accepts
- * any `KeeperHeaderProvider` — both `TestApp` (in-process) and
- * `TestFixture` (cross-backend) satisfy the shape structurally.
+ * Pick the principal matching an RPC method's auth requirement
+ * (`pick_auth_principal`, shared with the REST round-trip), and the headers
+ * carrying its credential. Accepts any `KeeperHeaderProvider` — both `TestApp`
+ * (in-process) and `TestFixture` (cross-backend) satisfy the shape
+ * structurally.
  */
-const pick_rpc_auth_headers = (method, keeper, authed_account, admin_account) => {
-    const { auth } = method;
-    if (is_public_auth(auth)) {
-        return { host: 'localhost', origin: 'http://localhost:5173' };
-    }
-    if (auth.credential_types?.includes('daemon_token')) {
-        return keeper.create_daemon_token_headers();
-    }
-    if (auth.roles?.length) {
-        if (auth.roles.includes(ROLE_ADMIN)) {
-            return admin_account.create_session_headers();
-        }
-        return keeper.create_session_headers();
-    }
-    return authed_account.create_session_headers();
+export const pick_rpc_auth = (method, keeper, authed_account, admin_account) => {
+    const principal = pick_auth_principal(method.auth);
+    return {
+        principal,
+        headers: to_principal_headers(principal, keeper, authed_account, admin_account)
+    };
+};
+/**
+ * Guard against a refusal that says the call carried no valid credential
+ * when it carried one (`is_unauthenticated_refusal`). The round-trip sends
+ * every non-public method a live credential its auth admits, so such a 401
+ * means the backend failed to authenticate it — most often because an earlier
+ * call destroyed it (a self-delete, a revoke-all), which would turn every
+ * later method's coverage into a vacuous refusal. A public method may still
+ * answer 401 (a login with a wrong password), and so may a handler refusing
+ * an authenticated call with a reason of its own (`invalid_credentials`).
+ *
+ * @param method - the RPC method name
+ * @param status - the HTTP status
+ * @param body - the parsed response body (or raw text when not JSON)
+ * @param principal - the principal the call was sent as
+ */
+export const assert_rpc_authenticated = (method, status, body, principal) => {
+    if (principal === 'public')
+        return;
+    const parsed = JsonrpcErrorResponse.safeParse(body);
+    const data = parsed.success ? parsed.data.error.data : undefined;
+    const reason = data !== null && typeof data === 'object' ? data.reason : undefined;
+    if (!is_unauthenticated_refusal(status, reason))
+        return;
+    const detail = parsed.success
+        ? `code ${parsed.data.error.code}, message ${JSON.stringify(parsed.data.error.message)}${data === undefined ? '' : `, data ${JSON.stringify(data)}`}`
+        : `body ${typeof body === 'string' ? body.slice(0, 500) : JSON.stringify(body).slice(0, 500)}`;
+    assert.fail(`method '${method}' answered 401 to the ${principal} principal's credential (${detail})` +
+        ' — the call carried a credential its auth admits, so the backend owed an' +
+        ' authenticated answer; a 401 here means that credential stopped working');
 };
 /**
  * Guard against silent parity gaps: a method enumerated from the local action
@@ -62,6 +96,76 @@ const assert_method_implemented = (method, body) => {
             ` returned method-not-found — backend is missing this method (parity gap)`);
     }
 };
+/**
+ * Read a response body as JSON, falling back to the raw text — a crashed
+ * backend may answer with a non-JSON body (an HTML or plain-text 500), and
+ * the round-trip must report that response, not a JSON parse error with no
+ * method attached.
+ */
+const read_rpc_body = async (res) => {
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+/** The HTTP status an `internal_error` maps to, read off the shared status table. */
+const INTERNAL_ERROR_HTTP_STATUS = jsonrpc_error_code_to_http_status(JSONRPC_INTERNAL_ERROR);
+/**
+ * Guard against a backend that crashes on schema-valid input. A response is
+ * a crash when any of these holds:
+ *
+ * - its HTTP status is the one `internal_error` maps to (500) — what an
+ *   uncaught throw and an unmapped error code both answer
+ * - its JSON-RPC code is `internal_error` (-32603)
+ * - its status is ≥500 and its body is not a well-formed JSON-RPC error
+ *   envelope (an HTML or plain-text crash page)
+ *
+ * Any other ≥500 that carries a well-formed envelope with a declared code
+ * passes like a 4xx: `service_unavailable` (503), `timeout` (504), or a
+ * consumer's own code declared with `register_jsonrpc_error_code` (a 502).
+ * Those are server conditions a handler declares on purpose — a dependency
+ * the test environment doesn't provide — while an undeclared 500 or -32603
+ * is a handler that failed where it owed an answer.
+ *
+ * @param method - the RPC method name
+ * @param status - the HTTP status
+ * @param body - the parsed response body (or raw text when not JSON)
+ * @param expected - what the call owed: a refusal (the generic nil-id loop)
+ *   or a success (a declared success fixture), for the failure message
+ */
+const assert_not_crash = (method, status, body, expected) => {
+    const parsed = JsonrpcErrorResponse.safeParse(body);
+    const code = parsed.success ? parsed.data.error.code : null;
+    const crashed = parsed.success
+        ? status === INTERNAL_ERROR_HTTP_STATUS || code === JSONRPC_INTERNAL_ERROR
+        : status >= 500;
+    if (!crashed)
+        return;
+    const message = parsed.success
+        ? parsed.data.error.message
+        : typeof body === 'string'
+            ? body.slice(0, 500)
+            : JSON.stringify(body).slice(0, 500);
+    assert.fail(`method '${method}' crashed on ${expected === 'success' ? 'its success fixture' : 'schema-valid params'} (status ${status}, code ${code ?? 'none'}, message ${JSON.stringify(message)})` +
+        (expected === 'success'
+            ? ' — the fixture built a real row, so the backend owed a success here'
+            : ' — the backend owes a declared refusal here (a 4xx, or a declared 5xx code)'));
+};
+/**
+ * Assert a non-ok response is an acceptable refusal: the method exists, the
+ * failure is not a crash (`assert_not_crash`), an authenticated call was not
+ * refused as unauthenticated (`assert_rpc_authenticated`), and the body is a
+ * well-formed JSON-RPC error envelope.
+ */
+const assert_rpc_refusal = (method, status, body, principal) => {
+    assert_method_implemented(method, body);
+    assert_not_crash(method, status, body, 'refusal');
+    assert_rpc_authenticated(method, status, body, principal);
+    assert_jsonrpc_error_response(body);
+};
 /**
  * Run schema-driven round-trip validation for RPC endpoints.
  *
@@ -74,10 +178,15 @@ const assert_method_implemented = (method, body) => {
  *
  * Error responses (from missing DB state, etc.) are expected and validated
  * as well-formed JSON-RPC errors. Successful responses are validated against
- * `action.spec.output`. A `method not found` (-32601) error is the one
- * exception — it means the backend is missing a method the local surface
- * advertises, so the round-trip fails loud (`assert_method_implemented`)
- * rather than accepting it as a valid error envelope.
+ * `action.spec.output`. Two error classes fail loud instead of passing as a
+ * valid envelope: `method not found` (-32601) means the backend is missing a
+ * method the local surface advertises (`assert_method_implemented`), and a
+ * crash — HTTP 500, `internal_error` (-32603), or a ≥500 with no JSON-RPC
+ * envelope — means the backend failed on schema-valid input
+ * (`assert_not_crash`). A declared ≥500 code (`service_unavailable`,
+ * `timeout`) passes as a refusal. A method the suite can't drive generically
+ * goes in `skip_methods`; one whose generated params can't reach its handler
+ * gets an `input_overrides` entry.
  */
 export const describe_rpc_round_trip_tests = (options) => {
     const skip_set = new Set(options.skip_methods);
@@ -116,18 +225,20 @@ export const describe_rpc_round_trip_tests = (options) => {
                         continue;
                     const override = options.input_overrides?.get(action.spec.method);
                     const params = override ?? generate_valid_body(action.spec.input) ?? null;
-                    const headers = pick_rpc_auth_headers(surface_method, fixture, authed_account, admin_account);
+                    const picked = pick_rpc_auth(surface_method, fixture, authed_account, admin_account);
+                    const { principal, headers } = round_trip_uses_fresh_account(picked.principal, action.spec.side_effects)
+                        ? pick_rpc_auth(surface_method, fixture, await fixture.create_account({ roles: [] }), admin_account)
+                        : picked;
                     const init = create_rpc_post_init(action.spec.method, params);
                     Object.assign(init.headers, headers);
                     const res = await fixture.transport(ep_spec.path, init);
-                    const body = await res.json();
+                    const body = await read_rpc_body(res);
                     try {
                         if (res.ok) {
                             assert_jsonrpc_success_response(body, action.spec.output);
                         }
                         else {
-                            assert_method_implemented(action.spec.method, body);
-                            assert_jsonrpc_error_response(body);
+                            assert_rpc_refusal(action.spec.method, res.status, body, principal);
                         }
                     }
                     catch (e) {
@@ -150,17 +261,16 @@ export const describe_rpc_round_trip_tests = (options) => {
                         continue;
                     const override = options.input_overrides?.get(action.spec.method);
                     const params = override ?? generate_valid_body(action.spec.input) ?? undefined;
-                    const headers = pick_rpc_auth_headers(surface_method, fixture, authed_account, admin_account);
+                    const { principal, headers } = pick_rpc_auth(surface_method, fixture, authed_account, admin_account);
                     const url = create_rpc_get_url(ep_spec.path, action.spec.method, params);
                     const res = await fixture.transport(url, { headers });
-                    const body = await res.json();
+                    const body = await read_rpc_body(res);
                     try {
                         if (res.ok) {
                             assert_jsonrpc_success_response(body, action.spec.output);
                         }
                         else {
-                            assert_method_implemented(action.spec.method, body);
-                            assert_jsonrpc_error_response(body);
+                            assert_rpc_refusal(action.spec.method, res.status, body, principal);
                         }
                     }
                     catch (e) {
@@ -178,14 +288,16 @@ export const describe_rpc_round_trip_tests = (options) => {
                 assert.ok(located, `success_fixtures references unknown RPC method '${method}'`);
                 const surface = find_rpc_method(surface_rpc_endpoints, method);
                 assert.ok(surface, `success_fixtures method '${method}' missing from generated surface`);
-                const params = await build(fixture);
-                const headers = pick_rpc_auth_headers(surface.method_spec, fixture, authed_account, admin_account);
-                const init = create_rpc_post_init(method, params);
+                const fixture_case = await build(fixture);
+                const headers = fixture_case.headers ??
+                    pick_rpc_auth(surface.method_spec, fixture, authed_account, admin_account).headers;
+                const init = create_rpc_post_init(method, fixture_case.params);
                 Object.assign(init.headers, headers);
                 const res = await fixture.transport(located.path, init);
-                const body = await res.json();
+                const body = await read_rpc_body(res);
                 try {
                     assert_method_implemented(method, body);
+                    assert_not_crash(method, res.status, body, 'success');
                     assert.ok(res.ok, `success fixture expected a success response, got status ${res.status}: ${JSON.stringify(body)}`);
                     assert_jsonrpc_success_response(body, located.action.spec.output);
                 }

package/dist/testing/schema_generators.d.ts

@@ -11,12 +11,109 @@ import './assert_dev_env.js';
 import { z } from 'zod';
 import { type ZodFieldInfo } from '../zod.js';
 /**
- * Detect format constraints on a field by converting to JSON Schema.
- * Returns format string (e.g. 'uuid', 'email') or null.
+ * The JSON Schema of a field's input side — where its format, pattern and
+ * bounds live — or `null` when JSON Schema can't render the field or any part
+ * of it (`z.date()`, `z.custom()`, a union with a `z.date()` branch).
+ *
+ * Rendered with `io: 'input'`, so a field carrying a `.transform()` or a pipe
+ * (`Username`) still yields the constraints its input is checked against;
+ * the default output side throws on a transform. A pipe yields its input
+ * side only, so constraints of the stage after it are not here. A
+ * `.nullable()` / `.nullish()` field renders as
+ * `anyOf: [{…}, {type: 'null'}]`; its one non-null branch is returned, so
+ * the bounds and pattern read the same as on the bare field. A union of two
+ * or more non-null branches returns the whole schema — its branches' bounds
+ * are no single field's bounds.
+ *
+ * A `.refine()` is never here: JSON Schema can't express one, so a bound a
+ * refinement enforces (a code-point length, a cross-field rule) generates no
+ * boundary case.
+ *
+ * @param field_schema - the field to read
+ * @returns the field's input-side JSON Schema, or `null` when it can't be rendered
+ */
+export declare const to_field_json_schema: (field_schema: z.ZodType) => Record<string, unknown> | null;
+/**
+ * The format constraint a field's input-side JSON Schema carries: its
+ * `format` (e.g. `'uuid'`, `'email'`), `'pattern'` for a regex, or `null`.
+ * A union (`anyOf` of several non-null branches) answers its first branch
+ * carrying one — a value violating every branch is what the caller needs,
+ * and the generators check the field refuses the candidate.
+ *
+ * @param json - a field's JSON Schema, as `to_field_json_schema` returns it
+ * @returns the format, `'pattern'`, or `null`
+ */
+export declare const detect_json_schema_format: (json: Record<string, unknown>) => string | null;
+/**
+ * Detect format constraints on a field from its input-side JSON Schema
+ * (`to_field_json_schema`). Returns the format string (e.g. `'uuid'`,
+ * `'email'`), `'pattern'` for a regex, or `null`.
  */
 export declare const detect_format: (field_schema: z.ZodType) => string | null;
 /** Generate a valid-ish value for a field based on its base type. */
 export declare const generate_valid_value: (field: ZodFieldInfo, field_schema: z.ZodType) => unknown;
+/**
+ * Generate a valid object for an object schema: its required and defaulted
+ * fields first; when `schema` still refuses it, each optional field alone on
+ * top of those, in declaration order, taking the first that parses; and
+ * failing that, the optional fields added one at a time, in declaration
+ * order, until it parses. The fill covers a `.refine()` over optional fields
+ * (at least one of, exactly one of, both of), which the required-only object
+ * can't satisfy, and the single-field pass keeps an unrelated optional field
+ * declared ahead of the refined ones (an `acting`, a note) out of the object.
+ *
+ * Shared by the top-level body generators and `generate_valid_value`'s
+ * nested-object case, so a refined object validates the same way at any depth.
+ *
+ * @param object_schema - the unwrapped object whose fields are generated
+ * @param schema - the schema the object must satisfy, refinements included
+ *   (`object_schema` or a schema wrapping it)
+ * @returns the generated object and its last `safeParse` result — the caller
+ *   decides whether a failure throws
+ */
+export declare const generate_valid_object: (object_schema: z.ZodObject, schema: z.ZodType) => {
+    value: Record<string, unknown>;
+    result: z.ZodSafeParseResult<unknown>;
+};
+/**
+ * A valid object that carries `field`, built from `base`, a valid object of
+ * `object_schema` — the body a case breaking `field` changes, so the case
+ * breaks that field and nothing else. `base` itself when it carries the
+ * field. Otherwise the field takes a generated value and joins `base`, with
+ * the optional fields `base` omits filled as `generate_valid_object` fills
+ * them (a pair rule: adding `scope_kind` needs `scope_id`); failing that, it
+ * replaces `base`'s optional fields, refilled the same way around it (an
+ * exactly-one-of rule: adding `slug` means dropping `id`).
+ *
+ * @param object_schema - the unwrapped object `base` is an instance of
+ * @param schema - the schema the object must satisfy, refinements included
+ * @param base - a valid object, the generated or seeded base
+ * @param field - the field the object must carry
+ * @returns the object, or `null` when no object the generator can build
+ *   carries the field and passes `schema`
+ */
+export declare const generate_valid_object_with_field: (object_schema: z.ZodObject, schema: z.ZodType, base: Record<string, unknown>, field: ZodFieldInfo) => Record<string, unknown> | null;
+/**
+ * A string a URL-sourced field accepts — a route param or a query value, which
+ * arrive as strings whatever the schema parses them into. The nil UUID for a
+ * UUID field; else the first the field accepts of `test_value`, the generated
+ * valid value written as a string, `1`, `0`, `true` and `false`, the field's
+ * JSON Schema `default` or lower bound written as a string (a preprocessed
+ * integer whose minimum is above one), and a string synthesized from the
+ * field's constraints.
+ *
+ * @param field - the field's info, from `zod_extract_fields`
+ * @param field_schema - the field's schema
+ * @returns the string, or `null` when no candidate passes
+ */
+export declare const generate_valid_string_param: (field: ZodFieldInfo, field_schema: z.ZodType) => string | null;
+/**
+ * Format Zod issues as `path: message` pairs for a generator's error message.
+ *
+ * @param error - the failed parse's error
+ * @returns the issues, comma-separated
+ */
+export declare const format_zod_issues: (error: z.ZodError) => string;
 /**
  * The `Content-Type` a well-formed request to a route sends: `application/json`,
  * or `application/octet-stream` for a `raw_body` route. Every `POST` route

package/dist/testing/schema_generators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema_generators.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_generators.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAKN,KAAK,YAAY,EACjB,MAAM,WAAW,CAAC;AAInB;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,cAAc,CAAC,CAAC,OAAO,KAAG,MAAM,GAAG,IAkBhE,CAAC;AAmHF,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,GAAI,OAAO,YAAY,EAAE,cAAc,CAAC,CAAC,OAAO,KAAG,OAgGnF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,KAAG,MACL,CAAC;AAElE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,EAAE,gBAAgB,CAAC,CAAC,SAAS,KAAG,MAiB9E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAC/B,cAAc,CAAC,CAAC,OAAO,KACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SA+B5B,CAAC"}
+{"version":3,"file":"schema_generators.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_generators.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAKN,KAAK,YAAY,EACjB,MAAM,WAAW,CAAC;AAInB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,CAAC,CAAC,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAcxF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,IAWlF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,cAAc,CAAC,CAAC,OAAO,KAAG,MAAM,GAAG,IAGhE,CAAC;AAqHF,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,GAAI,OAAO,YAAY,EAAE,cAAc,CAAC,CAAC,OAAO,KAAG,OAkGnF,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,GACjC,eAAe,CAAC,CAAC,SAAS,EAC1B,QAAQ,CAAC,CAAC,OAAO,KACf;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;CASzE,CAAC;AAsCF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gCAAgC,GAC5C,eAAe,CAAC,CAAC,SAAS,EAC1B,QAAQ,CAAC,CAAC,OAAO,EACjB,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,YAAY,KACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IA0B5B,CAAC;AAIF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,GACvC,OAAO,YAAY,EACnB,cAAc,CAAC,CAAC,OAAO,KACrB,MAAM,GAAG,IA6BX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,CAAC,CAAC,QAAQ,KAAG,MACkB,CAAC;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,KAAG,MACL,CAAC;AAElE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,EAAE,gBAAgB,CAAC,CAAC,SAAS,KAAG,MAiB9E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAC/B,cAAc,CAAC,CAAC,OAAO,KACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAY5B,CAAC"}