kibi-cli 0.19.0 → 2.0.0

package/dist/operations/mutation/workspace-mutation-lock.d.ts

@@ -0,0 +1,60 @@
+export interface WorkspaceMutationLockFileSystem {
+    readonly mkdirSync: (target: string, options?: {
+        readonly recursive?: boolean;
+    }) => void;
+    readonly readFileSync: (target: string) => string;
+    readonly writeFileSync: (target: string, data: string, options: {
+        readonly encoding: "utf8";
+        readonly flag: "wx";
+    }) => void;
+    readonly unlinkSync: (target: string) => void;
+    readonly rmdirSync: (target: string) => void;
+}
+export interface WorkspaceMutationLockOptions {
+    readonly lockFileRelative?: string;
+    readonly timeoutMs?: number;
+    readonly now?: () => number;
+    readonly sleep?: (ms: number) => Promise<void>;
+    readonly fileSystem?: WorkspaceMutationLockFileSystem;
+    readonly isProcessAlive?: (pid: number) => boolean;
+}
+export declare class WorkspaceMutationLockError extends Error {
+    readonly name = "WorkspaceMutationLockError";
+}
+export interface WorkspaceMutationLockHandle {
+    /**
+     * Remove this handle's validated owner metadata and then its empty lock
+     * directory. Transient cleanup errors are retried; exhausted or permanent
+     * failures leave the lock fail-closed and may require verified manual
+     * cleanup. Successful release is idempotent, and a stale handle never
+     * removes a different owner token.
+     */
+    readonly release: () => void;
+}
+export declare function releaseWorkspaceMutationLock(handle: WorkspaceMutationLockHandle | undefined, operationFailure?: {
+    readonly error: unknown;
+}, committed?: boolean): void;
+/**
+ * Classify the failure of an operation whose authoritative commit already
+ * happened. Typed operation errors keep their code and retryability; generic
+ * failures are wrapped immediately as non-retryable so callers never read a
+ * committed mutation as an invitation to retry.
+ */
+export declare function classifySourceMutationFailure(operation: string, error: unknown, committed: boolean): unknown;
+/**
+ * Acquire the workspace workspace mutation lock without a callback shape, for
+ * operations whose lock must span several awaits (source publication,
+ * coordinate refresh, canonical re-extraction, and the RDF commit).
+ */
+export declare function acquireWorkspaceMutationLock(workspaceRoot: string, options?: WorkspaceMutationLockOptions): Promise<WorkspaceMutationLockHandle>;
+/**
+ * Run `operation` while holding the workspace mutation lock.
+ *
+ * Atomic directory creation is the sole lock authority. Owner metadata is
+ * release authorization and diagnostics. Every existing target, including a
+ * legacy file or a directory with missing/corrupt metadata, blocks or fails
+ * closed without mutating the lock path. Release failures propagate so
+ * successful work is never reported unlocked.
+ */
+export declare function withWorkspaceMutationLock<T>(workspaceRoot: string, operation: () => Promise<T>, options?: WorkspaceMutationLockOptions): Promise<T>;
+//# sourceMappingURL=workspace-mutation-lock.d.ts.map

package/dist/operations/mutation/workspace-mutation-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-mutation-lock.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/workspace-mutation-lock.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,SAAS,EAAE,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,KACvC,IAAI,CAAC;IACV,QAAQ,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;KAAE,KACxD,IAAI,CAAC;IACV,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C;AAeD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,QAAQ,CAAC,UAAU,CAAC,EAAE,+BAA+B,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACpD;AAGD,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,SAAkB,IAAI,gCAAgC;CACvD;AAwMD,MAAM,WAAW,2BAA2B;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAGD,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,2BAA2B,GAAG,SAAS,EAC/C,gBAAgB,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAC9C,SAAS,UAAQ,GAChB,IAAI,CAoBN;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,OAAO,GACjB,OAAO,CAWT;AAED;;;;GAIG;AAEH,wBAAsB,4BAA4B,CAChD,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,2BAA2B,CAAC,CA4KtC;AAED;;;;;;;;GAQG;AAEH,wBAAsB,yBAAyB,CAAC,CAAC,EAC/C,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,CAAC,CAAC,CAWZ"}

