harnery 0.41.0 → 0.42.0

package/dist/core/servers/index.js

@@ -0,0 +1,560 @@
+/**
+ * Local server registry.
+ *
+ * Every command that starts a long-lived local server (a preview UI, a tuning
+ * panel, a tunnel gate, a dashboard) writes one record under
+ * `.harnery/servers/<id>.json` and removes it when the server stops. One
+ * reader can then list every running server, stop any of them, and clean up
+ * session servers whose starting agent is gone.
+ *
+ * Two kinds:
+ *   - `service`: one long-running copy (a dashboard, a tunnel). Listed and
+ *     stoppable by hand; never stopped automatically.
+ *   - `session`: one copy per piece of work (a preview for one scene). Eligible
+ *     for `gc` once its starting agent has ended or been unobserved for a long
+ *     time AND nobody has used the server for the idle window.
+ *
+ * Fail-closed rules: a record whose pid was recycled is treated as dead, never
+ * signalled; an unreadable coordination view makes every owner `unknown`,
+ * which `gc` never stops; a record without an owner is never stopped
+ * automatically.
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { hostname } from "node:os";
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { listStates } from "../../lib/tunnel/state.js";
+import { resolveCoordRoot } from "../agents/coord-client.js";
+import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.js";
+import { checkPidToken, processStartToken } from "../agents/state/proc-start.js";
+import { serverPortRange } from "../config.js";
+import { readCoordinationViewV3, requireAuthoritySafeCoordinationViewV3, } from "../events/v3/coordination-view.js";
+import { liveInstanceIdV3 } from "../events/v3/live-route-observer.js";
+import { resolveOwner } from "../hooks/resolve/owner.js";
+import { writePrivateJsonAtomic } from "../storage/atomic-json.js";
+import { ancestry, establishedConnectionCounts, listListeningPorts, listListeningSockets, processStartedAt, readProcessInfo, scanSupport, } from "./net.js";
+import { tunnelServerId, tunnelServerInput } from "./tunnels.js";
+export { ancestry, establishedConnectionCounts, listListeningPorts, listListeningSockets, lsofConnectionCounts, lsofListeningSockets, parseElapsed, parseLsofListen, parseProcNetTcp, processStartedAt, psProcessInfo, readProcessInfo, scanSupport, } from "./net.js";
+export { tunnelServerId, tunnelServerInput } from "./tunnels.js";
+export const SERVER_RECORD_SCHEMA_VERSION = 1;
+export const SERVER_DEFAULT_IDLE_HOURS = 2;
+export const SERVER_DEFAULT_OWNER_STALE_HOURS = 24;
+const TOUCH_INTERVAL_MS = 60_000;
+export function serversDir(coordRoot) {
+    return join(coordRoot, ".harnery", "servers");
+}
+function rootOf(options) {
+    return options?.coordRoot === undefined ? resolveCoordRoot() : options.coordRoot;
+}
+/** A stable id for one server family serving one scope. */
+export function serverId(type, scope) {
+    const family = slug(type) || "server";
+    if (!scope)
+        return family;
+    const digest = createHash("sha256").update(resolve(scope)).digest("hex").slice(0, 6);
+    const name = slug(basename(resolve(scope))).slice(0, 32);
+    return [family, name, digest].filter(Boolean).join("-");
+}
+function slug(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function isValidServerId(id) {
+    return /^[a-z0-9][a-z0-9._-]{0,95}$/.test(id);
+}
+function recordPath(coordRoot, id) {
+    if (!isValidServerId(id))
+        throw new Error(`invalid server id: ${id}`);
+    return join(serversDir(coordRoot), `${id}.json`);
+}
+/**
+ * Record a running server. Returns null when no coordination root resolves
+ * (a tool running outside any Harnery project), so callers never fail
+ * because registration was impossible.
+ */
+export function registerServer(input, options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot)
+        return null;
+    const pid = input.pid ?? process.pid;
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        throw new Error(`invalid server pid: ${pid}`);
+    if (input.port !== undefined &&
+        !(Number.isInteger(input.port) && input.port > 0 && input.port < 65536))
+        throw new Error(`invalid server port: ${input.port}`);
+    const id = input.id ?? serverId(input.type, input.scope);
+    const now = new Date().toISOString();
+    const startToken = processStartToken(pid);
+    const owner = input.owner === undefined ? callingOwner(coordRoot) : (input.owner ?? undefined);
+    const record = {
+        schema_version: SERVER_RECORD_SCHEMA_VERSION,
+        id,
+        kind: input.kind,
+        type: input.type,
+        label: input.label ?? id,
+        ...(input.url ? { url: input.url } : {}),
+        ...(input.port ? { port: input.port } : {}),
+        pid,
+        ...(startToken ? { start_token: startToken } : {}),
+        ...(input.pids?.length
+            ? { pids: input.pids.filter((p) => Number.isSafeInteger(p) && p > 0) }
+            : {}),
+        host: hostname(),
+        ...(input.scope ? { scope: resolve(input.scope) } : {}),
+        ...(input.cwd ? { cwd: resolve(input.cwd) } : {}),
+        ...(input.log ? { log: resolve(input.log) } : {}),
+        ...(input.stop_argv?.length ? { stop_argv: input.stop_argv } : {}),
+        ...(owner ? { owner } : {}),
+        started_at: input.started_at ?? now,
+        registered_at: now,
+        last_active_at: now,
+    };
+    writePrivateJsonAtomic(recordPath(coordRoot, id), record);
+    return record;
+}
+/** Best-effort registration that never throws (for server start paths). */
+export function tryRegisterServer(input, options) {
+    try {
+        return registerServer(input, options);
+    }
+    catch {
+        return null;
+    }
+}
+function callingOwner(coordRoot) {
+    try {
+        const owner = resolveOwner({ payload: null, coordRoot });
+        if (!owner)
+            return undefined;
+        const name = readLiveCoordinationRow(coordRoot, owner.instance_id)?.name;
+        return { instance_id: owner.instance_id, ...(name ? { name } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Remove a server's record. With `pid`, only a record still naming that pid
+ * is removed, so a replacement that re-registered the same id survives.
+ */
+export function unregisterServer(id, options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot || !isValidServerId(id))
+        return false;
+    const path = recordPath(coordRoot, id);
+    if (options?.pid !== undefined) {
+        const record = readRecord(path);
+        if (record && record.pid !== options.pid)
+            return false;
+    }
+    if (!existsSync(path))
+        return false;
+    rmSync(path, { force: true });
+    return true;
+}
+export function readServer(id, options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot || !isValidServerId(id))
+        return null;
+    return readRecord(recordPath(coordRoot, id));
+}
+/** Mark a server as used now. */
+export function touchServer(id, options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot || !isValidServerId(id))
+        return;
+    const path = recordPath(coordRoot, id);
+    const record = readRecord(path);
+    if (!record)
+        return;
+    writePrivateJsonAtomic(path, {
+        ...record,
+        last_active_at: (options?.now ?? new Date()).toISOString(),
+    });
+}
+/**
+ * A request hook for servers that want precise idle tracking: call the
+ * returned function on every request; it writes at most once a minute.
+ */
+export function createServerToucher(id, options) {
+    let last = 0;
+    return () => {
+        const now = Date.now();
+        if (now - last < TOUCH_INTERVAL_MS)
+            return;
+        last = now;
+        try {
+            touchServer(id, options);
+        }
+        catch {
+            // Activity tracking must never break the server.
+        }
+    };
+}
+function readRecord(path) {
+    try {
+        if (!existsSync(path) || statSync(path).size > 64 * 1024)
+            return null;
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (value?.schema_version !== SERVER_RECORD_SCHEMA_VERSION ||
+            typeof value.id !== "string" ||
+            !Number.isSafeInteger(value.pid) ||
+            (value.kind !== "service" && value.kind !== "session"))
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+export function readServerRecords(options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot)
+        return [];
+    const dir = serversDir(coordRoot);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => readRecord(join(dir, name)))
+        .filter((record) => record !== null)
+        .sort((a, b) => a.kind.localeCompare(b.kind) || a.type.localeCompare(b.type) || a.id.localeCompare(b.id));
+}
+export function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export function serverState(record) {
+    if (record.host !== hostname())
+        return "other-host";
+    if (!pidAlive(record.pid))
+        return "dead";
+    return checkPidToken(record.pid, record.start_token) === "mismatch" ? "dead" : "running";
+}
+function ownerReader(coordRoot, ownerStaleMs, nowMs) {
+    let view = null;
+    let failed = false;
+    try {
+        view = requireAuthoritySafeCoordinationViewV3(readCoordinationViewV3(coordRoot));
+    }
+    catch {
+        failed = true;
+    }
+    return (instanceId) => {
+        if (failed || !view)
+            return "unknown";
+        const generation = view.instances[liveInstanceIdV3(instanceId)];
+        if (generation?.phase !== "live")
+            return "ended";
+        const observed = Date.parse(generation.last_observed_at);
+        if (!Number.isFinite(observed))
+            return "unknown";
+        return nowMs - observed > ownerStaleMs ? "abandoned" : "live";
+    };
+}
+/** Read every record, observe it, and optionally find unregistered listeners. */
+export function listServers(options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot)
+        throw new Error("no Harnery project found (coordination root did not resolve)");
+    const now = options?.now ?? new Date();
+    const nowMs = now.getTime();
+    const ownerStaleMs = hours(options?.ownerStaleHours ?? SERVER_DEFAULT_OWNER_STALE_HOURS);
+    adoptRunningTunnels(coordRoot);
+    const records = readServerRecords({ coordRoot });
+    const ownerOf = ownerReader(coordRoot, ownerStaleMs, nowMs);
+    const states = records.map((record) => serverState(record));
+    const counts = establishedConnectionCounts(records.filter((_, i) => states[i] === "running").map((r) => r.port ?? 0));
+    const support = scanSupport();
+    const pruned = [];
+    const servers = [];
+    records.forEach((record, i) => {
+        const state = states[i];
+        if (state === "dead" && options?.prune !== false) {
+            unregisterServer(record.id, { coordRoot, pid: record.pid });
+            pruned.push(record.id);
+            return;
+        }
+        const connections = state === "running" && record.port && support !== "unsupported"
+            ? (counts.get(record.port) ?? 0)
+            : null;
+        let lastActive = record.last_active_at ?? record.registered_at;
+        if (connections && options?.sample !== false) {
+            lastActive = now.toISOString();
+            try {
+                touchServer(record.id, { coordRoot, now });
+            }
+            catch {
+                // Observation stays correct for this read even if the write fails.
+            }
+        }
+        const lastMs = Date.parse(lastActive);
+        servers.push({
+            record,
+            state,
+            owner_state: record.owner ? ownerOf(record.owner.instance_id) : "none",
+            connections,
+            last_active_at: lastActive,
+            idle_ms: Number.isFinite(lastMs) ? Math.max(0, nowMs - lastMs) : 0,
+        });
+    });
+    const unregistered = options?.scan === false ? [] : findUnregisteredListeners(coordRoot, servers);
+    return {
+        schema_version: 1,
+        coord_root: coordRoot,
+        scan: support,
+        servers,
+        unregistered,
+        pruned,
+    };
+}
+/** Register running tunnels that have no current record. Returns adopted ids. */
+export function adoptRunningTunnels(coordRoot) {
+    const adopted = [];
+    let states;
+    try {
+        states = listStates(coordRoot);
+    }
+    catch {
+        return adopted;
+    }
+    for (const state of states) {
+        if (!state.gate_pid || !pidAlive(state.gate_pid))
+            continue;
+        const id = tunnelServerId(state.name);
+        if (readServer(id, { coordRoot })?.pid === state.gate_pid)
+            continue;
+        if (tryRegisterServer(tunnelServerInput(state, coordRoot), { coordRoot }))
+            adopted.push(id);
+    }
+    return adopted;
+}
+/** Processes that browser automation and editors start; never project servers. */
+const IGNORED_LISTENER_COMMANDS = [
+    /(^|\/)(chrome|chromium|chrome-headless-shell|headless_shell|msedge|firefox)( |$)/i,
+    /\/(\.vscode-server|\.cursor-server|\.windsurf-server)\//,
+    /--type=(renderer|gpu-process|utility)/,
+];
+/**
+ * Listening processes that run inside the project (working directory or
+ * command line within the coordination root) but are not covered by any
+ * registered server: not a recorded pid, not a descendant of one, and not on
+ * a recorded port.
+ */
+export function findUnregisteredListeners(coordRoot, servers) {
+    const running = servers.filter((server) => server.state === "running");
+    const covered = new Set();
+    const ports = new Set();
+    for (const { record } of running) {
+        covered.add(record.pid);
+        for (const pid of record.pids ?? [])
+            covered.add(pid);
+        if (record.port)
+            ports.add(record.port);
+    }
+    const results = [];
+    const seenPids = new Map();
+    for (const socket of listListeningSockets()) {
+        if (ports.has(socket.port) || socket.pid === process.pid)
+            continue;
+        let inside = seenPids.get(socket.pid);
+        const info = readProcessInfo(socket.pid);
+        if (!info)
+            continue;
+        if (inside === undefined) {
+            inside =
+                !IGNORED_LISTENER_COMMANDS.some((pattern) => pattern.test(info.command)) &&
+                    (within(coordRoot, info.cwd) || mentions(info.command, coordRoot)) &&
+                    !ancestry(socket.pid).some((pid) => covered.has(pid));
+            seenPids.set(socket.pid, inside);
+        }
+        if (!inside)
+            continue;
+        results.push({
+            pid: socket.pid,
+            port: socket.port,
+            address: socket.address,
+            command: info.command.slice(0, 300),
+            cwd: info.cwd,
+        });
+    }
+    return results;
+}
+function within(root, path) {
+    if (!path)
+        return false;
+    const rel = relative(root, path);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function mentions(command, root) {
+    return command.split(/\s+/).some((arg) => arg === root || arg.startsWith(`${root}/`));
+}
+function hours(value) {
+    return value * 3_600_000;
+}
+/**
+ * Decide which session servers to stop. Pure: the caller supplies the views.
+ * A server is stopped only when all hold: kind `session`, running on this
+ * host, its owner ended or went unobserved past the stale window, and it has
+ * been idle for the idle window.
+ */
+export function planServerGc(views, policy) {
+    const idleMs = hours(policy?.idleHours ?? SERVER_DEFAULT_IDLE_HOURS);
+    return views.map(({ record, state, owner_state, idle_ms }) => {
+        const keep = (reason) => ({ id: record.id, action: "keep", reason });
+        if (state !== "running")
+            return keep(`server is ${state}`);
+        if (record.kind !== "session")
+            return keep("services are only stopped by hand");
+        if (owner_state === "none")
+            return keep("no starting agent was recorded");
+        if (owner_state === "unknown")
+            return keep("the starting agent's state could not be read");
+        if (owner_state === "live")
+            return keep("the starting agent is still active");
+        if (idle_ms < idleMs)
+            return keep(`used within the last ${policy?.idleHours ?? SERVER_DEFAULT_IDLE_HOURS}h`);
+        return {
+            id: record.id,
+            action: "stop",
+            reason: `starting agent ${owner_state === "ended" ? "has ended" : "has been unobserved past the stale window"} and the server has been idle ${Math.round(idle_ms / 60_000)} min`,
+        };
+    });
+}
+/**
+ * Stop one server: its graceful stop command first when recorded, then
+ * SIGTERM to its process group, then SIGKILL after the grace period. A pid
+ * whose start token no longer matches is never signalled.
+ */
+export async function stopServer(record, options) {
+    const coordRoot = rootOf(options);
+    const graceMs = options?.graceMs ?? 5_000;
+    const finish = (result) => {
+        if (result.stopped || result.method === "not-running")
+            unregisterServer(record.id, { coordRoot, pid: record.pid });
+        return result;
+    };
+    const state = serverState(record);
+    if (state === "other-host")
+        return { id: record.id, stopped: false, method: "refused", detail: `runs on ${record.host}` };
+    if (state === "dead")
+        return finish({ id: record.id, stopped: false, method: "not-running" });
+    if (record.stop_argv?.length) {
+        const [command, ...args] = record.stop_argv;
+        spawnSync(command, args, { stdio: "ignore", timeout: 30_000, cwd: record.cwd });
+        if (await exited(record, graceMs))
+            return finish({ id: record.id, stopped: true, method: "stop-command" });
+    }
+    signal(record.pid, "SIGTERM");
+    for (const pid of record.pids ?? [])
+        signal(pid, "SIGTERM");
+    if (await exited(record, graceMs))
+        return finish({ id: record.id, stopped: true, method: "signal" });
+    if (serverState(record) === "running") {
+        signal(record.pid, "SIGKILL");
+        for (const pid of record.pids ?? [])
+            signal(pid, "SIGKILL");
+    }
+    const stopped = await exited(record, 2_000);
+    return finish({
+        id: record.id,
+        stopped,
+        method: "signal",
+        ...(stopped ? {} : { detail: "process survived SIGKILL" }),
+    });
+}
+function signal(pid, name) {
+    // Detached servers lead their own process group; signal the group so a
+    // wrapper (npm, bunx) does not orphan the real listener.
+    try {
+        process.kill(-pid, name);
+        return;
+    }
+    catch {
+        // Not a group leader, or already gone.
+    }
+    try {
+        process.kill(pid, name);
+    }
+    catch {
+        // Already gone.
+    }
+}
+async function exited(record, waitMs) {
+    const deadline = Date.now() + waitMs;
+    while (Date.now() < deadline) {
+        if (serverState(record) !== "running")
+            return true;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    return serverState(record) !== "running";
+}
+/**
+ * The first free port in the configured range for `type`
+ * (`.harnery/config.jsonc` `servers.port_ranges`). Skips ports any process is
+ * listening on and ports a registered server claims. Returns null when the
+ * type has no configured range; throws when the range is exhausted.
+ */
+export function allocateServerPort(type, options) {
+    const coordRoot = rootOf(options);
+    const range = serverPortRange(type, coordRoot);
+    if (!range)
+        return null;
+    const taken = listListeningPorts();
+    for (const record of readServerRecords({ coordRoot })) {
+        if (record.port && serverState(record) === "running")
+            taken.add(record.port);
+    }
+    for (let port = range[0]; port <= range[1]; port++)
+        if (!taken.has(port))
+            return port;
+    throw new Error(`no free port for ${type} in ${range[0]}-${range[1]}`);
+}
+/**
+ * Register a running server that never registered itself. Only a pid the scan
+ * reports as an unregistered listener inside the project can be adopted.
+ */
+export function adoptServer(pid, options) {
+    const coordRoot = rootOf(options);
+    if (!coordRoot)
+        throw new Error("no Harnery project found (coordination root did not resolve)");
+    const report = listServers({ coordRoot, sample: false });
+    const listeners = report.unregistered.filter((item) => item.pid === pid);
+    if (!listeners.length)
+        throw new Error(`pid ${pid} is not an unregistered listener inside this project`);
+    const ports = listeners.map((item) => item.port).sort((a, b) => a - b);
+    const first = listeners[0];
+    const type = options?.type ?? "adopted";
+    const scope = options?.scope ?? first.cwd ?? undefined;
+    const started = processStartedAt(pid);
+    const record = registerServer({
+        id: serverId(type, `${scope ?? ""}#${pid}`),
+        kind: options?.kind ?? "session",
+        type,
+        label: options?.label ?? `Adopted: ${first.command.slice(0, 80)}`,
+        url: `http://127.0.0.1:${ports[0]}/`,
+        port: ports[0],
+        pid,
+        ...(scope ? { scope } : {}),
+        ...(first.cwd ? { cwd: first.cwd } : {}),
+        ...(options?.owner === "none" ? { owner: null } : {}),
+        ...(started ? { started_at: started } : {}),
+    }, { coordRoot });
+    if (!record)
+        throw new Error("registration failed");
+    return record;
+}
+/** Ensure the registry directory exists (for hosts that write records directly). */
+export function ensureServersDir(coordRoot) {
+    const dir = serversDir(coordRoot);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}

package/dist/core/servers/net.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Local socket and process observation for the server registry.
+ *
+ * Linux reads procfs directly (no `ss`/`lsof` dependency, works under WSL).
+ * macOS shells out to `lsof` and `ps`. Other platforms report `unsupported`
+ * so callers can say the scan did not run rather than implying it found
+ * nothing.
+ */
+export type ScanSupport = "procfs" | "lsof" | "unsupported";
+export interface ListeningSocket {
+    pid: number;
+    port: number;
+    address: string;
+}
+export interface ProcessInfo {
+    pid: number;
+    ppid: number | null;
+    command: string;
+    cwd: string | null;
+}
+export declare function scanSupport(): ScanSupport;
+interface ProcSocketRow {
+    localAddress: string;
+    localPort: number;
+    state: string;
+    inode: string;
+}
+/** Parse `/proc/net/tcp` or `/proc/net/tcp6` content. */
+export declare function parseProcNetTcp(content: string): ProcSocketRow[];
+/** Listening TCP sockets whose owning process this user can see. */
+export declare function listListeningSockets(): ListeningSocket[];
+/**
+ * Every listening TCP port on this machine, including ports whose owner this
+ * user cannot see (containers, other users). Used to avoid port collisions.
+ */
+export declare function listListeningPorts(): Set<number>;
+/** Parse `lsof -Fpn` output for listening sockets. */
+export declare function parseLsofListen(output: string): ListeningSocket[];
+/**
+ * Count established server-side connections per local port. A browser tab
+ * holding a live-reload socket or keep-alive connection counts as activity.
+ */
+export declare function establishedConnectionCounts(ports: number[]): Map<number, number>;
+/** Listening sockets via `lsof` (the macOS path; also runs wherever lsof exists). */
+export declare function lsofListeningSockets(): ListeningSocket[];
+/** Server-side established connections per wanted local port, via `lsof`. */
+export declare function lsofConnectionCounts(wanted: Set<number>): Map<number, number>;
+/** Parent, command line, and working directory via `ps` and `lsof` (the macOS path). */
+export declare function psProcessInfo(pid: number): ProcessInfo | null;
+export declare function readProcessInfo(pid: number): ProcessInfo | null;
+/** Parse `ps -o etime=` output (`[[dd-]hh:]mm:ss`) into seconds. */
+export declare function parseElapsed(value: string): number | null;
+/** When a process started, from its elapsed run time; null when unavailable. */
+export declare function processStartedAt(pid: number, now?: number): string | null;
+/** The pid followed by its ancestors, nearest first (bounded). */
+export declare function ancestry(pid: number, maxHops?: number): number[];
+export {};
+//# sourceMappingURL=net.d.ts.map

package/dist/core/servers/net.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"net.d.ts","sourceRoot":"","sources":["../../../src/core/servers/net.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,aAAa,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED,wBAAgB,WAAW,IAAI,WAAW,CAIzC;AAED,UAAU,aAAa;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,CAehE;AA4DD,oEAAoE;AACpE,wBAAgB,oBAAoB,IAAI,eAAe,EAAE,CAmBxD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CAAC,MAAM,CAAC,CAUhD;AAED,sDAAsD;AACtD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE,CAiBjE;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBhF;AAED,qFAAqF;AACrF,wBAAgB,oBAAoB,IAAI,eAAe,EAAE,CAExD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAS7E;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAa7D;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAoB/D;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOzD;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,MAAM,GAAG,IAAI,CAI7E;AAED,kEAAkE;AAClE,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,SAAK,GAAG,MAAM,EAAE,CAQ5D"}