@assethub/cli 0.1.5 → 0.1.7

package/dist/canvasAssetImport.d.ts

@@ -0,0 +1,45 @@
+import type { Source } from '@assethub/api-client';
+type DurableSource = Extract<Source, {
+    uploadId: string;
+} | {
+    resourceId: string;
+}>;
+type ImportedAsset = {
+    assetId: string;
+    mediaType: 'image';
+    canvasId: number;
+};
+type ImportClient = {
+    v2: {
+        uploadFile: (input: {
+            file: Blob;
+            fileName: string;
+            mediaType: 'image';
+        }) => Promise<{
+            uploadId?: string;
+        }>;
+        importCanvasAsset: (canvasId: number, input: {
+            source: DurableSource;
+            name?: string;
+        }) => Promise<ImportedAsset>;
+    };
+};
+type ImportOptions = {
+    client: ImportClient;
+    baseUrl: string;
+    ownerId: string;
+    canvasId: number;
+    stateDir: string;
+    filePath?: string;
+    contentType?: string;
+    source?: DurableSource;
+    name?: string;
+};
+/** Keep staging/import receipts separate from paid generation operation state. */
+export declare function importCanvasAssetWithState(options: ImportOptions): Promise<ImportedAsset & {
+    statePath: string;
+    sha256?: string;
+    uploadId?: string;
+}>;
+export {};
+//# sourceMappingURL=canvasAssetImport.d.ts.map

package/dist/canvasAssetImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasAssetImport.d.ts","sourceRoot":"","sources":["../src/canvasAssetImport.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAA;AAGhD,KAAK,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,GAAG;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAAC,CAAA;AAC/E,KAAK,aAAa,GAAG;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAA;AAC5E,KAAK,YAAY,GAAG;IAClB,EAAE,EAAE;QACF,UAAU,EAAE,CAAC,KAAK,EAAE;YAClB,IAAI,EAAE,IAAI,CAAA;YACV,QAAQ,EAAE,MAAM,CAAA;YAChB,SAAS,EAAE,OAAO,CAAA;SACnB,KAAK,OAAO,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC,CAAA;QAClC,iBAAiB,EAAE,CACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;YAAC,MAAM,EAAE,aAAa,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,KAC1C,OAAO,CAAC,aAAa,CAAC,CAAA;KAC5B,CAAA;CACF,CAAA;AAaD,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,YAAY,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAcD,kFAAkF;AAClF,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,aAAa,GACrB,OAAO,CACR,aAAa,GAAG;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAC,CACxE,CAwJA"}

package/dist/canvasAssetImport.js

