kibi-cli 0.19.0 → 2.0.0

package/dist/commands/branch.js

@@ -15,64 +15,399 @@
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { copyCleanSnapshot, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, } from "../utils/branch-resolver.js";
-function resolveExplicitFromBranch(fromBranch) {
-    if (!isValidBranchName(fromBranch)) {
-        console.warn(`Warning: invalid branch name provided via --from: '${fromBranch}'`);
-        return null;
-    }
-    const fromPath = path.join(process.cwd(), ".kb/branches", fromBranch);
-    if (fs.existsSync(fromPath)) {
-        return fromBranch;
-    }
-    console.warn(`Warning: --from branch '${fromBranch}' KB does not exist`);
-    return null;
+import { EngineClient, acquireEnginePublicationLease, engineSocketPath, } from "../engine.js";
+import { getBranchDiagnostic, isValidBranchName, resolveActiveBranch, resolveBranchAttachment, } from "../utils/branch-resolver.js";
+import { branchStoreManifestMatches, branchStoreManifestPath, branchStorePath, branchStoresRoot, ensureBranchStoreManifest, expectedBranchStoreManifest, legacyBranchStorePath, readBranchStoreManifest, } from "../utils/branch-store-locator.js";
+import { inspectBranchStore } from "../utils/branch-store.js";
+/** Legacy migration changes storage format for one exact branch identity. */
+export function isSupportedLegacyBranchMigration(from, to) {
+    return from === to;
 }
-function resolveDefaultSourceBranch() {
-    // No default branch concept - branches are independent
-    // When --from is not specified, an empty branch KB will be created
-    return null;
-}
-function determineSourceBranch(explicitFromBranch) {
-    if (explicitFromBranch) {
-        const fromResult = resolveExplicitFromBranch(explicitFromBranch);
-        if (fromResult) {
-            return fromResult;
+function hashLegacyStore(sourcePath) {
+    const hash = createHash("sha256");
+    const visit = (directory, relative = "") => {
+        for (const entry of fs
+            .readdirSync(directory, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name))) {
+            const absolute = path.join(directory, entry.name);
+            const child = relative ? path.join(relative, entry.name) : entry.name;
+            if (entry.isDirectory())
+                visit(absolute, child);
+            else if (entry.isFile()) {
+                hash.update(child.replaceAll(path.sep, "/"));
+                hash.update("\0");
+                hash.update(fs.readFileSync(absolute));
+                hash.update("\0");
+            }
         }
+    };
+    visit(sourcePath);
+    return hash.digest("hex");
+}
+export function branchMigrationApprovalHash(from, to, sourcePath, targetPath) {
+    const sourceHash = hashLegacyStore(sourcePath);
+    return createHash("sha256")
+        .update(JSON.stringify({
+        version: 2,
+        from,
+        to,
+        sourcePath,
+        targetPath,
+        sourceHash,
+        manifestVersion: expectedBranchStoreManifest(to).version,
+    }))
+        .digest("hex");
+}
+function migrationJournalPath(workspaceRoot, id) {
+    if (!/^[A-Za-z0-9._-]+$/.test(id)) {
+        throw new Error("branch migration journal ID is invalid");
     }
-    return resolveDefaultSourceBranch();
+    return path.join(workspaceRoot, ".kb", "recovery", "branch-migrations", `${id}.json`);
+}
+function writeMigrationJournal(journalPath, journal) {
+    fs.writeFileSync(journalPath, `${JSON.stringify(journal, null, 2)}\n`, {
+        mode: 0o600,
+    });
 }
-function createBranchKbFromSource(sourceBranch, targetBranch) {
-    const sourcePath = path.join(process.cwd(), ".kb/branches", sourceBranch);
-    const targetPath = path.join(process.cwd(), ".kb/branches", targetBranch);
-    copyCleanSnapshot(sourcePath, targetPath);
-    console.log(`Created branch KB: ${targetBranch} (from ${sourceBranch})`);
+export function completeBranchJournalPaths(paths) {
+    const [sourcePath, targetPath, stagingPath, backupPath] = paths;
+    if (!sourcePath || !targetPath || !stagingPath || !backupPath) {
+        throw new Error("Branch migration journal is incomplete");
+    }
+    return [sourcePath, targetPath, stagingPath, backupPath];
+}
+function recoverBranchMigration(workspaceRoot, id, apply) {
+    const journalPath = migrationJournalPath(workspaceRoot, id);
+    const journal = JSON.parse(fs.readFileSync(journalPath, "utf8"));
+    if (journal.version !== 2)
+        throw new Error("Unsupported branch migration journal version");
+    const root = path.resolve(workspaceRoot);
+    const paths = ["sourcePath", "targetPath", "stagingPath", "backupPath"].map((key) => path.resolve(root, String(journal[key])));
+    if (paths.some((candidate) => !candidate.startsWith(`${root}${path.sep}`))) {
+        throw new Error("Branch migration journal path escapes workspace");
+    }
+    const [sourcePath, targetPath, stagingPath, backupPath] = completeBranchJournalPaths(paths);
+    console.log(`Branch migration recovery preview: ${id}`);
+    console.log(`State: ${String(journal.state)}`);
+    console.log(`Source: ${sourcePath}`);
+    console.log(`Target: ${targetPath}`);
+    console.log(`Backup: ${backupPath}`);
+    if (!apply) {
+        console.log("Preview only. Re-run with --apply to recover this journal.");
+        return;
+    }
+    if (journal.state === "committed")
+        return;
+    if (journal.state === "prepared") {
+        if (fs.existsSync(sourcePath) &&
+            fs.existsSync(stagingPath) &&
+            !fs.existsSync(targetPath)) {
+            fs.renameSync(sourcePath, backupPath);
+            writeMigrationJournal(journalPath, {
+                ...journal,
+                state: "legacy_quarantined",
+            });
+        }
+        else if (fs.existsSync(sourcePath) && fs.existsSync(targetPath)) {
+            throw new Error("Recovery found both legacy source and target; refusing to choose a winner");
+        }
+    }
+    if (fs.existsSync(backupPath) &&
+        fs.existsSync(stagingPath) &&
+        !fs.existsSync(targetPath)) {
+        fs.renameSync(stagingPath, targetPath);
+        if (!branchStoreManifestMatches(targetPath, String(journal.to))) {
+            throw new Error("Recovered target manifest does not match the exact branch identity");
+        }
+        writeMigrationJournal(journalPath, {
+            ...journal,
+            state: "target_published",
+        });
+    }
+    if (fs.existsSync(backupPath) && fs.existsSync(targetPath)) {
+        if (!branchStoreManifestMatches(targetPath, String(journal.to))) {
+            const corrupt = `${targetPath}.corrupt-${Date.now()}`;
+            fs.renameSync(targetPath, corrupt);
+            fs.renameSync(backupPath, targetPath);
+            throw new Error(`Invalid target moved to ${corrupt}; verified legacy backup restored`);
+        }
+        writeMigrationJournal(journalPath, { ...journal, state: "committed" });
+        return;
+    }
+    throw new Error(`Migration journal ${id} remains incomplete; rerun its recovery preview`);
 }
-function createEmptyBranchKb(branch) {
-    const kbPath = path.join(process.cwd(), ".kb/branches", branch);
-    fs.mkdirSync(kbPath, { recursive: true });
-    console.log(`Created branch KB: ${branch} (empty schema)`);
+function createEmptyBranchKb(branch, workspaceRoot) {
+    const kbPath = ensureBranchStoreManifest(workspaceRoot, branch);
+    console.log(`Created branch KB: ${branch} (${kbPath})`);
 }
 export async function branchEnsureCommand(options) {
-    const branchResult = resolveActiveBranch(process.cwd());
+    const workspaceRoot = path.resolve(options?.workspaceRoot ?? process.cwd());
+    const branchResult = resolveBranchAttachment(workspaceRoot);
     if ("error" in branchResult) {
         console.error(getBranchDiagnostic(undefined, branchResult.error));
         throw new Error(`Failed to resolve active branch: ${branchResult.error}`);
     }
-    const currentBranch = branchResult.branch;
-    const kbPath = path.join(process.cwd(), ".kb/branches", currentBranch);
+    if (branchResult.migrationRequired) {
+        throw new Error(`Branch ensure blocked by legacy storage at ${branchResult.storePath}. Run an explicit 'kibi branch migrate --from ${branchResult.kbBranch} --to ${branchResult.gitBranch} --apply' first.`);
+    }
+    const currentBranch = branchResult.kbBranch;
+    const kbPath = branchResult.storePath;
+    if (options?.from !== undefined) {
+        throw new Error("branch ensure --from was removed: new branch stores compile from the current checkout's tracked sources. Use branch migrate for an explicit legacy-store move.");
+    }
     if (fs.existsSync(kbPath)) {
         console.log(`Branch KB already exists: ${currentBranch}`);
         return;
     }
-    const sourceBranch = determineSourceBranch(options?.from);
-    if (sourceBranch) {
-        createBranchKbFromSource(sourceBranch, currentBranch);
+    createEmptyBranchKb(currentBranch, workspaceRoot);
+}
+/**
+ * Move a legacy branch-named KB into the exact active Git branch namespace.
+ * Preview is the default; --apply is required because this changes tracked
+ * workspace state.
+ */
+export async function branchMigrateCommand(options = {}) {
+    const workspaceRoot = path.resolve(options.workspaceRoot ?? process.cwd());
+    if (options.recoverJournal !== undefined) {
+        recoverBranchMigration(workspaceRoot, options.recoverJournal, options.apply === true);
+        return;
+    }
+    const from = options.from;
+    if (!from || !isValidBranchName(from)) {
+        throw new Error("branch migrate requires a valid --from branch name");
+    }
+    const active = resolveActiveBranch(workspaceRoot);
+    if ("error" in active) {
+        throw new Error(`Failed to resolve active branch: ${active.error}`);
+    }
+    const to = options.to;
+    if (!to || !isValidBranchName(to)) {
+        throw new Error("branch migrate requires an explicit valid --to branch name");
+    }
+    if (active.branch !== to) {
+        throw new Error(`branch migrate --to '${to}' does not match the active Git branch '${active.branch}'`);
+    }
+    if (!isSupportedLegacyBranchMigration(from, to)) {
+        throw new Error("branch migrate only supports a same-identity literal-to-hashed migration; every cross-branch move is refused");
+    }
+    // `from === to` is valid for the same-identity storage bridge: it names the
+    // same exact Git identity while moving a legacy literal directory into its
+    // hashed compiled-store path. The explicit pair is still required; no
+    // rename is inferred from commit history.
+    const root = branchStoresRoot(workspaceRoot);
+    const sourcePath = legacyBranchStorePath(workspaceRoot, from);
+    const targetPath = branchStorePath(workspaceRoot, to);
+    if (!fs.existsSync(sourcePath)) {
+        throw new Error(`Legacy source KB does not exist: ${sourcePath}`);
+    }
+    if (fs.existsSync(targetPath)) {
+        throw new Error(`Target branch KB already exists: ${targetPath}`);
+    }
+    const approvalHash = branchMigrationApprovalHash(from, to, sourcePath, targetPath);
+    console.log(`Branch KB migration preview: ${from} -> ${to}`);
+    console.log(`Source: ${sourcePath}`);
+    console.log(`Target: ${targetPath}`);
+    console.log(`Approval hash: ${approvalHash}`);
+    if (!options.apply) {
+        console.log("Preview only. Re-run with --apply to move the branch KB.");
+        return;
+    }
+    if (!options.approvalHash) {
+        throw new Error(`branch migrate requires --approval-hash from the preview (${approvalHash})`);
+    }
+    if (options.approvalHash !== approvalHash) {
+        throw new Error(`branch migrate approval hash mismatch; expected ${approvalHash}`);
+    }
+    const publicationLease = acquireEnginePublicationLease(workspaceRoot, from);
+    try {
+        const engine = new EngineClient({
+            workspaceRoot,
+            branch: from,
+            timeout: 2_000,
+            allowPublicationLock: true,
+        });
+        const engineSocket = engineSocketPath(workspaceRoot, from);
+        try {
+            if (fs.existsSync(engineSocket))
+                await engine.start(false);
+            if (engine.isRunning()) {
+                await engine.stop(false);
+            }
+            else if (fs.existsSync(engineSocket)) {
+                throw new Error(`Kibi engine socket remains present but is not reachable: ${engineSocket}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Branch migration blocked: engine shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            await engine.terminate();
+        }
+        if (branchMigrationApprovalHash(from, to, sourcePath, targetPath) !==
+            approvalHash) {
+            throw new Error("Branch migration source changed after engine shutdown; rerun the preview");
+        }
+        fs.mkdirSync(root, { recursive: true });
+        const migrationId = `${Date.now()}-${from.replaceAll("/", "__")}-${to.replaceAll("/", "__")}`;
+        const journalPath = path.join(workspaceRoot, ".kb", "recovery", "branch-migrations", `${migrationId}.json`);
+        const stagingPath = `${targetPath}.staging-${process.pid}-${Date.now()}`;
+        const backupPath = path.join(workspaceRoot, ".kb", "recovery", "branch-migrations", `${migrationId}-legacy`);
+        fs.mkdirSync(path.dirname(backupPath), { recursive: true });
+        const journal = {
+            version: 2,
+            from,
+            to,
+            sourcePath: path.relative(workspaceRoot, sourcePath),
+            targetPath: path.relative(workspaceRoot, targetPath),
+            stagingPath: path.relative(workspaceRoot, stagingPath),
+            backupPath: path.relative(workspaceRoot, backupPath),
+            approvalHash,
+            state: "prepared",
+        };
+        writeMigrationJournal(journalPath, { ...journal });
+        try {
+            fs.cpSync(sourcePath, stagingPath, {
+                recursive: true,
+                errorOnExist: true,
+            });
+            fs.writeFileSync(branchStoreManifestPath(stagingPath), `${JSON.stringify(expectedBranchStoreManifest(to), null, 2)}\n`, { mode: 0o600 });
+            fs.renameSync(sourcePath, backupPath);
+            writeMigrationJournal(journalPath, {
+                ...journal,
+                state: "legacy_quarantined",
+            });
+            fs.renameSync(stagingPath, targetPath);
+            if (!branchStoreManifestMatches(targetPath, to)) {
+                throw new Error("migrated branch store manifest verification failed");
+            }
+            writeMigrationJournal(journalPath, {
+                ...journal,
+                state: "target_published",
+            });
+            writeMigrationJournal(journalPath, { ...journal, state: "committed" });
+        }
+        catch (error) {
+            // Leave the hash-bound journal and any staging bytes for explicit crash
+            // recovery; never silently select a winner between source and target.
+            throw new Error(`Branch migration failed before authoritative completion; recover ${journalPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        console.log(`Migrated branch KB to exact Git branch '${to}'.`);
+        console.log(`Legacy store preserved at ${backupPath}.`);
+        console.log(`Migration journal: ${journalPath}.`);
+    }
+    finally {
+        publicationLease.release();
+    }
+}
+/**
+ * Rebuild an unreadable exact branch store from the current authored sources.
+ * The existing bytes are moved to a Kibi-owned recovery directory only after a
+ * clean staging store has been created successfully.
+ */
+export async function branchRecoverCommand(options = {}) {
+    const workspaceRoot = path.resolve(options.workspaceRoot ?? process.cwd());
+    const attachment = resolveBranchAttachment(workspaceRoot);
+    if ("error" in attachment) {
+        throw new Error(`Failed to resolve active branch: ${attachment.error}`);
+    }
+    if (attachment.kind !== "exact") {
+        throw new Error("branch recover requires an exact Git/KB attachment; migrate legacy storage before recovery.");
+    }
+    const inspection = inspectBranchStore(workspaceRoot, attachment.kbBranch);
+    if (inspection.state === "missing") {
+        throw new Error(`Branch KB is missing at ${inspection.path}; run 'kibi branch ensure' instead.`);
+    }
+    const stamp = new Date().toISOString().replaceAll(":", "-");
+    const backupPath = path.join(workspaceRoot, ".kb", "recovery", attachment.kbBranch, stamp);
+    console.log(`Branch KB recovery preview: ${attachment.kbBranch}`);
+    console.log(`Store: ${inspection.path}`);
+    console.log(`State: ${inspection.state}${inspection.errorCode ? ` (${inspection.errorCode})` : ""}`);
+    console.log(`Backup: ${backupPath}`);
+    console.log("Strategy: rebuild a clean journaled store from current authored sources.");
+    console.log("Git branch remains unchanged; no branch rename will be performed.");
+    if (!options.apply) {
+        console.log("Preview only. Re-run with --apply to create the backup and publish the rebuilt store.");
+        return;
+    }
+    const { syncCommand } = await import("./sync.js");
+    const result = await syncCommand({
+        rebuild: true,
+        recoveryBackupPath: backupPath,
+        workspaceRoot,
+    });
+    if (!result.success) {
+        throw new Error("Branch KB recovery did not complete successfully.");
+    }
+    // Reattach through the normal delta path after publishing the isolated
+    // generation. This establishes the current checkpoint/snapshot metadata on
+    // the recovered store, so recovery finishes fresh rather than merely
+    // structurally readable.
+    const checkpoint = await syncCommand({ workspaceRoot });
+    if (!checkpoint.success) {
+        throw new Error("Recovered branch KB could not establish a fresh checkpoint.");
+    }
+    const auditPath = path.join(workspaceRoot, ".kb", "migrations", `${attachment.kbBranch.replaceAll("/", "__")}.recovery.json`);
+    fs.mkdirSync(path.dirname(auditPath), { recursive: true });
+    fs.writeFileSync(auditPath, `${JSON.stringify({
+        version: 1,
+        branch: attachment.kbBranch,
+        recoveredAt: new Date().toISOString(),
+        priorState: inspection.state,
+        priorErrorCode: inspection.errorCode ?? null,
+        backupPath: path.relative(workspaceRoot, backupPath),
+        strategy: "rebuild_from_authored_sources",
+    }, null, 2)}\n`, "utf8");
+    console.log(`Recovered exact branch KB '${attachment.kbBranch}'.`);
+    console.log(`Original bytes preserved at ${backupPath}.`);
+    console.log(`Recovery audit: ${auditPath}`);
+}
+/** Restore the newest quarantined store for an exact branch identity. */
+export async function branchRestoreCommand(options = {}) {
+    const workspaceRoot = path.resolve(options.workspaceRoot ?? process.cwd());
+    const branch = options.branch;
+    if (!branch || !isValidBranchName(branch)) {
+        throw new Error("branch restore requires a valid --branch identity");
+    }
+    const targetPath = branchStorePath(workspaceRoot, branch);
+    if (fs.existsSync(targetPath)) {
+        throw new Error(`Target branch store already exists: ${targetPath}`);
+    }
+    const keyRoot = path.join(workspaceRoot, ".kb", "quarantine", "branches", path.basename(targetPath));
+    const candidates = fs.existsSync(keyRoot)
+        ? fs
+            .readdirSync(keyRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(keyRoot, entry.name))
+            .sort()
+            .reverse()
+        : [];
+    const source = candidates.find((candidate) => {
+        try {
+            const metadata = JSON.parse(fs.readFileSync(path.join(candidate, "quarantine.json"), "utf8"));
+            return metadata.branch === branch;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!source)
+        throw new Error(`No quarantined store found for '${branch}'.`);
+    console.log(`Branch restore preview: ${branch}`);
+    console.log(`Source: ${source}`);
+    console.log(`Target: ${targetPath}`);
+    if (!options.apply) {
+        console.log("Preview only. Re-run with --apply to restore the store.");
+        return;
     }
-    else {
-        createEmptyBranchKb(currentBranch);
+    const manifest = readBranchStoreManifest(source);
+    if (manifest === null || !branchStoreManifestMatches(source, branch)) {
+        throw new Error(`Quarantined store identity mismatch for '${branch}'.`);
     }
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.renameSync(source, targetPath);
+    console.log(`Restored exact branch store for '${branch}'.`);
 }
 export default branchEnsureCommand;

package/dist/commands/check.d.ts

@@ -1,3 +1,4 @@
+import { PrologProcess } from "../prolog.js";
 import type { Violation } from "../utils/rule-registry.js";
 export type { Violation };
 export interface CheckOptions {
@@ -9,7 +10,20 @@ export interface CheckOptions {
     dryRun?: boolean;
     format?: "text" | "json";
 }
+export declare function requireActiveProlog<E, P>(engine: E | null | undefined, prolog: P | null | undefined): NonNullable<E | P>;
 export declare function checkCommand(options: CheckOptions): Promise<{
     exitCode: number;
 }>;
+export declare function checkMustPriorityCoverage(prolog: PrologProcess): Promise<Violation[]>;
+export declare function findMustPriorityReqs(prolog: PrologProcess): Promise<string[]>;
+export declare function getAllEntityIds(prolog: PrologProcess, type?: string): Promise<string[]>;
+export declare function checkNoDanglingRefs(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkNoCycles(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkRequiredFields(prolog: PrologProcess, allEntityIds: string[]): Promise<Violation[]>;
+export declare function checkDeprecatedAdrs(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkDomainContradictions(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkStrictFactShape(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkStrictReqFactPairing(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkStrictReadiness(prolog: PrologProcess): Promise<Violation[]>;
+export declare function checkSymbolCoverage(prolog: PrologProcess): Promise<Violation[]>;
 //# sourceMappingURL=check.d.ts.map

package/dist/commands/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AAmFA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,YAAY,EAAE,SAAS,EAAE,CAAC;AAG1B,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B;AA2bD,wBAAsB,YAAY,CAChC,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAqX/B"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAgE7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B;AA8eD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC5B,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAC3B,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAMpB;AAGD,wBAAsB,YAAY,CAChC,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA0a/B;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CAoDtB;AAID,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBnB;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB;AACD,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CA+DtB;AAID,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CAmGtB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,SAAS,EAAE,CAAC,CAyCtB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CAgDtB;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CA0BtB;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CAqBtB;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CAqBtB;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CAqBtB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,SAAS,EAAE,CAAC,CA+BtB"}