carrick 0.3.53

package/LICENSE.md

@@ -0,0 +1,99 @@
+Elastic License 2.0                                                                                                                                                                                                                                                                                                                             
+   
+  URL: https://www.elastic.co/licensing/elastic-license                                                                                                                                                                                                                                                                                           
+                                                            
+  Copyright (c) 2026 Far Harbour B.V.
+
+  Carrick is licensed under the Elastic License 2.0.                                                                                                                                                                                                                                                                                              
+   
+  ## Acceptance                                                                                                                                                                                                                                                                                                                                   
+                                                            
+  By using the software, you agree to all of the terms and conditions below.
+
+  ## Copyright License
+
+  The licensor grants you a non-exclusive, royalty-free, worldwide,                                                                                                                                                                                                                                                                               
+  non-sublicensable, non-transferable license to use, copy, distribute, make
+  available, and prepare derivative works of the software, in each case                                                                                                                                                                                                                                                                           
+  subject to the limitations and conditions below.          
+                                                                                                                                                                                                                                                                                                                                                  
+  ## Limitations
+                                                                                                                                                                                                                                                                                                                                                  
+  You may not provide the software to third parties as a hosted or managed
+  service, where the service provides users with access to any substantial
+  set of the features or functionality of the software.
+                                                                                                                                                                                                                                                                                                                                                  
+  You may not move, change, disable, or circumvent the license key
+  functionality in the software, and you may not remove or obscure any                                                                                                                                                                                                                                                                            
+  functionality in the software that is protected by the license key.
+
+  You may not alter, remove, or obscure any licensing, copyright, or other                                                                                                                                                                                                                                                                        
+  notices of the licensor in the software. Any use of the licensor's
+  trademarks is subject to applicable law.                                                                                                                                                                                                                                                                                                        
+                                                            
+  ## Patents
+
+  The licensor grants you a license, under any patent claims the licensor                                                                                                                                                                                                                                                                         
+  can license, or becomes able to license, to make, have made, use, sell,
+  offer for sale, import and have imported the software, in each case                                                                                                                                                                                                                                                                             
+  subject to the limitations and conditions in this license. This license
+  does not cover any patent claims that you cause to be infringed by                                                                                                                                                                                                                                                                              
+  modifications or additions to the software. If you or your company make
+  any written claim that the software infringes or contributes to                                                                                                                                                                                                                                                                                 
+  infringement of any patent, your patent license for the software granted
+  under these terms ends immediately. If your company makes such a claim,                                                                                                                                                                                                                                                                         
+  your patent license ends immediately for work on behalf of your company.
+                                                                                                                                                                                                                                                                                                                                                  
+  ## Notices                                                
+
+  You must ensure that anyone who gets a copy of any part of the software                                                                                                                                                                                                                                                                         
+  from you also gets a copy of these terms.
+                                                                                                                                                                                                                                                                                                                                                  
+  If you modify the software, you must include in any modified copies of
+  the software prominent notices stating that you have modified the
+  software.                                                                                                                                                                                                                                                                                                                                       
+   
+  ## No Other Rights                                                                                                                                                                                                                                                                                                                              
+                                                            
+  These terms do not imply any licenses other than those expressly granted
+  in these terms.
+
+  ## Termination
+
+  If you use the software in violation of these terms, such use is not
+  licensed, and your licenses will automatically terminate. If the licensor
+  provides you with a notice of your violation, and you cease all violation                                                                                                                                                                                                                                                                       
+  of this license no later than 30 days after you receive that notice, your
+  licenses will be reinstated retroactively. However, if you violate these                                                                                                                                                                                                                                                                        
+  terms after such reinstatement, any additional violation of these terms                                                                                                                                                                                                                                                                         
+  will cause your licenses to terminate automatically and permanently.
+                                                                                                                                                                                                                                                                                                                                                  
+  ## No Liability                                                                                                                                                                                                                                                                                                                                 
+   
+  As far as the law allows, the software comes as is, without any warranty                                                                                                                                                                                                                                                                        
+  or condition, and the licensor will not be liable to you for any damages
+  arising out of these terms or the use or nature of the software, under
+  any kind of legal claim.
+                                                                                                                                                                                                                                                                                                                                                  
+  ## Definitions
+                                                                                                                                                                                                                                                                                                                                                  
+  The licensor is the entity offering these terms, and the software is the
+  software the licensor makes available under these terms, including any
+  portion of it.
+
+  you refers to the individual or entity agreeing to these terms.                                                                                                                                                                                                                                                                                 
+   
+  your company is any legal entity, sole proprietorship, or other kind of                                                                                                                                                                                                                                                                         
+  organization that you work for, plus all organizations that have control
+  over, are under the control of, or are under common control with that
+  organization. control means ownership of substantially all the assets of                                                                                                                                                                                                                                                                        
+  an entity, or the power to direct its management and policies by vote,
+  contract, or otherwise. Control can be direct or indirect.                                                                                                                                                                                                                                                                                      
+                                                            
+  your licenses are all the licenses granted to you for the software under                                                                                                                                                                                                                                                                        
+  these terms.
+                                                                                                                                                                                                                                                                                                                                                  
+  use means anything you do with the software requiring one of your
+  licenses.
+
+  trademark means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,79 @@
+# carrick
+
+Carrick indexes the TypeScript repos sitting beside each other on your disk and
+answers, about the file you are editing right now: which routes and calls are in
+it, who is on the other side of them in the other repos, and whether the
+contract between them still holds. It answers in your editor's Problems panel
+and in your coding agent's context, without either of them asking.
+
+```
+npm install -g carrick
+cd ~/code            # the folder that holds your repos
+carrick init
+```
+
+`carrick init` needs a GitHub identity — `gh auth login`, or a `GITHUB_TOKEN` in
+the environment — and tells you so before it writes anything.
+
+## What it installs
+
+One package. The scanner is a Rust binary that arrives as
+`@carrick-tools/cli-<platform>-<arch>`, an optional dependency npm resolves by
+`os` and `cpu`; the type sidecar, the language server and the hook scripts come
+with this package. There is no postinstall step and nothing is downloaded after
+the install, so `--ignore-scripts` works.
+
+Node 24 or newer, because the sidecar that resolves your request and response
+types runs on it.
+
+## The commands
+
+| Command | What it does |
+|---|---|
+| `carrick init` | The repo list, the first index, the agent hooks, and the lines it cannot run for you |
+| `carrick index` | Scan every repo in `carrick-workspace.json` and write `.carrick/` |
+| `carrick refresh [--service X]` | Re-scan one repo, or all of them, and re-join |
+| `carrick check <file>` | What the index knows about that file, verdicts included |
+| `carrick touch <file>` | The same, without the verdicts |
+| `carrick status` | What the index holds, and how far each repo has moved since |
+| `carrick lsp --stdio` | The language server, for an editor or any LSP client |
+| `carrick hook post-edit` | Claude Code PostToolUse hook, reading the tool payload on stdin |
+| `carrick hook session-start` | Claude Code SessionStart hook |
+| `carrick templates workflow` | Print the CI workflow to add to a repo |
+| `carrick <path>` | The full scan, which is what the GitHub Action runs |
+
+`check`, `touch` and `status` read `.carrick/` and write nothing. Add `--json`
+for the machine-readable shape, pinned in
+[`docs/local-mode-output.md`](https://github.com/carrick-tools/carrick/blob/main/docs/local-mode-output.md).
+
+## Where the answers land
+
+- **Claude Code**: the hooks `carrick init` writes deliver on the edit itself.
+  `claude --plugin-dir <carrick checkout>/plugin` adds the language server too.
+- **VS Code, Cursor, Windsurf**: the `carrick-tools.carrick` extension is a
+  client on `carrick lsp --stdio`. Editor-hosted agents read the Problems panel
+  after their own edits.
+- **Neovim, Helix, Zed, JetBrains**: any LSP client, on the same command.
+- **Anything else**: `carrick check <file>` on demand, and the pull request
+  check in CI.
+
+## What a local index holds
+
+Deterministic rows: file-based and descriptor routes, class-controller routes,
+imported-member calls, GraphQL schema and document rows, socket and pub/sub
+operations, and the types on both sides of them. A route registered on a typed
+receiver, and a call whose URL is assembled at the call site, are classified in
+the hosted index and are absent here — every answer says how many of those it
+counted and did not classify, so a thin answer never reads as an empty one.
+
+The hosted index covers every repo in your organisation on its main branch,
+including the ones you do not have checked out, and answers over MCP:
+
+```
+claude mcp add --scope user --transport http carrick https://api.carrick.tools/mcp
+```
+
+## Licence
+
+Elastic License 2.0. See
+[LICENSE.md](https://github.com/carrick-tools/carrick/blob/main/LICENSE.md).

package/bin/carrick.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+// One command for every host.
+//
+// `carrick index|touch|check|refresh|status|<path>` is the Rust scanner, run
+// from the platform package npm installed. `carrick lsp`, `carrick hook` and
+// `carrick init` are this package's own TypeScript, run by Node's type
+// stripping — which is why the floor is Node 24 and why the check for it is
+// the first thing in this file, before any `.ts` is imported. On an older Node
+// the import itself is a syntax error, and a syntax error is not an answer to
+// "which Node do I need".
+//
+// What it imports is `dist/`, not `src/`: Node refuses to strip types for any
+// file under node_modules, so the published package carries the emit and the
+// checkout builds it (`npm run build`, and `prepack` before a publish).
+//
+// Nothing here re-enters `carrick` on PATH: the binary is resolved to an
+// absolute path (src/native.ts). A shim that shelled out to its own name would
+// loop forever the moment the platform package went missing.
+
+import { spawn } from "node:child_process";
+
+const NODE_FLOOR = 24;
+
+function nodeMajor() {
+  const [major] = process.versions.node.split(".");
+  return Number.parseInt(major ?? "0", 10);
+}
+
+if (nodeMajor() < NODE_FLOOR) {
+  process.stderr.write(
+    `carrick needs Node ${NODE_FLOOR} or newer; this is Node ${process.versions.node}.\n` +
+      `The type sidecar that resolves your request and response types runs on it, and this CLI is TypeScript run directly.\n` +
+      `Install Node ${NODE_FLOOR}+ (https://nodejs.org) and run carrick again.\n`,
+  );
+  process.exit(1);
+}
+
+const HOOKS = {
+  "post-edit": "../dist/hook/post-edit.js",
+  "session-start": "../dist/hook/session-start.js",
+};
+
+const argv = process.argv.slice(2);
+const [command, ...rest] = argv;
+
+/** Run the scanner binary, streaming its output and answering with its code. */
+async function runNative(args) {
+  const { resolveNativeBinary, nativeEnv } = await import("../dist/native.js");
+  const lookup = resolveNativeBinary();
+  if (!lookup.binary) {
+    process.stderr.write(`carrick: ${lookup.problem}\n`);
+    process.exit(1);
+  }
+  const child = spawn(lookup.binary, args, {
+    stdio: "inherit",
+    env: nativeEnv(),
+  });
+  child.on("error", (error) => {
+    process.stderr.write(`carrick: could not run ${lookup.binary}: ${error.message}\n`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    // A signalled child is reported the way a shell reports it, so a Ctrl-C
+    // through this shim looks like a Ctrl-C of the scanner.
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 1);
+  });
+}
+
+/**
+ * Point this package's own commands at the binary directly, rather than at
+ * whatever `carrick` PATH holds. The hook and the server run on every edit;
+ * one process, not two, and no dependence on the install being global.
+ */
+async function pointAtNativeBinary() {
+  const { resolveNativeBinary, resolveSidecarDir } = await import("../dist/native.js");
+  if (!process.env["CARRICK_BIN"]) {
+    const lookup = resolveNativeBinary();
+    if (lookup.binary) process.env["CARRICK_BIN"] = lookup.binary;
+  }
+  if (!process.env["CARRICK_SIDECAR_DIR"]) {
+    const sidecar = resolveSidecarDir();
+    if (sidecar) process.env["CARRICK_SIDECAR_DIR"] = sidecar;
+  }
+}
+
+async function printVersion() {
+  const { readFile } = await import("node:fs/promises");
+  const manifest = new URL("../package.json", import.meta.url);
+  const { version } = JSON.parse(await readFile(manifest, "utf8"));
+  process.stdout.write(`${version}\n`);
+}
+
+function extraHelp() {
+  return [
+    "",
+    "This package also carries the commands that put those answers where you work:",
+    "",
+    "    carrick init                 set up this folder: the repos to index, the first",
+    "                                 index, and the editor and agent wiring",
+    "    carrick lsp --stdio          the language server, for an editor or an agent",
+    "                                 that speaks LSP",
+    "    carrick hook post-edit       Claude Code PostToolUse hook (reads the tool",
+    "                                 payload on stdin)",
+    "    carrick hook session-start   Claude Code SessionStart hook",
+    "    carrick templates workflow   print the CI workflow to add to a repo",
+    "",
+  ].join("\n");
+}
+
+switch (command) {
+  case "lsp": {
+    await pointAtNativeBinary();
+    await import("../dist/server.js");
+    break;
+  }
+  case "hook": {
+    const [name] = rest;
+    const entry = name ? HOOKS[name] : undefined;
+    if (!entry) {
+      process.stderr.write(
+        `carrick hook needs one of: ${Object.keys(HOOKS).join(", ")}\n`,
+      );
+      process.exit(2);
+    }
+    await pointAtNativeBinary();
+    await import(entry);
+    break;
+  }
+  case "init": {
+    const { init } = await import("../dist/init/run.js");
+    process.exit(await init(rest));
+  }
+  case "templates": {
+    const { templates } = await import("../dist/init/run.js");
+    process.exit(templates(rest));
+  }
+  case "--version":
+  case "-V": {
+    await printVersion();
+    break;
+  }
+  case "--help":
+  case "-h":
+  case undefined: {
+    // The scanner owns its own help, including the environment variables, so
+    // print that and add what this package puts on top of it.
+    const { resolveNativeBinary, nativeEnv } = await import("../dist/native.js");
+    const lookup = resolveNativeBinary();
+    if (lookup.binary) {
+      await new Promise((resolve) => {
+        spawn(lookup.binary, ["--help"], { stdio: "inherit", env: nativeEnv() }).on(
+          "exit",
+          resolve,
+        );
+      });
+    } else {
+      process.stderr.write(`carrick: ${lookup.problem}\n`);
+    }
+    process.stderr.write(extraHelp());
+    process.exit(0);
+  }
+  default:
+    await runNative(argv);
+}

package/dist/channel.d.ts

@@ -0,0 +1,16 @@
+export type Channel = "hook" | "lsp" | "off";
+export type ChannelInput = {
+    env?: NodeJS.ProcessEnv;
+    /** True when a PostToolUse hook is registered alongside this process. */
+    hooksInstalled: boolean;
+};
+export type ChannelChoice = {
+    channel: Channel;
+    /** How it was decided, for the log line. */
+    source: "env" | "default";
+    /** Set when CARRICK_CHANNEL held a value we do not know. */
+    ignoredValue: string | null;
+};
+export declare function resolveChannel(input: ChannelInput): ChannelChoice;
+/** Whether this process is the one that delivers. */
+export declare function ownsDelivery(mine: Exclude<Channel, "off">, choice: ChannelChoice): boolean;

package/dist/channel.js

@@ -0,0 +1,37 @@
+// One channel per install.
+//
+// The hook and the language server carry the same verdicts. Delivering both in
+// one session means the model reads every finding twice and a measurement of
+// either channel measures the pair, so exactly one of them speaks.
+//
+// The decision is config, not sniffing. The Claude Code plugin registers the
+// hook and the server together, so its `.lsp.json` passes `--hooks-installed`
+// to the server: the manifest that knows the hook exists is the one that says
+// so. An editor or a generic LSP client starts the server without that flag and
+// has no hook at all, so the server publishes. `CARRICK_CHANNEL` overrides both
+// and is how a smoke run pins one arm.
+const KNOWN = ["hook", "lsp", "off"];
+export function resolveChannel(input) {
+    const raw = (input.env ?? process.env)["CARRICK_CHANNEL"];
+    if (raw) {
+        const value = raw.trim().toLowerCase();
+        if (KNOWN.includes(value)) {
+            return { channel: value, source: "env", ignoredValue: null };
+        }
+        return {
+            channel: input.hooksInstalled ? "hook" : "lsp",
+            source: "default",
+            ignoredValue: raw,
+        };
+    }
+    return {
+        channel: input.hooksInstalled ? "hook" : "lsp",
+        source: "default",
+        ignoredValue: null,
+    };
+}
+/** Whether this process is the one that delivers. */
+export function ownsDelivery(mine, choice) {
+    return choice.channel === mine;
+}
+//# sourceMappingURL=channel.js.map

package/dist/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,EAAE;AACF,+EAA+E;AAC/E,6EAA6E;AAC7E,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,8EAA8E;AAC9E,8EAA8E;AAC9E,gFAAgF;AAChF,gFAAgF;AAChF,uCAAuC;AAkBvC,MAAM,KAAK,GAAc,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEhD,MAAM,UAAU,cAAc,CAAC,KAAmB;IAChD,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC1D,IAAI,GAAG,EAAE,CAAC;QACR,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACvC,IAAK,KAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACxC,OAAO,EAAE,OAAO,EAAE,KAAgB,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;QAC1E,CAAC;QACD,OAAO;YACL,OAAO,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK;YAC9C,MAAM,EAAE,SAAS;YACjB,YAAY,EAAE,GAAG;SAClB,CAAC;IACJ,CAAC;IACD,OAAO;QACL,OAAO,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK;QAC9C,MAAM,EAAE,SAAS;QACjB,YAAY,EAAE,IAAI;KACnB,CAAC;AACJ,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,YAAY,CAAC,IAA6B,EAAE,MAAqB;IAC/E,OAAO,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC;AACjC,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,29 @@
+import { type CheckResult, type StatusResult } from "./contract.ts";
+/** Binary to run. `carrick` on PATH unless CARRICK_BIN names another. */
+export declare function binary(env?: NodeJS.ProcessEnv): string;
+/** Time limit for one CLI call. The budget for the hook is 300 ms of our own. */
+export declare function timeoutMs(env?: NodeJS.ProcessEnv): number;
+export type RunOutcome<T = CheckResult> = {
+    result: T | null;
+    /** Why there is no result, for the log. Null when there is one. */
+    failure: string | null;
+    ms: number;
+};
+export type RunOptions = {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    /** Injectable for tests; defaults to the real `carrick` binary. */
+    bin?: string;
+};
+/** `carrick check <file> --json`, run from the workspace root. */
+export declare function check(file: string, options: RunOptions): Promise<RunOutcome<CheckResult>>;
+/**
+ * `carrick status --json`: the workspace, with no file in the question.
+ *
+ * `check` and `touch` each take exactly one file, so this is the command a
+ * surface opening a session asks. `--workspace` is passed only when the caller
+ * names one; without it the CLI finds `.carrick/` from the working directory.
+ */
+export declare function status(options: RunOptions & {
+    workspace?: string | null;
+}): Promise<RunOutcome<StatusResult>>;

package/dist/cli.js

@@ -0,0 +1,60 @@
+// Running the `carrick` binary, read-only, with a hard time limit.
+//
+// Both channels go through here. Nothing in this file may throw at its caller:
+// a missing binary, a crash, a timeout and unparseable stdout all read as "no
+// answer", because neither an edit nor a session start may fail on Carrick.
+import { execFile } from "node:child_process";
+import { parseCheckResult, parseStatusResult, } from "./contract.js";
+/** Binary to run. `carrick` on PATH unless CARRICK_BIN names another. */
+export function binary(env = process.env) {
+    return env["CARRICK_BIN"] || "carrick";
+}
+/** Time limit for one CLI call. The budget for the hook is 300 ms of our own. */
+export function timeoutMs(env = process.env) {
+    const raw = env["CARRICK_TIMEOUT_MS"];
+    const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 5000;
+}
+async function run(args, options, parse) {
+    const env = options.env ?? process.env;
+    const bin = options.bin ?? binary(env);
+    const started = Date.now();
+    return await new Promise((resolve) => {
+        execFile(bin, args, {
+            cwd: options.cwd,
+            env,
+            timeout: timeoutMs(env),
+            maxBuffer: 32 * 1024 * 1024,
+            encoding: "utf8",
+        }, (error, stdout) => {
+            const ms = Date.now() - started;
+            const parsed = parse(stdout ?? "");
+            if (parsed) {
+                resolve({ result: parsed, failure: null, ms });
+                return;
+            }
+            const failure = error
+                ? `${bin} ${args.join(" ")} failed: ${error.message}`
+                : `${bin} ${args.join(" ")} printed no payload this reader knows`;
+            resolve({ result: null, failure, ms });
+        });
+    });
+}
+/** `carrick check <file> --json`, run from the workspace root. */
+export async function check(file, options) {
+    return await run(["check", file, "--json"], options, parseCheckResult);
+}
+/**
+ * `carrick status --json`: the workspace, with no file in the question.
+ *
+ * `check` and `touch` each take exactly one file, so this is the command a
+ * surface opening a session asks. `--workspace` is passed only when the caller
+ * names one; without it the CLI finds `.carrick/` from the working directory.
+ */
+export async function status(options) {
+    const args = options.workspace
+        ? ["status", "--workspace", options.workspace, "--json"]
+        : ["status", "--json"];
+    return await run(args, options, parseStatusResult);
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,EAAE;AACF,+EAA+E;AAC/E,8EAA8E;AAC9E,4EAA4E;AAE5E,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EACL,gBAAgB,EAChB,iBAAiB,GAGlB,MAAM,eAAe,CAAC;AAEvB,yEAAyE;AACzE,MAAM,UAAU,MAAM,CAAC,MAAyB,OAAO,CAAC,GAAG;IACzD,OAAO,GAAG,CAAC,aAAa,CAAC,IAAI,SAAS,CAAC;AACzC,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,SAAS,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC5D,MAAM,GAAG,GAAG,GAAG,CAAC,oBAAoB,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;IAC3D,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/D,CAAC;AAgBD,KAAK,UAAU,GAAG,CAChB,IAAc,EACd,OAAmB,EACnB,KAAmC;IAEnC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IACvC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC3B,OAAO,MAAM,IAAI,OAAO,CAAgB,CAAC,OAAO,EAAE,EAAE;QAClD,QAAQ,CACN,GAAG,EACH,IAAI,EACJ;YACE,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,GAAG;YACH,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC;YACvB,SAAS,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;YAC3B,QAAQ,EAAE,MAAM;SACjB,EACD,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAChB,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC;YAChC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;YACnC,IAAI,MAAM,EAAE,CAAC;gBACX,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC/C,OAAO;YACT,CAAC;YACD,MAAM,OAAO,GAAG,KAAK;gBACnB,CAAC,CAAC,GAAG,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,KAAK,CAAC,OAAO,EAAE;gBACrD,CAAC,CAAC,GAAG,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,uCAAuC,CAAC;YACpE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;QACzC,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED,kEAAkE;AAClE,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,IAAY,EAAE,OAAmB;IAC3D,OAAO,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAC1B,OAAmD;IAEnD,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS;QAC5B,CAAC,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC;QACxD,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACzB,OAAO,MAAM,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC;AACrD,CAAC"}