@parall/daemon 1.30.0 → 1.32.0

package/dist/clip-runtime/clip-installer.js

@@ -0,0 +1,501 @@
+/**
+ * ClipInstaller — Downloads and installs clips from the Pinix registry.
+ *
+ * Flow: parse source → resolve version → download tarball → verify checksum →
+ * extract to clipsDir/{alias}/ → install deps → return result.
+ *
+ * Uses only Node.js built-ins (no external npm packages).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { pipeline } from 'node:stream/promises';
+const DEFAULT_REGISTRY_URL = 'https://api.pinixai.com';
+// ---------------------------------------------------------------------------
+// Source parsing
+// ---------------------------------------------------------------------------
+/**
+ * Parse a source string into scope, name, and optional version.
+ *   "@scope/name"        → scope="scope", name="name", version=null
+ *   "@scope/name@1.0.0"  → scope="scope", name="name", version="1.0.0"
+ *   "name"               → scope=null,    name="name", version=null
+ *   "name@1.0.0"         → scope=null,    name="name", version="1.0.0"
+ */
+export function parseSource(source) {
+    const trimmed = source.trim();
+    if (!trimmed)
+        throw new Error('empty source string');
+    if (trimmed.startsWith('@')) {
+        // Scoped: "@scope/name" or "@scope/name@version"
+        const slashIdx = trimmed.indexOf('/');
+        if (slashIdx < 0)
+            throw new Error(`invalid scoped source "${trimmed}" — missing "/"`);
+        const scope = trimmed.slice(1, slashIdx);
+        const rest = trimmed.slice(slashIdx + 1);
+        // The version delimiter is the *last* "@" after the scope prefix
+        const atIdx = rest.indexOf('@');
+        if (atIdx > 0) {
+            const name = rest.slice(0, atIdx);
+            const version = rest.slice(atIdx + 1);
+            if (!version)
+                throw new Error(`invalid source "${trimmed}" — empty version after "@"`);
+            return { scope, name, fullName: `@${scope}/${name}`, version };
+        }
+        return { scope, name: rest, fullName: `@${scope}/${rest}`, version: null };
+    }
+    // Unscoped: "name" or "name@version"
+    const atIdx = trimmed.indexOf('@');
+    if (atIdx > 0) {
+        const name = trimmed.slice(0, atIdx);
+        const version = trimmed.slice(atIdx + 1);
+        if (!version)
+            throw new Error(`invalid source "${trimmed}" — empty version after "@"`);
+        return { scope: null, name, fullName: name, version };
+    }
+    return { scope: null, name: trimmed, fullName: trimmed, version: null };
+}
+/**
+ * Derive a filesystem-safe alias from a package name.
+ * "@pinix/github-tools" → "github-tools"
+ * "my-clip" → "my-clip"
+ */
+function deriveAlias(parsed) {
+    // Normalize to server's allowed alias charset: ^[a-z0-9][a-z0-9-_]*$
+    return parsed.name
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]/g, '-')
+        .replace(/^[^a-z0-9]+/, '');
+}
+// ---------------------------------------------------------------------------
+// HTTP helper (node:https / node:http)
+// ---------------------------------------------------------------------------
+async function httpGet(url, maxRedirects = 10) {
+    if (maxRedirects < 0)
+        throw new Error(`too many redirects for ${url}`);
+    const mod = url.startsWith('https') ? await import('node:https') : await import('node:http');
+    return new Promise((resolve, reject) => {
+        const req = mod.get(url, { headers: { Accept: 'application/json' } }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                httpGet(res.headers.location, maxRedirects - 1).then(resolve, reject);
+                res.resume();
+                return;
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                resolve({
+                    statusCode: res.statusCode ?? 0,
+                    headers: res.headers,
+                    body: Buffer.concat(chunks),
+                });
+            });
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Download a URL to a file, returning the file path.
+ * Follows redirects. Streams to disk (does not buffer the entire tarball in memory).
+ */
+async function httpDownload(url, destPath, maxRedirects = 10) {
+    if (maxRedirects < 0)
+        throw new Error(`too many redirects for ${url}`);
+    const mod = url.startsWith('https') ? await import('node:https') : await import('node:http');
+    return new Promise((resolve, reject) => {
+        const req = mod.get(url, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                httpDownload(res.headers.location, destPath, maxRedirects - 1).then(resolve, reject);
+                res.resume();
+                return;
+            }
+            if (!res.statusCode || res.statusCode >= 400) {
+                res.resume();
+                reject(new Error(`download failed: HTTP ${res.statusCode} for ${url}`));
+                return;
+            }
+            const ws = fs.createWriteStream(destPath);
+            pipeline(res, ws).then(resolve, reject);
+        });
+        req.on('error', reject);
+    });
+}
+// ---------------------------------------------------------------------------
+// Registry client
+// ---------------------------------------------------------------------------
+/**
+ * Resolve version metadata from the Pinix registry.
+ *
+ * Tries the Pinix REST API first, falls back to npm-style endpoints.
+ */
+async function resolveVersionMeta(registryUrl, parsed) {
+    // Build the package path for the API
+    const pkgPath = parsed.scope
+        ? `${encodeURIComponent(parsed.scope)}/${encodeURIComponent(parsed.name)}`
+        : encodeURIComponent(parsed.name);
+    // --- Attempt 1: Pinix REST API ---
+    const pinixResult = await tryPinixApi(registryUrl, pkgPath, parsed);
+    if (pinixResult)
+        return pinixResult;
+    // --- Attempt 2: npm-style registry ---
+    const npmResult = await tryNpmApi(registryUrl, parsed);
+    if (npmResult)
+        return npmResult;
+    throw new Error(`could not resolve "${parsed.fullName}${parsed.version ? `@${parsed.version}` : ''}" ` +
+        `from registry ${registryUrl}`);
+}
+async function tryPinixApi(registryUrl, pkgPath, parsed) {
+    try {
+        // Pinix registry API: GET /packages/{name} (not /api/v1/packages/)
+        // For scoped packages, URL-encode each segment: /packages/%40scope/name
+        const scopedPath = parsed.scope
+            ? `${encodeURIComponent(`@${parsed.scope}`)}/${encodeURIComponent(parsed.name)}`
+            : encodeURIComponent(parsed.fullName);
+        // If a specific version is requested, try the versioned endpoint first
+        if (parsed.version) {
+            const versionUrl = `${registryUrl}/packages/${scopedPath}/${encodeURIComponent(parsed.version)}`;
+            const vRes = await httpGet(versionUrl);
+            if (vRes.statusCode === 200) {
+                return extractPinixVersionMeta(vRes.body, parsed, registryUrl, scopedPath);
+            }
+        }
+        // Fetch package metadata (all versions / dist-tags)
+        const metaUrl = `${registryUrl}/packages/${scopedPath}`;
+        const res = await httpGet(metaUrl);
+        if (res.statusCode !== 200)
+            return null;
+        const meta = JSON.parse(res.body.toString('utf-8'));
+        // Find the target version — check both dist_tags (snake_case) and dist-tags (kebab)
+        let version = parsed.version;
+        if (!version) {
+            const distTags = (meta['dist_tags'] ?? meta['dist-tags']);
+            version = distTags?.latest ?? distTags?.stable ?? null;
+            if (!version) {
+                const versions = meta.versions;
+                if (versions) {
+                    const keys = Object.keys(versions);
+                    version = keys[keys.length - 1] ?? null;
+                }
+            }
+        }
+        if (!version)
+            return null;
+        // Get version-specific metadata from embedded versions
+        const versions = meta.versions;
+        const versionMeta = versions?.[version];
+        if (versionMeta) {
+            return extractVersionFromMeta(versionMeta, version, registryUrl, parsed);
+        }
+        // If not embedded, fetch via versioned endpoint
+        const versionUrl = `${registryUrl}/packages/${scopedPath}/${encodeURIComponent(version)}`;
+        const vRes = await httpGet(versionUrl);
+        if (vRes.statusCode === 200) {
+            return extractPinixVersionMeta(vRes.body, parsed, registryUrl, scopedPath);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function tryNpmApi(registryUrl, parsed) {
+    try {
+        // npm-style: GET /{fullName} (e.g., /@pinix/github-tools)
+        const encodedName = parsed.scope
+            ? `@${encodeURIComponent(parsed.scope)}%2f${encodeURIComponent(parsed.name)}`
+            : encodeURIComponent(parsed.name);
+        const metaUrl = `${registryUrl}/${encodedName}`;
+        const res = await httpGet(metaUrl);
+        if (res.statusCode !== 200)
+            return null;
+        const meta = JSON.parse(res.body.toString('utf-8'));
+        let version = parsed.version;
+        if (!version) {
+            const distTags = meta['dist-tags'];
+            version = distTags?.latest ?? null;
+        }
+        if (!version)
+            return null;
+        const versions = meta.versions;
+        const versionMeta = versions?.[version];
+        if (!versionMeta)
+            return null;
+        return extractVersionFromMeta(versionMeta, version, registryUrl, parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function extractPinixVersionMeta(body, parsed, registryUrl, scopedPath) {
+    const data = JSON.parse(body.toString('utf-8'));
+    const version = data.version ?? parsed.version;
+    if (!version)
+        return null;
+    const meta = extractVersionFromMeta(data, version, registryUrl, parsed);
+    if (meta && !meta.tarball) {
+        // Pinix download endpoint: GET /packages/{name}/{version}/download
+        meta.tarball = `${registryUrl}/packages/${scopedPath}/${encodeURIComponent(version)}/download`;
+    }
+    return meta;
+}
+function extractVersionFromMeta(meta, version, registryUrl, parsed) {
+    const dist = meta.dist;
+    // Pinix uses "tarball" / "TarballURL" (absolute) or "tarball_url" (relative marker).
+    let tarball = dist?.tarball ?? dist?.TarballURL ?? meta.tarball;
+    if (!tarball && dist?.tarball_url && registryUrl) {
+        // Pinix registry: dist.tarball_url is a relative pointer; the actual fetch
+        // route is GET /packages/{scope}/{name}/{version}/download (streams the blob).
+        const scopedPath = parsed.scope
+            ? `${encodeURIComponent(`@${parsed.scope}`)}/${encodeURIComponent(parsed.name)}`
+            : encodeURIComponent(parsed.name);
+        tarball = `${registryUrl}/packages/${scopedPath}/${encodeURIComponent(version)}/download`;
+    }
+    if (!tarball && registryUrl) {
+        // npm-style fallback tarball URL
+        const namePart = parsed.scope ? `${parsed.scope}-${parsed.name}` : parsed.name;
+        tarball = `${registryUrl}/${parsed.fullName}/-/${namePart}-${version}.tgz`;
+    }
+    // Checksum detection — pinixd uses length-based: 64 hex chars = SHA256, else SHA1
+    let checksumAlgo = 'sha1';
+    let checksumHex = '';
+    if (dist?.integrity) {
+        // Subresource Integrity: "sha256-<base64>"
+        const parts = dist.integrity.split('-', 2);
+        if (parts.length === 2 && parts[0] && parts[1]) {
+            checksumAlgo = parts[0];
+            checksumHex = Buffer.from(parts[1], 'base64').toString('hex');
+        }
+    }
+    else if (dist?.shasum) {
+        // pinixd: length 64 = SHA256, otherwise SHA1
+        checksumHex = dist.shasum.trim();
+        checksumAlgo = checksumHex.length === 64 ? 'sha256' : 'sha1';
+    }
+    else if (dist?.sha256) {
+        checksumAlgo = 'sha256';
+        checksumHex = dist.sha256;
+    }
+    else if (dist?.sha1) {
+        checksumAlgo = 'sha1';
+        checksumHex = dist.sha1;
+    }
+    return { version, tarball: tarball ?? '', checksumAlgo, checksumHex };
+}
+// ---------------------------------------------------------------------------
+// Tarball verification and extraction
+// ---------------------------------------------------------------------------
+function verifyChecksum(filePath, algo, expectedHex) {
+    if (!expectedHex) {
+        console.warn(`[clip-installer] WARNING: no checksum provided by registry — installing without integrity verification`);
+        return;
+    }
+    const hash = crypto.createHash(algo);
+    const content = fs.readFileSync(filePath);
+    hash.update(content);
+    const actual = hash.digest('hex');
+    if (actual !== expectedHex) {
+        throw new Error(`checksum mismatch for ${path.basename(filePath)}: ` +
+            `expected ${algo}:${expectedHex}, got ${algo}:${actual}`);
+    }
+}
+/**
+ * Validate that every entry in the tar listing is safe:
+ * - No absolute paths
+ * - No ".." traversal
+ */
+function validateTarEntries(tarballPath) {
+    let listing;
+    try {
+        listing = execFileSync('tar', ['tzf', tarballPath], {
+            encoding: 'utf-8',
+            maxBuffer: 16 * 1024 * 1024,
+        });
+    }
+    catch (err) {
+        throw new Error(`failed to list tarball contents: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    for (const entry of listing.split('\n')) {
+        const trimmed = entry.trim();
+        if (!trimmed)
+            continue;
+        if (path.isAbsolute(trimmed)) {
+            throw new Error(`tarball contains absolute path: "${trimmed}"`);
+        }
+        const normalized = path.normalize(trimmed);
+        if (normalized.startsWith('..') || normalized.includes(`${path.sep}..${path.sep}`)) {
+            throw new Error(`tarball contains path traversal: "${trimmed}"`);
+        }
+    }
+}
+/**
+ * Extract tarball to destDir, stripping the top-level prefix.
+ *
+ * Pinix tarballs typically have a "package/" prefix inside. We detect this
+ * by checking whether all entries share a common first directory component
+ * and strip accordingly.
+ */
+function extractTarball(tarballPath, destDir) {
+    // Determine the strip depth by inspecting the tarball listing
+    const stripComponents = detectStripComponents(tarballPath);
+    fs.mkdirSync(destDir, { recursive: true });
+    try {
+        execFileSync('tar', [
+            'xzf',
+            tarballPath,
+            '-C',
+            destDir,
+            ...(stripComponents > 0 ? [`--strip-components=${stripComponents}`] : []),
+        ], {
+            maxBuffer: 64 * 1024 * 1024,
+        });
+    }
+    catch (err) {
+        throw new Error(`failed to extract tarball: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Detect how many leading path components to strip. If all entries share
+ * a common prefix directory (e.g., "package/"), return 1. Otherwise 0.
+ */
+function detectStripComponents(tarballPath) {
+    let listing;
+    try {
+        listing = execFileSync('tar', ['tzf', tarballPath], {
+            encoding: 'utf-8',
+            maxBuffer: 16 * 1024 * 1024,
+        });
+    }
+    catch {
+        return 0;
+    }
+    const entries = listing
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+    if (entries.length === 0)
+        return 0;
+    // Find the common first component
+    let commonPrefix = null;
+    for (const entry of entries) {
+        const firstSlash = entry.indexOf('/');
+        const firstComponent = firstSlash > 0 ? entry.slice(0, firstSlash) : entry;
+        if (commonPrefix === null) {
+            commonPrefix = firstComponent;
+        }
+        else if (firstComponent !== commonPrefix) {
+            return 0; // no common prefix
+        }
+    }
+    // All entries share a common first directory component — strip it
+    return commonPrefix ? 1 : 0;
+}
+// ---------------------------------------------------------------------------
+// Dependency installation
+// ---------------------------------------------------------------------------
+function installDeps(clipDir) {
+    const pkgJsonPath = path.join(clipDir, 'package.json');
+    if (!fs.existsSync(pkgJsonPath))
+        return;
+    // Check if the package actually declares dependencies
+    let hasDeps = false;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        hasDeps = !!(pkg.dependencies && Object.keys(pkg.dependencies).length > 0);
+    }
+    catch {
+        /* ignore parse error, try install anyway */
+    }
+    const runners = [
+        { cmd: 'bun', args: ['install', '--frozen-lockfile'] },
+        { cmd: 'bun', args: ['install'] },
+        { cmd: 'npm', args: ['install', '--production'] },
+    ];
+    for (const runner of runners) {
+        try {
+            execFileSync(runner.cmd, runner.args, {
+                cwd: clipDir,
+                stdio: 'pipe',
+                timeout: 120_000,
+            });
+            return;
+        }
+        catch {
+            // try next runner
+        }
+    }
+    if (hasDeps) {
+        throw new Error(`failed to install dependencies in ${clipDir} — clip declares dependencies but no package manager succeeded`);
+    }
+    console.warn(`[clip-installer] could not run package manager in ${clipDir} (no dependencies declared, continuing)`);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export async function installClip(opts) {
+    const registryUrl = (opts.registryUrl ?? DEFAULT_REGISTRY_URL).replace(/\/+$/, '');
+    const parsed = parseSource(opts.source);
+    const alias = opts.alias ?? deriveAlias(parsed);
+    const destDir = path.join(opts.clipsDir, alias);
+    // 1. Resolve version
+    const versionMeta = await resolveVersionMeta(registryUrl, parsed);
+    // 2. Prepare temp directory for download + staging
+    const tmpDir = path.join(opts.clipsDir, `.tmp-${alias}-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const tarballPath = path.join(tmpDir, `${alias}-${versionMeta.version}.tgz`);
+    const stageDir = path.join(tmpDir, 'stage');
+    try {
+        // 3. Download tarball
+        await httpDownload(versionMeta.tarball, tarballPath);
+        // 4. Verify checksum
+        verifyChecksum(tarballPath, versionMeta.checksumAlgo, versionMeta.checksumHex);
+        // 5. Validate tarball (security)
+        validateTarEntries(tarballPath);
+        // 6. Extract to staging directory (not final destination)
+        extractTarball(tarballPath, stageDir);
+        // 7. Install dependencies in staging directory
+        installDeps(stageDir);
+        // 8. Atomic swap: old → backup, staged → final, then remove backup.
+        //    If anything fails after backup, restore the old version.
+        const backupDir = path.join(opts.clipsDir, `.backup-${alias}-${Date.now()}`);
+        let backedUp = false;
+        try {
+            if (fs.existsSync(destDir)) {
+                fs.renameSync(destDir, backupDir);
+                backedUp = true;
+            }
+            fs.renameSync(stageDir, destDir);
+            if (backedUp) {
+                fs.rmSync(backupDir, { recursive: true, force: true });
+            }
+        }
+        catch (swapErr) {
+            // Restore old version if swap failed
+            if (backedUp && !fs.existsSync(destDir)) {
+                try {
+                    fs.renameSync(backupDir, destDir);
+                }
+                catch {
+                    /* best effort */
+                }
+            }
+            throw swapErr;
+        }
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    return {
+        alias,
+        name: parsed.fullName,
+        version: versionMeta.version,
+        path: destDir,
+    };
+}
+export async function removeClip(clipsDir, alias) {
+    const clipDir = path.join(clipsDir, alias);
+    if (!fs.existsSync(clipDir)) {
+        throw new Error(`clip "${alias}" not found at ${clipDir}`);
+    }
+    fs.rmSync(clipDir, { recursive: true, force: true });
+}

package/dist/clip-runtime/clip-provider.d.ts

@@ -0,0 +1,76 @@
+/**
+ * ClipProvider — Connect-RPC client that connects the Daemon to the Clip
+ * Service (Hub) as a Provider. Uses Node.js http2 directly with Connect
+ * protocol bidi streaming (envelope-framed JSON over HTTP/2).
+ *
+ * Protocol: POST /clip.v1.ClipHubService/ProviderStream
+ *   Content-Type: application/connect+json
+ *   Authorization: Bearer mck_xxx
+ *   Body: envelope-framed ProviderMessage stream
+ *   Response: envelope-framed HubMessage stream
+ *
+ * Connect envelope format (JSON mode):
+ *   [flags:1][length:4 big-endian][JSON payload]
+ *   flags=0x00 data, flags=0x02 end-of-stream (trailers)
+ */
+import type { ClipProcessManager } from './process-manager.js';
+export interface ClipProviderOptions {
+    /** Clip Service URL (e.g., http://localhost:8095). */
+    serviceUrl: string;
+    /** mck_xxx machine key for authorization. */
+    authKey: string;
+    /** Org to register for. */
+    orgId: string;
+    /** Unique provider name (typically machine ID). */
+    providerName: string;
+    /** ClipProcessManager to delegate invoke commands to. */
+    clipManager: ClipProcessManager;
+    /** Log adapter. */
+    log: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string): void;
+    };
+}
+export declare class ClipProvider {
+    private readonly opts;
+    private session;
+    private stream;
+    private stopped;
+    private connected;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private statusUnsubscribe;
+    private manifestUnsubscribe;
+    private needsReregister;
+    private intentionalClose;
+    private static RECONNECT_BASE_MS;
+    private static RECONNECT_MAX_MS;
+    private static HEARTBEAT_INTERVAL_MS;
+    constructor(opts: ClipProviderOptions);
+    /** Connect to the Clip Service and register local clips. Reconnects on failure. */
+    connect(): Promise<void>;
+    /** Disconnect and stop reconnection. */
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    private openStream;
+    private handleDisconnect;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private clearHeartbeatTimer;
+    private startHeartbeat;
+    private closeStream;
+    private closeSession;
+    private subscribeStatusChanges;
+    private unsubscribeStatusChanges;
+    private handleHubMessage;
+    private handleRegistered;
+    private handleInvokeCommand;
+    private sendRegister;
+    private sendProviderMessage;
+    private buildClipRegistrations;
+    private clipConfigToRegistration;
+    private commandDetailToInfo;
+}
+//# sourceMappingURL=clip-provider.d.ts.map

package/dist/clip-runtime/clip-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip-provider.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/clip-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AA4H/D,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,WAAW,EAAE,kBAAkB,CAAC;IAChC,mBAAmB;IACnB,GAAG,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACrF;AAED,qBAAa,YAAY;IAiBX,OAAO,CAAC,QAAQ,CAAC,IAAI;IAhBjC,OAAO,CAAC,OAAO,CAAyC;IACxD,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,gBAAgB,CAAS;IAEjC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAS;IACzC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAU;IACzC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAU;gBAEjB,IAAI,EAAE,mBAAmB;IAEtD,mFAAmF;IAC7E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B,wCAAwC;IAClC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjC,WAAW,IAAI,OAAO;YAQR,UAAU;IAoExB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,cAAc;IAyBtB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,sBAAsB;IAyB9B,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,gBAAgB;YAeV,mBAAmB;YAsDnB,YAAY;YAWZ,mBAAmB;IAiBjC,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,wBAAwB;IAchC,OAAO,CAAC,mBAAmB;CAU5B"}