@nexart/cli 0.6.0 → 0.8.0

package/README.md

@@ -1,4 +1,4 @@
-# @nexart/cli v0.6.0
+# @nexart/cli v0.8.0
 
 Command-line interface for NexArt — run, replay, and verify deterministic generative art, plus AI execution certification commands.
 
@@ -80,7 +80,7 @@ The CLI has two command groups:
 
 **Code Mode commands** — render generative art sketches, create verifiable snapshots, replay and verify them.
 
-**AI certification commands** — create, certify, and verify tamper-evident Canonical Execution Records (CERs) for AI operations via the NexArt node API.
+**AI certification commands** — create, certify, and verify tamper-evident Canonical Execution Records (CERs) for AI operations via the NexArt node API. Also includes local verification of project bundles (`cer.project.bundle.v1`) with `nexart ai project-verify`.
 
 ## Authentication
 
@@ -287,9 +287,63 @@ attestation: present
 - `0` — Certified successfully
 - `1` — API error (e.g. 401 Unauthorized), missing input, or invalid response
 
+### `nexart ai seal` (v0.8.0+)
+
+Create a Certified Execution Record **locally** — no node required. Produces an integrity-only bundle suitable for offline workflows, CI, pre-certification, or piping straight into `nexart ai verify`. All snapshot construction, canonicalization, and certificate hashing is delegated to `createSnapshot()` + `sealCer()` from `@nexart/ai-execution` — the canonical source of truth.
+
+```bash
+# Seal from file
+nexart ai seal execution.json
+
+# Seal from stdin
+cat execution.json | nexart ai seal
+
+# Seal then verify in a pipe (--quiet keeps the pipe clean)
+cat execution.json | nexart ai seal --quiet | nexart ai verify
+
+# Save sealed bundle to file
+nexart ai seal execution.json --out cer.json
+```
+
+**Default output (stdout — bundle JSON):**
+```json
+{
+  "bundleType": "cer.ai.execution.v1",
+  "certificateHash": "sha256:...",
+  "createdAt": "2026-04-30T12:00:00.000Z",
+  "version": "0.1",
+  "snapshot": { ... }
+}
+```
+
+**Status banner (stderr):**
+```
+[nexart] Local CER created
+[nexart] State: Sealed (integrity only)
+[nexart] No node attestation present
+[nexart] This record is not certified — use `nexart ai certify` to attest via a node
+[nexart] certificateHash: sha256:...
+```
+
+**Options:**
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--out` / `-o` | stdout | Save sealed CER bundle to this file |
+| `--quiet` / `-q` | false | Suppress the stderr banner (clean pipe output) |
+
+**Sealed vs Certified:**
+- **Sealed** (`ai seal`): integrity only. No node receipt, no signature, no envelope. Verifies as `VERIFIED` with Receipt and Envelope reported as `SKIPPED` — that is correct, not a failure.
+- **Certified** (`ai certify`): integrity + node attestation receipt + signature. Requires a node and an API key.
+
+**Exit codes:**
+- `0` — Sealed successfully
+- `1` — Missing required fields, invalid input JSON, or stdin error
+
+---
+
 ### `nexart ai verify`
 
-Verify a CER bundle **or CER package** locally. No network call — computes and compares the `certificateHash` against the bundle contents. Fully compatible with v0.11.0+ CERs that include `context.signals`, and v0.6.0+ CER packages.
+Verify a CER bundle **or CER package** locally. No network call. All verification logic — `bundleType` discriminant, package detection / inner-CER unwrap, canonicalization, hash recomputation, and 3-layer status (Integrity / Receipt / Envelope) — is delegated to `verifyAiCerBundleDetailed()` from `@nexart/ai-execution`. The CLI owns input routing and output formatting only. Fully compatible with v0.11.0+ CERs that include `context.signals`, v0.6.0+ CER packages, and v0.8.0+ locally-sealed bundles from `nexart ai seal`.
 
 ```bash
 # Verify a raw CER bundle from file
@@ -343,9 +397,13 @@ bundleIntegrity: FAIL
   "reasonCodes": [],
   "certificateHash": "sha256:a1b2c3...",
   "bundleType": "cer.ai.execution.v1",
