kibi-cli 2.21.2 → 2.22.1

package/dist/operations/migration/schema6.js

@@ -21,13 +21,15 @@ import { migrationAction, } from "../../public/operations/migration-plan.js";
 import { CLOSE_SUPERSEDED_REQUIREMENTS_ACTION_ID, CLOSE_SUPERSEDED_REQUIREMENTS_CODE, MIGRATION_SYNC_ACTION_ID, MIGRATION_SYNC_CODE, SOURCE_PATH_REWRITE_ACTION_ID, SOURCE_PATH_REWRITE_CODE, closeSupersededRequirementsActionInput, exceptionUnapprovedActionInput, migrationSyncActionInput, sourcePathReviewActionInput, sourcePathRewriteActionInput, supersessionCycleReviewActionInput, } from "../../public/operations/schema6-check-actions.js";
 import { readAllShards } from "../../relationships/shards.js";
 import { CONTEXT_MISSING_TAG_CODE, SEMANTIC_TEXT_PIN_CODE, applyContextMissingTags, applySemanticTextPins, countByType, planContextMissingTags, planSemanticTextPins, } from "./entity-body-context.js";
-import { applyInventoryRederivation, planInventoryRederivation, } from "./inventory-rederive.js";
+import { applyInventoryRederivation, applyInventoryRederivationDroppingGrounding, planInventoryRederivation, } from "./inventory-rederive.js";
 import { listLaneMarkdownFiles } from "./kb-sources.js";
 import { applyOriginBackfill, planOriginBackfill } from "./origin-backfill.js";
 import { POLARITY_VALUE_BACKFILL_CODE, applyPolarityValueBackfill, planPolarityValueBackfill, } from "./polarity-values.js";
+import { applyRequirementStatusMapping, planRequirementStatusMappings, } from "./requirement-status.js";
 import { applySourcePathRepairs, findSourceRepairs, plannedSourcePathRepairs, } from "./source-paths.js";
 import { applySupersededClosures, planSupersededClosures, } from "./superseded-closure.js";
 import { SUPERSEDES_REASON_ACKNOWLEDGE_CODE, applySupersedesReasonAcknowledgement, planSupersedesReasonAcknowledgement, } from "./supersedes-reason.js";
+import { SYMBOL_LEGACY_LINK_MARK_ACTION_ID, SYMBOL_LEGACY_LINK_MARK_CODE, applySymbolLegacyLinks, planSymbolLegacyLinks, } from "./symbol-legacy-links.js";
 /** The KB schema generation that introduced entity `origin`. */
 // implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
 export const ORIGIN_SCHEMA_VERSION = 6;
@@ -43,6 +45,15 @@ export const SEMANTIC_INVENTORY_REDERIVE_CODE = "semantic_inventory_rederive";
 /** Review: a drifted inventory Kibi cannot re-derive safely. */
 // implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
 export const SEMANTIC_INVENTORY_REVIEW_CODE = "semantic_inventory_review";
+/**
+ * Review, applied only when approved by id: re-derive a drifted inventory and
+ * drop the grounding links that no longer ground a modeled claim.
+ */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const SEMANTIC_INVENTORY_REDERIVE_DROP_GROUNDING_CODE = "semantic_inventory_rederive_drop_grounding";
+/** Review, applied only when approved by id: map a legacy requirement status. */
+// implements REQ-cli-schema-migration
+export const REQ_STATUS_VOCABULARY_MAP_CODE = "req_status_vocabulary_map";
 /** Automatic: stamp `origin: {kind: migration}` on authored entities. */
 // implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
 export const ENTITY_ORIGIN_BACKFILL_CODE = "entity_origin_backfill";
@@ -56,15 +67,33 @@ const CURRENT_REQUIREMENT_STATUSES = new Set([
     "active",
     "approved",
 ]);