@@ -0,0 +1,154 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile, unlink } from 'node:fs/promises';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { readState, writeState } from './canvas.js';
+const imageContentTypes = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.avif': 'image/avif',
+    '.bmp': 'image/bmp',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+};
+/** Keep staging/import receipts separate from paid generation operation state. */
+export async function importCanvasAssetWithState(options) {
+    if (!Number.isSafeInteger(options.canvasId) ||
+        options.canvasId <= 0 ||
+        !options.ownerId)
+        throw new Error('An owned canvas is required for image import');
+    if (Boolean(options.filePath) === Boolean(options.source))
+        throw new Error('Provide exactly one file, upload ID, or resource ID');
+    const name = options.name?.trim();
+    if (name !== undefined && (!name || name.length > 200))
+        throw new Error('Import name must be between 1 and 200 characters');
+    const bytes = options.filePath
+        ? await readFile(resolve(options.filePath))
+        : undefined;
+    const sha256 = bytes
+        ? createHash('sha256').update(bytes).digest('hex')
+        : undefined;
+    const sourceIdentity = sha256
+        ? `sha256:${sha256}`
+        : options.source?.uploadId
+            ? `upload:${options.source.uploadId}`
+            : options.source?.resourceId
+                ? `resource:${options.source.resourceId}`
+                : undefined;
+    if (!sourceIdentity)
+        throw new Error('Import source ID is required');
+    const scope = {
+        baseUrl: options.baseUrl.replace(/\/+$/, ''),
+        ownerId: options.ownerId,
+        canvasId: options.canvasId,
+        sourceIdentity,
+    };
+    const key = createHash('sha256').update(JSON.stringify(scope)).digest('hex');
+    const statePath = join(options.stateDir, 'canvas-imports', `${key}.json`);
+    const readReceipt = async () => {
+        const value = await readState(statePath);
+        if (value === undefined)
+            return undefined;
+        if (!value ||
+            typeof value !== 'object' ||
+            !('schemaVersion' in value) ||
+            value.schemaVersion !== 'assethub.canvas-import.v1' ||
+            !('baseUrl' in value) ||
+            value.baseUrl !== scope.baseUrl ||
+            !('ownerId' in value) ||
+            value.ownerId !== scope.ownerId ||
+            !('canvasId' in value) ||
+            value.canvasId !== scope.canvasId ||
+            !('sourceIdentity' in value) ||
+            value.sourceIdentity !== sourceIdentity)
+            throw new Error(`Invalid or differently scoped import receipt: ${statePath}`);
+        const saved = value;
+        if ((saved.uploadId !== undefined &&
+            (typeof saved.uploadId !== 'string' || !saved.uploadId)) ||
+            (saved.resourceId !== undefined &&
+                (typeof saved.resourceId !== 'string' || !saved.resourceId)) ||
+            (sha256 !== undefined && saved.sha256 !== sha256))
+            throw new Error(`Invalid import source in receipt: ${statePath}`);
+        if (name !== undefined && saved.name !== name)
+            throw new Error(`This source has an import receipt with a different name. Reuse its original name: ${statePath}`);
+        return saved;
+    };
+    let saved = await readReceipt();
+    if (!saved?.uploadId && !saved?.resourceId) {
+        await mkdir(dirname(statePath), { recursive: true, mode: 0o700 });
+        const lockPath = `${statePath}.upload-lock`;
+        const lock = await open(lockPath, 'wx', 0o600).catch(error => {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'EEXIST')
+                throw new Error(`An upload for this source is already in progress. Retry the same command after it finishes. If its process was terminated, verify the PID in ${lockPath} is stopped before removing that lock.`);
+            throw error;
+        });
+        try {
+            await lock.writeFile(JSON.stringify({ pid: process.pid }));
+            // Another process may have completed its upload between our initial read and lock acquisition.
+            saved = await readReceipt();
+            if (!saved?.uploadId && !saved?.resourceId) {
+                saved ??= {
+                    schemaVersion: 'assethub.canvas-import.v1',
+                    ...scope,
+                    ...(sha256 ? { sha256 } : {}),
+                    ...(name === undefined ? {} : { name }),
+                };
+                await writeState(statePath, saved);
+                if (bytes && options.filePath) {
+                    const uploaded = await options.client.v2.uploadFile({
+                        file: new Blob([bytes], {
+                            type: options.contentType ??
+                                imageContentTypes[extname(options.filePath).toLowerCase()] ??
+                                'application/octet-stream',
+                        }),
+                        fileName: basename(options.filePath),
+                        mediaType: 'image',
+                    });
+                    if (!uploaded.uploadId)
+                        throw new Error('Server did not return a durable upload ID');
+                    saved.uploadId = uploaded.uploadId;
+                }
+                else if (options.source?.uploadId)
+                    saved.uploadId = options.source.uploadId;
+                else if (options.source?.resourceId)
+                    saved.resourceId = options.source.resourceId;
+                // Never call durable import before its upload identity has been persisted.
+                await writeState(statePath, saved);
+            }
+        }
+        finally {
+            await lock.close();
+            await unlink(lockPath);
+        }
+    }
+    const source = saved?.uploadId
+        ? { uploadId: saved.uploadId }
+        : saved?.resourceId
+            ? { resourceId: saved.resourceId }
+            : (() => {
+                throw new Error('Import receipt has no durable source');
+            })();
+    // Revalidate on the server even after a successful cached result. Promotion
+    // recognizes this same upload after staging cleanup and never creates a new asset.
+    const result = await options.client.v2.importCanvasAsset(options.canvasId, {
+        source,
+        name: saved.name,
+    });
+    if (result.canvasId !== options.canvasId ||
+        result.mediaType !== 'image' ||
+        !result.assetId ||
+        (saved.result && saved.result.assetId !== result.assetId))
+        throw new Error(`Server returned an inconsistent imported asset; inspect ${statePath}`);
+    await writeState(statePath, { ...saved, result });
+    return {
+        ...result,
+        statePath,
+        ...(sha256 ? { sha256 } : {}),
+        ...(saved.uploadId ? { uploadId: saved.uploadId } : {}),
+    };
+}

