@skhema/cli 0.3.1

package/dist/commands/auth.js

@@ -0,0 +1,403 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import readline from 'readline';
+import { resolveClient } from '../lib/api/client.js';
+import { AuthRequiredError, emitSuccess, runCommand, UsageError, } from '../lib/api/run-command.js';
+import { createApiKey, listApiKeys, revokeApiKey, } from '../lib/auth/api-key-admin.js';
+import { clearApiKey, getApiKeyStorageLocation, storeApiKey, } from '../lib/auth/api-key-store.js';
+import { startDeviceFlow } from '../lib/auth/device-flow.js';
+import { clearContributorStatusCache } from '../lib/auth/entitlements.js';
+import { startLocalhostFlow } from '../lib/auth/localhost-flow.js';
+import { ConsentRequiredError, fetchUserInfo, switchOrganization, } from '../lib/auth/oauth-client.js';
+import { clearCredentials, getStoredCredentials, storeCredentials, } from '../lib/auth/token-store.js';
+import { getGlobalOptions, log, logHeader, logTable, outputError, } from '../lib/output.js';
+const VALID_PERMISSIONS = ['read', 'write', 'read-write'];
+const VALID_SCOPES = ['org', 'user'];
+/**
+ * Resolve the logged-in user's OAuth token + active org for key-management calls
+ * (create/list/revoke go through `api-key-manage`, which requires a user token).
+ */
+async function requireOAuthContext() {
+    const creds = await getStoredCredentials();
+    if (!creds?.access_token) {
+        throw new AuthRequiredError('Managing API keys requires an interactive login. Run `skhema auth login` first.');
+    }
+    const organizationId = creds.organization?.id;
+    if (!organizationId) {
+        throw new UsageError('No active organization on your session. Run `skhema auth switch` to select one.');
+    }
+    return { accessToken: creds.access_token, organizationId };
+}
+export function registerAuthCommands(program) {
+    const auth = program.command('auth').description('Authentication management');
+    auth
+        .command('login')
+        .description('Authenticate with Skhema')
+        .option('--headless', 'Use device code flow (for headless environments)')
+        .action(async (options) => {
+        // Check if already logged in
+        const existing = await getStoredCredentials();
+        if (existing) {
+            log(chalk.yellow(`Already logged in as ${existing.user.email}. Run 'skhema auth logout' first.`));
+            return;
+        }
+        try {
+            if (options.headless) {
+                await startDeviceFlow();
+            }
+            else {
+                await startLocalhostFlow();
+            }
+        }
+        catch (error) {
+            outputError(error instanceof Error ? error.message : 'Login failed', 'auth login');
+            process.exit(1);
+        }
+    });
+    auth
+        .command('logout')
+        .description('Clear stored credentials')
+        .action(async () => {
+        try {
+            await clearCredentials();
+            clearContributorStatusCache();
+            log(chalk.green('Logged out successfully.'));
+            emitSuccess('auth logout', { loggedOut: true });
+        }
+        catch (error) {
+            outputError(error instanceof Error ? error.message : 'Logout failed', 'auth logout');
+            process.exit(1);
+        }
+    });
+    auth
+        .command('status')
+        .description('Show which credential the CLI will use, and for which org')
+        .action(async () => {
+        // `status` reports the resolved credential lane (spec §3.1 precedence).
+        // Absence of any credential is a normal, non-error outcome here.
+        let resolved;
+        try {
+            resolved = await resolveClient();
+        }
+        catch (error) {
+            if (error instanceof AuthRequiredError) {
+                log(chalk.yellow('Not authenticated. Run `skhema auth login`, or set SKHEMA_API_KEY / `skhema auth key use <key>`.'));
+                emitSuccess('auth status', { authenticated: false });
+                return;
+            }
+            outputError(error instanceof Error ? error.message : 'Failed to get status', 'auth status');
+            process.exit(1);
+        }
+        const cred = resolved.credential;
+        if (cred.kind === 'oauth') {
+            const creds = await getStoredCredentials();
+            const expiresAt = creds ? new Date(creds.expires_at) : null;
+            const isExpired = expiresAt ? expiresAt < new Date() : false;
+            if (getGlobalOptions().json) {
+                emitSuccess('auth status', {
+                    authenticated: true,
+                    credential: {
+                        lane: cred.lane,
+                        kind: cred.kind,
+                        source: cred.source,
+                    },
+                    expired: isExpired,
+                    user: creds?.user,
+                    organization: creds?.organization,
+                    expiresAt: expiresAt?.toISOString(),
+                    scope: creds?.scope,
+                });
+                return;
+            }
+            logHeader('Authentication Status');
+            log(`  Credential:   ${chalk.cyan(cred.source)}`);
+            if (creds) {
+                log(`  User:         ${chalk.cyan(creds.user.name)} (${creds.user.email})`);
+                if (creds.organization) {
+                    log(`  Organization: ${chalk.cyan(creds.organization.name)}`);
+                }
+                log(`  Token:        ${isExpired ? chalk.red('Expired') : chalk.green('Valid')}`);
+                log(`  Expires:      ${expiresAt?.toLocaleString()}`);
+                log(`  Scopes:       ${creds.scope}`);
+            }
+            return;
+        }
+        // API-key lane: verify the key by exchanging it (health forces the
+        // exchange), then report the org + permission carried by the key.
+        let verified = false;
+        let permission;
+        let organizationId;
+        try {
+            await resolved.client.meta.health();
+            const ctx = resolved.client.getContext();
+            permission = ctx.permission;
+            organizationId = ctx.organizationId;
+            verified = true;
+        }
+        catch {
+            verified = false;
+        }
+        if (getGlobalOptions().json) {
+            emitSuccess('auth status', {
+                authenticated: true,
+                credential: {
+                    lane: cred.lane,
+                    kind: cred.kind,
+                    source: cred.source,
+                    maskedKey: cred.maskedKey,
+                },
+                verified,
+                permission,
+                organization: organizationId ? { id: organizationId } : undefined,
+            });
+            return;
+        }
+        logHeader('Authentication Status');
+        log(`  Credential:   ${chalk.cyan(cred.source)}`);
+        log(`  Key:          ${cred.maskedKey}`);
+        log(`  Verified:     ${verified ? chalk.green('Yes') : chalk.red('No (invalid/expired key or network error)')}`);
+        if (verified) {
+            log(`  Permission:   ${permission ?? 'unknown'}`);
+            log(`  Organization: ${organizationId ?? 'unknown'}`);
+        }
+    });
+    auth
+        .command('switch [org-slug]')
+        .description('Switch active organization')
+        .option('--headless', 'Use device code flow for consent fallback')
+        .action(async (orgSlug, options) => {
+        try {
+            const creds = await getStoredCredentials();
+            if (!creds) {
+                outputError('Not logged in. Run `skhema auth login` to authenticate.', 'auth switch');
+                process.exit(1);
+            }
+            const spinner = ora('Fetching organizations...').start();
+            const userInfo = await fetchUserInfo(creds.access_token);
+            spinner.stop();
+            const orgs = userInfo.organizations ?? [];
+            if (orgs.length === 0) {
+                outputError('No organizations found for your account.', 'auth switch');
+                process.exit(1);
+            }
+            // If --json and no slug, output org list
+            if (getGlobalOptions().json && !orgSlug) {
+                emitSuccess('auth switch', {
+                    current: creds.organization?.slug ?? null,
+                    organizations: orgs,
+                });
+                return;
+            }
+            let targetOrg;
+            if (orgSlug) {
+                // Direct slug lookup
+                targetOrg = orgs.find((o) => o.slug === orgSlug);
+                if (!targetOrg) {
+                    outputError(`Organization '${orgSlug}' not found. Available: ${orgs.map((o) => o.slug).join(', ')}`, 'auth switch');
+                    process.exit(1);
+                }
+            }
+            else {
+                // Interactive picker
+                logHeader('Select Organization');
+                orgs.forEach((org, i) => {
+                    const current = creds.organization?.id === org.id ? chalk.green(' (current)') : '';
+                    log(`  ${chalk.dim(`${i + 1}.`)} ${org.name} ${chalk.dim(`(${org.slug})`)}${current}`);
+                });
+                log('');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question(`  Enter number (1-${orgs.length}): `, (ans) => {
+                        rl.close();
+                        resolve(ans.trim());
+                    });
+                });
+                const index = parseInt(answer, 10) - 1;
+                if (isNaN(index) || index < 0 || index >= orgs.length) {
+                    outputError('Invalid selection.', 'auth switch');
+                    process.exit(1);
+                }
+                targetOrg = orgs[index];
+            }
+            // Skip if already on the target org
+            if (creds.organization?.id === targetOrg.id) {
+                log(chalk.yellow(`Already on organization '${targetOrg.name}'.`));
+                return;
+            }
+            // Attempt fast switch via server endpoint
+            const switchSpinner = ora(`Switching to ${targetOrg.name}...`).start();
+            try {
+                const result = await switchOrganization(creds.access_token, targetOrg.id);
+                // Update stored credentials
+                await storeCredentials({
+                    ...creds,
+                    access_token: result.access_token,
+                    refresh_token: result.refresh_token,
+                    token_type: result.token_type,
+                    expires_at: Date.now() + result.expires_in * 1000,
+                    scope: result.scope,
+                    organization: result.organization ?? {
+                        id: targetOrg.id,
+                        name: targetOrg.name,
+                        slug: targetOrg.slug,
+                    },
+                });
+                switchSpinner.succeed(`Switched to ${chalk.cyan(targetOrg.name)} (${targetOrg.slug})`);
+                emitSuccess('auth switch', {
+                    switched: true,
+                    organization: result.organization ?? targetOrg,
+                });
+            }
+            catch (err) {
+                if (err instanceof ConsentRequiredError) {
+                    switchSpinner.warn('Consent required — opening browser for authorization...');
+                    if (options.headless) {
+                        await startDeviceFlow({ organizationId: targetOrg.id });
+                    }
+                    else {
+                        await startLocalhostFlow({ organizationId: targetOrg.id });
+                    }
+                }
+                else {
+                    switchSpinner.fail('Switch failed');
+                    throw err;
+                }
+            }
+        }
+        catch (error) {
+            if (!(error instanceof ConsentRequiredError) &&
+                !(error instanceof Error && error.message.includes('Logged in as'))) {
+                outputError(error instanceof Error
+                    ? error.message
+                    : 'Organization switch failed', 'auth switch');
+                process.exit(1);
+            }
+        }
+    });
+    registerAuthKeyCommands(auth);
+}
+/**
+ * `skhema auth key …` — the API-key credential lane for CI and agents.
+ * `use`/`remove` manage the locally stored key; `create`/`list`/`revoke` drive
+ * the server-side `api-key-manage` function with the logged-in user's token
+ * (issuance authorization is enforced there, unchanged).
+ */
+function registerAuthKeyCommands(auth) {
+    const key = auth
+        .command('key')
+        .description('Manage API keys for headless / CI / agent use');
+    key
+        .command('use <api-key>')
+        .description('Store an API key (sk_live_…) as the CLI credential')
+        .action(async (apiKey) => {
+        await runCommand('auth key use', async () => {
+            if (!apiKey.startsWith('sk_live_')) {
+                throw new UsageError('Invalid API key: expected a key starting with "sk_live_".');
+            }
+            storeApiKey(apiKey);
+            const location = getApiKeyStorageLocation();
+            const maskedKey = `sk_live_...${apiKey.slice(-4)}`;
+            log(chalk.green(`Stored API key ${maskedKey}.`));
+            log(chalk.dim(`  Location: ${location}`));
+            log(chalk.dim('  This key is used only when no --api-key flag or SKHEMA_API_KEY env is set.'));
+            return { stored: true, maskedKey, location };
+        });
+    });
+    key
+        .command('remove')
+        .description('Remove the stored API key')
+        .action(async () => {
+        await runCommand('auth key remove', async () => {
+            clearApiKey();
+            log(chalk.green('Removed stored API key.'));
+            return { removed: true };
+        });
+    });
+    key
+        .command('create')
+        .description('Create a new API key (requires an interactive login)')
+        .requiredOption('--name <name>', 'A label for the key')
+        .option('--permission <permission>', 'read | write | read-write', 'read-write')
+        .option('--scope <scope>', 'org | user', 'org')
+        .option('--use', 'Store the new key as the CLI credential immediately')
+        .action(async (options) => {
+        await runCommand('auth key create', async () => {
+            if (!VALID_PERMISSIONS.includes(options.permission)) {
+                throw new UsageError(`--permission must be one of: ${VALID_PERMISSIONS.join(', ')}`);
+            }
+            if (!VALID_SCOPES.includes(options.scope)) {
+                throw new UsageError(`--scope must be one of: ${VALID_SCOPES.join(', ')}`);
+            }
+            const { accessToken, organizationId } = await requireOAuthContext();
+            const created = await createApiKey(accessToken, {
+                organizationId,
+                name: options.name,
+                permission: options.permission,
+                scope: options.scope,
+            });
+            if (options.use)
+                storeApiKey(created.rawKey);
+            // The raw key is shown once — this is the only place it is ever printed.
+            logHeader('API key created');
+            log(`  Name:        ${chalk.cyan(created.name)}`);
+            log(`  Permission:  ${created.permission}`);
+            log(`  Scope:       ${created.scope}`);
+            log('');
+            log(`  ${chalk.bold('Key (shown once):')} ${chalk.yellow(created.rawKey)}`);
+            log('');
+            log(chalk.dim(options.use
+                ? '  Stored as the CLI credential (--use).'
+                : '  Store it now: skhema auth key use ' + created.rawKey));
+            return {
+                id: created.id,
+                name: created.name,
+                permission: created.permission,
+                scope: created.scope,
+                rawKey: created.rawKey,
+                stored: Boolean(options.use),
+            };
+        });
+    });
+    key
+        .command('list')
+        .description('List the organization’s API keys (masked)')
+        .action(async () => {
+        await runCommand('auth key list', async () => {
+            const { accessToken, organizationId } = await requireOAuthContext();
+            const result = await listApiKeys(accessToken, organizationId);
+            if (!getGlobalOptions().json) {
+                logHeader(`API keys (${result.limits.used}/${result.limits.max} used)`);
+                if (result.keys.length === 0) {
+                    log(chalk.dim('  No API keys.'));
+                }
+                else {
+                    logTable(['Prefix', 'Name', 'Perm', 'Scope', 'Status', 'Last used'], result.keys.map((k) => [
+                        k.keyPrefix,
+                        k.name,
+                        k.permission,
+                        k.scope,
+                        k.revokedAt ? 'revoked' : 'active',
+                        k.lastUsedAt
+                            ? new Date(k.lastUsedAt).toLocaleDateString()
+                            : 'never',
+                    ]));
+                }
+            }
+            return result;
+        });
+    });
+    key
+        .command('revoke <key-id>')
+        .description('Revoke an API key by id')
+        .action(async (keyId) => {
+        await runCommand('auth key revoke', async () => {
+            const { accessToken } = await requireOAuthContext();
+            const result = await revokeApiKey(accessToken, keyId);
+            log(chalk.green(`Revoked API key ${keyId}.`));
+            return result;
+        });
+    });
+}

