@vibesdotdev/terminal-client 0.0.0-stage → 1.0.0-rc.2

package/dist/client.js

@@ -0,0 +1,169 @@
+/**
+ * Local and explicitly remote terminal sessions over runtime/execution and
+ * kernel-rpc. The terminal semantic client owns remote identity and cleanup.
+ */
+import { CapabilityError, composeChildEnv } from '@vibesdotdev/kernel';
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import { OpenTerminalOptionsSchema, TerminalHostRefSchema } from "./schemas/session.js";
+export { OpenTerminalOptionsSchema } from "./schemas/session.js";
+import { getVibesRemoteFrom } from '@vibesdotdev/kernel-rpc';
+import { adaptRemoteSession } from "./remote-session.js";
+/**
+ * Options for opening a terminal session. A superset of L3's `SessionOptions`
+ * that this client maps onto `session()` — `command`/`args`/`cwd`/`env` plus the
+ * required `cols`/`rows` the renderer fits to.
+ */
+function admitTerminalOptions(input) {
+    try {
+        return OpenTerminalOptionsSchema.parse(input);
+    }
+    catch (cause) {
+        throw new CapabilityError('The terminal session request is invalid.', 'INVALID_INPUT', {
+            reason: 'terminal-session-request-invalid',
+            retryable: false,
+            cause
+        });
+    }
+}
+/** A local session: exactly the kernel's composed environment for this runtime's host. */
+function localSessionOptions(runtime, opts) {
+    return {
+        command: opts.command,
+        args: opts.args,
+        cwd: opts.cwd,
+        env: composeChildEnv(runtime, { env: opts.env ?? {} }),
+        envMode: 'replace',
+        cols: opts.cols,
+        rows: opts.rows
+    };
+}
+/**
+ * A remote session request: a declaration, never an environment (rc02-rc03
+ * C15, cross-host). The receiving host admits it and composes the child's
+ * environment on its own runtime (`composeDeclaredSession`); only the
+ * variables the caller names travel.
+ */
+export function remoteSessionRequest(opts) {
+    const admitted = admitTerminalOptions(opts);
+    const request = {
+        command: admitted.command,
+        cols: admitted.cols,
+        rows: admitted.rows,
+        declaration: admitted.env ? { env: admitted.env } : {}
+    };
+    if (admitted.args !== undefined)
+        request.args = admitted.args;
+    if (admitted.cwd !== undefined)
+        request.cwd = admitted.cwd;
+    return request;
+}
+/**
+ * Open a LOCAL terminal session against this runtime's execution impl.
+ *
+ * The default, zero-config path (Correction #1: local is the default). Resolves
+ * `runtime/execution` on consumer hardware (where `runtime-execution-local`
+ * self-registers `LocalExecution`) and opens a real Bun.Terminal PTY. The
+ * returned `ExecutionSession` is renderable directly by `<Terminal>`.
+ *
+ * Throws if no execution impl is resolvable here (e.g. on a CF Workers surface,
+ * which registers no PTY-capable impl) or if the impl lacks the `pty` capability.
+ */
+export async function openLocalSession(runtime, opts) {
+    const admitted = admitTerminalOptions(opts);
+    // Local-default resolution (Correction #1). The kind's `selectionBias:
+    // 'prefer-local'` picks the consumer impl. We do NOT constrain on
+    // `.matching({ capabilities: { pty: true } })` because that scope-capability
+    // filter checks the *environment's* declared capabilities, not the impl's
+    // own advertised mask — the PTY capability is the IMPL's fact, read off the
+    // resolved impl below via `getCapabilities()`.
+    const exec = await runtime
+        .query('runtime/execution')
+        .resolve();
+    const caps = exec.getCapabilities();
+    if (!caps.pty || caps.maxSessions <= 0) {
+        throw new CapabilityError('The selected execution provider cannot open a PTY session.', 'UNAVAILABLE', {
+            reason: 'terminal-pty-unavailable',
+            retryable: false
+        });
+    }
+    return exec.session(localSessionOptions(runtime, admitted));
+}
+/**
+ * Open a REMOTE terminal session on a specific fleet host (L9b — phase 4).
+ *
+ * Remoteness is an EXPLICIT constraint (Correction #1) — the caller names the host
+ * ref; this client never picks a remote silently. The returned session is an RPC
+ * PROXY adapted to the canonical `ExecutionSession` shape: its byte stream rides
+ * L4's `stream` verb (the `'pty'` channel) and its `write`/`resize`/`signal`/`kill`
+ * are `invoke` calls. Its `exited()` read can reject with `RPC_DISCONNECTED` when
+ * the transport drops — the visible result-type difference `<Terminal>` renders as
+ * a disconnect banner. The component consumes it with IDENTICAL code to the local
+ * case (terminal.md §"Target design" — same UI, only a proxied session).
+ *
+ * Composition (no transport of its own):
+ *   1. Reach the host EXPLICITLY via `getVibesRemoteFrom(runtime,
+ *      hostRef.runtimeId)` — the supplied runtime owns the registered
+ *      `runtime/rpc` descriptor and credential loader; this client never
+ *      reaches for an ambient registry or `discover()`s.
+ *   2. `query('runtime/execution')` over the wire → an execution proxy.
+ *   3. `session(opts)` → a session wire-proxy.
+ *   4. `adaptRemoteSession()` wraps that proxy in the `ExecutionSession` interface.
+ *
+ * The L5 authz + friction gates run on the HOST side inside L1's invoke pipeline
+ * (every arriving `invoke` is gated before the method applies) — this client does
+ * not re-implement them; an unauthorized peer or out-of-policy `session` open is
+ * denied at the host, surfacing here as a rejected invoke.
+ */
+export async function openRemoteSession(runtime, hostRef, opts) {
+    const reference = TerminalHostRefSchema.safeParse(hostRef);
+    if (!reference.success) {
+        throw new CapabilityError('The terminal runtime reference is invalid.', 'INVALID_INPUT', {
+            reason: 'terminal-remote-reference-invalid', retryable: false, cause: reference.error
+        });
+    }
+    if (reference.data.local) {
+        throw new CapabilityError('A remote terminal session requires an explicitly remote runtime reference.', 'INVALID_INPUT', {
+            reason: 'terminal-remote-reference-local',
+            retryable: false
+        });
+    }
+    const request = remoteSessionRequest(opts);
+    // 1) Reach the host EXPLICITLY. getVibesRemote is sugar over
+    //    query('runtime/rpc').withId(id).resolve() + connect(). The returned
+    //    RemoteRuntime pins its connection (and socket) alive until disposed.
+    const client = await getVibesClient('terminal', runtime);
+    client.prepareRemoteSession();
+    let remote;
+    try {
+        remote = await getVibesRemoteFrom(runtime, reference.data.runtimeId);
+    }
+    catch (cause) {
+        throw new CapabilityError('The terminal client could not reach the remote terminal host.', 'UNAVAILABLE', {
+            reason: 'terminal-remote-host-unavailable',
+            retryable: true,
+            cause
+        });
+    }
+    // Dispose the whole remote connection when the session ends — releasing the
+    // session ref on the host AND closing the socket so a closed terminal leaks
+    // neither a remote PTY nor a connection.
+    const disposeRemote = () => remote.close();
+    try {
+        // 2) Resolve the host's execution impl over the wire. The remote root's
+        //    query(kindId) is a proxied invoke that returns an execution ref.
+        const exec = await remote.query('runtime/execution');
+        // 3) Open the interactive PTY session on the host. This invoke passes the
+        //    host's L5 authz → friction gates before the PTY is created.
+        const sessionProxy = await exec.session(request);
+        // 4) Adapt the wire proxy into the canonical ExecutionSession the renderer
+        //    consumes unchanged. onClose disposes the remote connection.
+        return adaptRemoteSession(runtime, sessionProxy, reference.data.runtimeId, disposeRemote);
+    }
+    catch (err) {
+        // On any failure during resolve/open, free the connection we just opened so a
+        // failed remote terminal never leaks a socket.
+        await disposeRemote();
+        throw err;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @vibesdotdev/terminal-client
+ *
+ * Session management for the terminal surface: resolve a renderable
+ * `ExecutionSession` from this runtime (local, L9a) or from an explicitly-named
+ * fleet host (remote proxy, L9b). Composes L3's `runtime/execution` and (for the
+ * remote path) L4's `runtime/rpc` verbs; ships no transport of its own.
+ *
+ * The portable plugin registers runtime/client:terminal.
+ */
+export { openLocalSession, openRemoteSession, type OpenTerminalOptions, type ExecutionSession } from './client.ts';
+export { TerminalClient } from './terminal-runtime.ts';
+export { OpenTerminalOptionsSchema } from './schemas/session.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACN,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * @vibesdotdev/terminal-client
+ *
+ * Session management for the terminal surface: resolve a renderable
+ * `ExecutionSession` from this runtime (local, L9a) or from an explicitly-named
+ * fleet host (remote proxy, L9b). Composes L3's `runtime/execution` and (for the
+ * remote path) L4's `runtime/rpc` verbs; ships no transport of its own.
+ *
+ * The portable plugin registers runtime/client:terminal.
+ */
+export { openLocalSession, openRemoteSession } from "./client.js";
+export { TerminalClient } from "./terminal-runtime.js";
+export { OpenTerminalOptionsSchema } from "./schemas/session.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACN,gBAAgB,EAChB,iBAAiB,EAGjB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/pty-bridge/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @vibesdotdev/terminal-client/pty-bridge
+ *
+ * A tiny PTY-websocket bridge: a Bun-only server (`./server`) that opens a REAL
+ * PTY inside a container and streams it over a websocket, plus the pure,
+ * workerd-safe wire protocol (`./protocol`) shared with any client that bridges
+ * an `ExecutionSession` to it. The mechanism that makes cloud terminals HONESTLY
+ * interactive (`pty:true`) even though workerd itself has no PTY: the PTY lives
+ * in the CF Sandbox container; the client speaks to it over the exposed port.
+ *
+ * The default entry re-exports ONLY the workerd-safe protocol — importing the
+ * package index never pulls Bun in. The Bun server lives behind `./server`.
+ */
+export { type ClientFrame, type ServerControlFrame, bytesToBase64, base64ToBytes, encodeStdinFrame, encodeResizeFrame, encodeSignalFrame, decodeClientFrame, encodeExitFrame, decodeServerControlFrame } from './protocol.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/pty-bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pty-bridge/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,wBAAwB,EACxB,MAAM,eAAe,CAAC"}