package/dist/canvasComparison.d.ts

@@ -0,0 +1,21 @@
+import type { AssetHubClient } from '@assethub/api-client';
+/** A portable review artifact; downloading uses signed URLs, never the API key. */
+export declare function writeCanvasComparison(input: {
+    client: AssetHubClient;
+    canvasId: number;
+    sourceId: string;
+    assetId: string;
+    out: string;
+    title?: string;
+}): Promise<{
+    canvasId: number;
+    canvasUrl: string;
+    reviewStatus: string;
+    images: {
+        assetId: string;
+        sha256: string;
+    }[];
+    path: string;
+    provenancePath: string;
+}>;
+//# sourceMappingURL=canvasComparison.d.ts.map

package/dist/canvasComparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasComparison.d.ts","sourceRoot":"","sources":["../src/canvasComparison.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAA;AAWxD,mFAAmF;AACnF,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,cAAc,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;;;;;;;;;;GAuDA"}

package/dist/canvasComparison.js

@@ -0,0 +1,58 @@
+import { createHash } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+const escapeHtml = (value) => value.replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character]);
+/** A portable review artifact; downloading uses signed URLs, never the API key. */
+export async function writeCanvasComparison(input) {
+    const canvas = await input.client.v2.getCanvas(input.canvasId);
+    const images = await Promise.all([input.sourceId, input.assetId].map(async (assetId) => {
+        const { url } = await input.client.v2.getAsset(assetId);
+        const response = await fetch(url, { signal: AbortSignal.timeout(60_000) });
+        if (!response.ok)
+            throw new Error(`Asset download failed: ${assetId} HTTP ${response.status}`);
+        const mime = response.headers.get('content-type')?.split(';')[0];
+        if (!mime ||
+            !['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(mime))
+            throw new Error(`Comparison requires a raster image: ${assetId}`);
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error(`Empty asset response: ${assetId}`);
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > 32 * 1024 * 1024)
+                    throw new Error('Comparison image exceeds 32 MiB');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        const bytes = Buffer.concat(chunks);
+        return {
+            assetId,
+            sha256: createHash('sha256').update(bytes).digest('hex'),
+            dataUrl: `data:${mime};base64,${bytes.toString('base64')}`,
+        };
+    }));
+    const title = input.title ?? 'Storyboard / generated image';
+    const provenance = {
+        canvasId: canvas.id,
+        canvasUrl: canvas.url,
+        reviewStatus: 'awaiting_creator_review',
+        images: images.map(({ dataUrl: _, ...image }) => image),
+    };
+    const html = `<!doctype html><html lang="ja"><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>${escapeHtml(title)}</title><style>body{margin:24px;background:#17191d;color:#fff;font:16px system-ui}main{display:grid;grid-template-columns:1fr 1fr;gap:20px}figure{margin:0}img{width:100%;height:70vh;object-fit:contain;background:#252830}figcaption{padding:12px 0}a{color:#a9cbff}pre{white-space:pre-wrap;overflow-wrap:anywhere;font-size:12px}@media(max-width:700px){main{grid-template-columns:1fr}img{height:auto}}</style><h1>${escapeHtml(title)}</h1><p>Creator review pending · <a href="${escapeHtml(canvas.url)}">AssetHub canvas ${canvas.id}</a></p><main>${images.map((image, index) => `<figure><img alt="${index === 0 ? '元のVコンテ' : 'AI生成画像'}" src="${image.dataUrl}"><figcaption>${index === 0 ? '元のVコンテ' : 'AI生成画像'} · ${escapeHtml(image.assetId)}</figcaption></figure>`).join('')}</main><details><summary>Source provenance</summary><pre>${escapeHtml(JSON.stringify(provenance, null, 2))}</pre></details></html>`;
+    const path = resolve(input.out);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, html, { mode: 0o600 });
+    await writeFile(`${path}.json`, `${JSON.stringify(provenance, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    return { path, provenancePath: `${path}.json`, ...provenance };
+}

package/dist/execution.d.ts

@@ -0,0 +1,175 @@
+import { type AssetHubClient, type CanvasExecution, type ExecutionContext, type ImageGenerationRequest, type MeshGenerationRequest, type ProductionAnalyzeRequest, type ProductionExecuteRequest, type ProductionAutomationRequest } from '@assethub/api-client';
+declare const operations: readonly ["image.generate", "mesh.generate", "production.analyze", "production.execute", "production.automation"];
+type Operation = (typeof operations)[number];
+type SessionOptions = {
+    client: AssetHubClient;
+    stateDir: string;
+    cwd: string;
+    canvasId?: number;
+    operation?: Operation;
+    create?: boolean;
+};
+export declare const openExecutionSession: (options: SessionOptions) => Promise<{
+    canvas: import("@assethub/api-client").Canvas;
+    capabilities: import("@assethub/api-client").ApiCapabilities;
+    baseUrl: string;
+    ownerId: string;
+    client: AssetHubClient;
+    stateDir: string;
+    cwd: string;
+    canvasId?: number;
+    operation?: Operation;
+    create?: boolean;
+}>;
+type Session = Awaited<ReturnType<typeof openExecutionSession>>;
+type RequestBody = ImageGenerationRequest | MeshGenerationRequest | ProductionAnalyzeRequest | ProductionExecuteRequest | ProductionAutomationRequest;
+export declare const hasRecordedOperation: (stateDir: string, operationId: string) => Promise<boolean>;
+type SubmitOptions = {
+    operationId?: string;
+    retryDelayMs?: number;
+    agent?: ExecutionContext['agent'];
+    parentRunId?: string;
+    source?: ExecutionContext['source'];
+    graphSource?: ExecutionContext['graphSource'];
+};
+export declare class CliExecutionError extends Error {
+    readonly exitCode: number;
+    readonly operationId?: string | undefined;
+    readonly execution?: CanvasExecution | undefined;
+    readonly runId: string | undefined;
+    constructor(message: string, exitCode?: number, operationId?: string | undefined, execution?: CanvasExecution | undefined, runId?: string | undefined);
+}
+/** Kept only for SIGINT reporting; interrupting the client never cancels server work. */
+export declare const activeExecution: {
+    operationId?: string;
+    runId?: string;
+    execution?: CanvasExecution;
+};
+export declare const executeRecorded: (session: Session, operation: Operation, body: RequestBody, options?: SubmitOptions) => Promise<{
+    execution: CanvasExecution;
+} | {
+    execution: CanvasExecution;
+    jobId: string;
+    imageGenId: string;
+    status: "queued";
+    modelId: string;
+    batchSize: number;
+    referenceImageCount: number;
+    aspectRatio?: string;
+    resolution?: number;
+    strength?: number;
+} | {
+    execution: CanvasExecution;
+    jobId: string;
+    meshGenId: string;
+    status: "queued";
+    modelId: string;
+    inputMode: "image" | "multiview";
+    imageCount: number;
+} | {
+    execution: CanvasExecution;
+    engine?: "artifact-graph";
+    graphId?: string;
+    orderId: string;
+    runId: string;
+    publicAccessToken: string;
+    agentVersion: string;
+    status: "analyzing" | "in_progress";
+    credits?: import("@assethub/api-client").CreditInfo;
+} | {
+    execution: CanvasExecution;
+    orderId: string;
+    missionId: string;
+    runId: string;
+    publicAccessToken: string;
+    status: "executing";
+    agentVersion?: string | null;
+    tag?: string;
+    partExtractionMode?: import("@assethub/api-client").ProductionPartExtractionMode | null;
+    effectiveOptions: import("@assethub/api-client").ProductionEffectiveOptions;
+    confirmedParts?: string[];
+    credits?: import("@assethub/api-client").CreditInfo;
+} | {
+    execution: CanvasExecution;
+    batchId: string;
+    agentVersion: string;
+    estimatedCostCredits: number;
+    images: Array<{
+        imageIndex: number;
+        orderId: string;
+        projectId: number;
+        url: string;
+        runId: string;
+        publicAccessToken: string;
+    }>;
+}>;
+export declare const resumeRecorded: (options: Omit<SessionOptions, "canvasId" | "operation"> & {
+    operationId: string;
+    retryDelayMs?: number;
+    expectedCanvasId?: number;
+    expectedBody?: Record<string, unknown>;
+}) => Promise<{
+    execution: CanvasExecution;
+} | {
+    execution: CanvasExecution;
+    jobId: string;
+    imageGenId: string;
+    status: "queued";
+    modelId: string;
+    batchSize: number;
+    referenceImageCount: number;
+    aspectRatio?: string;
+    resolution?: number;
+    strength?: number;
+} | {
+    execution: CanvasExecution;
+    jobId: string;
+    meshGenId: string;
+    status: "queued";
+    modelId: string;
+    inputMode: "image" | "multiview";
+    imageCount: number;
+} | {
+    execution: CanvasExecution;
+    engine?: "artifact-graph";
+    graphId?: string;
+    orderId: string;
+    runId: string;
+    publicAccessToken: string;
+    agentVersion: string;
+    status: "analyzing" | "in_progress";
+    credits?: import("@assethub/api-client").CreditInfo;
+} | {
+    execution: CanvasExecution;
+    orderId: string;
+    missionId: string;
+    runId: string;
+    publicAccessToken: string;
+    status: "executing";
+    agentVersion?: string | null;
+    tag?: string;
+    partExtractionMode?: import("@assethub/api-client").ProductionPartExtractionMode | null;
+    effectiveOptions: import("@assethub/api-client").ProductionEffectiveOptions;
+    confirmedParts?: string[];
+    credits?: import("@assethub/api-client").CreditInfo;
+} | {
+    execution: CanvasExecution;
+    batchId: string;
+    agentVersion: string;
+    estimatedCostCredits: number;
+    images: Array<{
+        imageIndex: number;
+        orderId: string;
+        projectId: number;
+        url: string;
+        runId: string;
+        publicAccessToken: string;
+    }>;
+}>;
+export declare const waitForExecution: (client: AssetHubClient, runId: string, options?: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    onProgress?: (execution: CanvasExecution) => void;
+}) => Promise<CanvasExecution>;
+export {};
+//# sourceMappingURL=execution.d.ts.map

package/dist/execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../src/execution.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EACjC,MAAM,sBAAsB,CAAA;AAG7B,QAAA,MAAM,UAAU,mHAMN,CAAA;AACV,KAAK,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAC5C,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,cAAc,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AACD,eAAO,MAAM,oBAAoB,GAAU,SAAS,cAAc;;;;;YAPxD,cAAc;cACZ,MAAM;SACX,MAAM;eACA,MAAM;gBACL,SAAS;aACZ,OAAO;EAoBjB,CAAA;AACD,KAAK,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAA;AAC/D,KAAK,WAAW,GACZ,sBAAsB,GACtB,qBAAqB,GACrB,wBAAwB,GACxB,wBAAwB,GACxB,2BAA2B,CAAA;AAU/B,eAAO,MAAM,oBAAoB,GAC/B,UAAU,MAAM,EAChB,aAAa,MAAM,qBACyD,CAAA;AAC9E,KAAK,aAAa,GAAG;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACjC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IACnC,WAAW,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CAC9C,CAAA;AAED,qBAAa,iBAAkB,SAAQ,KAAK;IAGxC,QAAQ,CAAC,QAAQ;IACjB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;gBAJlC,OAAO,EAAE,MAAM,EACN,QAAQ,SAAI,EACZ,WAAW,CAAC,EAAE,MAAM,YAAA,EACpB,SAAS,CAAC,EAAE,eAAe,YAAA,EAC3B,KAAK,GAAE,MAAM,GAAG,SAA4B;CAIxD;AAED,yFAAyF;AACzF,eAAO,MAAM,eAAe,EAAE;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,eAAe,CAAA;CACvB,CAAA;AAoJN,eAAO,MAAM,eAAe,GAC1B,SAAS,OAAO,EAChB,WAAW,SAAS,EACpB,MAAM,WAAW,EACjB,UAAS,aAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsD5B,CAAA;AAED,eAAO,MAAM,cAAc,GACzB,SAAS,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,WAAW,CAAC,GAAG;IACxD,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCF,CAAA;AAED,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,cAAc,EACtB,OAAO,MAAM,EACb,UAAS;IACP,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,IAAI,CAAA;CAC7C,KACL,OAAO,CAAC,eAAe,CA2CzB,CAAA"}