@astrale-os/kernel-server 0.4.17 → 0.5.0-beta.10

package/dist/transport/websocket/session.js

@@ -0,0 +1,335 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { classifyError } from '../../errors/index.js';
+import { ResponseBodyTooLargeError } from '../../errors/index.js';
+import { invocationContext, publicationRouteDecision, } from '../../invocation/index.js';
+import { byteLength } from '../body.js';
+import { resolveCredential } from '../credential.js';
+import { renderBinary, renderRedirect } from '../http/render.js';
+import { interruptedStreamError } from '../stream-error.js';
+const WS_OPEN = 1;
+/** Build one socket-pinned transport session. */
+export function createWebSocketSession(config) {
+    const codec = config.codec;
+    const scopes = new Set();
+    const operations = new Map();
+    let opened;
+    let output = Promise.resolve();
+    const sendOutput = (socket, data) => {
+        if (byteLength(data) > config.maximumResponseBytes) {
+            socket.close(1009, 'Message too big');
+            return Promise.reject(new ResponseBodyTooLargeError(config.maximumResponseBytes));
+        }
+        const pending = output.then(async () => {
+            if (socket.readyState !== WS_OPEN)
+                return;
+            try {
+                await socket.send(data);
+            }
+            catch (cause) {
+                socket.close(1011, 'Internal error');
+                throw new WebSocketOutputError(cause);
+            }
+        });
+        output = pending.catch(() => undefined);
+        return pending;
+    };
+    const handlers = {
+        async open(socket) {
+            if (!config.active.attachSocket(socket)) {
+                socket.close(1012, 'Server draining');
+                return;
+            }
+            opened = socket;
+        },
+        async message(socket, data) {
+            const admittedCodec = codec;
+            if (socket.readyState !== WS_OPEN)
+                return;
+            if ((admittedCodec.binary && typeof data === 'string') ||
+                (!admittedCodec.binary && typeof data !== 'string')) {
+                socket.close(1003, 'Unsupported message type');
+                return;
+            }
+            if (byteLength(data) > config.maximumRequestBytes) {
+                socket.close(1009, 'Message too big');
+                return;
+            }
+            let decoded;
+            try {
+                decoded = admittedCodec.decode(data);
+            }
+            catch {
+                socket.close(1002, 'Invalid Invocation message');
+                return;
+            }
+            if (isCancelRequest(decoded)) {
+                let cancellation;
+                try {
+                    cancellation = protocol.decodeCancelRequest(decoded);
+                }
+                catch {
+                    socket.close(1002, 'Invalid cancellation message');
+                    return;
+                }
+                const operation = operations.get(requestKey(cancellation.requestId));
+                if (operation === undefined) {
+                    await sendError(socket, admittedCodec, cancellation.requestId, config.invocation(), {
+                        code: errors.CODES.INVALID_REQUEST,
+                        message: 'Request ID is not active on this connection.',
+                    }, sendOutput);
+                    return;
+                }
+                operation.cancel('client cancelled invocation');
+                return;
+            }
+            let envelope;
+            try {
+                envelope = protocol.decodeRequest(decoded);
+            }
+            catch {
+                socket.close(1002, 'Invalid Invocation request');
+                return;
+            }
+            const assigned = config.invocation();
+            const key = requestKey(envelope.requestId);
+            if (operations.has(key)) {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
+                    code: errors.CODES.INVALID_REQUEST,
+                    message: 'Request ID is already active on this connection.',
+                }, sendOutput);
+                return;
+            }
+            const publication = config.currentPublication?.();
+            if (config.currentPublication !== undefined && publication === undefined) {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
+                    code: errors.CODES.BACKEND_UNAVAILABLE,
+                    message: 'Publication is unavailable.',
+                }, sendOutput);
+                return;
+            }
+            if (envelope.routing?.kind === 'via') {
+                if (publication === undefined) {
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, {
+                        code: errors.CODES.INVALID_REQUEST,
+                        message: 'Publication routing requires a Publication-backed destination.',
+                    }, sendOutput);
+                    return;
+                }
+                const decision = publicationRouteDecision(publication.publication, envelope.routing.publication);
+                if (decision.kind === 'rejected') {
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, decision.error, sendOutput);
+                    return;
+                }
+            }
+            const credential = resolveCredential(envelope.credential, config.authorization);
+            if (!credential.ok) {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, credential.error, sendOutput);
+                return;
+            }
+            const operation = config.active.begin(config.invocationTimeoutMs);
+            if (operation === undefined) {
+                await sendError(socket, admittedCodec, envelope.requestId, assigned, {
+                    code: errors.CODES.BACKEND_UNAVAILABLE,
+                    message: 'server is unavailable.',
+                }, sendOutput);
+                return;
+            }
+            operations.set(key, operation);
+            scopes.add(operation);
+            try {
+                const result = await config.handler.dispatch(Object.freeze({
+                    call: envelope.call,
+                    ...(envelope.trace === undefined ? {} : { trace: envelope.trace }),
+                    ...(credential.credential === undefined ? {} : { credential: credential.credential }),
+                    ...(envelope.delegate === undefined ? {} : { delegate: envelope.delegate }),
+                    ...(envelope.routing?.kind === 'via' ? { via: envelope.routing } : {}),
+                    ...(envelope.schema === undefined ? {} : { schema: envelope.schema }),
+                    ...(publication === undefined ? {} : { publication }),
+                    context: invocationContext(assigned, operation, config.active, config.host, undefined, envelope.idempotencyKey),
+                }));
+                await sendResult(socket, admittedCodec, envelope.requestId, assigned, result, operation, sendOutput);
+            }
+            catch (input) {
+                if (input instanceof ResponseBodyTooLargeError || input instanceof WebSocketOutputError) {
+                    return;
+                }
+                if (socket.readyState === WS_OPEN) {
+                    const error = operation.timedOut
+                        ? {
+                            code: errors.CODES.DEADLINE_EXCEEDED,
+                            message: 'Invocation deadline exceeded.',
+                        }
+                        : operation.signal.aborted
+                            ? { code: errors.CODES.CANCELLED, message: 'Invocation was cancelled.' }
+                            : classifyError(input);
+                    if (error.code === errors.CODES.INTERNAL_ERROR) {
+                        socket.close(1011, 'Internal error');
+                        return;
+                    }
+                    await sendError(socket, admittedCodec, envelope.requestId, assigned, error, sendOutput);
+                }
+            }
+            finally {
+                operations.delete(key);
+                scopes.delete(operation);
+                operation.settle();
+            }
+        },
+        close(socket) {
+            config.active.detachSocket(socket);
+            for (const scope of scopes)
+                scope.cancel('websocket closed');
+            if (opened === socket)
+                opened = undefined;
+        },
+        error(socket) {
+            config.active.detachSocket(socket);
+            for (const scope of scopes)
+                scope.cancel('websocket failed');
+            if (socket.readyState === WS_OPEN)
+                socket.close(1011, 'Internal error');
+            if (opened === socket)
+                opened = undefined;
+        },
+    };
+    return handlers;
+}
+async function sendResult(socket, codec, requestId, assigned, result, operation, sendOutput) {
+    switch (result.kind) {
+        case 'value':
+            await send(socket, codec, {
+                result: result.value,
+                requestId,
+                invocation: assigned,
+            }, sendOutput);
+            return;
+        case 'redirect':
+            await send(socket, codec, renderRedirect(requestId, assigned, result.redirect), sendOutput);
+            return;
+        case 'miss':
+            await send(socket, codec, protocol.miss(requestId, assigned), sendOutput);
+            return;
+        case 'binary': {
+            const binary = renderBinary(requestId, assigned, result.value);
+            if (socket.readyState === WS_OPEN) {
+                await sendOutput(socket, protocol.websocket.encodeBinary(binary));
+            }
+            return;
+        }
+        case 'stream': {
+            const iterator = result.stream[Symbol.asyncIterator]();
+            let terminal = false;
+            let cancellation;
+            let sequence = Promise.resolve();
+            const emit = (frame) => {
+                const pending = sequence.then(() => send(socket, codec, frame, sendOutput));
+                sequence = pending.catch(() => undefined);
+                return pending;
+            };
+            const cancel = (reason) => {
+                cancellation ??= cancelStream(reason);
+                return cancellation;
+            };
+            const cancelStream = async (reason) => {
+                if (terminal)
+                    return;
+                terminal = true;
+                const terminalOutput = emit({
+                    kind: 'stream.error',
+                    requestId,
+                    error: interruptedStreamError(operation.timedOut),
+                });
+                await Promise.allSettled([
+                    terminalOutput,
+                    Promise.resolve().then(() => result.stream.cancel(reason)),
+                    Promise.resolve().then(() => iterator.return?.()),
+                ]);
+            };
+            const started = emit({
+                kind: 'stream.start',
+                requestId,
+                invocation: assigned,
+            });
+            operation.onCancel(cancel);
+            let count = 0;
+            try {
+                await started;
+                while (!terminal) {
+                    const next = await iterator.next();
+                    if (terminal)
+                        break;
+                    if (next.done) {
+                        terminal = true;
+                        await emit({ kind: 'stream.end', requestId, count });
+                        break;
+                    }
+                    await emit(protocol.decodeStreamFrame({
+                        kind: 'stream.item',
+                        requestId,
+                        index: count,
+                        value: next.value,
+                    }));
+                    count += 1;
+                }
+                if (cancellation !== undefined)
+                    await cancellation;
+            }
+            catch (input) {
+                if (input instanceof ResponseBodyTooLargeError || input instanceof WebSocketOutputError) {
+                    terminal = true;
+                    await Promise.allSettled([
+                        Promise.resolve().then(() => result.stream.cancel('transport output failed')),
+                        Promise.resolve().then(() => iterator.return?.()),
+                    ]);
+                    throw input;
+                }
+                if (terminal) {
+                    if (cancellation !== undefined)
+                        await cancellation;
+                    return;
+                }
+                terminal = true;
+                const error = classifyError(input);
+                if (error.code === errors.CODES.INTERNAL_ERROR) {
+                    socket.close(1011, 'Internal error');
+                    await Promise.allSettled([
+                        Promise.resolve().then(() => result.stream.cancel('stream failed')),
+                        Promise.resolve().then(() => iterator.return?.()),
+                    ]);
+                    return;
+                }
+                await Promise.allSettled([
+                    emit({
+                        kind: 'stream.error',
+                        requestId,
+                        error,
+                    }),
+                    Promise.resolve().then(() => result.stream.cancel('stream failed')),
+                    Promise.resolve().then(() => iterator.return?.()),
+                ]);
+            }
+        }
+    }
+}
+function sendError(socket, codec, requestId, invocation, error, output) {
+    return send(socket, codec, { error, requestId, invocation }, output);
+}
+function send(socket, codec, value, output) {
+    return output(socket, codec.encode(value));
+}
+class WebSocketOutputError extends Error {
+    constructor(cause) {
+        super('WebSocket adapter rejected output.', { cause });
+        this.name = 'WebSocketOutputError';
+    }
+}
+function requestKey(requestId) {
+    return requestId === null ? 'null:' : `${typeof requestId}:${String(requestId)}`;
+}
+function isCancelRequest(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        !Array.isArray(input) &&
+        input.kind === 'cancel');
+}

