@archrad/deterministic 0.1.0

package/dist/ir-structural.js

@@ -0,0 +1,267 @@
+/**
+ * Deterministic structural validation of blueprint IR (graph JSON).
+ * OSS boundary: shape, references, cycles — not security/compliance semantics (ArchRad Cloud).
+ */
+import { isHttpLikeType } from './graphPredicates.js';
+import { materializeNormalizedGraph } from './ir-normalize.js';
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']);
+/**
+ * Normalize product / CLI shapes to a single graph object.
+ * Accepts `{ graph: { nodes, edges } }` or a bare `{ nodes, edges }`.
+ */
+export function normalizeIrGraph(ir) {
+    if (ir == null || typeof ir !== 'object') {
+        return {
+            findings: [
+                {
+                    code: 'IR-STRUCT-INVALID_ROOT',
+                    severity: 'error',
+                    message: 'IR must be a JSON object',
+                    fixHint: 'Use an object with a `graph` key or a graph object with a `nodes` array.',
+                },
+            ],
+        };
+    }
+    const o = ir;
+    if (o.graph != null && typeof o.graph === 'object') {
+        return { graph: o.graph };
+    }
+    if (Array.isArray(o.nodes)) {
+        return { graph: o };
+    }
+    return {
+        findings: [
+            {
+                code: 'IR-STRUCT-NO_GRAPH',
+                severity: 'error',
+                message: 'IR has no graph: expected `.graph` or top-level `.nodes` array',
+                fixHint: 'Use { "graph": { "nodes": [], "edges": [] } } or { "nodes": [], "edges": [] }.',
+            },
+        ],
+    };
+}
+/**
+ * Structural validation only: well-formed graph, edge references, directed cycles, HTTP node config.
+ * Same input → same findings (deterministic).
+ */
+export function validateIrStructural(ir) {
+    const norm = normalizeIrGraph(ir);
+    if ('findings' in norm)
+        return norm.findings;
+    const graph = norm.graph;
+    const findings = [];
+    if (!Array.isArray(graph.nodes)) {
+        findings.push({
+            code: 'IR-STRUCT-NODES_NOT_ARRAY',
+            severity: 'error',
+            message: '`nodes` must be an array',
+            fixHint: 'Set `nodes` to at least one node object.',
+        });
+        return findings;
+    }
+    const nodes = graph.nodes;
+    if (nodes.length === 0) {
+        findings.push({
+            code: 'IR-STRUCT-EMPTY_GRAPH',
+            severity: 'error',
+            message: 'Graph has no nodes',
+            fixHint: 'Add at least one node to export API code.',
+        });
+        return findings;
+    }
+    const { normalized, edgesInputWasMalformed } = materializeNormalizedGraph(graph);
+    if (edgesInputWasMalformed) {
+        findings.push({
+            code: 'IR-STRUCT-EDGES_NOT_ARRAY',
+            severity: 'warning',
+            message: '`edges` is present but not an array; treating as []',
+            fixHint: 'Set `edges` to an array of edge objects.',
+        });
+    }
+    const edges = Array.isArray(graph.edges) ? graph.edges : [];
+    /** Ids that appear on at least one valid node object with a non-empty id */
+    const seenIds = new Set();
+    /** Ids that appear on more than one node — edges must not treat these as unambiguous */
+    const duplicateIds = new Set();
+    for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        const nn = normalized.nodes[i];
+        if (n == null || typeof n !== 'object') {
+            findings.push({
+                code: 'IR-STRUCT-NODE_INVALID',
+                severity: 'error',
+                message: `Node at index ${i} is not an object`,
+                fixHint: 'Each node must be a JSON object with an `id`.',
+            });
+            continue;
+        }
+        const id = nn.id;
+        if (!id) {
+            findings.push({
+                code: 'IR-STRUCT-NODE_NO_ID',
+                severity: 'error',
+                message: `Node at index ${i} is missing a non-empty \`id\``,
+                fixHint: 'Assign a stable string id to every node.',
+            });
+            continue;
+        }
+        if (seenIds.has(id)) {
+            duplicateIds.add(id);
+            findings.push({
+                code: 'IR-STRUCT-DUP_NODE_ID',
+                severity: 'error',
+                message: `Duplicate node id "${id}"`,
+                nodeId: id,
+                fixHint: 'Ids must be unique across nodes.',
+            });
+        }
+        else {
+            seenIds.add(id);
+        }
+        if (isHttpLikeType(nn.type)) {
+            const cfg = nn.config;
+            /** Generators accept `route` or `url`; structural checks align so OpenAPI merge + ingest both validate. */
+            const url = String(cfg.url ?? cfg.route ?? '').trim();
+            // Align default with generators (pythonFastAPI / nodeExpress use post when omitted)
+            const method = String(cfg.method ?? 'post').trim();
+            if (!url.startsWith('/')) {
+                findings.push({
+                    code: 'IR-STRUCT-HTTP_PATH',
+                    severity: 'error',
+                    message: `HTTP-like node "${id}" has invalid path: config.url must be a non-empty string starting with /`,
+                    nodeId: id,
+                    fixHint: 'Set config.url (or config.route) to e.g. "/signup".',
+                });
+            }
+            const m = method.toUpperCase();
+            if (!HTTP_METHODS.has(m)) {
+                findings.push({
+                    code: 'IR-STRUCT-HTTP_METHOD',
+                    severity: 'error',
+                    message: `HTTP-like node "${id}" has unsupported method "${method}"`,
+                    nodeId: id,
+                    fixHint: 'Use GET, POST, PUT, PATCH, DELETE, HEAD, or OPTIONS.',
+                });
+            }
+        }
+    }
+    const isUniqueNodeRef = (id) => seenIds.has(id) && !duplicateIds.has(id);
+    for (let i = 0; i < edges.length; i++) {
+        const e = edges[i];
+        const ne = normalized.edges[i];
+        if (e == null || typeof e !== 'object') {
+            findings.push({
+                code: 'IR-STRUCT-EDGE_INVALID',
+                severity: 'error',
+                message: `Edge at index ${i} is not an object`,
+                edgeIndex: i,
+                fixHint: 'Each edge must be an object with from/to (or source/target).',
+            });
+            continue;
+        }
+        const { from, to } = ne;
+        if (!from || !to) {
+            findings.push({
+                code: 'IR-STRUCT-EDGE_NO_ENDPOINTS',
+                severity: 'error',
+                message: `Edge at index ${i} is missing from/source or to/target`,
+                edgeIndex: i,
+                fixHint: 'Set from→to or source→target to existing node ids.',
+            });
+            continue;
+        }
+        if (duplicateIds.has(from)) {
+            findings.push({
+                code: 'IR-STRUCT-EDGE_AMBIGUOUS_FROM',
+                severity: 'error',
+                message: `Edge at index ${i} references duplicate node id "${from}" (ambiguous source)`,
+                edgeIndex: i,
+                nodeId: from,
+                fixHint: 'Resolve duplicate node ids before edges can reference them unambiguously.',
+            });
+        }
+        else if (!seenIds.has(from)) {
+            findings.push({
+                code: 'IR-STRUCT-EDGE_UNKNOWN_FROM',
+                severity: 'error',
+                message: `Edge at index ${i} references unknown source node "${from}"`,
+                edgeIndex: i,
+                nodeId: from,
+                fixHint: 'Create a node with this id or fix the edge endpoint.',
+            });
+        }
+        if (duplicateIds.has(to)) {
+            findings.push({
+                code: 'IR-STRUCT-EDGE_AMBIGUOUS_TO',
+                severity: 'error',
+                message: `Edge at index ${i} references duplicate node id "${to}" (ambiguous target)`,
+                edgeIndex: i,
+                nodeId: to,
+                fixHint: 'Resolve duplicate node ids before edges can reference them unambiguously.',
+            });
+        }
+        else if (!seenIds.has(to)) {
+            findings.push({
+                code: 'IR-STRUCT-EDGE_UNKNOWN_TO',
+                severity: 'error',
+                message: `Edge at index ${i} references unknown target node "${to}"`,
+                edgeIndex: i,
+                nodeId: to,
+                fixHint: 'Create a node with this id or fix the edge endpoint.',
+            });
+        }
+    }
+    const adj = new Map();
+    for (const ne of normalized.edges) {
+        const { from, to } = ne;
+        if (!from || !to || !isUniqueNodeRef(from) || !isUniqueNodeRef(to))
+            continue;
+        if (!adj.has(from))
+            adj.set(from, []);
+        adj.get(from).push(to);
+    }
+    const visiting = new Set();
+    const done = new Set();
+    let cycleExampleNode;
+    function dfs(u) {
+        if (visiting.has(u)) {
+            cycleExampleNode = u;
+            return true;
+        }
+        if (done.has(u))
+            return false;
+        visiting.add(u);
+        for (const v of adj.get(u) || []) {
+            if (dfs(v))
+                return true;
+        }
+        visiting.delete(u);
+        done.add(u);
+        return false;
+    }
+    let hasCycle = false;
+    for (const id of seenIds) {
+        if (duplicateIds.has(id))
+            continue;
+        if (!done.has(id) && dfs(id)) {
+            hasCycle = true;
+            break;
+        }
+    }
+    if (hasCycle) {
+        const hint = cycleExampleNode != null
+            ? `Directed cycle detected (node "${cycleExampleNode}" was reached again while traversing dependencies).`
+            : 'Dependency graph contains a directed cycle';
+        findings.push({
+            code: 'IR-STRUCT-CYCLE',
+            severity: 'error',
+            message: hint,
+            nodeId: cycleExampleNode,
+            fixHint: 'Remove or break cyclic edges unless your tooling explicitly allows execution loops.',
+        });
+    }
+    return findings;
+}
+export function hasIrStructuralErrors(findings) {
+    return findings.some((f) => f.severity === 'error');
+}

