dexto 1.14.6 → 2.0.0-beta.1

package/dist/cli/cloud/commands/chats.js

@@ -0,0 +1,204 @@
+// `chat local` and `chat import`: find Claude Code and Codex chats on this machine and import them.
+import { requireConsent } from '../../interaction.js';
+import { z } from 'zod';
+import { flag, MissingScopeFailure, stringOption, UsageError, YES_OPTION, } from '../command.js';
+import { findLocalChats, } from '../../import/local-chats.js';
+import { toImportInput } from '../../import/redaction.js';
+import { LOCAL_CHAT_SOURCES, } from '../../import/transcript.js';
+import { queryWorkspaceTool } from './workspace.js';
+const FIND_OPTIONS = {
+    dir: {
+        description: 'Read sessions from this folder (default: $CLAUDE_CONFIG_DIR/projects or ~/.claude/projects; $CODEX_HOME/sessions or ~/.codex/sessions).',
+        type: 'string',
+        valueName: 'PATH',
+    },
+    from: {
+        description: `Where the chats are: ${LOCAL_CHAT_SOURCES.join(' or ')}.`,
+        type: 'string',
+        valueName: 'SOURCE',
+    },
+    folder: {
+        description: 'Only sessions run in this folder or inside it, such as . for this repository.',
+        type: 'string',
+        valueName: 'PATH',
+    },
+    since: {
+        description: 'Only sessions with a turn on or after this date, such as 2026-10-01.',
+        type: 'string',
+        valueName: 'DATE',
+    },
+};
+const ImportedSchema = z.object({
+    session: z.object({ id: z.string() }),
+    status: z.enum(['already_imported', 'imported']),
+    url: z.string(),
+});
+function localQuery(input) {
+    const from = stringOption(input, 'from');
+    if (from === undefined)
+        throw new UsageError(`--from is required: ${LOCAL_CHAT_SOURCES.join(' or ')}.`);
+    const source = LOCAL_CHAT_SOURCES.find((each) => each === from);
+    if (source === undefined)
+        throw new UsageError(`--from takes ${LOCAL_CHAT_SOURCES.join(' or ')}, not ${from}.`);
+    const since = stringOption(input, 'since') ?? null;
+    if (since !== null && Number.isNaN(new Date(since).getTime()))
+        throw new UsageError('--since must be a date, such as 2026-10-01.');
+    return {
+        dir: stringOption(input, 'dir') ?? null,
+        folder: stringOption(input, 'folder') ?? null,
+        since,
+        source,
+    };
+}
+function sourceName(source) {
+    return source === 'claude-code' ? 'Claude Code' : 'Codex';
+}
+const local = {
+    options: FIND_OPTIONS,
+    path: ['chat', 'local'],
+    summary: 'List Claude Code or Codex chats on this machine, newest first, to pick some for chat import.',
+    async run(context, input) {
+        const scan = await findLocalChats(context.runtime, localQuery(input));
+        noteScan(context, scan);
+        context.output.list({
+            data: scan.chats.map((chat) => ({
+                cwd: chat.cwd,
+                id: chat.id,
+                messages: chat.messages.length,
+                path: chat.path,
+                pullRequests: chat.pullRequests,
+                repository: chat.repository,
+                source: chat.source,
+                startedAt: chat.startedAt,
+                title: chat.title,
+                updatedAt: chat.updatedAt,
+            })),
+        }, [
+            { header: 'id', value: (row) => row.id },
+            { header: 'title', value: (row) => row.title },
+            { header: 'messages', value: (row) => row.messages },
+            { header: 'updated', value: (row) => row.updatedAt },
+            { header: 'folder', value: (row) => row.cwd },
+        ]);
+    },
+};
+const importChats = {
+    arguments: '[session_ids...]',
+    options: {
+        ...FIND_OPTIONS,
+        all: { description: 'Import every session chat local lists.', type: 'boolean' },
+        'dry-run': {
+            description: 'Send nothing; show what each import would send and what was redacted.',
+            type: 'boolean',
+        },
+        ...YES_OPTION,
+    },
+    path: ['chat', 'import'],
+    summary: 'Import Claude Code or Codex chats from this machine as your private Dexto chats, redacted here first.',
+    async run(context, input) {
+        const query = localQuery(input);
+        const ids = input.positionals;
+        const all = flag(input, 'all');
+        if (ids.length === 0 && !all)
+            throw new UsageError('Name the sessions to import, by the ids chat local lists, or pass --all.');
+        const scan = await findLocalChats(context.runtime, query);
+        noteScan(context, scan);
+        const found = scan.chats;
+        const planned = (all ? found : ids.map((id) => found.find((chat) => chat.id === id) ?? id)).map((chat) => plan(chat, query.source));
+        const sending = planned.filter((each) => each.input !== null);
+        if (flag(input, 'dry-run') || sending.length === 0) {
+            report(context, planned.map((each) => each.result));
+            return flag(input, 'dry-run') || planned.length === 0 ? 0 : 1;
+        }
+        const messages = sending.reduce((sum, each) => sum + (each.result.messages ?? 0), 0);
+        const redacted = sending.reduce((sum, each) => sum + Object.values(each.result.redactions ?? {}).reduce((one, n) => one + n, 0), 0);
+        await requireConsent(context, flag(input, 'yes'), `Upload ${sending.length} ${sourceName(query.source)} chat${sending.length === 1 ? '' : 's'} (${messages} messages, ${redacted} secrets redacted) as your private Dexto chats?`);
+        const finished = await Promise.all(planned.map(async ({ input: sent, result }) => {
+            if (sent === null)
+                return result;
+            try {
+                const imported = ImportedSchema.parse(await queryWorkspaceTool(context, 'dexto_chat_import', sent));
+                return {
+                    ...result,
+                    chatId: imported.session.id,
+                    status: imported.status,
+                    url: imported.url,
+                };
+            }
+            catch (error) {
+                // A missing permission fails every import alike: exit 3 with the sign-in that fixes it.
+                if (error instanceof MissingScopeFailure)
+                    throw error;
+                return {
+                    ...result,
+                    reason: error instanceof Error ? error.message : 'The import failed.',
+                    status: 'failed',
+                };
+            }
+        }));
+        report(context, finished);
+        return finished.some((result) => result.status === 'failed' || result.status === 'skipped')
+            ? 1
+            : 0;
+    },
+};
+/** What importing one chosen session would send, or why it can't go. */
+function plan(chat, source) {
+    if (typeof chat === 'string')
+        return {
+            input: null,
+            result: {
+                id: chat,
+                reason: `No ${sourceName(source)} session with this id matches here.`,
+                status: 'skipped',
+            },
+        };
+    const prepared = toImportInput(chat);
+    if (prepared.kind === 'skipped')
+        return {
+            input: null,
+            result: { id: chat.id, reason: prepared.reason, status: 'skipped', title: chat.title },
+        };
+    return {
+        input: prepared.input,
+        result: {
+            id: chat.id,
+            leftOut: prepared.leftOut,
+            messages: prepared.input.messages.length,
+            redactions: prepared.redactions,
+            status: 'ready',
+            title: prepared.input.title,
+            truncated: prepared.truncated,
+        },
+    };
+}
+/** What the scan found that its chats don't show, such as Codex history it can't read yet. */
+function noteScan(context, scan) {
+    for (const notice of scan.notices)
+        context.output.note(notice.message);
+}
+function report(context, sessions) {
+    context.output.result({ sessions }, sessions
+        .map((session) => [
+        `${session.status.padEnd(16)} ${session.id}`,
+        session.title === undefined ? '' : `  ${session.title}`,
+        session.url === undefined ? '' : `  ${session.url}`,
+        session.reason === undefined ? '' : `  ${session.reason}`,
+        session.status === 'ready' ? `  ${readyLine(session)}` : '',
+    ].join(''))
+        .join('\n'));
+}
+function readyLine(session) {
+    const redactions = Object.entries(session.redactions ?? {})
+        .map(([kind, count]) => `${count} ${kind}`)
+        .join(', ');
+    return [
+        `${session.messages ?? 0} messages`,
+        redactions === '' ? 'nothing redacted' : `redacted ${redactions}`,
+        session.truncated ? `${session.truncated} cut to size` : '',
+        session.leftOut ? `first ${session.leftOut} left out` : '',
+    ]
+        .filter((part) => part !== '')
+        .join('; ');
+}
+export const chatCommands = [local, importChats];