package/dist/transport/websocket/upgrade.d.ts

@@ -0,0 +1,20 @@
+import type { CorsPolicy } from '../../cors/index.js';
+import type { ApplicationHost, Handler } from '../../invocation/index.js';
+import type { NextInvocationId } from '../../invocation/index.js';
+import type { ActiveOperations } from '../../lifecycle/index.js';
+import type { PublicationSnapshot } from '../../publication/index.js';
+import type { WebSocketAdapter } from '../types.js';
+export interface WebSocketHandlerConfig {
+    readonly request: Request;
+    readonly adapter: WebSocketAdapter;
+    readonly handler: Handler;
+    readonly active: ActiveOperations;
+    readonly invocation: NextInvocationId;
+    readonly maximumRequestBytes: number;
+    readonly maximumResponseBytes: number;
+    readonly invocationTimeoutMs: number;
+    readonly cors: CorsPolicy;
+    readonly currentPublication?: () => PublicationSnapshot | undefined;
+    readonly host?: ApplicationHost;
+}
+export declare function handleWebSocketUpgrade(config: WebSocketHandlerConfig): Promise<Response>;

package/dist/transport/websocket/upgrade.js

@@ -0,0 +1,46 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { loadCodecs } from '../codecs.js';
+import { createWebSocketSession } from './session.js';
+export async function handleWebSocketUpgrade(config) {
+    if (!config.cors.allowsBrowserOrigin(config.request))
+        return failure(403);
+    const operation = config.active.begin(config.invocationTimeoutMs, config.request.signal);
+    if (operation === undefined)
+        return failure(503, config.cors.response(config.request));
+    try {
+        const supported = await loadCodecs();
+        const selection = protocol.websocket.selectSubprotocol(config.request.headers.get('sec-websocket-protocol'), supported);
+        if (selection === undefined)
+            return failure(400, config.cors.response(config.request));
+        return await config.adapter.upgrade(config.request, {
+            subprotocol: selection.subprotocol,
+            handlers: createWebSocketSession({
+                codec: selection.codec,
+                authorization: config.request.headers.get('authorization'),
+                handler: config.handler,
+                active: config.active,
+                invocation: config.invocation,
+                maximumRequestBytes: config.maximumRequestBytes,
+                maximumResponseBytes: config.maximumResponseBytes,
+                invocationTimeoutMs: config.invocationTimeoutMs,
+                ...(config.currentPublication === undefined
+                    ? {}
+                    : { currentPublication: config.currentPublication }),
+                ...(config.host === undefined ? {} : { host: config.host }),
+            }),
+            signal: operation.signal,
+        });
+    }
+    catch {
+        return failure(500, config.cors.response(config.request));
+    }
+    finally {
+        operation.settle();
+    }
+}
+function failure(status, input = {}) {
+    return new Response(null, {
+        status,
+        headers: { ...input, 'cache-control': 'no-store' },
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+import type { CorsConfig } from './cors/index.js';
+import type { Handler, InvocationSource } from './invocation/index.js';
+import type { exchange, Issuer } from './issuer/index.js';
+import type { Provider as DeliveryProvider } from './publication/delivery/index.js';
+import type { PublicationSource } from './publication/index.js';
+import type { Application, WebSocketAdapter } from './transport/index.js';
+export interface ServerLimits {
+    readonly maximumRequestBytes: number;
+    /** Maximum bytes in one encoded envelope, finite-binary body, or stream frame. */
+    readonly maximumResponseBytes?: number;
+    /** Maximum Server-owned active operations across all mounted protocol surfaces. */
+    readonly maximumConcurrentOperations?: number;
+    readonly maximumPublicationBytes?: number;
+    readonly maximumBundleBytes?: number;
+    readonly maximumDeliveryBytes?: number;
+    /** Maximum lifetime of one invocation, including a returned stream. */
+    readonly invocationTimeoutMs: number;
+}
+export interface ServerCloseOptions {
+    /** Absolute Unix time in milliseconds after which active work is cancelled. */
+    readonly deadline: number;
+}
+export interface HealthProbe {
+    /** Non-blocking snapshot; health never performs provider I/O. */
+    check(): boolean;
+}
+/** Static transport configuration admitted before Runtime Boot performs I/O. */
+export interface ServerOptions {
+    readonly limits: ServerLimits;
+    /** Required source-owned identity allocation for every Invocation response attempt. */
+    readonly invocation: InvocationSource;
+    readonly path?: string;
+    /** `false` delegates CORS and every preflight to an outer Application. */
+    readonly cors?: CorsConfig | false;
+    readonly health?: {
+        readonly path?: string;
+        readonly probe: HealthProbe;
+    } | false;
+    readonly issuer?: Issuer;
+    /** Present only for the configured self issuer; owns verification and signing. */
+    readonly tokenExchange?: exchange.Provider;
+    readonly publication?: PublicationSource;
+    /** Required exactly when the current Publication advertises delivery. */
+    readonly delivery?: DeliveryProvider;
+    readonly websocket?: WebSocketAdapter;
+}
+/** Static options plus the one ready semantic capability consumed by Server. */
+export interface ServerConfig extends ServerOptions {
+    readonly handler: Handler;
+}
+/** Admitted Server construction with the ready handler deliberately left unbound. */
+export interface PreparedServer {
+    create(handler: Handler): Server;
+}
+export interface Server {
+    readonly app: Application;
+    drain(): void;
+    close(options: ServerCloseOptions): Promise<void>;
+}
+export type { CorsConfig } from './cors/index.js';
+export type { InvocationSource } from './invocation/index.js';
+export type { ApplicationHost, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, InvocationContext, RequestBackground, RequestEvidence, RequestSleep, } from './invocation/index.js';
+export type { exchange, Issuer } from './issuer/index.js';
+export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource, } from './publication/index.js';
+export type { Application, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './transport/index.js';

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@astrale-os/kernel-server",
-  "version": "0.4.17",
-  "description": "Astrale Kernel Server - kernel envelope HTTP/WS server with Hono",
+  "version": "0.5.0-beta.10",
+  "description": "Portable HTTP and WebSocket boundary for Astrale invocation, publication, installation, and issuer protocols",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/astrale-os/kernel.git",
+    "directory": "server"
+  },
   "files": [
     "dist"
   ],
@@ -14,9 +19,13 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./app": {
-      "types": "./dist/app/index.d.ts",
-      "import": "./dist/app/index.js"
+    "./publication/snapshot": {
+      "types": "./dist/publication/snapshot.d.ts",
+      "import": "./dist/publication/snapshot.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     },
     "./package.json": "./package.json"
   },
@@ -24,23 +33,24 @@
     "access": "public"
   },
   "dependencies": {
+    "@astrale-os/kernel-core": ">=0.9.0-beta.9 <1.0.0",
+    "@astrale-os/kernel-dsl": ">=0.2.0-beta.7 <1.0.0",
+    "@astrale-os/kernel-protocol": ">=0.5.0-beta.9 <1.0.0",
     "hono": "^4.6.20",
-    "zod": "^4.3.6",
-    "@astrale-os/kernel-api": "^0.4.18",
-    "@astrale-os/kernel-core": "^0.8.1"
+    "msgpackr": "^2.0.5"
   },
   "devDependencies": {
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
-    "@types/node": "^22.15.0",
-    "@typescript/native-preview": "latest",
-    "typescript": "~6.0.1-rc",
-    "vitest": "^3.0.0"
+    "typescript": "7.0.2",
+    "vitest": "^4.1.10"
   },
   "scripts": {
-    "build": "tsgo",
+    "build": "tsc",
     "clean": "rm -rf dist",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:boundary:protocol": "vitest run --config vitest.protocol-boundary.config.ts",
+    "test:file": "vitest run",
     "preinstall": "node -e \"try{require('./.check-workspace.cjs')}catch{}\""
   }
 }