package/dist/lint-graph.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Normalized graph context for architecture lint rules (visitor pattern).
+ */
+import type { IrStructuralFinding } from './ir-structural.js';
+/** Re-export shared predicates (structural + lint use the same HTTP/datastore semantics). */
+export { isHttpLikeType, isDbLikeType, isQueueLikeNodeType } from './graphPredicates.js';
+export type ParsedLintGraph = {
+    nodeById: Map<string, Record<string, unknown>>;
+    edges: unknown[];
+    adj: Map<string, string[]>;
+    outDegree: Map<string, number>;
+    /** In-degree per node id (built once; use instead of recomputing per rule). */
+    inDegree: Map<string, number>;
+};
+export type BuildParsedLintGraphResult = ParsedLintGraph | {
+    findings: IrStructuralFinding[];
+};
+export declare function edgeEndpoints(e: Record<string, unknown>): {
+    from: string;
+    to: string;
+};
+export declare function nodeType(n: Record<string, unknown>): string;
+export declare function looksLikeHealthUrl(url: string): boolean;
+/**
+ * When true, the edge is treated as **async** for IR-LINT-SYNC-CHAIN-001 (excluded from sync depth).
+ * Convention: `edge.config` / `edge.metadata` may set `async: true`, `protocol: async|message|queue|event`, or channel-like `kind`.
+ * Top-level `edge.kind` is merged into `metadata` during normalization; raw edges still pass `rec.kind` here.
+ * If `graph` is provided, edges **to** queue/topic-like nodes are treated as async even without edge metadata.
+ */
+export declare function edgeRepresentsAsyncBoundary(e: Record<string, unknown>, graph?: ParsedLintGraph): boolean;
+/** Adjacency for sync-only dependency depth (omits edges marked async). */
+export declare function buildSyncAdjacencyForLint(g: ParsedLintGraph): Map<string, string[]>;
+/**
+ * Build a parsed graph for lint visitors.
+ * On failure (invalid IR root, empty graph, etc.) returns `{ findings }` with IR-STRUCT-* errors instead of `null`.
+ */
+export declare function buildParsedLintGraph(ir: unknown): BuildParsedLintGraphResult;
+/** Type guard: successful parse vs structural blockers. */
+export declare function isParsedLintGraph(r: BuildParsedLintGraphResult): r is ParsedLintGraph;
+//# sourceMappingURL=lint-graph.d.ts.map