package/dist/pty-bridge/index.js

@@ -0,0 +1,15 @@
+/**
+ * @vibesdotdev/terminal-client/pty-bridge
+ *
+ * A tiny PTY-websocket bridge: a Bun-only server (`./server`) that opens a REAL
+ * PTY inside a container and streams it over a websocket, plus the pure,
+ * workerd-safe wire protocol (`./protocol`) shared with any client that bridges
+ * an `ExecutionSession` to it. The mechanism that makes cloud terminals HONESTLY
+ * interactive (`pty:true`) even though workerd itself has no PTY: the PTY lives
+ * in the CF Sandbox container; the client speaks to it over the exposed port.
+ *
+ * The default entry re-exports ONLY the workerd-safe protocol — importing the
+ * package index never pulls Bun in. The Bun server lives behind `./server`.
+ */
+export { bytesToBase64, base64ToBytes, encodeStdinFrame, encodeResizeFrame, encodeSignalFrame, decodeClientFrame, encodeExitFrame, decodeServerControlFrame } from "./protocol.js";
+//# sourceMappingURL=index.js.map

package/dist/pty-bridge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/pty-bridge/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAGN,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,wBAAwB,EACxB,MAAM,eAAe,CAAC"}

package/dist/pty-bridge/protocol.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compatibility names for the runtime-owned terminal PTY wire contract.
+ * The feature consumes the protocol; the runtime kernel owns its neutral schema.
+ */
+export { terminalPtyBytesToBase64 as bytesToBase64, terminalPtyBase64ToBytes as base64ToBytes, encodeTerminalPtyStdinFrame as encodeStdinFrame, encodeTerminalPtyResizeFrame as encodeResizeFrame, encodeTerminalPtySignalFrame as encodeSignalFrame, decodeTerminalPtyClientFrame as decodeClientFrame, encodeTerminalPtyExitFrame as encodeExitFrame, decodeTerminalPtyServerControlFrame as decodeServerControlFrame, type TerminalPtyClientFrame as ClientFrame, type TerminalPtyServerControlFrame as ServerControlFrame } from '@vibesdotdev/kernel/execution';
+//# sourceMappingURL=protocol.d.ts.map

