harnery 0.41.0 → 0.43.0

package/dist/commands/servers.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+import { type ServersReport } from "../core/servers/index.js";
+export declare function registerServersCommand(program: Command, emit: EmitContext, context?: HarneryProgramContext): void;
+/** Plain-text table grouped by kind; exported for tests. */
+export declare function renderReport(report: ServersReport, bin: string): string;
+//# sourceMappingURL=servers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../src/commands/servers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAG1E,OAAO,EAWL,KAAK,aAAa,EAMnB,MAAM,0BAA0B,CAAC;AAElC,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CA0YN;AA8BD,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAmDvE"}

package/dist/commands/servers.js

@@ -0,0 +1,394 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { hostname } from "node:os";
+import { resolveCoordRoot } from "../core/agents/coord-client.js";
+import { resolveBinName, serverGcConfig } from "../core/config.js";
+import { adoptServer, allocateServerPort, isValidServerId, listServers, planServerGc, readServer, registerServer, SERVER_DEFAULT_IDLE_HOURS, SERVER_DEFAULT_OWNER_STALE_HOURS, stopServer, touchServer, unregisterServer, } from "../core/servers/index.js";
+export function registerServersCommand(program, emit, context) {
+    const root = () => {
+        const resolved = context?.resolveCoordRoot?.() ?? context?.repoRoot ?? resolveCoordRoot();
+        if (!resolved)
+            throw new Error("not inside a Harnery project");
+        return resolved;
+    };
+    const fail = (error, code = "servers_error") => {
+        emit.error({ code, message: error instanceof Error ? error.message : String(error) });
+        emit.setExitCode(1);
+    };
+    const cmd = program
+        .command("servers")
+        .description("Every local server started in this project: list, stop, clean up idle session servers, read logs");
+    cmd
+        .command("list", { isDefault: true })
+        .alias("status")
+        .description("List registered servers and any unregistered listener running inside the project")
+        .option("--no-scan", "Skip the scan for unregistered listeners")
+        .option("--json", "Emit the versioned report")
+        .action((options) => {
+        try {
+            const report = listServers({ coordRoot: root(), scan: options.scan !== false });
+            if (options.json) {
+                emit.config({ format: "json" });
+                emit.data(report);
+            }
+            else
+                emit.text(renderReport(report, resolveBinName(report.coord_root)));
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("stop [ids...]")
+        .description("Stop named servers now; --type selects several and previews unless --yes")
+        .option("--type <type>", "Select every running server of this type")
+        .option("--pid <pid>", "Stop an unregistered listener found by the list scan (repeatable)", (value, previous = []) => [...previous, value])
+        .option("--kind <kind>", "With --type, limit to session or service")
+        .option("--yes", "Apply a --type selection")
+        .option("--json", "Emit JSON")
+        .action(async (ids, options) => {
+        try {
+            const coordRoot = root();
+            const pids = (options.pid ?? []).map((value) => integer(value, "--pid"));
+            if (!ids.length && !options.type && !pids.length)
+                throw new Error("name server ids, or pass --type or --pid");
+            const report = listServers({ coordRoot, scan: pids.length > 0 });
+            const strays = pids.map((pid) => {
+                const found = report.unregistered.find((item) => item.pid === pid);
+                if (!found)
+                    throw new Error(`pid ${pid} is not an unregistered listener inside this project; only pids shown by "servers list" can be stopped this way`);
+                return found;
+            });
+            const byId = new Map(report.servers.map((view) => [view.record.id, view]));
+            const missing = ids.filter((id) => !byId.has(id));
+            if (missing.length)
+                throw new Error(`no running server named: ${missing.join(", ")}`);
+            const selected = [
+                ...ids.map((id) => byId.get(id)),
+                ...(options.type
+                    ? report.servers.filter((view) => view.record.type === options.type &&
+                        view.state === "running" &&
+                        (!options.kind || view.record.kind === options.kind) &&
+                        !ids.includes(view.record.id))
+                    : []),
+            ];
+            const preview = Boolean(options.type) && !options.yes;
+            const results = [];
+            for (const stray of strays) {
+                results.push(await stopServer({
+                    schema_version: 1,
+                    id: `pid-${stray.pid}`,
+                    kind: "session",
+                    type: "unregistered",
+                    label: stray.command,
+                    pid: stray.pid,
+                    host: hostname(),
+                    started_at: new Date().toISOString(),
+                    registered_at: new Date().toISOString(),
+                }, { coordRoot }));
+            }
+            for (const view of selected) {
+                if (preview && !ids.includes(view.record.id))
+                    results.push({ id: view.record.id, would_stop: true });
+                else
+                    results.push(await stopServer(view.record, { coordRoot }));
+            }
+            if (options.json) {
+                emit.config({ format: "json" });
+                emit.data({ applied: !preview, results });
+            }
+            else {
+                emit.text(results.length
+                    ? results
+                        .map((r) => "would_stop" in r
+                        ? `would stop ${r.id}`
+                        : `${r.stopped ? "stopped" : r.method === "not-running" ? "already stopped" : "could not stop"} ${r.id}${r.detail ? ` (${r.detail})` : ""}`)
+                        .join("\n") +
+                        (preview ? `\nPreview only. Re-run with --yes to stop these.` : "")
+                    : "No matching running servers.");
+            }
+            if (results.some((r) => "stopped" in r && !r.stopped && r.method === "refused"))
+                emit.setExitCode(1);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("gc")
+        .description(`Stop idle session servers whose starting agent ended (preview unless --yes); services are never touched`)
+        .option("--idle-hours <hours>", `Idle window before a server may stop (default ${SERVER_DEFAULT_IDLE_HOURS})`)
+        .option("--owner-stale-hours <hours>", `Treat a starting agent unobserved this long as gone (default ${SERVER_DEFAULT_OWNER_STALE_HOURS})`)
+        .option("--yes", "Stop the selected servers")
+        .option("--json", "Emit JSON")
+        .action(async (options) => {
+        try {
+            const coordRoot = root();
+            const configured = serverGcConfig(coordRoot);
+            const idleHours = positive(options.idleHours, configured.idle_hours ?? SERVER_DEFAULT_IDLE_HOURS, "--idle-hours");
+            const ownerStaleHours = positive(options.ownerStaleHours, configured.owner_stale_hours ?? SERVER_DEFAULT_OWNER_STALE_HOURS, "--owner-stale-hours");
+            const report = listServers({ coordRoot, scan: false, ownerStaleHours });
+            const decisions = planServerGc(report.servers, { idleHours, ownerStaleHours });
+            const stops = decisions.filter((d) => d.action === "stop");
+            const results = [];
+            if (options.yes) {
+                for (const decision of stops) {
+                    const view = report.servers.find((v) => v.record.id === decision.id);
+                    results.push(await stopServer(view.record, { coordRoot }));
+                }
+            }
+            if (options.json) {
+                emit.config({ format: "json" });
+                emit.data({ applied: Boolean(options.yes), pruned: report.pruned, decisions, results });
+            }
+            else {
+                const lines = decisions.map((d) => `${d.action === "stop" ? (options.yes ? "stopped" : "would stop") : "keep"}  ${d.id}  ${d.reason}`);
+                if (report.pruned.length)
+                    lines.push(`Removed records of exited servers: ${report.pruned.join(", ")}`);
+                if (!decisions.length)
+                    lines.push("No registered servers.");
+                if (stops.length && !options.yes)
+                    lines.push("Preview only. Re-run with --yes to stop.");
+                emit.text(lines.join("\n"));
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("adopt")
+        .description("Register running servers that never registered (only pids the list reports as unregistered)")
+        .option("--pid <pid>", "Adopt this unregistered listener (repeatable)", (value, previous = []) => [...previous, value])
+        .option("--all", "Adopt every unregistered listener the scan reports")
+        .option("--type <type>", "Server family to record", "adopted")
+        .option("--kind <kind>", "session (cleaned up when idle) or service", "session")
+        .option("--label <label>", "Human-readable name (single --pid only)")
+        .option("--scope <path>", "What the server serves (default: its working directory)")
+        .option("--no-owner", "Record no owner, so gc never stops it")
+        .option("--json", "Emit JSON")
+        .action((options) => {
+        try {
+            const coordRoot = root();
+            if (options.kind !== "session" && options.kind !== "service")
+                throw new Error("--kind must be session or service");
+            const pids = options.all
+                ? [...new Set(listServers({ coordRoot, sample: false }).unregistered.map((u) => u.pid))]
+                : (options.pid ?? []).map((value) => integer(value, "--pid"));
+            if (!pids.length)
+                throw new Error(options.all ? "no unregistered listeners" : "pass --pid or --all");
+            if (options.label && pids.length > 1)
+                throw new Error("--label needs a single --pid");
+            const records = pids.map((pid) => adoptServer(pid, {
+                coordRoot,
+                type: options.type,
+                kind: options.kind,
+                ...(options.label ? { label: options.label } : {}),
+                ...(options.scope ? { scope: options.scope } : {}),
+                owner: options.owner === false ? "none" : "self",
+            }));
+            if (options.json) {
+                emit.config({ format: "json" });
+                emit.data({ adopted: records });
+            }
+            else
+                emit.text(records.map((r) => `adopted ${r.id}  ${r.url ?? ""}`).join("\n"));
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("port <type>")
+        .description("Print a free port from the type's configured range (.harnery/config.jsonc servers.port_ranges)")
+        .action((type) => {
+        try {
+            const port = allocateServerPort(type, { coordRoot: root() });
+            if (port === null)
+                throw new Error(`no port range configured for ${type}`);
+            emit.text(String(port));
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("logs <id>")
+        .description("Print the end of a server's log file")
+        .option("-n, --lines <n>", "Lines to print", "60")
+        .action((id, options) => {
+        try {
+            const record = readServer(id, { coordRoot: root() });
+            if (!record)
+                throw new Error(`no server named ${id}`);
+            if (!record.log || !existsSync(record.log))
+                throw new Error(`${id} did not record a log file`);
+            const lines = positive(options.lines, 60, "--lines");
+            const size = statSync(record.log).size;
+            const content = readFileSync(record.log, "utf8").slice(Math.max(0, size - 512 * 1024));
+            emit.text(content
+                .split("\n")
+                .slice(-Math.floor(lines) - 1)
+                .join("\n"));
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("open <id>")
+        .description("Print a server's URL")
+        .action((id) => {
+        try {
+            const record = readServer(id, { coordRoot: root() });
+            if (!record)
+                throw new Error(`no server named ${id}`);
+            if (!record.url)
+                throw new Error(`${id} did not record a URL`);
+            emit.text(record.url);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("register")
+        .description("Record a server started by a script or another language (prints the record; the calling agent is recorded as owner)")
+        .requiredOption("--type <type>", "Server family, for example preview or review")
+        .option("--kind <kind>", "session (per piece of work) or service (long-running)", "session")
+        .option("--pid <pid>", "Process that owns the server's lifetime (default: this command's parent)")
+        .option("--port <port>", "Listening port")
+        .option("--id <id>", "Stable id (default derived from type and scope)")
+        .option("--url <url>", "Local URL")
+        .option("--scope <path>", "What the server serves, usually a directory")
+        .option("--label <label>", "Human-readable name")
+        .option("--log <path>", "Log file")
+        .option("--cwd <path>", "Working directory")
+        .action((options) => {
+        try {
+            if (options.kind !== "session" && options.kind !== "service")
+                throw new Error("--kind must be session or service");
+            if (options.id && !isValidServerId(options.id))
+                throw new Error(`invalid id: ${options.id}`);
+            const record = registerServer({
+                kind: options.kind,
+                type: options.type,
+                pid: options.pid ? integer(options.pid, "--pid") : process.ppid,
+                ...(options.port ? { port: integer(options.port, "--port") } : {}),
+                ...(options.id ? { id: options.id } : {}),
+                ...(options.url ? { url: options.url } : {}),
+                ...(options.scope ? { scope: options.scope } : {}),
+                ...(options.label ? { label: options.label } : {}),
+                ...(options.log ? { log: options.log } : {}),
+                ...(options.cwd ? { cwd: options.cwd } : {}),
+            }, { coordRoot: root() });
+            emit.config({ format: "json" });
+            emit.data(record);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("unregister <id>")
+        .description("Remove a server's record (with --pid, only if the record still names that pid)")
+        .option("--pid <pid>", "Only remove when the record names this pid")
+        .action((id, options) => {
+        try {
+            const removed = unregisterServer(id, {
+                coordRoot: root(),
+                ...(options.pid ? { pid: integer(options.pid, "--pid") } : {}),
+            });
+            emit.config({ format: "json" });
+            emit.data({ id, removed });
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    cmd
+        .command("touch <id>")
+        .description("Mark a server as used now, postponing idle cleanup")
+        .action((id) => {
+        try {
+            touchServer(id, { coordRoot: root() });
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+}
+function integer(value, flag) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1)
+        throw new Error(`${flag} must be a positive integer`);
+    return parsed;
+}
+function positive(value, fallback, flag) {
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        throw new Error(`${flag} must be a positive number`);
+    return parsed;
+}
+function duration(ms) {
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function ownerText(view) {
+    if (!view.record.owner)
+        return "no agent";
+    const name = view.record.owner.name ?? view.record.owner.instance_id.slice(0, 8);
+    return view.owner_state === "live" ? name : `${name} (${view.owner_state})`;
+}
+/** Plain-text table grouped by kind; exported for tests. */
+export function renderReport(report, bin) {
+    const lines = [];
+    for (const kind of ["service", "session"]) {
+        const views = report.servers.filter((view) => view.record.kind === kind);
+        lines.push(kind === "service"
+            ? "Services (stopped only by hand)"
+            : "Session servers (cleaned up when idle and their agent is gone)");
+        if (!views.length) {
+            lines.push("  none");
+            continue;
+        }
+        for (const view of views) {
+            const { record } = view;
+            const state = view.state === "running" ? "" : ` [${view.state}]`;
+            const started = Date.parse(record.started_at);
+            const use = kind === "service"
+                ? `up ${Number.isFinite(started) ? duration(Date.now() - started) : "?"}`
+                : view.connections === null
+                    ? `idle ${duration(view.idle_ms)}`
+                    : view.connections > 0
+                        ? `${view.connections} open connection(s)`
+                        : `idle ${duration(view.idle_ms)}`;
+            lines.push(`  ${record.id}${state}  ${record.url ?? (record.port ? `port ${record.port}` : "")}`, `      ${record.label} · ${ownerText(view)} · ${use}`);
+        }
+    }
+    if (report.scan === "unsupported") {
+        lines.push("Unregistered listeners: not checked on this platform");
+    }
+    else if (report.unregistered.length) {
+        const byPid = new Map();
+        for (const item of report.unregistered) {
+            const entry = byPid.get(item.pid) ?? { ports: [], command: item.command };
+            entry.ports.push(item.port);
+            byPid.set(item.pid, entry);
+        }
+        lines.push(`Unregistered servers inside this project (${byPid.size} processes):`);
+        for (const [pid, entry] of byPid)
+            lines.push(`  pid ${pid}  port ${entry.ports.join(", ")}  ${entry.command.slice(0, 100)}`);
+        lines.push(`  These started without registering. Stop one with: ${bin} servers stop --pid <pid>`);
+    }
+    if (report.pruned.length)
+        lines.push(`Removed records of exited servers: ${report.pruned.join(", ")}`);
+    lines.push(`Control: ${bin} servers stop <id> · ${bin} servers gc · ${bin} servers logs <id>`);
+    return lines.join("\n");
+}

package/dist/commands/tunnel.d.ts

@@ -1,10 +1,48 @@
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.js";
+import { type DetectOptions, detectPublicAddresses } from "../lib/tunnel/current-address.js";
 import { type TunnelProvider, type TunnelState } from "../lib/tunnel/state.js";
 export declare function tunnelLogDestinations(name: string, provider: TunnelProvider, env?: NodeJS.ProcessEnv, root?: string): {
     gate: string;
     provider: string;
 };
+export interface GateLaunch {
+    command: string;
+    /** Arguments before the gate's own `--name` and `--port`. */
+    arguments: string[];
+}
+export interface GateLaunchInputs {
+    /** Absolute path of `lib/tunnel/gate.ts` beside this file, whether or not it exists. */
+    gateScript: string;
+    gateScriptExists: boolean;
+    /** True when this process runs on Bun (so `execPath` is a Bun binary). */
+    underBun: boolean;
+    execPath: string;
+    /** The script this process was started with (`argv[1]`): the host CLI's entry or bundle. */
+    entryScript: string | undefined;
+    entryScriptExists: boolean;
+    bunOnPath: boolean;
+}
+/**
+ * How to start the gate worker, which is a `Bun.serve` process (HTTP and
+ * WebSocket reverse proxy):
+ *   1. From a source or package checkout, `gate.ts` sits beside this module and
+ *      runs directly.
+ *   2. Inside a single-file bundle there is no such file. The CLI then
+ *      re-executes itself with the hidden `tunnel gate` task, which loads the
+ *      gate in-process. This uses the running Bun binary, so Bun need not be
+ *      on PATH.
+ * Null means neither works (a Node host with no Bun, or an unknown entry).
+ */
+export declare function resolveGateLaunch(i: GateLaunchInputs): GateLaunch | null;
+/**
+ * How to start the log wrapper that rotates each process's output. Beside a
+ * source or package checkout the default (this package's own wrapper file)
+ * works; inside a single-file bundle the CLI re-executes itself with the hidden
+ * `tunnel log-worker` task instead.
+ */
+export declare function resolveWorkerLaunch(i: GateLaunchInputs): GateLaunch | undefined;
+export declare function downOne(name: string, killed: Set<number>): number;
 /**
  * Restart ONE instance's gate in place, deliberately leaving the provider
  * process running.
@@ -20,5 +58,32 @@ export declare function reloadOne(state: TunnelState): Promise<{
     ok: boolean;
     message: string;
 }>;
+export interface RefreshCurrentOptions {
+    emit?: EmitContext;
+    /** Reload running Cloudflare gates after an allowlist change, keeping their URLs. */
+    reload: boolean;
+    /** Speak only when the allowlist changed or no address could be detected. */
+    quiet?: boolean;
+    /** Lookup timeout and retries; a sync that must not stall offline passes small ones. */
+    detectOptions?: DetectOptions;
+    /** Replaces the lookup (tests). */
+    detect?: typeof detectPublicAddresses;
+}
+export interface RefreshCurrentResult {
+    /** False only when a requested reload of a live gate failed. A failed lookup is a warning, not a failure. */
+    ok: boolean;
+    /** The allowlist gained or lost an entry. */
+    changed: boolean;
+    /** Entries newly allowed. */
+    added: string[];
+    removed: string[];
+    warnings: string[];
+}
+/**
+ * `tunnel allow add --current`: allow this machine's own public addresses, as
+ * Cloudflare sees them, and drop the ones allowed by the previous refresh.
+ * Exported so a host CLI can run it before `tunnel up` and from its own sync.
+ */
+export declare function refreshCurrentAddress(options: RefreshCurrentOptions): Promise<RefreshCurrentResult>;
 export declare function registerTunnelCommand(program: Command, emitParam: EmitContext, contextParam?: HarneryProgramContext): void;
 //# sourceMappingURL=tunnel.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tunnel.d.ts","sourceRoot":"","sources":["../../src/commands/tunnel.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAQ1E,OAAO,EAYL,KAAK,cAAc,EACnB,KAAK,WAAW,EAGjB,MAAM,wBAAwB,CAAC;AAoDhC,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,EACxB,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,IAAI,SAAgB,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAcpC;AAuoBD;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAsE7F;AA+MD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,WAAW,EACtB,YAAY,CAAC,EAAE,qBAAqB,GACnC,IAAI,CA2EN"}
+{"version":3,"file":"tunnel.d.ts","sourceRoot":"","sources":["../../src/commands/tunnel.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAiB1E,OAAO,EACL,KAAK,aAAa,EAClB,qBAAqB,EAEtB,MAAM,kCAAkC,CAAC;AAQ1C,OAAO,EAYL,KAAK,cAAc,EACnB,KAAK,WAAW,EAGjB,MAAM,wBAAwB,CAAC;AAyDhC,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,EACxB,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,IAAI,SAAgB,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAcpC;AAmHD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,wFAAwF;IACxF,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,gBAAgB,GAAG,UAAU,GAAG,IAAI,CAWxE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,gBAAgB,GAAG,UAAU,GAAG,SAAS,CAM/E;AA2iBD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,CA0BjE;AA2DD;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAwF7F;AAoQD,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,qFAAqF;IACrF,MAAM,EAAE,OAAO,CAAC;IAChB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wFAAwF;IACxF,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,mCAAmC;IACnC,MAAM,CAAC,EAAE,OAAO,qBAAqB,CAAC;CACvC;AAED,MAAM,WAAW,oBAAoB;IACnC,6GAA6G;IAC7G,EAAE,EAAE,OAAO,CAAC;IACZ,6CAA6C;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CAuC/B;AAaD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,WAAW,EACtB,YAAY,CAAC,EAAE,qBAAqB,GACnC,IAAI,CA+GN"}