-  "inputType": "bundle",
-  "verifiedAt": "2026-03-25T12:00:00.000Z",
-  "verifier": "@nexart/cli"
+  "verifiedAt": "2026-04-30T12:00:00.000Z",
+  "verifier": "@nexart/ai-execution",
+  "cli": {
+    "version": "0.8.0",
+    "sdkVersion": "0.16.1",
+    "inputType": "bundle"
+  }
 }
 ```
 
@@ -361,14 +419,20 @@ bundleIntegrity: FAIL
   "reasonCodes": [],
   "certificateHash": "sha256:a1b2c3...",
   "bundleType": "cer.ai.execution.v1",
-  "inputType": "package",
-  "verifiedAt": "2026-03-25T12:00:00.000Z",
-  "verifier": "@nexart/cli",
-  "verifiedInnerCer": true,
-  "packageTrustLayersVerified": false
+  "verifiedAt": "2026-04-30T12:00:00.000Z",
+  "verifier": "@nexart/ai-execution",
+  "cli": {
+    "version": "0.8.0",
+    "sdkVersion": "0.16.1",
+    "inputType": "package",
+    "verifiedInnerCer": true,
+    "packageTrustLayersVerified": false
+  }
 }
 ```
 
+The top-level fields (`status`, `checks`, `reasonCodes`, `certificateHash`, `bundleType`, `verifiedAt`, `verifier`) are the SDK's `CerVerificationResult` verbatim. The additive `cli` envelope carries CLI-only metadata (`version`, `sdkVersion`, `inputType`, and package-specific flags when applicable).
+
 **Options:**
 | Flag | Default | Description |
 |------|---------|-------------|
@@ -380,6 +444,100 @@ bundleIntegrity: FAIL
 
 ---
 