package/dist/pty-bridge/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/pty-bridge/protocol.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACN,wBAAwB,IAAI,aAAa,EACzC,wBAAwB,IAAI,aAAa,EACzC,2BAA2B,IAAI,gBAAgB,EAC/C,4BAA4B,IAAI,iBAAiB,EACjD,4BAA4B,IAAI,iBAAiB,EACjD,4BAA4B,IAAI,iBAAiB,EACjD,0BAA0B,IAAI,eAAe,EAC7C,mCAAmC,IAAI,wBAAwB,EAC/D,KAAK,sBAAsB,IAAI,WAAW,EAC1C,KAAK,6BAA6B,IAAI,kBAAkB,EACxD,MAAM,+BAA+B,CAAC"}

package/dist/pty-bridge/protocol.js

@@ -0,0 +1,6 @@
+/**
+ * Compatibility names for the runtime-owned terminal PTY wire contract.
+ * The feature consumes the protocol; the runtime kernel owns its neutral schema.
+ */
+export { terminalPtyBytesToBase64 as bytesToBase64, terminalPtyBase64ToBytes as base64ToBytes, encodeTerminalPtyStdinFrame as encodeStdinFrame, encodeTerminalPtyResizeFrame as encodeResizeFrame, encodeTerminalPtySignalFrame as encodeSignalFrame, decodeTerminalPtyClientFrame as decodeClientFrame, encodeTerminalPtyExitFrame as encodeExitFrame, decodeTerminalPtyServerControlFrame as decodeServerControlFrame } from '@vibesdotdev/kernel/execution';
+//# sourceMappingURL=protocol.js.map