package/dist/cli/cloud/commands/data-deletions.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const dataDeletionCommands: readonly Command[];
+//# sourceMappingURL=data-deletions.d.ts.map

package/dist/cli/cloud/commands/data-deletions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-deletions.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/data-deletions.ts"],"names":[],"mappings":"AAKA,OAAO,EAQH,KAAK,OAAO,EACf,MAAM,eAAe,CAAC;AAiFvB,eAAO,MAAM,oBAAoB,EAAE,SAAS,OAAO,EAAwB,CAAC"}

package/dist/cli/cloud/commands/data-deletions.js

@@ -0,0 +1,55 @@
+// `cloud data-deletions`: delete an end user's or an agent's data in the background.
+import { requireConsent } from '../../interaction.js';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, flag, PAGE_OPTIONS, pageQuery, stringOption, UsageError, YES_OPTION, } from '../command.js';
+const COLUMNS = [
+    { header: 'id', value: (deletion) => deletion.id },
+    { header: 'status', value: (deletion) => deletion.status },
+    { header: 'scope', value: (deletion) => JSON.stringify(deletion.scope) },
+    { header: 'created', value: (deletion) => deletion.created_at },
+];
+const create = {
+    options: {
+        agent: { description: 'The agent whose data to delete.', type: 'string', valueName: 'ID' },
+        user: { description: 'The end-user label whose sessions to delete.', type: 'string' },
+        ...YES_OPTION,
+    },
+    path: ['cloud', 'data-deletions', 'create'],
+    summary: "Delete an end user's sessions (--user, optionally of one --agent), or all of an agent's data (--agent).",
+    async run(context, input) {
+        const agentId = stringOption(input, 'agent');
+        const user = stringOption(input, 'user');
+        if (agentId === undefined && user === undefined)
+            throw new UsageError('Pass --user, --agent, or both.');
+        await requireConsent(context, flag(input, 'yes'), user === undefined
+            ? `This deletes all of agent ${agentId}'s data for good.`
+            : `This deletes ${user}'s sessions${agentId === undefined ? '' : ` with agent ${agentId}`} for good.`);
+        const deletion = await unwrap(await (await context.client()).POST('/v1/data_deletions', {
+            body: { agent_id: agentId ?? null, ...(user === undefined ? {} : { user }) },
+        }));
+        context.output.result(deletion, `Data deletion ${deletion.id} is ${deletion.status}.`);
+    },
+};
+const list = {
+    options: PAGE_OPTIONS,
+    path: ['cloud', 'data-deletions', 'list'],
+    summary: 'List data deletions.',
+    async run(context, input) {
+        context.output.list(await unwrap(await (await context.client()).GET('/v1/data_deletions', {
+            params: { query: pageQuery(input) },
+        })), COLUMNS);
+    },
+};
+const get = {
+    arguments: '<data_deletion_id>',
+    path: ['cloud', 'data-deletions', 'get'],
+    summary: 'Show a data deletion and what it deleted.',
+    async run(context, input) {
+        context.output.record(await unwrap(await (await context.client()).GET('/v1/data_deletions/{data_deletion_id}', {
+            params: {
+                path: { data_deletion_id: argument(input, 0, 'data_deletion_id') },
+            },
+        })));
+    },
+};
+export const dataDeletionCommands = [create, list, get];