-function rederiveAction(plan) {
+function rederiveAction(plan, after) {
     const changed = plan.changes.filter((change) => change.change !== "kept");
+    const id = `semantic-inventory-rederive-${plan.requirementId}`;
     return migrationAction({
-        id: `semantic-inventory-rederive-${plan.requirementId}`,
+        id,
         code: SEMANTIC_INVENTORY_REDERIVE_CODE,
         category: "semantic",
-        safety: "automatic",
-        autoApplicable: true,
-        invocation: { kind: "cli", command_argv: ["kibi", "migrate", "--yes"] },
+        ...(after === undefined
+            ? {
+                safety: "automatic",
+                autoApplicable: true,
+                invocation: {
+                    kind: "cli",
+                    command_argv: ["kibi", "migrate", "--yes"],
+                },
+            }
+            : {
+                safety: "review",
+                autoApplicable: false,
+                invocation: {
+                    kind: "cli",
+                    command_argv: approvalArgv([after.actionId, id]),
+                },
+                dependsOn: [after.actionId],
+                dispositionRequired: true,
+                allowedDispositions: ["fixed", "deferred"],
+            }),
         affectedEntityIds: [plan.requirementId],
         affectedFiles: [plan.path],
         postconditions: [
@@ -81,9 +110,23 @@ function rederiveAction(plan) {
             changes: changed,
             contractHash: plan.contractHash,
             rule: "Claims whose claim_key and claim_text still match keep their status and grounding; new or changed claims are unresolved, never modeled.",
+            ...(after === undefined
+                ? {}
+                : {
+                    afterStatus: after.status,
+                    note: `This drift shows once the requirement has status ${after.status}; approve it together with ${after.actionId}.`,
+                }),
         },
     });
 }
+function approvalArgv(ids) {
+    return [
+        "kibi",
+        "migrate",
+        "--apply-safe",
+        ...ids.flatMap((id) => ["--approved-action", id]),
+    ];
+}
 function reviewAction(plan) {
     return migrationAction({
         id: `semantic-inventory-review-${plan.requirementId}`,
@@ -92,7 +135,7 @@ function reviewAction(plan) {
         safety: "review",
         invocation: {
             kind: "review",
-            instruction: `${plan.requirementId} (${plan.path}) no longer matches the current semantic advisor and cannot be re-derived automatically: ${plan.reasons.join("; ")}. Fix it in ${plan.path} itself: kibi sync rejects this requirement, so store-backed tools (kb_upsert, kb_delete) cannot see it until it compiles. In its front matter, write the re-derived contract from this action's evidence.contract (semantic_inventory, logic_claims, semantic_source_hash and their version fields), then make modeled claims and requires_* links match one to one: re-ground or remove each listed grounding link, and keep a claim modeled only while a grounding fact with the same claim_key remains. Run kibi sync to confirm. To see how the advisor reads the prose, run \`kibi model --input -\` with {"mode":"analyze","type":"req","id":"${plan.requirementId}","text":<the requirement's semantic_text, or its statement when it has none>}.`,
+            instruction: `${plan.requirementId} (${plan.path}) no longer matches the current semantic advisor and cannot be re-derived automatically: ${plan.reasons.join("; ")}. Fix it in ${plan.path} itself: kibi sync rejects this requirement, so store-backed tools (kb_upsert, kb_delete) cannot see it until it compiles. In its front matter, write the re-derived contract from this action's evidence.contract (semantic_inventory, logic_claims, semantic_source_hash and their version fields), then make modeled claims and requires_* links match one to one: re-ground or remove each listed grounding link, and keep a claim modeled only while a grounding fact with the same claim_key remains. Run kibi sync to confirm.${plan.rederivableByDroppingGrounding ? ` Or approve semantic-inventory-rederive-drop-grounding-${plan.requirementId}, which writes that contract and removes exactly the listed orphaned grounding links.` : ""} To see how the advisor reads the prose, run \`kibi model --input -\` with {"mode":"analyze","type":"req","id":"${plan.requirementId}","text":<the requirement's semantic_text, or its statement when it has none>}.`,
         },
         affectedEntityIds: [plan.requirementId],
         affectedFiles: [plan.path],
@@ -108,6 +151,146 @@ function reviewAction(plan) {
         },
     });
 }
+/**
+ * The explicit alternative to a manual inventory fix: write the re-derived
+ * contract and remove the orphaned grounding links from the requirement's
+ * front matter. It drops modeled logic, so it is a review action that
+ * `--apply-safe` never selects on its own; approving its id runs it.
+ */
+function dropGroundingAction(plan, after) {
+    const id = `semantic-inventory-rederive-drop-grounding-${plan.requirementId}`;
+    const drops = plan.orphanedGrounding.map(({ type, target, claimKey }) => ({
+        type,
+        target,
+        claimKey,
+    }));
+    return migrationAction({
+        id,
+        code: SEMANTIC_INVENTORY_REDERIVE_DROP_GROUNDING_CODE,
+        category: "semantic",
+        safety: "review",
+        autoApplicable: false,
+        invocation: {
+            kind: "cli",
+            command_argv: approvalArgv(after === undefined ? [id] : [after.actionId, id]),
+        },
+        dependsOn: after === undefined ? [] : [after.actionId],
+        affectedEntityIds: [plan.requirementId],
+        affectedFiles: [plan.path],
+        postconditions: [
+            {
+                check: "proposition-complete-ingestion",
+                entityId: plan.requirementId,
+                errors: 0,
+            },
+        ],
+        dispositionRequired: true,
+        allowedDispositions: ["fixed", "deferred"],
+        evidence: {
+            reason: `Re-derive the semantic inventory of ${plan.requirementId} and drop the ${drops.length} grounding link(s) that no longer ground a modeled claim, so kibi sync accepts it. The modeled logic those links carried is removed from the requirement (the facts themselves stay); re-ground the claims later with kibi model if they still matter.`,
+            approve: `kibi migrate --apply-safe --approved-plan-hash <this plan's planHash>${after === undefined ? "" : ` --approved-action ${after.actionId}`} --approved-action ${id}`,
+            ...(after === undefined ? {} : { afterStatus: after.status }),
+            droppedGrounding: drops,
+            summary: plan.summary,
+            changes: plan.changes.filter((change) => change.change !== "kept"),
+            contract: plan.contract,
+            contractHash: plan.contractHash,
+            ...(after === undefined
+                ? { alternativeTo: `semantic-inventory-review-${plan.requirementId}` }
+                : {}),
+        },
+    });
+}
+/** The grounding links an approved drop-grounding action lists. */
+function plannedDrops(action) {
+    return plannedRecords(action.evidence.droppedGrounding).flatMap(({ type, target }) => typeof type === "string" && typeof target === "string"
+        ? [{ type, target }]
+        : []);
+}
+/**
+ * One action per requirement whose status is outside the vocabulary: a
+ * review (the target status is a semantic choice) carrying the suggested
+ * mapping and the inventory drift the requirement shows once mapped. With a
+ * suggestion it is executable when approved by id; the re-derivation of the
+ * latent drift depends on it.
+ */
+// implements REQ-cli-schema-migration, REQ-kibi-proposition-complete-ingestion
+export function requirementStatusActions(workspaceRoot) {
+    const actions = [];
+    for (const finding of planRequirementStatusMappings(workspaceRoot)) {
+        const id = `req-status-vocabulary-map-${finding.requirementId}`;
+        const drift = finding.latentDrift;
+        const target = finding.suggestedStatus;
+        actions.push(migrationAction({
+            id,
+            code: REQ_STATUS_VOCABULARY_MAP_CODE,
+            category: "schema",
+            safety: "review",
+            autoApplicable: false,
+            invocation: target === null
+                ? {
+                    kind: "review",
+                    instruction: `${finding.requirementId} (${finding.path}) has status ${finding.status}, which is not a requirement status, so it is skipped by the proof ladder and its semantic inventory is never validated. Set status to open, in_progress or closed (legacy: active, approved) in the file, or use proof_exempt to park it, then rerun kibi migrate.`,
+                }
+                : { kind: "cli", command_argv: approvalArgv([id]) },
+            affectedEntityIds: [finding.requirementId],
+            affectedFiles: [finding.path],
+            postconditions: [{ rule: "req-status-vocabulary", findings: 0 }],
+            dispositionRequired: true,
+            allowedDispositions: ["fixed", "deferred"],
+            evidence: {
+                reason: `Status ${finding.status} is ADR or lifecycle vocabulary, not a requirement status: the requirement is skipped by the proof ladder and kibi sync never validates its semantic inventory.`,
+                status: finding.status,
+                suggestedStatus: target,
+                ...(target === null
+                    ? {}
+                    : {
+                        mapping: `${finding.status} -> ${target}`,
+                        approve: `kibi migrate --apply-safe --approved-plan-hash <this plan's planHash> --approved-action ${id}`,
+                        choice: "The target status is a semantic choice; to pick another one, set it in the file by hand instead of approving this action.",
+                    }),
+                latentDrift: drift === null
+                    ? null
+                    : {
+                        ingestionErrors: drift.errors,
+                        safe: drift.safe,
+                        reasons: drift.reasons,
+                        summary: drift.summary,
+                        contractHash: drift.contractHash,
+                        orphanedGrounding: drift.orphanedGrounding,
+                        ...(drift.safe
+                            ? {
+                                rederiveAction: `semantic-inventory-rederive-${finding.requirementId}`,
+                            }
+                            : drift.rederivableByDroppingGrounding
+                                ? {
+                                    rederiveAction: `semantic-inventory-rederive-drop-grounding-${finding.requirementId}`,
+                                }
+                                : {
+                                    note: "After the mapping, kibi sync rejects this requirement until its inventory is fixed by hand; rerun kibi migrate for the semantic_inventory_review action.",
+                                }),
+                    },
+            },
+        }));
+        if (target === null || drift === null)
+            continue;
+        const after = { actionId: id, status: target };
+        if (drift.safe)
+            actions.push(rederiveAction(drift, after));
+        else if (drift.rederivableByDroppingGrounding)
+            actions.push(dropGroundingAction(drift, after));
+    }
+    return actions;
+}
+/** The status mapping an approved req_status_vocabulary_map action lists. */
+function plannedStatusMapping(action) {
+    const path = action.affectedFiles[0];
+    const from = action.evidence.status;
+    const to = action.evidence.suggestedStatus;
+    if (path === undefined || typeof from !== "string" || typeof to !== "string")
+        throw new Error("Requirement status mapping names no file or target status; set the status by hand.");
+    return { path, from, to };
+}
 /**
  * Exceptions without approved_by, read from authored sources so the list is
  * available before the KB compiles.
@@ -293,7 +476,12 @@ export function buildSchema6MigrationFragment(input) {
         actions.push(action);
         if (plan.safe)
             sourceRewriteActionIds.push(action.id);
+        if (!plan.safe && plan.rederivableByDroppingGrounding)
+            actions.push(dropGroundingAction(plan));
     }
+    // Requirements with a status outside the vocabulary: mapping is a review,
+    // and their latent drift is re-derived only after an approved mapping.
+    actions.push(...requirementStatusActions(input.workspaceRoot));
     if (drift.some((plan) => !plan.safe)) {
         diagnostics.push(`${drift.filter((plan) => !plan.safe).length} requirement inventory(ies) need a manual fix before kibi sync succeeds; see the semantic_inventory_review actions.`);
     }
@@ -346,6 +534,13 @@ export function buildSchema6MigrationFragment(input) {
     const lifecycle = buildLifecycleRepairActions(input.workspaceRoot);
     actions.push(...lifecycle.actions);
     sourceRewriteActionIds.push(...lifecycle.sourceRewriteActionIds);
+    // Coarse symbol links the staged gate would block are marked at any schema
+    // version, by the gate's own rule.
+    const legacyLinks = symbolLegacyLinkAction(input.workspaceRoot);
+    if (legacyLinks !== null) {
+        actions.push(legacyLinks);
+        sourceRewriteActionIds.push(legacyLinks.id);
+    }
     return { actions, sourceRewriteActionIds, diagnostics };
 }
 /**
@@ -386,6 +581,33 @@ export function buildLifecycleRepairActions(workspaceRoot) {
     }
     return { actions, sourceRewriteActionIds };
 }
+/**
+ * The automatic legacy-link pass over `.kb/symbols.yaml`, bound to the
+ * manifest bytes it was planned from; null when no link needs a mark.
+ */
+// implements REQ-cli-schema-migration, REQ-symbol-behavioral-anchors
+export function symbolLegacyLinkAction(workspaceRoot) {
+    const plan = planSymbolLegacyLinks(workspaceRoot);
+    if (plan.targets.length === 0)
+        return null;
+    return migrationAction({
+        id: SYMBOL_LEGACY_LINK_MARK_ACTION_ID,
+        code: SYMBOL_LEGACY_LINK_MARK_CODE,
+        category: "symbol",
+        safety: "automatic",
+        autoApplicable: true,
+        invocation: { kind: "cli", command_argv: ["kibi", "migrate", "--yes"] },
+        affectedEntityIds: plan.targets.map((target) => target.id),
+        affectedFiles: [plan.manifestPath],
+        postconditions: [{ rule: "symbol_granularity_violation", findings: 0 }],
+        evidence: {
+            reason: "These symbols link a source file coarsely while it declares narrower behavioral symbols, so the staged check (kibi check --staged) blocks the next commit that touches them. Each gets granularity_reason: legacy-link (accepted legacy granularity); no link moves and no other field changes.",
+            count: plan.targets.length,
+            manifestHash: plan.manifestHash,
+            symbols: plan.targets,
+        },
+    });
+}
 /** The sync that recompiles sources rewritten by earlier actions. */
 // implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
 export function migrationSyncAction(dependsOn) {
@@ -449,9 +671,33 @@ export async function applySchema6MigrationAction(action, context) {
             applyInventoryRederivation(context.workspaceRoot, requirementId, contractHash);
             return;
         }
+        case REQ_STATUS_VOCABULARY_MAP_CODE: {
+            const mapping = plannedStatusMapping(action);
+            applyRequirementStatusMapping(context.workspaceRoot, mapping.path, mapping.from, mapping.to);
+            return;
+        }
+        case SEMANTIC_INVENTORY_REDERIVE_DROP_GROUNDING_CODE: {
+            const requirementId = action.affectedEntityIds[0];
+            const contractHash = action.evidence.contractHash;
+            if (requirementId === undefined || typeof contractHash !== "string")
+                throw new Error("Inventory re-derivation names no requirement or contract hash.");
+            applyInventoryRederivationDroppingGrounding(context.workspaceRoot, requirementId, contractHash, plannedDrops(action));
+            return;
+        }
         case ENTITY_ORIGIN_BACKFILL_CODE:
             applyOriginBackfill(context.workspaceRoot, context.clock().toISOString());
             return;
+        case SYMBOL_LEGACY_LINK_MARK_CODE: {
+            const result = applySymbolLegacyLinks(context.workspaceRoot, {
+                ...(typeof action.evidence.manifestHash === "string"
+                    ? { expectedHash: action.evidence.manifestHash }
+                    : {}),
+                expectedIds: action.affectedEntityIds,
+            });
+            if (result.unmarked.length > 0)
+                throw new Error(`Could not mark ${result.unmarked.join(", ")} as legacy-link in place; add granularity_reason: legacy-link to them by hand.`);
+            return;
+        }
         case CLOSE_SUPERSEDED_REQUIREMENTS_CODE: {
             const result = applySupersededClosures(context.workspaceRoot, new Set(action.affectedEntityIds));
             if (result.skipped.length > 0)
@@ -477,6 +723,17 @@ export async function applySchema6MigrationAction(action, context) {
             throw new Error(`Migration action '${action.code}' has no schema 6 executor.`);
     }
 }
+/**
+ * Review actions Kibi can execute, but only when a person approves them by
+ * id (`--approved-action`): `--apply-safe` selects automatic actions alone.
+ */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration, REQ-agent-guided-migration-orchestration
+export const SCHEMA6_APPROVABLE_REVIEW_CODES = new Set([
+    SEMANTIC_INVENTORY_REDERIVE_DROP_GROUNDING_CODE,
+    REQ_STATUS_VOCABULARY_MAP_CODE,
+    // A re-derivation that waits on an approved status mapping.
+    SEMANTIC_INVENTORY_REDERIVE_CODE,
+]);
 // implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
 export const SCHEMA6_AUTOMATIC_CODES = new Set([
     POLARITY_VALUE_BACKFILL_CODE,
@@ -487,5 +744,6 @@ export const SCHEMA6_AUTOMATIC_CODES = new Set([
     ENTITY_ORIGIN_BACKFILL_CODE,
     CLOSE_SUPERSEDED_REQUIREMENTS_CODE,
     SOURCE_PATH_REWRITE_CODE,
+    SYMBOL_LEGACY_LINK_MARK_CODE,
     MIGRATION_SYNC_CODE,
 ]);

package/dist/operations/migration/symbol-legacy-links.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Mark the coarse traceability links of a symbols manifest
+ * `granularity_reason: legacy-link`.
+ *
+ * A link is coarse by the staged granularity gate's own rule
+ * (`coarseLinkBehavioralNames`): the source declares behavioral symbols
+ * narrower than the manifest symbol, so `kibi check --staged` would block the
+ * first commit that touches it. The pass is idempotent and independent of
+ * the schema version: it marks whatever the current rule calls coarse and
+ * has no reason yet, and a second run finds nothing.
+ */
+/** Automatic migration action code of the legacy-link pass. */
+export declare const SYMBOL_LEGACY_LINK_MARK_CODE = "symbol_legacy_link_mark";
+export declare const SYMBOL_LEGACY_LINK_MARK_ACTION_ID = "symbol-legacy-link-mark";
+/** One coarse link the pass marks. */
+export type LegacyLinkTarget = Readonly<{
+    id: string;
+    title: string;
+    sourceFile: string;
+    /** The narrower behavioral symbols that make the link coarse. */
+    granularSymbols: readonly string[];
+}>;
+export type LegacyLinkPlan = Readonly<{
+    /** Workspace-relative manifest path. */
+    manifestPath: string;
+    /** SHA-256 of the manifest bytes the plan was read from; null when absent. */
+    manifestHash: string | null;
+    targets: readonly LegacyLinkTarget[];
+}>;
+/**
+ * The coarse links of `manifestPath` (default `.kb/symbols.yaml`) that carry
+ * no granularity_reason yet. Read-only.
+ */
+export declare function planSymbolLegacyLinks(workspaceRoot: string, manifestPath?: string): LegacyLinkPlan;
+/**
+ * Mark the coarse links found by `planSymbolLegacyLinks`. With
+ * `expectedHash` (a migration plan's evidence), the manifest must still hold
+ * the bytes the plan was read from; a manifest whose planned links are all
+ * marked already is left alone, so the pass is idempotent. Returns the ids
+ * marked, and the planned ones that could not be marked in place (an entry
+ * whose `id` is not its first key, for example).
+ */
+export declare function applySymbolLegacyLinks(workspaceRoot: string, options?: {
+    manifestPath?: string;
+    expectedHash?: string;
+    expectedIds?: readonly string[];
+}): {
+    marked: string[];
+    unmarked: string[];
+};
+//# sourceMappingURL=symbol-legacy-links.d.ts.map

package/dist/operations/migration/symbol-legacy-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-legacy-links.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/symbol-legacy-links.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;GAUG;AAEH,+DAA+D;AAE/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE,eAAO,MAAM,iCAAiC,4BAA4B,CAAC;AAE3E,sCAAsC;AAEtC,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC,CAAC;AAGH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACtC,CAAC,CAAC;AAkHH;;;GAGG;AAEH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,YAAY,GAAE,MAAiC,GAC9C,cAAc,CAwDhB;AAoED;;;;;;;GAOG;AAEH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B,GACL;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAoC1C"}