package/dist/pty-bridge/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/pty-bridge/protocol.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACN,wBAAwB,IAAI,aAAa,EACzC,wBAAwB,IAAI,aAAa,EACzC,2BAA2B,IAAI,gBAAgB,EAC/C,4BAA4B,IAAI,iBAAiB,EACjD,4BAA4B,IAAI,iBAAiB,EACjD,4BAA4B,IAAI,iBAAiB,EACjD,0BAA0B,IAAI,eAAe,EAC7C,mCAAmC,IAAI,wBAAwB,EAG/D,MAAM,+BAA+B,CAAC"}

package/dist/pty-bridge/server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compatibility composition root for the Bun-owned PTY websocket host.
+ * New host code imports `@vibesdotdev/host-bun/terminal-pty-bridge`.
+ */
+import { ptyServerConfigFromEnv, runPtyWsServerFromCli, startPtyWsServer, type PtyServerConfig } from '@vibesdotdev/host-bun/terminal-pty-bridge';
+export { ptyServerConfigFromEnv, runPtyWsServerFromCli, startPtyWsServer, type PtyServerConfig };
+//# sourceMappingURL=server.d.ts.map

package/dist/pty-bridge/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/pty-bridge/server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACN,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,eAAe,EACpB,MAAM,2CAA2C,CAAC;AAEnD,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,CAAC"}

package/dist/pty-bridge/server.js

@@ -0,0 +1,9 @@
+/**
+ * Compatibility composition root for the Bun-owned PTY websocket host.
+ * New host code imports `@vibesdotdev/host-bun/terminal-pty-bridge`.
+ */
+import { ptyServerConfigFromEnv, runPtyWsServerFromCli, startPtyWsServer } from '@vibesdotdev/host-bun/terminal-pty-bridge';
+export { ptyServerConfigFromEnv, runPtyWsServerFromCli, startPtyWsServer };
+if (import.meta.main)
+    await runPtyWsServerFromCli();
+//# sourceMappingURL=server.js.map

