@weaveio/weave-adapter-opencode 0.0.0-preview-20260708084849

package/README.md

@@ -0,0 +1,83 @@
+# @weaveio/weave-adapter-opencode
+
+OpenCode adapter for Weave.
+
+## Plugin entrypoint
+
+When loading this adapter as an OpenCode plugin, use the plugin bundle entrypoint:
+
+```json
+{
+  "plugin": [
+    "@weaveio/weave-adapter-opencode/plugin"
+  ]
+}
+```
+
+For a direct file URL during local development, point OpenCode at `dist/plugin.js`, not `dist/index.js`:
+
+```json
+{
+  "plugin": [
+    "file:///abs/path/to/packages/adapters/opencode/dist/plugin.js"
+  ]
+}
+```
+
+Rebuild the package before using a `dist/` file path so the plugin bundle matches the current source:
+
+```bash
+bun run --filter @weaveio/weave-adapter-opencode build
+```
+
+Do **not** use the bare package entry (`@weaveio/weave-adapter-opencode`) or `dist/index.js` as a plugin target. The bare entry is the programmatic barrel and exports non-plugin values in addition to the plugin function, which is incompatible with OpenCode's legacy plugin loader.
+
+## Isolated OpenCode validation
+
+OpenCode merges global config, project config, explicit config, and plugin directories. `OPENCODE_CONFIG` and `OPENCODE_CONFIG_CONTENT` add config; they do not replace every other source by themselves.
+
+To validate this adapter in isolation:
+
+```bash
+TMP_HOME="$(mktemp -d)"
+TMP_XDG="$(mktemp -d)"
+
+HOME="$TMP_HOME" \
+XDG_CONFIG_HOME="$TMP_XDG" \
+OPENCODE_DISABLE_PROJECT_CONFIG=1 \
+OPENCODE_CONFIG_CONTENT='{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "file:///abs/path/to/packages/adapters/opencode/dist/plugin.js"
+  ]
+}' \
+opencode debug config
+```
+
+Use the same environment with `opencode debug info` to verify that the plugin executes, not just that it appears in merged config.
+
+## Expected behavior
+
+- `opencode debug config` should show the Weave-materialized `agent` map injected by the plugin's `config` hook.
+- `opencode debug info` should show the plugin loading and executing.
+- The resulting OpenCode `agent` entries should reflect the resolved Weave DSL for the loaded `.weave/config.weave` plus builtin Weave agent defaults.
+
+## Logging
+
+When the plugin runs inside OpenCode, Weave logs are written to a file automatically instead of stdout. Writing structured JSON logs to stdout would surface raw log lines in the OpenCode UI, which is confusing for users.
+
+**Default log path**: `.weave/weave.log` under the project directory (the same directory OpenCode passes as `input.directory`).
+
+**Override**: set `WEAVE_LOG_FILE=/absolute/path/to/weave.log` in the environment to write logs to a custom path instead.
+
+```bash
+# Use the default path (.weave/weave.log in the project root)
+opencode
+
+# Override with a custom path
+WEAVE_LOG_FILE=/tmp/weave-debug.log opencode
+```
+
+The log file is created automatically when the plugin starts. Parent directories are created if they do not exist. Logs are written synchronously (one write per log line) to ensure lines are visible immediately even if the process is killed.
+
+**Non-plugin usage**: when `@weaveio/weave-engine` is used outside the OpenCode plugin path (e.g. in tests or other adapters), logs go to stdout by default unless `WEAVE_LOG_FILE` is set.

package/dist/adapter.d.ts

