kibi-cli 0.19.0 → 1.0.1

package/dist/extractors/symbol-coordinates.js

@@ -1,4 +1,18 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
 import { dump as dumpYAML, load as parseYAML } from "js-yaml";
+/**
+ * Format version of the generated coordinate artifact. Version 2 binds every
+ * record to the extraction identity that produced it so stale coordinates can
+ * never silently overlay a changed symbol.
+ */
+// implements REQ-generated-coordinate-persistence
+export const SYMBOL_COORDINATES_FORMAT_VERSION = 2;
+// implements REQ-generated-coordinate-persistence
+export class CoordinateArtifactError extends Error {
+    name = "CoordinateArtifactError";
+}
 const SYMBOL_COORDINATES_COMMENT_BLOCK = `# symbol-coordinates.yaml
 # GENERATED coordinate artifact — do not edit manually.
 # Run \`kibi sync --refresh-symbol-coordinates\` to refresh.
@@ -6,78 +20,402 @@ const SYMBOL_COORDINATES_COMMENT_BLOCK = `# symbol-coordinates.yaml
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function normalizeCoordinateRecord(value) {
-    if (!isRecord(value)) {
-        return null;
+function canonicalIdentityValue(value) {
+    return typeof value === "string" ? value : "";
+}
+/** Deterministic canonical identity string for a symbol extraction state. */
+// implements REQ-generated-coordinate-persistence
+export function coordinateIdentityKey(identity) {
+    return [
+        identity.id,
+        canonicalIdentityValue(identity.title),
+        canonicalIdentityValue(identity.sourceFile),
+        canonicalIdentityValue(identity.granularity_reason),
+    ].join("\u0000");
+}
+/** Stable hash binding a generated coordinate record to its extraction identity. */
+// implements REQ-generated-coordinate-persistence
+export function coordinateIdentityHash(identity) {
+    return createHash("sha256")
+        .update(coordinateIdentityKey(identity))
+        .digest("hex");
+}
+/** Stable hash of the exact source text used to generate a coordinate span. */
+// implements REQ-generated-coordinate-persistence
+export function coordinateSourceHash(sourceText) {
+    return createHash("sha256").update(sourceText).digest("hex");
+}
+/** Select a stable coarse anchor, preferring a title match over the whole file. */
+// implements REQ-generated-coordinate-persistence
+export function coarseCoordinateSpan(sourceFile, title, content) {
+    if (title.length > 0) {
+        const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const pattern = new RegExp(`\\b${escaped}\\b`);
+        const lines = content.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (line === undefined)
+                continue;
+            const match = pattern.exec(line);
+            if (!match || match.index < 0)
+                continue;
+            return {
+                sourceFile,
+                sourceLine: index + 1,
+                sourceColumn: match.index,
+                sourceEndLine: index + 1,
+                sourceEndColumn: match.index + title.length,
+            };
+        }
     }
-    const { sourceColumn, sourceEndColumn, sourceEndLine, sourceFile, sourceLine, } = value;
-    if (typeof sourceFile !== "string" ||
-        typeof sourceLine !== "number" ||
-        typeof sourceColumn !== "number" ||
-        typeof sourceEndLine !== "number" ||
-        typeof sourceEndColumn !== "number") {
+    const lines = content.split(/\r?\n/);
+    const lastLine = lines[lines.length - 1] ?? "";
+    return {
+        sourceFile,
+        sourceLine: 1,
+        sourceColumn: 0,
+        sourceEndLine: Math.max(1, lines.length),
+        sourceEndColumn: lastLine.length,
+    };
+}
+function isSha256Hash(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+/**
+ * Validate a coordinate span against the same rules requirement proof enforces:
+ * nonempty source file, sourceLine >= 1, columns >= 0, endLine >= sourceLine.
+ */
+// implements REQ-generated-coordinate-persistence
+export function isValidCoordinateSpan(value) {
+    if (!isRecord(value))
+        return false;
+    const { sourceFile, sourceLine, sourceColumn, sourceEndLine, sourceEndColumn, } = value;
+    return (typeof sourceFile === "string" &&
+        sourceFile.length > 0 &&
+        typeof sourceLine === "number" &&
+        Number.isInteger(sourceLine) &&
+        sourceLine >= 1 &&
+        typeof sourceColumn === "number" &&
+        Number.isInteger(sourceColumn) &&
+        sourceColumn >= 0 &&
+        typeof sourceEndLine === "number" &&
+        Number.isInteger(sourceEndLine) &&
+        sourceEndLine >= sourceLine &&
+        typeof sourceEndColumn === "number" &&
+        Number.isInteger(sourceEndColumn) &&
+        sourceEndColumn >= 0);
+}
+function normalizeRawEntry(value) {
+    if (!isRecord(value))
+        return null;
+    const { identityHash, sourceHash, ...rest } = value;
+    if (!isValidCoordinateSpan(rest))
+        return null;
+    if (("identityHash" in value && !isSha256Hash(identityHash)) ||
+        ("sourceHash" in value && !isSha256Hash(sourceHash))) {
         return null;
     }
     return {
-        sourceFile,
-        sourceLine,
-        sourceColumn,
-        sourceEndLine,
-        sourceEndColumn,
+        span: {
+            sourceFile: rest.sourceFile,
+            sourceLine: rest.sourceLine,
+            sourceColumn: rest.sourceColumn,
+            sourceEndLine: rest.sourceEndLine,
+            sourceEndColumn: rest.sourceEndColumn,
+        },
+        ...(typeof identityHash === "string" && identityHash.length > 0
+            ? { identityHash }
+            : {}),
+        ...(typeof sourceHash === "string" && sourceHash.length > 0
+            ? { sourceHash }
+            : {}),
     };
 }
-function sortCoordinates(coordinates) {
-    const sortedCoordinates = {};
-    for (const symbolId of Object.keys(coordinates).sort((left, right) => left.localeCompare(right))) {
-        const record = normalizeCoordinateRecord(coordinates[symbolId]);
-        if (!record) {
-            continue;
+/**
+ * Strictly parse a generated coordinate artifact. Records failing span
+ * validation make the whole artifact invalid; consumers must fail closed
+ * instead of silently dropping evidence.
+ */
+// implements REQ-generated-coordinate-persistence
+export function parseCoordinateArtifact(content) {
+    let parsed;
+    try {
+        parsed = parseYAML(content);
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+    if (parsed === null || parsed === undefined) {
+        return { status: "legacy", coordinates: {} };
+    }
+    if (!isRecord(parsed)) {
+        return { status: "invalid", reason: "artifact root is not a mapping" };
+    }
+    const rawCoordinates = parsed.coordinates ?? {};
+    if (!isRecord(rawCoordinates)) {
+        return { status: "invalid", reason: "coordinates is not a mapping" };
+    }
+    const declaredVersion = parsed.version;
+    const entries = {};
+    for (const [id, value] of Object.entries(rawCoordinates)) {
+        const entry = normalizeRawEntry(value);
+        if (entry === null) {
+            return {
+                status: "invalid",
+                reason: `record '${id}' has an invalid coordinate span`,
+            };
         }
-        sortedCoordinates[symbolId] = record;
+        entries[id] = entry;
     }
-    return sortedCoordinates;
-}
-// implements REQ-core-extractors
-export function readCoordinateArtifact(content) {
-    const parsed = parseYAML(content);
-    if (!isRecord(parsed) || !isRecord(parsed.coordinates)) {
-        return { coordinates: {} };
+    if (declaredVersion === undefined) {
+        const legacy = {};
+        for (const [id, entry] of Object.entries(entries)) {
+            legacy[id] = entry.span;
+        }
+        return { status: "legacy", coordinates: legacy };
     }
-    const coordinates = {};
-    for (const [symbolId, record] of Object.entries(parsed.coordinates)) {
-        const normalizedRecord = normalizeCoordinateRecord(record);
-        if (!normalizedRecord) {
-            continue;
+    if (declaredVersion !== SYMBOL_COORDINATES_FORMAT_VERSION) {
+        return {
+            status: "invalid",
+            reason: `unsupported or missing artifact version: ${String(declaredVersion)}`,
+        };
+    }
+    if (declaredVersion === SYMBOL_COORDINATES_FORMAT_VERSION) {
+        const bound = {};
+        for (const [id, entry] of Object.entries(entries)) {
+            const identityHash = entry.identityHash;
+            const sourceHash = entry.sourceHash;
+            if (identityHash === undefined || sourceHash === undefined) {
+                return {
+                    status: "invalid",
+                    reason: `record '${id}' is missing its identity or source binding in a versioned artifact`,
+                };
+            }
+            bound[id] = { ...entry.span, identityHash, sourceHash };
         }
-        coordinates[symbolId] = normalizedRecord;
+        return {
+            status: "parsed",
+            formatVersion: SYMBOL_COORDINATES_FORMAT_VERSION,
+            coordinates: bound,
+        };
     }
-    return { coordinates };
+    return { status: "invalid", reason: "unreachable artifact parser state" };
 }
-// implements REQ-core-extractors
-export function writeCoordinateArtifact(coordinates) {
+/**
+ * Serialize the generated artifact as a version 2 document. Every record is
+ * bound to both its manifest identity and exact source content.
+ * Key order is deterministic without relying on YAML sortKeys so the
+ * human-readable header stays first.
+ */
+// implements REQ-generated-coordinate-persistence
+export function writeCoordinateArtifact(entries) {
+    const coordinates = {};
+    for (const id of Object.keys(entries).sort((left, right) => left.localeCompare(right))) {
+        const entry = entries[id];
+        if (entry === undefined || !isValidCoordinateSpan(entry)) {
+            throw new CoordinateArtifactError(`refusing to publish an invalid or missing coordinate span${id === undefined ? "" : ` for ${id}`}`);
+        }
+        if (!isSha256Hash(entry.identityHash) || !isSha256Hash(entry.sourceHash)) {
+            throw new CoordinateArtifactError(`refusing to publish an invalid or missing identityHash/sourceHash binding for ${id}`);
+        }
+        coordinates[id] = {
+            identityHash: entry.identityHash,
+            sourceHash: entry.sourceHash,
+            sourceColumn: entry.sourceColumn,
+            sourceEndColumn: entry.sourceEndColumn,
+            sourceEndLine: entry.sourceEndLine,
+            sourceFile: entry.sourceFile,
+            sourceLine: entry.sourceLine,
+        };
+    }
     const artifact = {
-        coordinates: sortCoordinates(coordinates),
+        version: SYMBOL_COORDINATES_FORMAT_VERSION,
+        coordinates,
     };
     return `${SYMBOL_COORDINATES_COMMENT_BLOCK}${dumpYAML(artifact, {
         lineWidth: -1,
         noRefs: true,
-        sortKeys: true,
     })}`;
 }
-// implements REQ-core-extractors
-export function mergeCoordinatesWithManifest(symbolRecords, coordinateArtifact) {
-    const coordinates = coordinateArtifact?.coordinates ?? {};
+/** Serialize a legacy artifact without introducing v2 bindings or metadata. */
+// implements REQ-generated-coordinate-persistence
+export function writeLegacyCoordinateArtifact(entries) {
+    const coordinates = {};
+    for (const id of Object.keys(entries).sort((left, right) => left.localeCompare(right))) {
+        const entry = entries[id];
+        if (entry === undefined || !isValidCoordinateSpan(entry)) {
+            throw new CoordinateArtifactError(`refusing to publish an invalid or missing legacy coordinate span for ${id}`);
+        }
+        coordinates[id] = {
+            sourceColumn: entry.sourceColumn,
+            sourceEndColumn: entry.sourceEndColumn,
+            sourceEndLine: entry.sourceEndLine,
+            sourceFile: entry.sourceFile,
+            sourceLine: entry.sourceLine,
+        };
+    }
+    return `${SYMBOL_COORDINATES_COMMENT_BLOCK}${dumpYAML({ coordinates }, { lineWidth: -1, noRefs: true })}`;
+}
+/**
+ * Reader kept for diff/traceability surfaces. Legacy records remain available
+ * as spans while v2 records retain their bindings.
+ */
+// implements REQ-generated-coordinate-persistence
+export function readCoordinateArtifact(content) {
+    const parsed = parseCoordinateArtifact(content);
+    if (parsed.status === "invalid") {
+        throw new CoordinateArtifactError(parsed.reason);
+    }
+    const coordinates = {};
+    for (const [id, record] of Object.entries(parsed.coordinates)) {
+        coordinates[id] = record;
+    }
+    return { coordinates };
+}
+const GENERATED_MANIFEST_FIELDS = [
+    "sourceLine",
+    "sourceColumn",
+    "sourceEndLine",
+    "sourceEndColumn",
+    "coordinatesGeneratedAt",
+];
+function stripGeneratedFields(record) {
+    const next = { ...record };
+    for (const field of GENERATED_MANIFEST_FIELDS) {
+        delete next[field];
+    }
+    return next;
+}
+function manifestSourceFile(record) {
+    if (typeof record.sourceFile === "string" && record.sourceFile.length > 0) {
+        return record.sourceFile;
+    }
+    if (typeof record.source === "string" && record.source.length > 0) {
+        return record.source;
+    }
+    return undefined;
+}
+function defaultResolveSourceText(sourceFile) {
+    const absolute = path.isAbsolute(sourceFile)
+        ? sourceFile
+        : path.resolve(process.cwd(), sourceFile);
+    if (!existsSync(absolute))
+        return null;
+    try {
+        const content = readFileSync(absolute, "utf8");
+        return typeof content === "string" ? content : null;
+    }
+    catch {
+        return null;
+    }
+}
+function overlaySpan(stripped, span) {
+    return {
+        ...stripped,
+        sourceFile: span.sourceFile,
+        sourceLine: span.sourceLine,
+        sourceColumn: span.sourceColumn,
+        sourceEndLine: span.sourceEndLine,
+        sourceEndColumn: span.sourceEndColumn,
+    };
+}
+/**
+ * Overlay generated coordinates onto authored manifest records.
+ *
+ * Generated fields are always stripped first so stale spans can never reach
+ * compiled state. Bound v2 records apply only when both their identity hash
+ * and exact source-content hash match the current manifest and source. Legacy
+ * records and inline coordinates are accepted only after live declaration
+ * validation.
+ */
+export function mergeCoordinatesWithManifest(symbolRecords, coordinateArtifact, options = {}) {
+    if (coordinateArtifact !== null && "status" in coordinateArtifact) {
+        if (coordinateArtifact.status === "invalid") {
+            throw new CoordinateArtifactError(coordinateArtifact.reason);
+        }
+    }
+    const resolveSourceText = options.resolveSourceText ?? defaultResolveSourceText;
+    const rawCoordinates = coordinateArtifact?.coordinates ?? {};
     return symbolRecords.map((symbolRecord) => {
-        const legacyRecord = { ...symbolRecord };
+        const stripped = stripGeneratedFields(symbolRecord);
         const symbolId = typeof symbolRecord.id === "string" ? symbolRecord.id : undefined;
-        const coordinateRecord = symbolId ? coordinates[symbolId] : undefined;
-        if (!coordinateRecord) {
-            return legacyRecord;
+        if (symbolId === undefined)
+            return stripped;
+        const entry = rawCoordinates[symbolId];
+        const candidate = entry ??
+            (coordinateArtifact === null ? inlineSpanOf(symbolRecord) : undefined);
+        if (candidate === undefined)
+            return stripped;
+        const identityHash = candidate.identityHash;
+        const sourceHash = candidate.sourceHash;
+        if (identityHash !== undefined || sourceHash !== undefined) {
+            const recordSourceFile = manifestSourceFile(symbolRecord);
+            const expected = coordinateIdentityHash({
+                id: symbolId,
+                ...(symbolRecord.title === undefined
+                    ? {}
+                    : { title: symbolRecord.title }),
+                ...(recordSourceFile === undefined
+                    ? {}
+                    : { sourceFile: recordSourceFile }),
+                ...(typeof symbolRecord.granularity_reason === "string"
+                    ? { granularity_reason: symbolRecord.granularity_reason }
+                    : {}),
+            });
+            if (!isSha256Hash(identityHash) ||
+                !isSha256Hash(sourceHash) ||
+                identityHash !== expected ||
+                !isValidCoordinateSpan(candidate) ||
+                recordSourceFile === undefined ||
+                candidate.sourceFile !== recordSourceFile) {
+                return stripped;
+            }
+            const sourceText = resolveSourceText(candidate.sourceFile);
+            if (sourceText === null ||
+                coordinateSourceHash(sourceText) !== sourceHash) {
+                return stripped;
+            }
+            return overlaySpan(stripped, candidate);
         }
-        const { coordinatesGeneratedAt: _coordinatesGeneratedAt, ...mergedRecord } = legacyRecord;
-        return {
-            ...mergedRecord,
-            ...coordinateRecord,
-        };
+        if (!isValidCoordinateSpan(candidate))
+            return stripped;
+        if (!legacyRecordMatchesCurrentExtraction(symbolRecord, candidate, resolveSourceText)) {
+            return stripped;
+        }
+        return overlaySpan(stripped, candidate);
     });
 }
+function legacyRecordMatchesCurrentExtraction(record, entry, resolveSourceText) {
+    const sourceFile = manifestSourceFile(record);
+    if (sourceFile === undefined || entry.sourceFile !== sourceFile)
+        return false;
+    const title = typeof record.title === "string" ? record.title : "";
+    const declarationName = title.slice(title.lastIndexOf(".") + 1);
+    if (declarationName.length === 0)
+        return false;
+    const content = resolveSourceText(entry.sourceFile);
+    if (content === null)
+        return false;
+    const lines = content.split(/\r?\n/);
+    const lineText = lines[entry.sourceLine - 1];
+    if (lineText === undefined)
+        return false;
+    if (entry.sourceColumn > lineText.length - declarationName.length) {
+        return false;
+    }
+    return (lineText.slice(entry.sourceColumn, entry.sourceColumn + declarationName.length) === declarationName);
+}
+function inlineSpanOf(record) {
+    const sourceFile = manifestSourceFile(record) ?? "";
+    const span = {
+        sourceFile,
+        sourceLine: typeof record.sourceLine === "number" ? record.sourceLine : -1,
+        sourceColumn: typeof record.sourceColumn === "number" ? record.sourceColumn : -1,
+        sourceEndLine: typeof record.sourceEndLine === "number" ? record.sourceEndLine : -1,
+        sourceEndColumn: typeof record.sourceEndColumn === "number" ? record.sourceEndColumn : -1,
+    };
+    return isValidCoordinateSpan(span) ? span : undefined;
+}

package/dist/extractors/symbols-coordinator.js

@@ -77,7 +77,7 @@ export function analyzeSourceText(filePathOrEntries, contentOrWorkspaceRoot, opt
 export async function enrichSymbolCoordinates(entries, workspaceRoot, deps) {
     // implements REQ-vscode-traceability
     const enrichTsCoordinates = deps?.enrichTsCoordinates ?? enrichSymbolCoordinatesWithTsMorph;
-    const output = entries.map((entry) => ({ ...entry }));
+    const output = entries.map((entry) => withoutGeneratedCoordinates(entry));
     const tsIndices = [];
     const tsEntries = [];
     for (let index = 0; index < output.length; index++) {
@@ -107,6 +107,16 @@ export async function enrichSymbolCoordinates(entries, workspaceRoot, deps) {
     }
     return output;
 }
+function withoutGeneratedCoordinates(entry) {
+    const generatedFields = new Set([
+        "sourceLine",
+        "sourceColumn",
+        "sourceEndLine",
+        "sourceEndColumn",
+        "coordinatesGeneratedAt",
+    ]);
+    return Object.fromEntries(Object.entries(entry).filter(([field]) => !generatedFields.has(field)));
+}
 function enrichWithRegexHeuristic(entry, absolutePath) {
     try {
         const content = fs.readFileSync(absolutePath, "utf8");

package/dist/intent-search.d.ts

@@ -0,0 +1,60 @@
+import { type VALID_ENTITY_TYPES } from "./public/operations/discovery-entities.js";
+import type { PrologPort } from "./public/operations/runtime-types.js";
+import type { SearchMatch } from "./search-ranking.js";
+export type IntentSearchFacetName = "actors" | "actions" | "objects" | "constraints" | "aliases";
+export type IntentSearchFacets = Readonly<Partial<Record<IntentSearchFacetName, readonly string[]>>>;
+export type SourceLocation = Readonly<{
+    path: string;
+    line?: number;
+    column?: number;
+    symbol?: string;
+}>;
+export type IntentSearchOptions = Readonly<{
+    query: string;
+    type?: (typeof VALID_ENTITY_TYPES)[number] | string;
+    semanticFacets?: IntentSearchFacets;
+    sourceLocations?: readonly SourceLocation[];
+    minScore?: number;
+}>;
+export type IntentSourceMatch = Readonly<{
+    path: string;
+    symbolId?: string;
+    distance?: number;
+}>;
+export type IntentGraphPath = Readonly<{
+    from: string;
+    relationships: readonly string[];
+    to: string;
+}>;
+export type IntentSearchEvidence = Readonly<{
+    normalizedScore: number;
+    matchedFacets: readonly string[];
+    sourceMatches: readonly IntentSourceMatch[];
+    graphPaths: readonly IntentGraphPath[];
+    abstentionEligible: boolean;
+}>;
+export type IntentSearchMatch = SearchMatch & {
+    readonly evidence: IntentSearchEvidence;
+};
+export type IntentSearchAnalysis = Readonly<{
+    rankingMode: "intent-v1";
+    candidateCount: number;
+    acceptedCount: number;
+    topScore: number | null;
+    topTwoMargin: number | null;
+    abstained: boolean;
+}>;
+export type IntentSearchResult = Readonly<{
+    matches: readonly IntentSearchMatch[];
+    analysis: IntentSearchAnalysis;
+}>;
+type GraphEdge = Readonly<{
+    relationship: string;
+    from: string;
+    to: string;
+}>;
+export declare function rankIntentEntities(entities: readonly Record<string, unknown>[], options: IntentSearchOptions, workspaceRoot: string, graphEdges?: readonly GraphEdge[]): Promise<IntentSearchResult>;
+export declare function executeIntentSearch(options: IntentSearchOptions, prolog: PrologPort, workspaceRoot: string): Promise<IntentSearchResult>;
+export declare function validateIntentSearchInput(input: IntentSearchOptions): void;
+export {};
+//# sourceMappingURL=intent-search.d.ts.map

package/dist/intent-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-search.d.ts","sourceRoot":"","sources":["../src/intent-search.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAIvD,MAAM,MAAM,qBAAqB,GAC7B,QAAQ,GACR,SAAS,GACT,SAAS,GACT,aAAa,GACb,SAAS,CAAC;AAGd,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CACvC,OAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAC1D,CAAC;AAGF,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAGH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IACpD,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACpC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAGH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAGH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC,CAAC;AAGH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC5C,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IACvC,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC,CAAC;AAGH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG;IAC5C,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;CACzC,CAAC;AAGF,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,WAAW,EAAE,WAAW,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACtC,QAAQ,EAAE,oBAAoB,CAAC;CAChC,CAAC,CAAC;AAEH,KAAK,SAAS,GAAG,QAAQ,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC,CAAC;AA+RH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC5C,OAAO,EAAE,mBAAmB,EAC5B,aAAa,EAAE,MAAM,EACrB,UAAU,GAAE,SAAS,SAAS,EAAO,GACpC,OAAO,CAAC,kBAAkB,CAAC,CA8F7B;AAyFD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAuC7B;AAGD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CA0C1E"}