package/dist/lint-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-graph.d.ts","sourceRoot":"","sources":["../src/lint-graph.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,6FAA6F;AAC7F,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC/C,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,+EAA+E;IAC/E,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,eAAe,GAAG;IAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC;AAE/F,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAItF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAE3D;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAWvD;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,eAAe,GAAG,OAAO,CAqBxG;AAED,2EAA2E;AAC3E,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,eAAe,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAYnF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,0BAA0B,CAqD5E;AAED,2DAA2D;AAC3D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,0BAA0B,GAAG,CAAC,IAAI,eAAe,CAErF"}

package/dist/lint-graph.js

@@ -0,0 +1,133 @@
+/**
+ * Normalized graph context for architecture lint rules (visitor pattern).
+ */
+import { normalizeIrGraph } from './ir-structural.js';
+import { materializeNormalizedGraph } from './ir-normalize.js';
+import { isQueueLikeNodeType } from './graphPredicates.js';
+/** Re-export shared predicates (structural + lint use the same HTTP/datastore semantics). */
+export { isHttpLikeType, isDbLikeType, isQueueLikeNodeType } from './graphPredicates.js';
+export function edgeEndpoints(e) {
+    const from = String(e.from ?? e.source ?? '').trim();
+    const to = String(e.to ?? e.target ?? '').trim();
+    return { from, to };
+}
+export function nodeType(n) {
+    return String(n.type ?? n.kind ?? '').toLowerCase();
+}
+export function looksLikeHealthUrl(url) {
+    const u = url.toLowerCase();
+    return (/(^|\/)health(z)?(\/|$|\?)/.test(u) ||
+        /(^|\/)healthcheck(\/|$|\?)/.test(u) ||
+        /(^|\/)ping(\/|$|\?)/.test(u) ||
+        /(^|\/)status(\/|$|\?)/.test(u) ||
+        /(^|\/)alive(\/|$|\?)/.test(u) ||
+        /(^|\/)live(\/|$|\?)/.test(u) ||
+        /(^|\/)ready(\/|$|\?)/.test(u));
+}
+/**
+ * When true, the edge is treated as **async** for IR-LINT-SYNC-CHAIN-001 (excluded from sync depth).
+ * Convention: `edge.config` / `edge.metadata` may set `async: true`, `protocol: async|message|queue|event`, or channel-like `kind`.
+ * Top-level `edge.kind` is merged into `metadata` during normalization; raw edges still pass `rec.kind` here.
+ * If `graph` is provided, edges **to** queue/topic-like nodes are treated as async even without edge metadata.
+ */
+export function edgeRepresentsAsyncBoundary(e, graph) {
+    const cfg = e.config;
+    const meta = e.metadata;
+    const c = cfg && typeof cfg === 'object' && !Array.isArray(cfg) ? cfg : undefined;
+    const m = meta && typeof meta === 'object' && !Array.isArray(meta) ? meta : undefined;
+    if (m?.async === true || c?.async === true)
+        return true;
+    const proto = String(m?.protocol ?? c?.protocol ?? '').toLowerCase();
+    if (proto === 'async' || proto === 'message' || proto === 'queue' || proto === 'event' || proto === 'pubsub') {
+        return true;
+    }
+    const topKind = String(e.kind ?? '').toLowerCase();
+    const kind = String(m?.kind ?? c?.kind ?? topKind ?? '').toLowerCase();
+    if (/queue|topic|stream|kafka|sns|sqs|amqp|mqtt|nats/.test(kind))
+        return true;
+    if (graph) {
+        const { to } = edgeEndpoints(e);
+        if (to) {
+            const tn = graph.nodeById.get(to);
+            if (tn && isQueueLikeNodeType(nodeType(tn)))
+                return true;
+        }
+    }
+    return false;
+}
+/** Adjacency for sync-only dependency depth (omits edges marked async). */
+export function buildSyncAdjacencyForLint(g) {
+    const m = new Map();
+    for (const id of g.nodeById.keys())
+        m.set(id, []);
+    for (const e of g.edges) {
+        if (!e || typeof e !== 'object')
+            continue;
+        const rec = e;
+        if (edgeRepresentsAsyncBoundary(rec, g))
+            continue;
+        const { from, to } = edgeEndpoints(rec);
+        if (!from || !to || !g.nodeById.has(from) || !g.nodeById.has(to))
+            continue;
+        m.get(from).push(to);
+    }
+    return m;
+}
+/**
+ * Build a parsed graph for lint visitors.
+ * On failure (invalid IR root, empty graph, etc.) returns `{ findings }` with IR-STRUCT-* errors instead of `null`.
+ */
+export function buildParsedLintGraph(ir) {
+    const norm = normalizeIrGraph(ir);
+    if ('findings' in norm)
+        return { findings: norm.findings };
+    const graph = norm.graph;
+    const nodesRaw = graph.nodes;
+    if (!Array.isArray(nodesRaw) || nodesRaw.length === 0) {
+        return {
+            findings: [
+                {
+                    code: 'IR-STRUCT-EMPTY_GRAPH',
+                    severity: 'error',
+                    message: 'Graph has no nodes',
+                    fixHint: 'Add at least one node before running architecture lint.',
+                },
+            ],
+        };
+    }
+    const { normalized } = materializeNormalizedGraph(graph);
+    const nodeById = new Map();
+    for (const n of normalized.nodes) {
+        if (!n.id)
+            continue;
+        nodeById.set(n.id, {
+            id: n.id,
+            type: n.type,
+            name: n.name,
+            config: n.config,
+            schema: n.schema,
+        });
+    }
+    const edges = normalized.edges;
+    const adj = new Map();
+    const outDegree = new Map();
+    const inDegree = new Map();
+    for (const id of nodeById.keys()) {
+        adj.set(id, []);
+        outDegree.set(id, 0);
+        inDegree.set(id, 0);
+    }
+    for (const ne of normalized.edges) {
+        const { from, to } = ne;
+        if (!from || !to || !nodeById.has(from) || !nodeById.has(to))
+            continue;
+        adj.get(from).push(to);
+        outDegree.set(from, (outDegree.get(from) || 0) + 1);
+        inDegree.set(to, (inDegree.get(to) || 0) + 1);
+    }
+    return { nodeById, edges, adj, outDegree, inDegree };
+}
+/** Type guard: successful parse vs structural blockers. */
+export function isParsedLintGraph(r) {
+    return 'nodeById' in r && r.nodeById instanceof Map;
+}

