sela-core 0.1.0-alpha.1

package/dist/utils/FileLock.js

@@ -0,0 +1,189 @@
+"use strict";
+// src/utils/FileLock.ts
+//
+// Cross-process mutex built on atomic `mkdir`, extracted from the proven
+// three-layer model in HealingCacheService so every shared-write site reuses
+// ONE audited primitive instead of re-rolling its own lock.
+//
+// Why mkdir (not a lock library): `mkdir` of an existing directory fails with
+// EEXIST atomically on every OS and filesystem Node supports — no extra
+// dependency, no supply-chain surface, works identically across POSIX and
+// Windows and across separate Playwright worker processes.
+//
+// Lock identity IS the directory path. Callers derive it from the resource
+// being guarded (e.g. `<file>.sela.lock`), so locks on different files never
+// contend — per-file granularity preserves worker scalability.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLock = void 0;
+exports.lockDirFor = lockDirFor;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const DEFAULT_DELAYS_MS = [50, 100, 200, 400, 800, 800];
+const DEFAULT_SYNC_DELAYS_MS = [10, 25, 50, 100];
+class FileLock {
+    lockDir;
+    opts;
+    constructor(lockDir, opts = {}) {
+        this.lockDir = lockDir;
+        this.opts = opts;
+    }
+    warn(msg) {
+        (this.opts.logger?.warn ?? ((m) => logger_1.logger.warn(m)))(msg);
+    }
+    /** Ensure the lock dir's PARENT exists (never the lock dir itself — that
+     *  would defeat the EEXIST mutex). */
+    ensureParent() {
+        const parent = path.dirname(this.lockDir);
+        if (!fs.existsSync(parent)) {
+            fs.mkdirSync(parent, { recursive: true });
+        }
+    }
+    reclaimIfStale() {
+        const staleMs = this.opts.staleMs ?? 0;
+        if (staleMs <= 0)
+            return false;
+        try {
+            const age = Date.now() - fs.statSync(this.lockDir).mtimeMs;
+            if (age > staleMs) {
+                fs.rmdirSync(this.lockDir);
+                this.warn(`[FileLock] reclaimed stale lock ${this.lockDir} (age ${Math.round(age)}ms)`);
+                return true;
+            }
+        }
+        catch {
+            // stat/rmdir lost a race with the real holder — fall back to a retry.
+        }
+        return false;
+    }
+    /** One attempt, no wait. True iff this call now holds the lock. */
+    tryAcquire() {
+        this.ensureParent();
+        try {
+            fs.mkdirSync(this.lockDir);
+            return true;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "EEXIST") {
+                if (this.reclaimIfStale()) {
+                    try {
+                        fs.mkdirSync(this.lockDir);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                return false;
+            }
+            this.warn(`[FileLock] acquire failed at ${this.lockDir}: ${err.message}`);
+            return false;
+        }
+    }
+    /** Async acquire with exponential backoff. */
+    async acquire() {
+        const delays = this.opts.delaysMs ?? DEFAULT_DELAYS_MS;
+        for (let attempt = 0; attempt <= delays.length; attempt++) {
+            if (this.tryAcquire())
+                return true;
+            if (attempt === delays.length)
+                break;
+            await sleep(delays[attempt]);
+        }
+        return false;
+    }
+    release() {
+        try {
+            fs.rmdirSync(this.lockDir);
+        }
+        catch {
+            // best-effort — a missing lock dir is already the desired end state.
+        }
+    }
+    /**
+     * Run `fn` while holding the lock. Returns `fn`'s result, or `undefined`
+     * (and warns) when the lock could not be acquired within the backoff
+     * window. Mirrors the cache contract: a contended write is skipped, never
+     * thrown — the lock guards an optimisation/idempotent write, not a
+     * correctness invariant the caller cannot recover from.
+     */
+    async withLock(fn) {
+        if (!(await this.acquire())) {
+            this.warn(`[FileLock] could not acquire ${this.lockDir} — skipped`);
+            return undefined;
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    /** Synchronous variant — busy-waits between attempts. */
+    withLockSync(fn) {
+        const delays = this.opts.syncDelaysMs ?? DEFAULT_SYNC_DELAYS_MS;
+        for (let attempt = 0; attempt <= delays.length; attempt++) {
+            if (this.tryAcquire()) {
+                try {
+                    return fn();
+                }
+                finally {
+                    this.release();
+                }
+            }
+            if (attempt === delays.length)
+                break;
+            sleepBusy(delays[attempt]);
+        }
+        this.warn(`[FileLock] could not acquire ${this.lockDir} (sync) — skipped`);
+        return undefined;
+    }
+}
+exports.FileLock = FileLock;
+/** Derive the conventional lock-dir path for a guarded file. */
+function lockDirFor(filePath) {
+    return `${filePath}.sela.lock`;
+}
+function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+function sleepBusy(ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {
+        // intentional spin — sync callers cannot await
+    }
+}

package/dist/utils/IsolatedDiff.d.ts

@@ -0,0 +1,45 @@
+export interface IsolatedDiffOptions {
+    /** Lines of unchanged context around each hunk. Default 3 (git default). */
+    context?: number;
+    /**
+     * Path to render in the `--- a/<path>` / `+++ b/<path>` preamble. When
+     * omitted the preamble is dropped entirely (hunks only).
+     */
+    filePath?: string;
+}
+/**
+ * Generate a `git`-style unified diff between two in-memory strings.
+ * Returns `""` when the two buffers are identical.
+ */
+export declare function generateUnifiedDiff(before: string, after: string, opts?: IsolatedDiffOptions): string;
+export interface ChangeBlock {
+    /** Old text (newlines preserved). Empty string for pure additions. */
+    oldBlock: string;
+    /** New text (newlines preserved). Empty string for pure deletions. */
+    newBlock: string;
+    /** 1-based line in `before` where the block starts (0 if pure add). */
+    oldLineStart: number;
+    /** 1-based line in `after` where the block starts (0 if pure delete). */
+    newLineStart: number;
+    /**
+     * For pure additions: a non-empty line of unchanged anchor text immediately
+     * PRECEDING the new block in the `before` buffer. The replayer uses this
+     * to locate the insertion point. `null` when adding at the very top.
+     */
+    anchorBefore: string | null;
+}
+export declare function extractChangeBlocks(before: string, after: string): ChangeBlock[];
+export interface ApplyBlocksResult {
+    ok: boolean;
+    result?: string;
+    /** Human-readable failure reason - surfaced in the PR-automation log. */
+    reason?: string;
+}
+/**
+ * Replay a list of change blocks against a fresh base buffer (typically
+ * the file's `HEAD` blob). Each block is applied via UNIQUE substring
+ * replacement - when the old block is missing or ambiguous in the base,
+ * we fail loudly rather than silently mutating the wrong spot.
+ */
+export declare function applyChangeBlocks(base: string, blocks: ChangeBlock[]): ApplyBlocksResult;
+//# sourceMappingURL=IsolatedDiff.d.ts.map

package/dist/utils/IsolatedDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsolatedDiff.d.ts","sourceRoot":"","sources":["../../src/utils/IsolatedDiff.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,mBAAwB,GAC7B,MAAM,CAsBR;AA6PD,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,WAAW,EAAE,CAoDf;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EAAE,GACpB,iBAAiB,CAuDnB"}

package/dist/utils/IsolatedDiff.js

@@ -0,0 +1,382 @@
+"use strict";
+// src/utils/IsolatedDiff.ts
+//
+// Pure-JS unified-diff generator. No external `diff` package, no shell-out to
+// `git diff` - the result is guaranteed to be a function ONLY of the two
+// in-memory buffers passed in, never of any global working-tree state.
+//
+// This is the foundation of the Clean-Room Architecture: the HTML report
+// renders diffs computed here, so a developer's pre-existing uncommitted
+// edits CANNOT leak into Sela's report.
+//
+// Algorithm: classic LCS over lines, then a unified-diff emitter with
+// configurable context. Memory is O(N*M) which is fine for the spec files
+// Sela mutates (typically a few thousand lines max).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnifiedDiff = generateUnifiedDiff;
+exports.extractChangeBlocks = extractChangeBlocks;
+exports.applyChangeBlocks = applyChangeBlocks;
+/**
+ * Generate a `git`-style unified diff between two in-memory strings.
+ * Returns `""` when the two buffers are identical.
+ */
+function generateUnifiedDiff(before, after, opts = {}) {
+    if (before === after)
+        return "";
+    const context = Math.max(0, opts.context ?? 3);
+    const a = splitKeepEol(before);
+    const b = splitKeepEol(after);
+    const ops = diffLines(a, b);
+    if (ops.length === 0)
+        return "";
+    const hunks = groupHunks(ops, { a, b, context });
+    if (hunks.length === 0)
+        return "";
+    const out = [];
+    if (opts.filePath) {
+        const p = opts.filePath.split(/[\\/]/).join("/");
+        out.push(`diff --git a/${p} b/${p}`);
+        out.push(`--- a/${p}`);
+        out.push(`+++ b/${p}`);
+    }
+    for (const hunk of hunks) {
+        out.push(formatHunkHeader(hunk));
+        for (const row of hunk.rows)
+            out.push(row);
+    }
+    return out.join("\n") + "\n";
+}
+// ────────────────────────────────────────────────────────────────────
+// LINE SPLITTER - preserves trailing newline / CRLF so we can emit the
+// canonical `` marker when needed.
+// ────────────────────────────────────────────────────────────────────
+function splitKeepEol(text) {
+    if (text.length === 0)
+        return [];
+    const out = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10 /* \n */) {
+            out.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    if (start < text.length)
+        out.push(text.slice(start));
+    return out;
+}
+function stripEol(line) {
+    if (line.endsWith("\r\n"))
+        return line.slice(0, -2);
+    if (line.endsWith("\n"))
+        return line.slice(0, -1);
+    return line;
+}
+function hasEol(line) {
+    return line.endsWith("\n");
+}
+function diffLines(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const w = n + 1;
+    const dp = new Uint32Array((m + 1) * w);
+    for (let i = m - 1; i >= 0; i--) {
+        const ai = a[i];
+        for (let j = n - 1; j >= 0; j--) {
+            if (ai === b[j]) {
+                dp[i * w + j] = dp[(i + 1) * w + (j + 1)] + 1;
+            }
+            else {
+                const down = dp[(i + 1) * w + j];
+                const right = dp[i * w + (j + 1)];
+                dp[i * w + j] = down >= right ? down : right;
+            }
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            ops.push({ kind: "eq", a: i, b: j });
+            i++;
+            j++;
+        }
+        else if (dp[(i + 1) * w + j] >= dp[i * w + (j + 1)]) {
+            ops.push({ kind: "del", a: i });
+            i++;
+        }
+        else {
+            ops.push({ kind: "add", b: j });
+            j++;
+        }
+    }
+    while (i < m) {
+        ops.push({ kind: "del", a: i });
+        i++;
+    }
+    while (j < n) {
+        ops.push({ kind: "add", b: j });
+        j++;
+    }
+    return ops;
+}
+function groupHunks(ops, ctx) {
+    const hunks = [];
+    const ctxN = ctx.context;
+    let i = 0;
+    while (i < ops.length) {
+        // Locate the next non-equal op.
+        let firstChange = -1;
+        for (let k = i; k < ops.length; k++) {
+            if (ops[k].kind !== "eq") {
+                firstChange = k;
+                break;
+            }
+        }
+        if (firstChange === -1)
+            break;
+        // Leading-context start, bounded by previous hunk end.
+        let hunkStart = firstChange - ctxN;
+        if (hunkStart < i)
+            hunkStart = i;
+        if (hunkStart < 0)
+            hunkStart = 0;
+        let hunkEnd = firstChange;
+        // Extend by merging change groups separated by <= 2*ctxN equality lines.
+        // Avoid merging across the very end of `ops`.
+        while (true) {
+            let cursor = hunkEnd + 1;
+            let runEqs = 0;
+            let nextChange = -1;
+            while (cursor < ops.length) {
+                if (ops[cursor].kind === "eq") {
+                    runEqs++;
+                    cursor++;
+                    continue;
+                }
+                nextChange = cursor;
+                break;
+            }
+            if (nextChange !== -1 && runEqs <= 2 * ctxN) {
+                hunkEnd = nextChange;
+            }
+            else {
+                break;
+            }
+        }
+        // Trailing context.
+        let trailing = 0;
+        while (hunkEnd + 1 < ops.length &&
+            ops[hunkEnd + 1].kind === "eq" &&
+            trailing < ctxN) {
+            hunkEnd++;
+            trailing++;
+        }
+        // Materialise rows + compute header coordinates.
+        const rows = [];
+        let oldStartIdx = -1;
+        let newStartIdx = -1;
+        let oldLen = 0;
+        let newLen = 0;
+        for (let k = hunkStart; k <= hunkEnd; k++) {
+            const op = ops[k];
+            if (op.kind === "eq") {
+                if (oldStartIdx === -1)
+                    oldStartIdx = op.a;
+                if (newStartIdx === -1)
+                    newStartIdx = op.b;
+                const line = ctx.a[op.a];
+                rows.push(" " + stripEol(line));
+                oldLen++;
+                newLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+            else if (op.kind === "del") {
+                if (oldStartIdx === -1)
+                    oldStartIdx = op.a;
+                if (newStartIdx === -1) {
+                    // Anchor on the corresponding `b` position. For pure-deletions at
+                    // the top of file `op.a === 0` ⇒ newStart should be 0 (special
+                    // header form `+0,0`). For mid-file deletions use the running b
+                    // cursor - derive it from prior ops.
+                    newStartIdx = computeBAnchor(ops, k);
+                }
+                const line = ctx.a[op.a];
+                rows.push("-" + stripEol(line));
+                oldLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+            else {
+                if (newStartIdx === -1)
+                    newStartIdx = op.b;
+                if (oldStartIdx === -1)
+                    oldStartIdx = computeAAnchor(ops, k);
+                const line = ctx.b[op.b];
+                rows.push("+" + stripEol(line));
+                newLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+        }
+        hunks.push({
+            oldStart: oldLen === 0 ? oldStartIdx : oldStartIdx + 1,
+            oldLen,
+            newStart: newLen === 0 ? newStartIdx : newStartIdx + 1,
+            newLen,
+            rows,
+        });
+        i = hunkEnd + 1;
+    }
+    return hunks;
+}
+/**
+ * For a pure-add op at position `k`, walk backwards to find the prior
+ * `a` index (so we know which line of the old file the hunk starts at).
+ */
+function computeAAnchor(ops, k) {
+    for (let p = k - 1; p >= 0; p--) {
+        const op = ops[p];
+        if (op.kind === "eq")
+            return op.a + 1;
+        if (op.kind === "del")
+            return op.a + 1;
+    }
+    return 0;
+}
+function computeBAnchor(ops, k) {
+    for (let p = k - 1; p >= 0; p--) {
+        const op = ops[p];
+        if (op.kind === "eq")
+            return op.b + 1;
+        if (op.kind === "add")
+            return op.b + 1;
+    }
+    return 0;
+}
+function formatHunkHeader(hunk) {
+    const oldPart = hunk.oldLen === 1 ? `${hunk.oldStart}` : `${hunk.oldStart},${hunk.oldLen}`;
+    const newPart = hunk.newLen === 1 ? `${hunk.newStart}` : `${hunk.newStart},${hunk.newLen}`;
+    return `@@ -${oldPart} +${newPart} @@`;
+}
+function extractChangeBlocks(before, after) {
+    if (before === after)
+        return [];
+    const a = splitKeepEol(before);
+    const b = splitKeepEol(after);
+    const ops = diffLines(a, b);
+    const blocks = [];
+    let i = 0;
+    while (i < ops.length) {
+        if (ops[i].kind === "eq") {
+            i++;
+            continue;
+        }
+        const start = i;
+        while (i < ops.length && ops[i].kind !== "eq")
+            i++;
+        const oldLines = [];
+        const newLines = [];
+        let oldStart = -1;
+        let newStart = -1;
+        for (let k = start; k < i; k++) {
+            const op = ops[k];
+            if (op.kind === "del") {
+                if (oldStart === -1)
+                    oldStart = op.a;
+                oldLines.push(a[op.a]);
+            }
+            else if (op.kind === "add") {
+                if (newStart === -1)
+                    newStart = op.b;
+                newLines.push(b[op.b]);
+            }
+        }
+        let anchorBefore = null;
+        if (oldLines.length === 0) {
+            // Pure addition - find preceding unchanged anchor line.
+            for (let k = start - 1; k >= 0; k--) {
+                const op = ops[k];
+                if (op.kind === "eq") {
+                    anchorBefore = a[op.a];
+                    break;
+                }
+            }
+        }
+        blocks.push({
+            oldBlock: oldLines.join(""),
+            newBlock: newLines.join(""),
+            oldLineStart: oldStart >= 0 ? oldStart + 1 : 0,
+            newLineStart: newStart >= 0 ? newStart + 1 : 0,
+            anchorBefore,
+        });
+    }
+    return blocks;
+}
+/**
+ * Replay a list of change blocks against a fresh base buffer (typically
+ * the file's `HEAD` blob). Each block is applied via UNIQUE substring
+ * replacement - when the old block is missing or ambiguous in the base,
+ * we fail loudly rather than silently mutating the wrong spot.
+ */
+function applyChangeBlocks(base, blocks) {
+    let working = base;
+    for (const block of blocks) {
+        if (block.oldBlock.length === 0) {
+            // Pure addition.
+            if (block.anchorBefore === null) {
+                if (working.length === 0) {
+                    // Empty file - prepend.
+                    working = block.newBlock + working;
+                    continue;
+                }
+                // Prepend at top of file.
+                working = block.newBlock + working;
+                continue;
+            }
+            const idx = working.indexOf(block.anchorBefore);
+            if (idx === -1) {
+                return {
+                    ok: false,
+                    reason: `pure-add anchor not found in clean base: "${snippet(block.anchorBefore)}"`,
+                };
+            }
+            const lastIdx = working.lastIndexOf(block.anchorBefore);
+            if (idx !== lastIdx) {
+                return {
+                    ok: false,
+                    reason: `pure-add anchor is not unique in clean base: "${snippet(block.anchorBefore)}"`,
+                };
+            }
+            const insertAt = idx + block.anchorBefore.length;
+            working =
+                working.slice(0, insertAt) + block.newBlock + working.slice(insertAt);
+            continue;
+        }
+        const idx = working.indexOf(block.oldBlock);
+        if (idx === -1) {
+            return {
+                ok: false,
+                reason: `block not found in clean base - developer's dirty state likely overlaps Sela's mutation site: "${snippet(block.oldBlock)}"`,
+            };
+        }
+        const lastIdx = working.lastIndexOf(block.oldBlock);
+        if (idx !== lastIdx) {
+            return {
+                ok: false,
+                reason: `block matches multiple locations in clean base - refusing to guess: "${snippet(block.oldBlock)}"`,
+            };
+        }
+        working =
+            working.slice(0, idx) +
+                block.newBlock +
+                working.slice(idx + block.oldBlock.length);
+    }
+    return { ok: true, result: working };
+}
+function snippet(s) {
+    const flat = s.replace(/\r?\n/g, "\\n");
+    return flat.length > 80 ? flat.slice(0, 77) + "..." : flat;
+}

package/dist/utils/StackUtils.d.ts

@@ -0,0 +1,11 @@
+export declare class StackUtils {
+    static getCallerInfo(stackOverride?: string): {
+        filePath: string;
+        fileName: string;
+        line: number;
+        column: number;
+        locationKey: string;
+    };
+    static getActionKey(testTitle: string, action: string, index: number): string;
+}
+//# sourceMappingURL=StackUtils.d.ts.map

package/dist/utils/StackUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StackUtils.d.ts","sourceRoot":"","sources":["../../src/utils/StackUtils.ts"],"names":[],"mappings":"AAGA,qBAAa,UAAU;IACrB,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG;QAC5C,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;KACrB;IAmED,MAAM,CAAC,YAAY,CACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM;CA6BV"}