package/dist/pty-bridge/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/pty-bridge/server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACN,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAEhB,MAAM,2CAA2C,CAAC;AAEnD,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,gBAAgB,EAAwB,CAAC;AAEjG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;IAAE,MAAM,qBAAqB,EAAE,CAAC"}

package/dist/remote-session.d.ts

@@ -0,0 +1,51 @@
+/**
+ * remote-session — adapt an RPC session WIRE-PROXY into a real `ExecutionSession`.
+ *
+ * `openRemoteSession` reaches a fleet host's `runtime/execution` impl over L4's
+ * RPC and calls `session(opts)`. What comes back is NOT an `ExecutionSession` — it
+ * is a kind-agnostic wire proxy (`makeRemoteProxy`) whose surface is:
+ *
+ *   - the methods the OWNER declared when it classified the session as a ref
+ *     (`write` / `resize` / `signal` / `exited` / `kill`) — each an `invoke` that
+ *     resolves to a Promise; and
+ *   - `__openStream(channel)` — opens the raw byte channel (`stream` verb) the PTY
+ *     output rides (the consumer names the channel `'pty'`, never the protocol).
+ *
+ * The terminal-svelte `<Terminal>` component consumes the canonical L3
+ * `ExecutionSession` interface UNCHANGED — synchronous `write`/`resize`/`signal`/
+ * `kill`, an `onOutput(handler) => unsubscribe`, an `exited(): Promise<…>`, and the
+ * readonly `id`/`environmentId`. This adapter is the bridge: it makes a proxy
+ * session look IDENTICAL to a local one so the component never forks on transport
+ * (the whole point of the proxy model — terminal.md §"Target design").
+ *
+ * Remoteness stays VISIBLE in behavior (Correction #1): when the transport drops,
+ * `exited()` rejects with `RPC_DISCONNECTED` (the proxy invoke fails) — which the
+ * component already renders as a disconnect banner. This adapter never silently
+ * swallows a disconnect into a clean exit.
+ *
+ * This module ships NO transport of its own — it composes the proxy `runtime-rpc`
+ * already minted. It only translates async-proxy semantics into the synchronous
+ * `ExecutionSession` shape the renderer expects.
+ */
+import { type VibesRuntime } from '@vibesdotdev/kernel';
+import type { ExecutionSession } from '@vibesdotdev/kernel/execution';
+/**
+ * The session wire-proxy surface, as the owner declared it (see the execution
+ * listen target's `classifyResult`). Every method is an `invoke` → a Promise; the
+ * stream channel is opened via the proxy's `__openStream`. `id`/`environmentId`
+ * are NOT on the wire (they were readonly props, not methods) — this adapter
+ * synthesizes them.
+ */
+export type { RemoteSessionProxy } from './schemas/remote.ts';
+import { type RemoteSessionProxy } from './schemas/remote.ts';
+/**
+ * Wrap a session wire-proxy in the canonical `ExecutionSession` interface.
+ *
+ * @param proxy   the wire proxy returned by `exec.session(opts)` over RPC.
+ * @param hostId  the explicitly-named host (for a stable, descriptive session id).
+ * @param onClose optional teardown run when the session is killed/exited — used by
+ *                the client to dispose the underlying RPC connection so a closed
+ *                terminal frees the remote PTY *and* its socket (no leak).
+ */
+export declare function adaptRemoteSession(runtime: VibesRuntime, proxyInput: RemoteSessionProxy, hostIdInput: string, onClose?: () => void | Promise<void>): ExecutionSession;
+//# sourceMappingURL=remote-session.d.ts.map

package/dist/remote-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-session.d.ts","sourceRoot":"","sources":["../src/remote-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAKN,KAAK,YAAY,EACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAStE;;;;;;GAMG;AACH,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAA4D,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAUxH;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAClC,gBAAgB,CA8QlB"}