package/dist/commands/component.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerComponentCommands(program: Command): void;
+//# sourceMappingURL=component.d.ts.map

package/dist/commands/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/commands/component.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAkEnC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkKhE"}

package/dist/commands/component.js

@@ -0,0 +1,221 @@
+import chalk from 'chalk';
+import { resolveClient } from '../lib/api/client.js';
+import { assertExportOutput, reportExport } from '../lib/api/export-cli.js';
+import { assertFormat, DOCUMENT_FORMATS } from '../lib/api/formats.js';
+import { resolveBody } from '../lib/api/payload.js';
+import { runCommand } from '../lib/api/run-command.js';
+import { resolveWorkspaceId } from '../lib/api/scope.js';
+import { performExport } from '../lib/api/transfer.js';
+import { log, logHeader, logTable } from '../lib/output.js';
+/** Attach the shared `--workspace` selector to a workspace-scoped subcommand. */
+function withWorkspace(cmd) {
+    return cmd.option('--workspace <id>', 'Workspace id (defaults to `skhema workspace use`)');
+}
+function renderComponents(components = []) {
+    if (components.length === 0) {
+        log(chalk.dim('No components.'));
+        return;
+    }
+    logHeader(`Components (${components.length})`);
+    logTable(['id', 'name', 'type', 'pos'], components.map((c) => [
+        c.id,
+        c.name ?? '',
+        c.componentType ?? '',
+        c.position === undefined ? '' : String(c.position),
+    ]));
+}
+function renderComponentLinks(links = []) {
+    if (links.length === 0) {
+        log(chalk.dim('No component links.'));
+        return;
+    }
+    logHeader(`Component links (${links.length})`);
+    logTable(['id', 'source', 'target', 'status'], links.map((l) => [
+        l.id,
+        l.sourceComponentId ?? '',
+        l.targetComponentId ?? '',
+        l.status ?? '',
+    ]));
+}
+export function registerComponentCommands(program) {
+    const component = program
+        .command('component')
+        .description('Component commands');
+    withWorkspace(component.command('list'))
+        .description('List components in a workspace')
+        .action(async (opts) => {
+        await runCommand('component list', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const data = await client.components.list(ws);
+            renderComponents(data.components);
+            return data;
+        });
+    });
+    withWorkspace(component.command('create'))
+        .description('Create a component')
+        .option('--type <componentType>', 'Component type (e.g. diagnosis)')
+        .option('--name <name>', 'Component name')
+        .option('--file <path>', 'JSON payload file (or - for stdin)')
+        .action(async (opts) => {
+        await runCommand('component create', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const body = resolveBody({
+                file: opts.file,
+                fields: { componentType: opts.type, name: opts.name },
+            });
+            const data = await client.components.create(ws, body);
+            log(chalk.green(`Created component ${chalk.cyan(data.component?.id)}`));
+            return data;
+        });
+    });
+    withWorkspace(component.command('update <componentId>'))
+        .description('Update a component')
+        .option('--name <name>', 'New name')
+        .option('--position <n>', 'New position')
+        .option('--file <path>', 'JSON payload file (or - for stdin)')
+        .action(async (componentId, opts) => {
+        await runCommand('component update', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const fields = {};
+            if (opts.name !== undefined)
+                fields.name = opts.name;
+            if (opts.position !== undefined)
+                fields.position = Number(opts.position);
+            const body = resolveBody({ file: opts.file, fields });
+            const data = await client.components.update(ws, componentId, body);
+            log(chalk.green(`Updated component ${chalk.cyan(componentId)}`));
+            return data;
+        });
+    });
+    withWorkspace(component.command('delete <componentId>'))
+        .description('Delete a component')
+        .action(async (componentId, opts) => {
+        await runCommand('component delete', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const data = await client.components.delete(ws, componentId);
+            log(chalk.green(`Deleted component ${chalk.cyan(componentId)}`));
+            return data;
+        });
+    });
+    withWorkspace(component.command('duplicate <componentId>'))
+        .description('Duplicate a component')
+        .action(async (componentId, opts) => {
+        await runCommand('component duplicate', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const data = await client.components.duplicate(ws, componentId);
+            log(chalk.green(`Duplicated component ${chalk.cyan(componentId)}`));
+            return data;
+        });
+    });
+    withWorkspace(component.command('reorder'))
+        .description('Reorder components (payload: { positions: [{ componentId, position }] })')
+        .requiredOption('--file <path>', 'JSON payload file (or - for stdin)')
+        .action(async (opts) => {
+        await runCommand('component reorder', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const body = resolveBody({ file: opts.file });
+            const data = await client.components.reorder(ws, body);
+            log(chalk.green('Reordered components'));
+            return data;
+        });
+    });
+    withWorkspace(component.command('export <componentId>'))
+        .description('Export a component (pdf/docx/md/json)')
+        .requiredOption('--format <format>', 'pdf | docx | md | json')
+        .option('--out <path>', 'Write to this path (- for stdout; default: server filename in cwd)')
+        .option('--email <recipient>', 'Email the export to an org member instead of downloading')
+        .action(async (componentId, opts) => {
+        await runCommand('component export', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const format = assertFormat(opts.format, DOCUMENT_FORMATS);
+            assertExportOutput(opts);
+            const result = await performExport({
+                out: opts.email ? undefined : opts.out,
+                exec: () => client.components.export(ws, componentId, {
+                    format,
+                    ...(opts.email
+                        ? { delivery: 'email', recipientEmail: opts.email }
+                        : {}),
+                }),
+            });
+            reportExport(result);
+            return result;
+        });
+    });
+    registerComponentLinkCommands(program);
+}
+function registerComponentLinkCommands(program) {
+    const link = program
+        .command('component-link')
+        .description('Component-to-component link commands');
+    withWorkspace(link.command('list'))
+        .description('List component links')
+        .action(async (opts) => {
+        await runCommand('component-link list', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const data = await client.components.links.list(ws);
+            renderComponentLinks(data.componentLinks ?? data.links);
+            return data;
+        });
+    });
+    withWorkspace(link.command('create'))
+        .description('Create a component link')
+        .option('--source <id>', 'Source component id')
+        .option('--target <id>', 'Target component id')
+        .option('--notes <text>', 'Notes')
+        .option('--file <path>', 'JSON payload file (or - for stdin)')
+        .action(async (opts) => {
+        await runCommand('component-link create', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const body = resolveBody({
+                file: opts.file,
+                fields: {
+                    sourceComponentId: opts.source,
+                    targetComponentId: opts.target,
+                    notes: opts.notes,
+                },
+            });
+            const data = await client.components.links.create(ws, body);
+            log(chalk.green('Created component link'));
+            return data;
+        });
+    });
+    withWorkspace(link.command('update <componentLinkId>'))
+        .description('Update a component link')
+        .option('--notes <text>', 'Notes')
+        .option('--status <status>', 'Status')
+        .option('--file <path>', 'JSON payload file (or - for stdin)')
+        .action(async (componentLinkId, opts) => {
+        await runCommand('component-link update', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const body = resolveBody({
+                file: opts.file,
+                fields: { notes: opts.notes, status: opts.status },
+            });
+            const data = await client.components.links.update(ws, componentLinkId, body);
+            log(chalk.green(`Updated component link ${chalk.cyan(componentLinkId)}`));
+            return data;
+        });
+    });
+    withWorkspace(link.command('delete <componentLinkId>'))
+        .description('Delete a component link')
+        .action(async (componentLinkId, opts) => {
+        await runCommand('component-link delete', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const data = await client.components.links.delete(ws, componentLinkId);
+            log(chalk.green(`Deleted component link ${chalk.cyan(componentLinkId)}`));
+            return data;
+        });
+    });
+}

package/dist/commands/contribute.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerContributeCommands(program: Command): void;
+//# sourceMappingURL=contribute.d.ts.map

package/dist/commands/contribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribute.d.ts","sourceRoot":"","sources":["../../src/commands/contribute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAmFnC,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA8VjE"}