package/dist/cli/cloud/commands/deploys.d.ts

@@ -0,0 +1,10 @@
+import { type Command, type CommandContext } from '../command.js';
+/**
+ * A person's sign-in needs the kind's permission, and to deploy also `cloud:write`, which the API
+ * checks first; asking for every missing one at once lets a single sign-in cover the command. A
+ * deploy spends credits, so running one is asking for `cloud:write`. At a terminal the CLI then
+ * offers to sign in again for them. A key's permissions are checked by the API.
+ */
+export declare function requireLoginScopes(context: CommandContext, scopes: readonly string[]): Promise<void>;
+export declare const deployCommands: readonly Command[];
+//# sourceMappingURL=deploys.d.ts.map

package/dist/cli/cloud/commands/deploys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploys.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/deploys.ts"],"names":[],"mappings":"AAWA,OAAO,EAMH,KAAK,OAAO,EACZ,KAAK,cAAc,EAGtB,MAAM,eAAe,CAAC;AAkLvB;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACpC,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CAYf;AAwED,eAAO,MAAM,cAAc,EAAE,SAAS,OAAO,EAM5C,CAAC"}

package/dist/cli/cloud/commands/deploys.js

@@ -0,0 +1,225 @@
+// `cloud sites` and `cloud functions`: pack a project with its own packer, deploy, list and delete.
+import { CommandFailure } from '../../failure.js';
+import { requireConsent } from '../../interaction.js';
+import { access, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { argument, flag, MissingScopeFailure, stringOption, UsageError, YES_OPTION, } from '../command.js';
+import { callV1 } from '../v1.js';
+const PACKER = path.join('.dexto', 'pack.mjs');
+const PROVIDERS = ['cloudflare-workers', 'aws-lambda'];
+const SiteSchema = z.object({
+    id: z.string(),
+    slug: z.string(),
+    url: z.string(),
+    visibility: z.string(),
+});
+const FunctionSchema = z.object({
+    access: z.string(),
+    id: z.string(),
+    slug: z.string(),
+    status: z.string(),
+    url: z.string().nullable(),
+});
+const DeployedSiteSchema = z.object({
+    deployment: z.object({ id: z.string() }),
+    promoted: z.boolean(),
+    site: z.object({ id: z.string(), slug: z.string() }),
+    url: z.string(),
+});
+const DeployedFunctionSchema = z.object({
+    deployment: z.object({ id: z.string(), preview_url: z.string() }),
+    dexto: z.object({ configured: z.boolean(), scopes: z.array(z.string()) }).nullable(),
+    function: z.object({ id: z.string(), slug: z.string() }),
+    promoted: z.boolean(),
+    url: z.string().nullable(),
+});
+const DEPLOY_OPTIONS = {
+    'no-promote': {
+        description: 'Deploy a preview to promote later, instead of making it live.',
+        type: 'boolean',
+    },
+    provider: {
+        description: `Where its Function runs: ${PROVIDERS.join(' or ')}. Omit for the default.`,
+        type: 'string',
+        valueName: 'PROVIDER',
+    },
+};
+const deploySite = {
+    arguments: '[dir]',
+    options: DEPLOY_OPTIONS,
+    path: ['cloud', 'sites', 'deploy'],
+    summary: 'Pack the Site in dir (default: here) with its packer and deploy it to the Cloud project; it goes live unless --no-promote.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['sites:write', 'cloud:write']);
+        // Options are checked before packing, which can build and rewrite project files.
+        const query = deployQuery(input, {});
+        const packed = await pack(context, input.positionals[0], 'site');
+        const deployed = DeployedSiteSchema.parse(await callV1(context, 'POST', `/v1/sites/deployments?${query}`, packed));
+        context.output.result(deployed, deployed.promoted
+            ? `Deployed ${deployed.site.slug} to ${deployed.url} (deployment ${deployed.deployment.id}).`
+            : `Deployed a preview of ${deployed.site.slug} at ${deployed.url}. Make it live with: dexto cloud api POST /v1/sites/${deployed.site.id}/deployments/${deployed.deployment.id}/promote`);
+    },
+};
+const deployFunction = {
+    arguments: '[dir]',
+    options: {
+        ...DEPLOY_OPTIONS,
+        public: {
+            description: 'Let anyone on the internet reach it. Functions are private by default.',
+            type: 'boolean',
+        },
+    },
+    path: ['cloud', 'functions', 'deploy'],
+    summary: 'Pack the Function in dir (default: here) with its packer and deploy it to the Cloud project; it goes live unless --no-promote.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['functions:write', 'cloud:write']);
+        // Options are checked before packing, which can build and rewrite project files.
+        const query = deployQuery(input, {
+            access: flag(input, 'public') ? 'public' : 'private',
+        });
+        const packed = await pack(context, input.positionals[0], 'function');
+        const deployed = DeployedFunctionSchema.parse(await callV1(context, 'POST', `/v1/functions/deployments?${query}`, packed));
+        const key = deployed.dexto === null || deployed.dexto.configured
+            ? ''
+            : ` Its Dexto key was not bound: your sign-in lacks ${deployed.dexto.scopes.join(', ')}.`;
+        context.output.result(deployed, deployed.promoted
+            ? `Deployed ${deployed.function.slug}${deployed.url === null ? '' : ` to ${deployed.url}`} (deployment ${deployed.deployment.id}).${key}`
+            : `Deployed ${deployed.function.slug} without making it live; preview at ${deployed.deployment.preview_url}. Make it live with: dexto cloud api POST /v1/functions/${deployed.function.id}/deployments/${deployed.deployment.id}/promote${key}`);
+    },
+};
+const SITE_COLUMNS = [
+    { header: 'id', value: (site) => site.id },
+    { header: 'slug', value: (site) => site.slug },
+    { header: 'visibility', value: (site) => site.visibility },
+    { header: 'url', value: (site) => site.url },
+];
+const FUNCTION_COLUMNS = [
+    { header: 'id', value: (deployed) => deployed.id },
+    { header: 'slug', value: (deployed) => deployed.slug },
+    { header: 'status', value: (deployed) => deployed.status },
+    { header: 'access', value: (deployed) => deployed.access },
+    { header: 'url', value: (deployed) => deployed.url },
+];
+const listSites = {
+    path: ['cloud', 'sites', 'list'],
+    summary: "List the Cloud project's Sites.",
+    async run(context) {
+        await requireLoginScopes(context, ['sites:read']);
+        const page = z
+            .object({ data: z.array(SiteSchema) })
+            .parse(await callV1(context, 'GET', '/v1/sites', null));
+        context.output.list(page, SITE_COLUMNS);
+    },
+};
+const deleteSite = {
+    arguments: '<site>',
+    options: YES_OPTION,
+    path: ['cloud', 'sites', 'delete'],
+    summary: 'Delete a Site of the Cloud project, by id or slug, with its deployments and data; its slug is free again. Asks first.',
+    async run(context, input) {
+        // The Site is found by listing, which takes sites:read, before it is deleted.
+        await requireLoginScopes(context, ['sites:read', 'sites:write', 'cloud:write']);
+        const wanted = argument(input, 0, 'site');
+        const sites = z
+            .object({ data: z.array(SiteSchema) })
+            .parse(await callV1(context, 'GET', '/v1/sites', null)).data;
+        const site = sites.find((each) => each.id === wanted || each.slug === wanted);
+        if (site === undefined)
+            throw new CommandFailure('not_found', `The Cloud project has no Site ${wanted}.`, 'dexto cloud sites list');
+        await requireConsent(context, flag(input, 'yes'), `This deletes ${site.slug} (${site.url}) with its deployments and data. It can't be undone.`);
+        await callV1(context, 'DELETE', `/v1/sites/${encodeURIComponent(site.id)}`, null);
+        context.output.result({ deleted: true, id: site.id, slug: site.slug }, `Deleted ${site.slug}. Its slug is free to deploy again.`);
+    },
+};
+const listFunctions = {
+    path: ['cloud', 'functions', 'list'],
+    summary: "List the Cloud project's Functions.",
+    async run(context) {
+        await requireLoginScopes(context, ['functions:read']);
+        const page = z
+            .object({ data: z.array(FunctionSchema) })
+            .parse(await callV1(context, 'GET', '/v1/functions', null));
+        context.output.list(page, FUNCTION_COLUMNS);
+    },
+};
+/**
+ * A person's sign-in needs the kind's permission, and to deploy also `cloud:write`, which the API
+ * checks first; asking for every missing one at once lets a single sign-in cover the command. A
+ * deploy spends credits, so running one is asking for `cloud:write`. At a terminal the CLI then
+ * offers to sign in again for them. A key's permissions are checked by the API.
+ */
+export async function requireLoginScopes(context, scopes) {
+    const connection = await context.connection();
+    if (connection.kind !== 'oauth')
+        return;
+    const missing = scopes.filter((scope) => !connection.login.scopes.includes(scope));
+    if (missing.length === 0)
+        return;
+    throw new MissingScopeFailure(context, missing.join(','), missing.length === 1
+        ? `This needs the ${missing[0]} permission, which your sign-in lacks.`
+        : `This needs the ${missing.join(' and ')} permissions, which your sign-in lacks.`);
+}
+function deployQuery(input, extra) {
+    const provider = stringOption(input, 'provider');
+    if (provider !== undefined && !PROVIDERS.some((each) => each === provider))
+        throw new UsageError(`--provider must be ${PROVIDERS.join(' or ')}.`);
+    return new URLSearchParams({
+        ...extra,
+        promote: flag(input, 'no-promote') ? 'false' : 'true',
+        ...(provider === undefined ? {} : { provider }),
+    });
+}
+/**
+ * Runs the project's own packer, `.dexto/pack.mjs`, or its `pack` script when it has none, into a
+ * temporary file, and returns the deploy request it wrote once it is the kind asked for.
+ */
+async function pack(context, dir, kind) {
+    const projectDir = path.resolve(dir ?? '.');
+    const outputDir = await mkdtemp(path.join(tmpdir(), 'dexto-pack-'));
+    const outputPath = path.join(outputDir, 'deploy-request.json');
+    try {
+        const ownPacker = await exists(path.join(projectDir, PACKER));
+        const [command, args] = ownPacker
+            ? ['node', [PACKER, '.', '--out', outputPath]]
+            : ['pnpm', ['run', 'pack', '.', '--out', outputPath]];
+        context.output.note(`Packing ${projectDir} with ${ownPacker ? PACKER : 'pnpm run pack'}…`);
+        const packed = await context.runtime.runProcess(command, args, { cwd: projectDir });
+        if (packed.exitCode !== 0)
+            throw new CommandFailure('invalid_input', `Packing failed:\n${packed.output.trim()}`, null);
+        const text = await readFile(outputPath, 'utf8').catch(() => {
+            throw new CommandFailure('failed', `The packer wrote no deploy request to ${outputPath}.`, null);
+        });
+        const packedKind = packageKind(text);
+        if (packedKind !== kind)
+            throw new UsageError(`${projectDir} packs a ${packedKind}. Deploy it with dexto cloud ${packedKind}s deploy.`);
+        return text;
+    }
+    finally {
+        await rm(outputDir, { force: true, recursive: true });
+    }
+}
+/** A Site's deploy request has pages (`assets`); a Function's has none. */
+function packageKind(text) {
+    const parsed = JSON.parse(text);
+    return typeof parsed === 'object' && parsed !== null && 'assets' in parsed
+        ? 'site'
+        : 'function';
+}
+async function exists(file) {
+    try {
+        await access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const deployCommands = [
+    deploySite,
+    listSites,
+    deleteSite,
+    deployFunction,
+    listFunctions,
+];

package/dist/cli/cloud/commands/drive.d.ts

@@ -0,0 +1,12 @@
+import { type Command, type CommandContext } from '../command.js';
+/**
+ * Uploads one local file into an app's own Drive folder, which gives the app the file to refer to
+ * as `drive:<id>`.
+ */
+export declare function putAppFile(context: CommandContext, localPath: string, appId: string): Promise<{
+    id: string;
+    mimeType: string;
+    name: string;
+}>;
+export declare const driveCommands: readonly Command[];
+//# sourceMappingURL=drive.d.ts.map

package/dist/cli/cloud/commands/drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/drive.ts"],"names":[],"mappings":"AAWA,OAAO,EAIH,KAAK,OAAO,EACZ,KAAK,cAAc,EACtB,MAAM,eAAe,CAAC;AA4VvB;;;GAGG;AACH,wBAAsB,UAAU,CAC5B,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAezD;AAwED,eAAO,MAAM,aAAa,EAAE,SAAS,OAAO,EAAU,CAAC"}