package/dist/operations/mutation/workspace-mutation-lock.js

@@ -0,0 +1,362 @@
+import { mkdirSync, readFileSync, rmdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import * as path from "node:path";
+import { InputError, OperationError } from "../../cli-errors.js";
+/**
+ * Portable cooperative mutex for Kibi source mutations. The lock protects
+ * cooperating Kibi writers; arbitrary external processes remain outside this
+ * protocol and cannot be CAS-protected by it.
+ */
+const DEFAULT_LOCK_FILE_RELATIVE = path.join(".kb", "recovery", "source-authoring.lock");
+const OWNER_FILE = "owner.json";
+const DEFAULT_TIMEOUT_MS = 15_000;
+const RETRY_INTERVAL_MS = 25;
+const MAX_RELEASE_FILESYSTEM_ATTEMPTS = 3;
+/** Bounded rereads for the transient mkdir->owner and unlink->rmdir windows. */
+const MAX_MISSING_OWNER_REREADS = 4;
+const NODE_FILE_SYSTEM = {
+    mkdirSync: (target, options) => {
+        mkdirSync(target, options);
+    },
+    readFileSync: (target) => readFileSync(target, "utf8"),
+    writeFileSync: (target, data, options) => {
+        writeFileSync(target, data, options);
+    },
+    unlinkSync: (target) => unlinkSync(target),
+    rmdirSync: (target) => rmdirSync(target),
+};
+// implements REQ-generated-coordinate-persistence
+export class WorkspaceMutationLockError extends Error {
+    name = "WorkspaceMutationLockError";
+}
+function lockPath(workspaceRoot, lockFileRelative) {
+    return path.join(workspaceRoot, lockFileRelative);
+}
+function randomToken() {
+    return `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function readLockRecord(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            typeof parsed.pid !== "number" ||
+            typeof parsed.token !== "string" ||
+            typeof parsed.acquiredAt !== "number") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function errorDetail(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const code = error.code;
+    return code === undefined ? error.message : `${code}: ${error.message}`;
+}
+function errorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    return error.code;
+}
+function isTransientFilesystemError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const code = error.code;
+    return (code === "EBUSY" ||
+        code === "EAGAIN" ||
+        code === "EINTR" ||
+        code === "EPERM");
+}
+function retryTransientFilesystemOperation(operation, canRetry = () => true) {
+    let attempts = 0;
+    while (attempts < MAX_RELEASE_FILESYSTEM_ATTEMPTS) {
+        attempts += 1;
+        try {
+            return { ok: true, value: operation(), attempts };
+        }
+        catch (error) {
+            if (!isTransientFilesystemError(error) ||
+                attempts === MAX_RELEASE_FILESYSTEM_ATTEMPTS ||
+                !canRetry(error)) {
+                return { ok: false, error, attempts };
+            }
+        }
+    }
+    throw new Error("unreachable retry state");
+}
+function manualCleanupGuidance(target, ownerPath) {
+    return `To clean it manually, verify no operation is active, verify ${ownerPath} and ${target}, then remove ${target}`;
+}
+function removeLockDirectory(fileSystem, target) {
+    const result = retryTransientFilesystemOperation(() => fileSystem.rmdirSync(target));
+    if (result.ok)
+        return;
+    const ownerPath = path.join(target, OWNER_FILE);
+    throw new WorkspaceMutationLockError(`failed to remove workspace mutation lock directory at ${target} after ${result.attempts} attempt(s): ${errorDetail(result.error)}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+}
+function removeLockOwner(fileSystem, target, ownerPath, ignoreMissing) {
+    const result = retryTransientFilesystemOperation(() => fileSystem.unlinkSync(ownerPath));
+    if (result.ok)
+        return;
+    const code = errorCode(result.error);
+    if (ignoreMissing && code === "ENOENT")
+        return;
+    throw new WorkspaceMutationLockError(`failed to remove workspace mutation lock owner at ${ownerPath} after ${result.attempts} attempt(s): ${errorDetail(result.error)}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+}
+function observeExistingLock(fileSystem, target, ownerPath, isProcessAlive) {
+    let record = null;
+    let source = "lock owner metadata";
+    let ownerMissing = false;
+    try {
+        record = readLockRecord(fileSystem.readFileSync(ownerPath));
+    }
+    catch (ownerError) {
+        ownerMissing = errorCode(ownerError) === "ENOENT";
+        try {
+            source = "legacy lock metadata";
+            record = readLockRecord(fileSystem.readFileSync(target));
+        }
+        catch {
+            // A lock directory without readable owner metadata is the normal
+            // mkdir->owner-publish window (and the unlink->rmdir release window):
+            // callers reread it a bounded number of times before failing closed.
+            // Any other owner read failure is not a creation gap.
+            if (ownerMissing) {
+                return {
+                    kind: "missing",
+                    description: "lock owner metadata is missing",
+                };
+            }
+            return {
+                kind: "recovery",
+                description: "lock owner metadata is missing or unverifiable",
+            };
+        }
+    }
+    if (record === null) {
+        return {
+            kind: "recovery",
+            description: `${source} is corrupt or unverifiable`,
+        };
+    }
+    try {
+        if (isProcessAlive(record.pid)) {
+            return { kind: "live", description: `held by pid ${record.pid}` };
+        }
+    }
+    catch {
+        return {
+            kind: "recovery",
+            description: `holder pid ${record.pid} could not be verified as live`,
+        };
+    }
+    return {
+        kind: "recovery",
+        description: `holder pid ${record.pid} is not live`,
+    };
+}
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+async function defaultSleep(ms) {
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+// implements REQ-generated-coordinate-persistence
+export function releaseWorkspaceMutationLock(handle, operationFailure, committed = false) {
+    if (handle === undefined)
+        return;
+    try {
+        handle.release();
+    }
+    catch (releaseError) {
+        if (committed) {
+            throw new OperationError("SOURCE_MUTATION_LOCK_RELEASE_FAILED", `Mutation committed, but workspace source lock release failed: ${errorDetail(releaseError)}; do not retry the mutation until the lock is manually verified and released`, false);
+        }
+        if (operationFailure !== undefined) {
+            throw new AggregateError([operationFailure.error, releaseError], "Operation failed and workspace mutation lock release failed");
+        }
+        throw releaseError;
+    }
+}
+/**
+ * Classify the failure of an operation whose authoritative commit already
+ * happened. Typed operation errors keep their code and retryability; generic
+ * failures are wrapped immediately as non-retryable so callers never read a
+ * committed mutation as an invitation to retry.
+ */
+export function classifySourceMutationFailure(operation, error, committed) {
+    if (!committed)
+        return error;
+    if (error instanceof OperationError || error instanceof InputError) {
+        return error;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    return new OperationError("SOURCE_MUTATION_POST_COMMIT_FAILED", `${operation} committed, but a postcommit step failed: ${detail}; do not retry the original mutation; inspect the committed snapshot and recovery metadata before repairing`, false);
+}
+/**
+ * Acquire the workspace workspace mutation lock without a callback shape, for
+ * operations whose lock must span several awaits (source publication,
+ * coordinate refresh, canonical re-extraction, and the RDF commit).
+ */
+// implements REQ-generated-coordinate-persistence
+export async function acquireWorkspaceMutationLock(workspaceRoot, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? defaultSleep;
+    const fileSystem = options.fileSystem ?? NODE_FILE_SYSTEM;
+    const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+    const target = lockPath(workspaceRoot, options.lockFileRelative ?? DEFAULT_LOCK_FILE_RELATIVE);
+    const ownerPath = path.join(target, OWNER_FILE);
+    const token = randomToken();
+    const deadline = now() + timeoutMs;
+    const parentPath = path.dirname(target);
+    const parentResult = retryTransientFilesystemOperation(() => fileSystem.mkdirSync(parentPath, { recursive: true }));
+    if (!parentResult.ok) {
+        throw new WorkspaceMutationLockError(`failed to create workspace mutation lock parent at ${parentPath} after ${parentResult.attempts} attempt(s): ${errorDetail(parentResult.error)}`);
+    }
+    let acquired = false;
+    let lastBlocker = "unknown";
+    let lastObservationMissing = false;
+    let missingOwnerRereads = 0;
+    while (now() < deadline) {
+        const targetResult = retryTransientFilesystemOperation(() => {
+            // Directory creation is the sole atomic lock authority.
+            fileSystem.mkdirSync(target);
+        });
+        if (targetResult.ok) {
+            acquired = true;
+            break;
+        }
+        if (errorCode(targetResult.error) !== "EEXIST") {
+            throw new WorkspaceMutationLockError(`failed to acquire workspace mutation lock directory at ${target} after ${targetResult.attempts} attempt(s): ${errorDetail(targetResult.error)}`);
+        }
+        const observation = observeExistingLock(fileSystem, target, ownerPath, isProcessAlive);
+        lastBlocker = observation.description;
+        lastObservationMissing = observation.kind === "missing";
+        if (observation.kind === "missing") {
+            // A missing owner is usually another holder's transient
+            // mkdir->owner-publish or unlink->rmdir window. Reread a bounded number
+            // of times; never reclaim the lock automatically.
+            if (missingOwnerRereads < MAX_MISSING_OWNER_REREADS) {
+                missingOwnerRereads += 1;
+                await sleep(RETRY_INTERVAL_MS);
+                continue;
+            }
+            throw new OperationError("SOURCE_MUTATION_LOCK_RECOVERY_REQUIRED", `workspace mutation lock at ${target} requires operator recovery: ${observation.description} after ${missingOwnerRereads} reread(s). Quiesce all Kibi and source-mutating writers, then manually verify the owner metadata and remove the lock only after confirming no operation is active`, false);
+        }
+        if (observation.kind === "recovery") {
+            throw new OperationError("SOURCE_MUTATION_LOCK_RECOVERY_REQUIRED", `workspace mutation lock at ${target} requires operator recovery: ${observation.description}. Quiesce all Kibi and source-mutating writers, then manually verify the owner metadata and remove the lock only after confirming no operation is active`, false);
+        }
+        await sleep(RETRY_INTERVAL_MS);
+    }
+    if (!acquired) {
+        if (lastObservationMissing) {
+            // The deadline expired inside a sustained missing-owner window: that is
+            // a fail-closed recovery state, not a busy holder.
+            throw new OperationError("SOURCE_MUTATION_LOCK_RECOVERY_REQUIRED", `workspace mutation lock at ${target} requires operator recovery: ${lastBlocker} for the whole acquisition window. Quiesce all Kibi and source-mutating writers, then manually verify the owner metadata and remove the lock only after confirming no operation is active`, false);
+        }
+        throw new OperationError("SOURCE_MUTATION_LOCK_TIMEOUT", `workspace mutation lock is ${lastBlocker}; acquisition timed out after ${timeoutMs}ms while the live owner remained in place; retry after the owner releases the lock to avoid a lost update`, true);
+    }
+    const payload = `${JSON.stringify({
+        pid: process.pid,
+        token,
+        acquiredAt: now(),
+    })}\n`;
+    try {
+        const ownerResult = retryTransientFilesystemOperation(() => fileSystem.writeFileSync(ownerPath, payload, {
+            encoding: "utf8",
+            flag: "wx",
+        }), () => {
+            try {
+                fileSystem.readFileSync(ownerPath);
+                return false;
+            }
+            catch (probeError) {
+                return errorCode(probeError) === "ENOENT";
+            }
+        });
+        if (!ownerResult.ok)
+            throw ownerResult.error;
+    }
+    catch (error) {
+        const cleanupFailures = [];
+        try {
+            removeLockOwner(fileSystem, target, ownerPath, true);
+        }
+        catch (cleanupError) {
+            cleanupFailures.push(`owner cleanup: ${errorDetail(cleanupError)}`);
+        }
+        try {
+            removeLockDirectory(fileSystem, target);
+        }
+        catch (cleanupError) {
+            cleanupFailures.push(`directory cleanup: ${errorDetail(cleanupError)}`);
+        }
+        const cleanupContext = cleanupFailures.length === 0
+            ? "lock directory cleanup completed"
+            : `lock remains fail-closed at ${target}; ${cleanupFailures.join("; ")}`;
+        throw new WorkspaceMutationLockError(`failed to initialize workspace mutation lock owner at ${ownerPath}: ${errorDetail(error)}; ${cleanupContext}`);
+    }
+    let releaseState = "owned";
+    return {
+        release: () => {
+            if (releaseState === "released")
+                return;
+            if (releaseState === "owned") {
+                const readResult = retryTransientFilesystemOperation(() => fileSystem.readFileSync(ownerPath));
+                if (!readResult.ok) {
+                    throw new WorkspaceMutationLockError(`failed to validate workspace mutation lock owner at ${ownerPath} after ${readResult.attempts} attempt(s): ${errorDetail(readResult.error)}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+                }
+                const record = readLockRecord(readResult.value);
+                if (record === null) {
+                    throw new WorkspaceMutationLockError(`refused to release workspace mutation lock with corrupt owner metadata at ${ownerPath}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+                }
+                if (record.token !== token) {
+                    releaseState = "released";
+                    return;
+                }
+                removeLockOwner(fileSystem, target, ownerPath, false);
+                releaseState = "owner-removed";
+            }
+            removeLockDirectory(fileSystem, target);
+            releaseState = "released";
+        },
+    };
+}
+/**
+ * Run `operation` while holding the workspace mutation lock.
+ *
+ * Atomic directory creation is the sole lock authority. Owner metadata is
+ * release authorization and diagnostics. Every existing target, including a
+ * legacy file or a directory with missing/corrupt metadata, blocks or fails
+ * closed without mutating the lock path. Release failures propagate so
+ * successful work is never reported unlocked.
+ */
+// implements REQ-generated-coordinate-persistence
+export async function withWorkspaceMutationLock(workspaceRoot, operation, options = {}) {
+    const handle = await acquireWorkspaceMutationLock(workspaceRoot, options);
+    let operationFailure;
+    try {
+        return await operation();
+    }
+    catch (error) {
+        operationFailure = { error };
+        throw error;
+    }
+    finally {
+        releaseWorkspaceMutationLock(handle, operationFailure);
+    }
+}

package/dist/operations/planning/apply-plan.d.ts

@@ -0,0 +1,19 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import { type BootstrapAction } from "../bootstrap/types.js";
+import type { ApplyPlanArgs, ApplyPlanResult } from "./apply-plan-types.js";
+export type { ApplyPlanArgs, ApplyPlanResult, EntityDeletionPlan, } from "./apply-plan-types.js";
+export declare const PLAN_APPLY_RESULT_VERSION: "kibi.plan-apply-result.v1";
+export declare function assertSourceWriteStaysInWorkspace(root: string, absolute: string, writePath: string): void;
+export declare function assertBootstrapRecoveryDependencies(remaining: readonly {
+    id: string;
+    dependsOn?: readonly string[];
+}[], applied: ReadonlySet<string>): void;
+export declare function orderBootstrapActions(actions: readonly BootstrapAction[], completed?: Set<string>): BootstrapAction[];
+export declare function executeApplyPlan(args: ApplyPlanArgs, context: OperationContext): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent: ApplyPlanResult;
+}>;
+//# sourceMappingURL=apply-plan.d.ts.map

package/dist/operations/planning/apply-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-plan.d.ts","sourceRoot":"","sources":["../../../src/operations/planning/apply-plan.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAGjF,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,uBAAuB,CAAC;AAqB/B,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,aAAa,EACb,eAAe,EACf,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAG/B,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AA6G9E,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN;AAED,wBAAgB,mCAAmC,CACjD,SAAS,EAAE,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,EACnE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,IAAI,CAaN;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,SAAS,cAAoB,GAC5B,eAAe,EAAE,CA2CnB;AAggDD,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IACT,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC,CA2BD"}