package/dist/app/create.d.ts

@@ -1,48 +0,0 @@
-/**
- * createKernelApp — Hono app builder for the kernel protocol.
- *
- * Walks a domain of MountableContract and mounts:
- *  - kernel HTTP envelope (POST) at each base URL
- *  - native HTTP routes per route binding
- *  - kernel WS upgrade at the same base URL when transports includes 'ws'
- *
- * Codecs are hardcoded (json + msgpack). Credentials for kernel HTTP are
- * fixed to the Authorization header; route bindings can override via
- * `route.credential`.
- */
-import type { MountableContract } from '@astrale-os/kernel-api/routed';
-import type { Hono } from 'hono';
-import type { CorsConfig } from '../cors.js';
-import type { Dispatcher } from '../invocation/index.js';
-import type { JwksKeys } from '../jwks/index.js';
-import type { MountPlan, ServerHost } from '../plan/index.js';
-import { type WsAdapter } from './ws-upgrade.js';
-export type { WsAdapter };
-export type KernelAppConfig = {
-    /** The dispatcher handling hosted invocations. */
-    dispatcher: Dispatcher;
-    /** The domain's mountable contracts — produced by defineMethods(schema, methods). */
-    domain: MountableContract[];
-    /** Server host URL. Functions anchor against this (ambient functions mount here). */
-    host: ServerHost;
-    /** Required — OpenID Connect Discovery + JWKS endpoints. */
-    jwks: JwksKeys;
-    /** Allowed transports. 'http' is mandatory. 'ws' is opt-in. */
-    transports?: readonly ('http' | 'ws')[];
-    /** CORS configuration. Defaults to { origin: '*' }. */
-    cors?: CorsConfig;
-    /** Optional health endpoint path (defaults to '/health'; false disables). */
-    health?: string | false;
-    /** Pre-created Hono app (for attaching to an existing app). */
-    app?: Hono;
-    /**
-     * Runtime-specific WS adapter (from `hono/bun`, `@hono/node-ws`, `hono/deno`).
-     * Required when `transports` includes `'ws'`.
-     */
-    ws?: WsAdapter;
-};
-export declare function createKernelApp(config: KernelAppConfig): {
-    app: Hono;
-    plan: MountPlan;
-};
-//# sourceMappingURL=create.d.ts.map

package/dist/app/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../app/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,MAAM,CAAA;AAIzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAO7D,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE/D,YAAY,EAAE,SAAS,EAAE,CAAA;AAIzB,MAAM,MAAM,eAAe,GAAG;IAC5B,kDAAkD;IAClD,UAAU,EAAE,UAAU,CAAA;IACtB,qFAAqF;IACrF,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,qFAAqF;IACrF,IAAI,EAAE,UAAU,CAAA;IAChB,4DAA4D;IAC5D,IAAI,EAAE,QAAQ,CAAA;IACd,+DAA+D;IAC/D,UAAU,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IACvC,uDAAuD;IACvD,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IACvB,+DAA+D;IAC/D,GAAG,CAAC,EAAE,IAAI,CAAA;IACV;;;OAGG;IACH,EAAE,CAAC,EAAE,SAAS,CAAA;CACf,CAAA;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG;IAAE,GAAG,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAyFvF"}