package/dist/lint-rules.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Architecture lint as a registry of visitor functions: each rule inspects ParsedLintGraph
+ * and returns IrStructuralFinding[] (layer: lint). Deterministic, no AI, no cloud.
+ */
+import type { IrStructuralFinding } from './ir-structural.js';
+import type { ParsedLintGraph } from './lint-graph.js';
+/** IR-LINT-DIRECT-DB-ACCESS-002 — HTTP-like → datastore-like in one hop (broader than strict api/gateway + database enum). */
+export declare function ruleDirectDbAccess(g: ParsedLintGraph): IrStructuralFinding[];
+/** IR-LINT-HIGH-FANOUT-004 */
+export declare function ruleHighFanout(g: ParsedLintGraph): IrStructuralFinding[];
+/**
+ * IR-LINT-SYNC-CHAIN-001 — longest **synchronous** path from HTTP entry nodes.
+ * Edges marked async (see `edgeRepresentsAsyncBoundary` in `lint-graph.ts`) are excluded from depth.
+ *
+ * **HTTP entry roots:** Prefer HTTP-like nodes with **no incoming sync** edges. If every HTTP-like node
+ * has an incoming sync edge (e.g. internal-only graph shape), we **fall back** to treating **all** HTTP-like
+ * nodes as possible starts so the rule can still surface deep sync chains. See `docs/ENGINEERING_NOTES.md`.
+ */
+export declare function ruleSyncChainFromHttpEntry(g: ParsedLintGraph): IrStructuralFinding[];
+/** IR-LINT-NO-HEALTHCHECK-003 */
+export declare function ruleNoHealthcheck(g: ParsedLintGraph): IrStructuralFinding[];
+/**
+ * IR-LINT-ISOLATED-NODE-005 — node with no incident edges while the graph has at least one edge elsewhere.
+ */
+export declare function ruleIsolatedNode(g: ParsedLintGraph): IrStructuralFinding[];
+/** IR-LINT-DUPLICATE-EDGE-006 — same from→to pair appears more than once. */
+export declare function ruleDuplicateEdge(g: ParsedLintGraph): IrStructuralFinding[];
+/** IR-LINT-HTTP-MISSING-NAME-007 */
+export declare function ruleHttpMissingName(g: ParsedLintGraph): IrStructuralFinding[];
+/** IR-LINT-DATASTORE-NO-INCOMING-008 */
+export declare function ruleDatastoreNoIncoming(g: ParsedLintGraph): IrStructuralFinding[];
+/** IR-LINT-MULTIPLE-HTTP-ENTRIES-009 — more than one HTTP node with no incoming edges (multiple public entry surfaces). */
+export declare function ruleMultipleHttpEntries(g: ParsedLintGraph): IrStructuralFinding[];
+/**
+ * Ordered registry: add a new rule by implementing `(g) => findings` and appending here.
+ */
+export declare const LINT_RULE_REGISTRY: ReadonlyArray<(g: ParsedLintGraph) => IrStructuralFinding[]>;
+/** Run all registered architecture lint visitors (same as legacy `validateIrLint` behavior). */
+export declare function runArchitectureLinting(g: ParsedLintGraph): IrStructuralFinding[];
+//# sourceMappingURL=lint-rules.d.ts.map

package/dist/lint-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-rules.d.ts","sourceRoot":"","sources":["../src/lint-rules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAavD,8HAA8H;AAC9H,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CA6B5E;AAED,8BAA8B;AAC9B,wBAAgB,cAAc,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAkBxE;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAwDpF;AAED,iCAAiC;AACjC,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAsB3E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAoB1E;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CA0B3E;AAED,oCAAoC;AACpC,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAmB7E;AAED,wCAAwC;AACxC,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAkBjF;AAED,2HAA2H;AAC3H,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAkBjF;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,eAAe,KAAK,mBAAmB,EAAE,CAU3F,CAAC;AAEF,gGAAgG;AAChG,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,eAAe,GAAG,mBAAmB,EAAE,CAEhF"}