@@ -0,0 +1,218 @@
+/**
+ * OpenCode harness adapter implementation.
+ *
+ * This module contains the `OpenCodeAdapter` class and its constructor options.
+ * It is extracted from `index.ts` to allow `plugin.ts` to import the adapter
+ * without creating a circular dependency through the barrel.
+ *
+ * Boundary rule: this module imports SDK types only through `./sdk-types`.
+ * It must not import directly from `@opencode-ai/sdk`.
+ */
+import type { AgentDescriptor, HarnessAdapter, PlanStateProvider, SkillInfo } from "@weaveio/weave-engine";
+import { type ResultAsync } from "neverthrow";
+import { type OpenCodeModelContext } from "./model-resolution.js";
+import type { OpenCodeClientFacade } from "./opencode-client.js";
+import type { OpenCodeAgentConfig } from "./sdk-types.js";
+type OpenCodeAdapterErrorType = "ModelResolutionError" | "TranslateAgentError" | "ReconcileAgentError";
+export declare class OpenCodeAdapterError extends Error {
+    readonly type: OpenCodeAdapterErrorType;
+    readonly agentName: string;
+    readonly cause: unknown;
+    constructor(input: {
+        type: OpenCodeAdapterErrorType;
+        agentName: string;
+        message: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Constructor options for `OpenCodeAdapter`.
+ */
+export interface OpenCodeAdapterOptions {
+    /**
+     * Absolute path to the project root directory.
+     *
+     * Used to construct the `BunFilesystemPlanStateProvider` so that plan files
+     * are resolved relative to the correct project root. Defaults to
+     * `Bun.env.PWD ?? "."` when omitted.
+     */
+    readonly projectRoot?: string;
+    /**
+     * Injected OpenCode client facade.
+     *
+     * Callers (e.g. an OpenCode plugin entry point) provide a pre-constructed
+     * `OpenCodeClientFacade` that wraps the SDK client available in the
+     * plugin/runtime context. When omitted, the adapter operates in
+     * translation-only mode (no live SDK calls).
+     *
+     * Dependency injection through this option is the primary adapter entry
+     * path. No global SDK client state is created or mutated by the adapter.
+     *
+     * @example
+     * ```ts
+     * import { createOpencodeClient } from "@opencode-ai/sdk";
+     * import { OpenCodeAdapter, SdkOpenCodeClient } from "@weaveio/weave-adapter-opencode";
+     *
+     * const sdkClient = createOpencodeClient({ directory: projectDir });
+     * const adapter = new OpenCodeAdapter({
+     *   projectRoot: projectDir,
+     *   client: new SdkOpenCodeClient(sdkClient),
+     * });
+     * ```
+     */
+    readonly client?: OpenCodeClientFacade;
+    /**
+     * OpenCode model context for model resolution.
+     *
+     * When provided, `spawnSubagent()` calls `resolveModelForAgent()` with this
+     * context to validate model intent before materializing each agent.
+     *
+     * When omitted, model resolution falls back to the engine's constant
+     * fallback model (`DEFAULT_FALLBACK_MODEL`).
+     */
+    readonly modelContext?: OpenCodeModelContext;
+    /**
+     * Harness-provided skill list for `loadAvailableSkills()`.
+     *
+     * The OpenCode harness (SDK/runtime) is responsible for discovering which
+     * skills are available. Callers inject the harness-provided skill list here
+     * so the adapter can forward it to the engine without performing any
+     * filesystem scanning.
+     *
+     * When omitted, `loadAvailableSkills()` returns an empty list. The engine
+     * will then emit `MissingSkill` errors for any declared skills that cannot
+     * be resolved — this is the correct hard-error behavior.
+     *
+     * @example
+     * ```ts
+     * // In an OpenCode plugin entry point, the SDK provides available skills:
+     * const harnessSkills = sdk.listAvailableSkills(); // harness-owned discovery
+     * const adapter = new OpenCodeAdapter({
+     *   availableSkills: harnessSkills.map(s => ({ name: s.name, metadata: s })),
+     * });
+     * ```
+     */
+    readonly availableSkills?: SkillInfo[];
+}
+/**
+ * OpenCode harness adapter.
+ *
+ * Implements the `HarnessAdapter` interface to materialise Weave agent
+ * descriptors into a running OpenCode instance via the OpenCode SDK client.
+ *
+ * When an `OpenCodeClientFacade` is injected, `spawnSubagent()` performs
+ * real SDK-backed materialization using the `list → reconcile → create/update`
+ * flow in `reconcile-agent.ts`. Without a client the adapter falls back to
+ * translation-only mode (no SDK calls are made).
+ *
+ * `translatedAgents` is retained as a read-only snapshot of the last
+ * translated config for each agent. It is populated regardless of whether SDK
+ * materialization succeeds, and is available for test inspection and
+ * transitional compatibility. It is NOT the primary materialization path.
+ *
+ * A `BunFilesystemPlanStateProvider` is constructed during `init()` and stored
+ * as `this.planStateProvider`. Pass it to any `completeStep` call that uses a
+ * `plan_created` or `plan_complete` completion method.
+ */
+export declare class OpenCodeAdapter implements HarnessAdapter {
+    /**
+     * Read-only snapshot of the last translated OpenCode agent config for each
+     * agent, keyed by agent name.
+     *
+     * Populated by `spawnSubagent()` after successful translation, regardless of
+     * whether SDK materialization is attempted. Useful for test inspection and
+     * transitional compatibility.
+     *
+     * The primary materialization path is the SDK-backed `reconcileAgent()` call
+     * inside `spawnSubagent()`. This map is a secondary artifact, not the source
+     * of truth for what is actually registered in OpenCode.
+     */
+    readonly translatedAgents: Map<string, OpenCodeAgentConfig>;
+    /**
+     * Provider for querying plan file state.
+     *
+     * Constructed during `init()` using `projectRoot`. Pass to `completeStep`
+     * calls that use `plan_created` or `plan_complete` completion methods.
+     *
+     * `undefined` before `init()` is called.
+     */
+    planStateProvider: PlanStateProvider | undefined;
+    /** Absolute path to the project root. Defaults to `Bun.env.PWD ?? "."`. */
+    private readonly projectRoot;
+    /**
+     * Injected OpenCode client facade.
+     *
+     * Provided by the caller at construction time. `undefined` when the adapter
+     * is constructed without a client (translation-only mode). No global SDK
+     * state is created or mutated by the adapter.
+     */
+    private readonly openCodeClient;
+    /**
+     * OpenCode model context for model resolution.
+     *
+     * Provided by the caller at construction time. When `undefined`, model
+     * resolution falls back to the engine's constant fallback model.
+     */
+    private readonly modelContext;
+    /**
+     * Harness-provided skill list.
+     *
+     * Injected at construction time by the caller (e.g. an OpenCode plugin entry
+     * point that received the skill list from the harness SDK). The adapter
+     * forwards this list to the engine via `loadAvailableSkills()` without
+     * performing any filesystem scanning.
+     *
+     * `undefined` when no skills were injected (adapter returns empty list).
+     */
+    private readonly harnessSkills;
+    constructor(options?: OpenCodeAdapterOptions);
+    /**
+     * Perform one-time initialisation required before any agent can be
+     * materialised. Called exactly once by the bootstrap entry point.
+     *
+     * Constructs a `BunFilesystemPlanStateProvider` rooted at `this.projectRoot`
+     * and stores it as `this.planStateProvider` for use in lifecycle calls.
+     */
+    init(): Promise<void>;
+    /**
+     * Return the list of skills available in the current OpenCode instance.
+     *
+     * Forwards the harness-provided skill list injected at construction time via
+     * `OpenCodeAdapterOptions.availableSkills`. The OpenCode harness (SDK/runtime)
+     * is responsible for discovering which skills exist; the adapter's role is to
+     * receive that list and forward it to the engine for skill resolution.
+     *
+     * When no skills were injected, returns an empty list. The engine will then
+     * emit `MissingSkill` errors for any declared skills that cannot be resolved —
+     * this is the correct hard-error behavior (no silent skips).
+     *
+     * Boundary rule: this method must not scan the filesystem, query harness
+     * directories, or perform any harness-owned discovery. All discovery is
+     * delegated to the harness and injected via the constructor.
+     */
+    loadAvailableSkills(): Promise<SkillInfo[]>;
+    /**
+     * Materialise a sub-agent from the provided normalized descriptor.
+     *
+     * ## Flow
+     *
+     * 1. Resolve the model for this agent using `resolveModelForAgent()` with
+     *    the adapter-provided OpenCode model context. Returns `err` on model
+     *    resolution failure (e.g. unsupported explicit subagent model).
+     * 2. Translate the descriptor into an OpenCode `AgentConfig` via
+     *    `translateAgent`, passing the resolved model. Returns `err` on failure.
+     * 3. Store the translated config in `translatedAgents` for test inspection
+     *    and transitional compatibility.
+     * 4. When an `OpenCodeClientFacade` is available, call `reconcileAgent()` to
+     *    perform the SDK-backed `list → reconcile → create/update` flow.
+     *    Returns `err` on reconciliation failure (including collision errors).
+     * 5. When no client is available, log a warning and return `ok(undefined)`
+     *    (translation-only mode — no SDK calls are made).
+     *
+     * @param descriptor - Full normalized agent descriptor to materialise.
+     * @returns `ok(undefined)` on success, `err(OpenCodeAdapterError)` on failure.
+     */
+    spawnSubagent(descriptor: AgentDescriptor): ResultAsync<void, OpenCodeAdapterError>;
+}
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,SAAS,EACV,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAK1D,KAAK,wBAAwB,GACzB,sBAAsB,GACtB,qBAAqB,GACrB,qBAAqB,CAAC;AAE1B,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;gBAEZ,KAAK,EAAE;QACjB,IAAI,EAAE,wBAAwB,CAAC;QAC/B,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAOF;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAEvC;;;;;;;;OAQG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;IAE7C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,EAAE,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAgB,YAAW,cAAc;IACpD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAa;IAExE;;;;;;;OAOG;IACH,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,CAAa;IAE7D,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmC;IAElE;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;IAEpD;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0B;gBAE5C,OAAO,GAAE,sBAA2B;IAOhD;;;;;;OAMG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAa3B;;;;;;;;;;;;;;;OAeG;IACG,mBAAmB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IASjD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CACX,UAAU,EAAE,eAAe,GAC1B,WAAW,CAAC,IAAI,EAAE,oBAAoB,CAAC;CAiG3C"}

package/dist/command-templates.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Command templates for OpenCode slash commands.
+ *
+ * These templates are injected into the conversation when the user types
+ * `/start-work` or `/weave:start` in the OpenCode TUI. They instruct the
+ * Tapestry agent to execute a Weave plan.
+ *
+ * ## How OpenCode commands work
+ *
+ * OpenCode commands are prompt-based — when a user types `/start-work my-plan`,
+ * OpenCode replaces `$ARGUMENTS` with `my-plan` and sends the template as a
+ * user message to the configured agent. This is NOT programmatic execution;
+ * it's prompt injection that instructs the agent to act.
+ *
+ * ## Placeholders
+ *
+ * - `$ARGUMENTS` — the text after the command name (e.g. plan name)
+ * - `$SESSION_ID` — OpenCode session identifier
+ * - `$TIMESTAMP` — ISO-8601 timestamp of command invocation
+ *
+ * @see https://opencode.ai/docs/commands/ — OpenCode commands documentation
+ * @see docs/adapter-bootstrap.md — Command Surface Registration section
+ */
+/**
+ * Template for the `/start-work` slash command (legacy name).
+ *
+ * Registered as `cfg.command["start-work"]` in the plugin config hook.
+ * When invoked, OpenCode sends this template to the Tapestry agent.
+ */
+export declare const START_WORK_COMMAND_TEMPLATE: string;
+/**
+ * Template for the `/weave:start` slash command (preferred name).
+ *
+ * Registered as `cfg.command["weave:start"]` in the plugin config hook.
+ * When invoked, OpenCode sends this template to the Tapestry agent.
+ */
+export declare const WEAVE_START_COMMAND_TEMPLATE: string;
+//# sourceMappingURL=command-templates.d.ts.map

package/dist/command-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-templates.d.ts","sourceRoot":"","sources":["../src/command-templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAkFH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,QAKA,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,QAKD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @weaveio/weave-adapter-opencode
+ *
+ * OpenCode harness adapter and plugin entry point for the Weave orchestration
+ * framework.
+ *
+ * This package serves two roles:
+ *
+ * 1. **OpenCode plugin** — When listed in `opencode.json`'s `plugin` array,
+ *    OpenCode loads this package at startup and calls the default-exported
+ *    `WeavePlugin` function. The plugin materializes all agents declared in
+ *    `.weave/config.weave` into the running OpenCode instance.
+ *
+ * 2. **Harness adapter library** — `OpenCodeAdapter` implements the
+ *    `HarnessAdapter` interface and can be used programmatically by any caller
+ *    that wants to materialize Weave agents into OpenCode.
+ *
+ * ## Installation as an OpenCode plugin
+ *
+ * Use the `./plugin` subpath export — **not** the bare package name:
+ *
+ * ```jsonc
+ * // opencode.json
+ * {
+ *   "plugin": ["@weaveio/weave-adapter-opencode/plugin"]
+ * }
+ * ```
+ *
+ * The bare `@weaveio/weave-adapter-opencode` entry (`dist/index.js`, this file) exports
+ * non-function values (constants, type re-exports) that cause OpenCode's
+ * `getLegacyPlugins` loader to throw `TypeError: Plugin export is not a function`.
+ * Use `@weaveio/weave-adapter-opencode/plugin` (`dist/plugin.js`) as the OpenCode plugin
+ * entry point. This barrel is for programmatic use only.
+ *
+ * Restart OpenCode after adding the plugin. The plugin entry point receives
+ * the runtime context, constructs an `OpenCodeAdapter` with the injected SDK
+ * client, and materializes all agents declared in `.weave/config.weave`.
+ *
+ * ## Boundary rule
+ *
+ * This package is the only consumer of `@opencode-ai/sdk` and
+ * `@opencode-ai/plugin`. All SDK type imports flow through `./sdk-types` —
+ * never directly from the SDK package. Plugin types are confined to
+ * `./plugin.ts`.
+ */
+export type { OpenCodeAdapterOptions } from "./adapter.js";
+export { OpenCodeAdapter, OpenCodeAdapterError } from "./adapter.js";
+export type { ModelResolutionError, OpenCodeModelContext, } from "./model-resolution.js";
+export { resolveModelForAgent } from "./model-resolution.js";
+export type { OpenCodeClientError, OpenCodeClientFacade, } from "./opencode-client.js";
+export { SdkOpenCodeClient } from "./opencode-client.js";
+export type { ReconcileAgentError, ReconcileDecision, } from "./reconcile-agent.js";
+export { classifyExistingAgent, reconcileAgent, tagWithOwnership, WEAVE_OWNERSHIP_TAG, } from "./reconcile-agent.js";
+export type { RunWorkflowError, RunWorkflowInput, RunWorkflowResult, } from "./run-workflow.js";
+export { runWorkflow } from "./run-workflow.js";
+export type { StartPlanExecutionError, StartPlanExecutionInput, } from "./start-plan-execution.js";
+export { DEFAULT_EXECUTION_WORKFLOW, startPlanExecution, WEAVE_START_COMMAND, WEAVE_START_LEGACY_COMMAND, } from "./start-plan-execution.js";
+export type { AbortExecutionProjectionInput, AdvanceStepProjectionInput, InspectStatusProjectionInput, ProjectionDegraded, ProjectionFailure, ProjectionResult, ProjectionSuccess, RuntimeHealthProjectionInput, RunWorkflowProjectionInput, StartPlanProjectionInput, } from "./runtime-command-projection.js";
+export { buildOpenCodeHealthReport, createDefaultStore, DEGRADED_AFFORDANCES, RuntimeCommandProjection, WEAVE_COMMAND_LABELS, } from "./runtime-command-projection.js";
+export { START_WORK_COMMAND_TEMPLATE, WEAVE_START_COMMAND_TEMPLATE, } from "./command-templates.js";
+export { buildSkillInfoList, validateDeclaredSkills, } from "./skill-discovery.js";
+export type { Plugin, PluginInput, PluginModule } from "@opencode-ai/plugin";
+export type { WeavePluginOptions } from "./plugin.js";
+/**
+ * Default log file path relative to the project directory.
+ *
+ * When the OpenCode plugin runs without an explicit `WEAVE_LOG_FILE` env var,
+ * Weave logs are written to this path under the project root. The `.weave/`
+ * directory is already the conventional home for Weave project state, so
+ * placing the log file there keeps everything in one place.
+ *
+ * Example: `/path/to/project/.weave/weave.log`
+ *
+ * Defined here (not re-exported from `plugin.ts`) because the plugin entry
+ * point must export only functions to satisfy OpenCode's `getLegacyPlugins`
+ * loader. This constant is safe to export from the barrel.
+ */
+export declare const DEFAULT_PLUGIN_LOG_SUBPATH = ".weave/weave.log";
+/**
+ * Default export: the OpenCode `Plugin` function.
+ *
+ * OpenCode loads this as the plugin entry point when `@weaveio/weave-adapter-opencode`
+ * is listed in `opencode.json`'s `plugin` array.
+ */
+export { createWeavePlugin, server as WeavePluginServer, WeavePlugin, WeavePlugin as default, } from "./plugin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAMH,YAAY,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAMrE,YAAY,EACV,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAM7D,YAAY,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAMzD,YAAY,EACV,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAM9B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMhD,YAAY,EACV,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,0BAA0B,EAC1B,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAMnC,YAAY,EACV,6BAA6B,EAC7B,0BAA0B,EAC1B,4BAA4B,EAC5B,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,4BAA4B,EAC5B,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AAMzC,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,wBAAwB,CAAC;AAMhC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAM9B,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B,qBAAqB,CAAC;AAE7D;;;;;GAKG;AACH,OAAO,EACL,iBAAiB,EACjB,MAAM,IAAI,iBAAiB,EAC3B,WAAW,EACX,WAAW,IAAI,OAAO,GACvB,MAAM,aAAa,CAAC"}