+### `nexart ai project-verify` (v0.7.0+)
+
+Verify a **project bundle** (`cer.project.bundle.v1`) locally. No network required. Delegates all verification logic to `verifyProjectBundle()` from `@nexart/ai-execution` — the canonical source of truth for project bundle semantics. The CLI provides the command surface and output formatting.
+
+```bash
+# From file
+nexart ai project-verify project-bundle.json
+
+# From stdin
+cat project-bundle.json | nexart ai project-verify
+
+# Machine-readable JSON output
+nexart ai project-verify project-bundle.json --json
+```
+
+**Checks performed (in order, via `@nexart/ai-execution`):**
+1. `bundleType` discriminant: must be `cer.project.bundle.v1`
+2. Required fields: `version`, `protocolVersion`, `projectBundleId`, `projectTitle`, `startedAt`, `completedAt`, `integrity` block shape
+3. `stepRegistry` is a non-empty array
+4. `embeddedBundles` is a plain object keyed by `stepId`
+5. `totalSteps` must equal `stepRegistry.length`
+6. Per-step: embedded bundle exists; `executionId` and `certificateHash` match the registry entry; inner CER `certificateHash` is independently valid
+7. `integrity.projectHash` is recomputed from all material project metadata and compared to the declared value
+
+**Default output (PASS):**
+```
+Verification result: VERIFIED
+bundleType: cer.project.bundle.v1
+projectBundleId: proj-abc123
+projectTitle: My Project
+totalSteps: 3
+passedSteps: 3
+failedSteps: 0
+projectHashIntegrity: PASS
+stepIntegrity: PASS
+```
+
+**Default output (FAIL):**
+```
+Verification result: FAILED
+bundleType: cer.project.bundle.v1
+projectBundleId: proj-abc123
+projectTitle: My Project
+totalSteps: 3
+passedSteps: 2
+failedSteps: 1
+projectHashIntegrity: FAIL
+stepIntegrity: FAIL
+[nexart] Error: integrity.projectHash mismatch: expected sha256:..., got sha256:...
+```
+
+**JSON output** (`--json`):
+```json
+{
+  "status": "VERIFIED",
+  "bundleType": "cer.project.bundle.v1",
+  "projectBundleId": "proj-abc123",
+  "projectTitle": "My Project",
+  "totalSteps": 3,
+  "passedSteps": 3,
+  "failedSteps": 0,
+  "projectHashValid": true,
+  "checks": {
+    "structuralValid": true,
+    "projectHashIntegrity": "PASS",
+    "stepIntegrity": "PASS"
+  },
+  "steps": [
+    {
+      "stepId": "step-001",
+      "sequence": 0,
+      "executionId": "exec-abc",
+      "certificateHash": "sha256:...",
+      "ok": true,
+      "errors": []
+    }
+  ],
+  "errors": [],
+  "verifiedAt": "2026-04-06T12:00:00.000Z",
+  "verifier": "@nexart/cli"
+}
+```
+
+**Options:**
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--json` | false | Machine-readable JSON output |
+
+**Exit codes:**
+- `0` — VERIFIED (all checks pass)
+- `1` — FAILED (any structural, step, or hash error)
+
+---
+
 ## Context Signals (v0.5.0+)
 
 Context signals attach upstream evidence — CI approvals, webhook events, human-review records — to a CER. They are included in the `context.signals` array and are **tamper-evident**: the `certificateHash` covers the full `context` block, so any post-creation modification to signals is detected by `nexart ai verify`.

package/dist/index.d.ts

@@ -1,28 +1,60 @@
 #!/usr/bin/env node
 /**
- * @nexart/cli v0.6.0 — NexArt CLI
+ * @nexart/cli v0.8.0 — NexArt CLI
  *
  * Code Mode commands:
- * - nexart run <file>      — Execute via remote renderer and create snapshot
+ * - nexart run <file>        — Execute via remote renderer and create snapshot
  * - nexart replay <snapshot> — Re-execute from snapshot
  * - nexart verify <snapshot> — Verify snapshot hash
  *
  * AI Certification commands:
- * - nexart ai create <file>  — Create a CER bundle via node API
- * - nexart ai certify <file> — Certify an AI execution and attest
- * - nexart ai verify <file>  — Verify a CER bundle or CER package locally (signals-aware)
+ * - nexart ai create <file>         — Create a CER bundle via node API
+ * - nexart ai certify <file>        — Certify an AI execution and attest
+ * - nexart ai seal <file>           — Seal a CER bundle locally (offline, no node)
+ * - nexart ai verify <file>         — Verify a CER bundle or CER package locally
+ * - nexart ai project-verify <file> — Verify a cer.project.bundle.v1 artifact locally
  *
- * Context signals (v0.5.0+):
+ * Sealed vs Certified:
+ *   - Sealed     = integrity only. Bundle is locally produced via SDK sealCer().
+ *                  No node receipt, no signature, no envelope. Use for offline
+ *                  workflows, CI, or pre-certification staging. `ai seal` builds
+ *                  these.
+ *   - Certified  = integrity + node attestation receipt. Bundle has been
+ *                  attested by a NexArt node and includes a signed receipt.
+ *                  `ai certify` builds these.
+ *   `ai verify` works on both. For sealed bundles, the Receipt and Envelope
+ *   layers report SKIPPED — that is correct, not a failure.
+ *
+ * VERIFICATION ALIGNMENT (v0.8.0):
+ *   `ai verify` and `ai project-verify` both delegate ALL verification logic to
+ *   @nexart/ai-execution (>=0.16.1). The CLI implements ZERO independent
+ *   cryptographic logic — no canonicalization, no hash recomputation, no
+ *   integrity checks. This guarantees byte-for-byte parity with:
+ *     - the SDK (`verifyAiCerBundleDetailed`, `verifyProjectBundle`)
+ *     - NexArt Node (`/v1/cer/verify`)
+ *     - verify.nexart.io
+ *
+ *   `ai verify` reports the three SDK protocol layers independently:
+ *     - bundleIntegrity   (Integrity: certificate hash recomputation)
+ *     - nodeSignature     (Receipt:   node attestation signature validity)
+ *     - receiptConsistency (Envelope: bundle/receipt envelope consistency)
+ *   Each layer is reported as PASS / FAIL / SKIPPED with no aggregation, and
+ *   the SDK reason codes are passed through unmodified.
+ *
+ * Context signals:
  *   Pass --signals-file <path> to ai create / ai certify to attach upstream
- *   context signals to the CER. Signals are evidence-only and are included in
- *   the certificateHash. ai verify handles signals-containing bundles correctly.
- *
- * CER packages (v0.6.0+):
- *   nexart ai verify accepts both raw CER bundles and CER packages.
- *   A CER package is { cer: <bundle>, receipt?, signature?, ... }.
- *   Only the inner cer bundle is verified. Package-level receipt/signature/
- *   envelope fields are not verified by this command.
+ *   context signals to the CER. Signals are evidence and are bound by the
+ *   SDK into the certificateHash. ai verify validates them via the SDK.
+ *
+ * CER packages:
+ *   ai verify accepts raw CER bundles and CER packages. For packages, the
+ *   inner CER bundle is unwrapped and passed to the SDK verifier.
+ *
+ * Project bundles:
+ *   ai project-verify delegates to verifyProjectBundle() from @nexart/ai-execution.
+ *   No network required. The CLI provides command surface and output formatting only.
  */
+import { hasAttestation as sdkHasAttestation } from '@nexart/ai-execution';
 /**
  * Read all bytes from stdin (non-TTY only).
  */
@@ -40,29 +72,55 @@ export declare function callNodeApi(endpoint: string, apiPath: string, body: unk
     data: unknown;
 }>;
 /**
- * Deterministic canonical JSON serialization matching CER v1 spec:
- * - Object keys sorted lexicographically
- * - Nested objects recursively sorted
- * - Arrays maintain insertion order
- * - undefined values omitted
- */
-export declare function canonicalJson(value: unknown): string;
-/**
- * Recompute the certificateHash for a CER v1 bundle.
- * Protected set: { bundleType, version, createdAt, snapshot }
- * v0.11.0+: context is included in the protected set when present (non-null/non-undefined),
- * ensuring signals are tamper-evident. When absent, the hash is identical to pre-v0.11.0.
- */
-export declare function computeBundleHash(bundle: Record<string, unknown>): string;
-/**
- * Check whether a CER bundle has a valid-looking attestation.
+ * NOTE: As of v0.8.0, the CLI implements ZERO independent cryptographic logic.
+ *
+ * Removed in v0.8.0 (drift hazard — canonical CER semantics live in the SDK):
+ *   - canonicalJson()      → use @nexart/ai-execution canonicalization
+ *   - computeBundleHash()  → use verifyAiCerBundleDetailed() / verifyCer()
+ *   - hasAttestation()     → re-exported below from @nexart/ai-execution
+ *
+ * The CLI MUST NOT recompute certificateHash, canonicalize CER JSON, or compare
+ * hashes by hand. All such logic is owned by @nexart/ai-execution. This is what
+ * guarantees CLI verification matches the SDK, NexArt Node (`/v1/cer/verify`),
+ * and verify.nexart.io exactly.
  */
-export declare function hasAttestation(bundle: Record<string, unknown>): boolean;
+export declare const hasAttestation: typeof sdkHasAttestation;
 /**
  * Load a JSON array of context signals from a file path.
  * Exits with an error message if the file is missing, invalid JSON, or not an array.
  */
 export declare function loadSignalsFile(signalsPath: string): unknown[];
+/**
+ * nexart ai seal — Build a Certified Execution Record locally.
+ *
+ * This command is offline-only. It performs ZERO network I/O and ZERO local
+ * cryptography: all snapshot construction, canonicalization, and certificate
+ * hashing are delegated to @nexart/ai-execution via createSnapshot() and
+ * sealCer(). The CLI's job is parsing input, calling the SDK, and formatting
+ * output.
+ *
+ * Output contract:
+ *   - stdout: the CER bundle JSON (pipe-friendly into `nexart ai verify`)
+ *   - stderr: a status banner (suppress with --quiet)
+ *   - --out:  also writes the bundle JSON to the given file
+ *
+ * The sealed bundle is integrity-only. It does NOT contain a node attestation
+ * receipt, a node signature, or an envelope. Use `nexart ai certify` (or
+ * `attest()` from the SDK) to upgrade a sealed bundle to a certified one.
+ *
+ * Compatibility guarantee: a sealed bundle from this command verifies as
+ * VERIFIED by `nexart ai verify`, by SDK `verifyAiCerBundleDetailed`, and by
+ * NexArt Node `/v1/cer/verify` (Integrity layer PASS, Receipt and Envelope
+ * layers SKIPPED — that is by design, not a failure).
+ *
+ * To merge upstream context signals into the bundle, include `signals: [...]`
+ * in the input JSON. Signals are bound by the SDK into certificateHash via
+ * context.contextHash + signalCount + contextSummary.
+ */
+export declare function aiSealCommand(file: string | undefined, opts: {
+    out?: string;
+    quiet?: boolean;
+}, stdinReader?: () => Promise<string>): Promise<void>;
 /**
  * nexart ai create — Read execution input, call POST /v1/cer/ai/create,
  * print CER bundle JSON to stdout, optionally save to --out file.
@@ -89,14 +147,50 @@ export declare function aiCertifyCommand(file: string | undefined, opts: {
 }, fetchFn?: typeof fetch, stdinReader?: () => Promise<string>): Promise<void>;
 /**
  * nexart ai verify — Read a CER bundle or CER package JSON from file or stdin,
- * verify integrity locally, report VERIFIED/FAILED.
- * --json outputs a canonical CerVerificationResult object.
+ * delegate verification to verifyAiCerBundleDetailed() from @nexart/ai-execution,
+ * and report the protocol layer results.
+ *
+ * The CLI does ZERO crypto here. It only:
+ *   1. parses input
+ *   2. unwraps a CER package to its inner CER bundle (via SDK's isCerPackage / getCerFromPackage)
+ *   3. calls verifyAiCerBundleDetailed(bundle)
+ *   4. formats the SDK's CerVerificationResult for human / JSON output
+ *
+ * The three SDK protocol layers are reported INDEPENDENTLY (no aggregation):
+ *   - bundleIntegrity   (Integrity layer:  certificate hash recomputation)
+ *   - nodeSignature     (Receipt layer:    node attestation signature validity)
+ *   - receiptConsistency (Envelope layer:  bundle/receipt envelope consistency)
+ *
+ * Each layer is PASS / FAIL / SKIPPED. SDK reason codes are passed through
+ * unmodified. Exit code is driven by the SDK's `status` field (VERIFIED → 0,
+ * anything else → 1).
  *
- * v0.6.0: Also accepts CER packages ({ cer: <bundle>, receipt?, signature?, ... }).
- * When a package is detected, only the inner cer bundle is verified.
- * Package-level receipt/signature/envelope fields are NOT verified by this command.
+ * --json prints the SDK's CerVerificationResult verbatim, plus a minimal
+ * `cli` envelope describing input handling. The SDK fields are never rewritten
+ * or reinterpreted.
  */
 export declare function aiVerifyCommand(file: string | undefined, opts: {
     json: boolean;
 }, stdinReader?: () => Promise<string>): Promise<void>;
+/**
+ * nexart ai project-verify — Read a cer.project.bundle.v1 JSON from file or stdin,
+ * delegate all verification to verifyProjectBundle() from @nexart/ai-execution,
+ * and report VERIFIED/FAILED.
+ *
+ * CLI responsibilities:
+ *   - file/stdin input handling
+ *   - artifact type routing (early discriminant check for clear user-facing errors)
+ *   - calling verifyProjectBundle() from @nexart/ai-execution (canonical source of truth)
+ *   - formatting ProjectBundleVerifyResult for human-readable terminal output
+ *   - emitting the structured result in JSON mode
+ *
+ * The CLI does NOT own project bundle schema, project hash computation,
+ * per-step verification logic, or any competing implementation of those semantics.
+ *
+ * Exit code: 0 on VERIFIED, 1 on FAILED or structural error.
+ * --json outputs a machine-readable result object.
+ */
+export declare function aiProjectVerifyCommand(file: string | undefined, opts: {
+    json: boolean;
+}, stdinReader?: () => Promise<string>): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AA4kBH;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAerD;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,OAAO,CAAC,CA0BlB;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,EACb,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE,OAAO,KAAwB,GACvC,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAoB5C;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAapD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAQzE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAKvE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,EAAE,CAwB9D;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IACJ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,OAAO,GAAE,OAAO,KAAwB,EACxC,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CA8Cf;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IACJ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,OAAO,GAAE,OAAO,KAAwB,EACxC,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CA8Df;AAeD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EACvB,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CA4Ef"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAYH,OAAO,EAGL,cAAc,IAAI,iBAAiB,EAYpC,MAAM,sBAAsB,CAAC;AAulB9B;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAerD;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,OAAO,CAAC,CA0BlB;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,EACb,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE,OAAO,KAAwB,GACvC,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAoB5C;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,0BAAoB,CAAC;AAEhD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,EAAE,CAwB9D;AAuDD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IACJ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,EACD,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IACJ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,OAAO,GAAE,OAAO,KAAwB,EACxC,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CA8Cf;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IACJ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,OAAO,GAAE,OAAO,KAAwB,EACxC,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CA8Df;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EACvB,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CA0Ef;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EACvB,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAiB,GACjD,OAAO,CAAC,IAAI,CAAC,CAwBf"}