@codeworksh/plugin 0.0.1-canary.10.1.g65d5c167

package/tool-DuYBgiJf.d.mts

@@ -0,0 +1,142 @@
+import { t as ToolExecutionError } from "./error-ClDISWlT.mjs";
+import { Message } from "@codeworksh/aikit";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/tool/progress.d.ts
+/**
+ * `ToolProgress` — the side-channel a long-running tool (e.g. streaming bash)
+ * writes interim output to, instead of an `onUpdate` callback.
+ *
+ * Most tools never call `report` and keep a clean `Effect<Success, Failure>`
+ * signature. Throttling / coalescing lives in the Layer (the live one routes to
+ * the run's event PubSub, tagged with the active callID); the handler just
+ * reports.
+ */
+/** Mirror of aikit's `Message.ToolRunningPartial` (kept structural to stay decoupled). */
+interface ToolProgressPartial {
+  readonly content?: ModelContent;
+  readonly details?: unknown;
+}
+interface IToolProgress {
+  readonly report: (partial: ToolProgressPartial) => Effect.Effect<void>;
+}
+declare const ToolProgress_base: Context.ServiceClass<ToolProgress, "@codeworksh/plugin/tool/progress/ToolProgress", IToolProgress>;
+declare class ToolProgress extends ToolProgress_base {}
+/** Build a `ToolProgress` Layer from a `report` implementation. */
+declare const make$1: (report: IToolProgress["report"]) => Layer.Layer<ToolProgress>;
+/** Drops every update — the default until the executor wires a live event sink. */
+declare const noop: Layer.Layer<ToolProgress>;
+declare namespace tool_d_exports {
+  export { AnyToolDef, AnyToolImpl, Handler, ModelContent, RegisteredTool, ToolCallContext, ToolDef, ToolImpl, define, implement, make, provide, register, toAikitTool, toProviderJsonSchema };
+}
+/**
+ * The tool definition + handler model.
+ *
+ * A tool definition is pure, serializable data: name, description, and Effect
+ * Schema for parameters / success / failure. Execution is a separate `Handler`
+ * — an `Effect` whose capability dependencies (e.g. `ToolShell`) live in its
+ * requirements `R`, provided by a Layer at runtime. Separating the two is the
+ * main testing win: assert on the definition as plain data, and run the handler
+ * against a stub capability Layer.
+ *
+ * Effect Schema is the single source of truth. {@link toAikitTool} derives a
+ * provider-safe JSON Schema object for the aikit wire view; the harness
+ * decode/encodes arguments and results with Effect Schema natively (it does not
+ * use aikit's Typebox validators).
+ */
+/** What the model reads next turn (the `content` side of content/details). */
+type ModelContent = ReadonlyArray<Message.TextContent | Message.ImageContent>;
+/** Per-call metadata handed to a handler instead of positional args. */
+declare const ToolCallContext: Schema.Struct<{
+  readonly callID: Schema.String;
+  readonly toolName: Schema.String;
+  readonly rawArgs: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+type ToolCallContext = typeof ToolCallContext.Type;
+/**
+ * A pure tool definition. Parametrised over the *schema* instances so the
+ * decoded parameter/success/failure types can be recovered via `["Type"]`.
+ */
+interface ToolDef<Name extends string = string, Params extends Schema.Top = Schema.Top, Success extends Schema.Top = Schema.Top, Failure extends Schema.Top = Schema.Top> {
+  readonly name: Name;
+  readonly description: string;
+  /** Human-readable display label (kept from the previous `AgentTool`). */
+  readonly label?: string;
+  /**
+   * A short one-line summary for compact tool listings (e.g. a system-prompt tool index),
+   * distinct from the fuller `description`.
+   */
+  readonly promptSnippet?: string;
+  /** Optional guideline bullets appended to the default system prompt Guidelines section when this tool is active. */
+  readonly promptGuidelines?: ReadonlyArray<string>;
+  readonly parameters: Params;
+  readonly success: Success;
+  /** Declared, model-visible failures (typed). Omit for tools that cannot fail expectedly. */
+  readonly failure?: Failure;
+  /** Render success for the model. Omit → executor falls back to JSON text. */
+  readonly encodeContent?: (success: Success["Type"]) => ModelContent;
+  /** Render an expected failure for the model. Omit → executor falls back to JSON text. */
+  readonly encodeFailureContent?: (failure: Failure["Type"]) => ModelContent;
+}
+/** A handler: validated params + context → typed success or typed failure. */
+type Handler<Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never> = (params: Params["Type"], ctx: ToolCallContext) => Effect.Effect<Success["Type"], Failure["Type"], R>;
+/** A definition paired with its handler (the unit the executor runs). */
+interface ToolImpl<Name extends string = string, Params extends Schema.Top = Schema.Top, Success extends Schema.Top = Schema.Top, Failure extends Schema.Top = Schema.Top, R = never> {
+  readonly definition: ToolDef<Name, Params, Success, Failure>;
+  readonly handler: Handler<Params, Success, Failure, R>;
+}
+type AnyToolDef = ToolDef<string, any, any, any>;
+type AnyToolImpl<R = never> = ToolImpl<string, any, any, any, R>;
+interface DefineInput<Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top> {
+  readonly name: Name;
+  readonly description: string;
+  readonly label?: string;
+  readonly promptSnippet?: string;
+  readonly parameters: Params;
+  readonly success: Success;
+  readonly failure?: Failure;
+  readonly encodeContent?: (success: Success["Type"]) => ModelContent;
+  readonly encodeFailureContent?: (failure: Failure["Type"]) => ModelContent;
+}
+/** Define a pure tool (handler attached later via {@link implement} or a toolkit). */
+declare const define: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top = Schema.Top>(input: DefineInput<Name, Params, Success, Failure>) => ToolDef<Name, Params, Success, Failure>;
+/** Attach a handler to an existing definition (the testable def/exec split). */
+declare const implement: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never>(definition: ToolDef<Name, Params, Success, Failure>, handler: Handler<Params, Success, Failure, R>) => ToolImpl<Name, Params, Success, Failure, R>;
+/** Sugar for the co-located case: a definition with its handler in one object. */
+declare const make: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top = Schema.Top, R = never>(input: DefineInput<Name, Params, Success, Failure> & {
+  readonly handler: Handler<Params, Success, Failure, R>;
+}) => ToolImpl<Name, Params, Success, Failure, R>;
+/**
+ * A tool ready to register: its capability requirements have been discharged, leaving only
+ * the executor-provided {@link ToolProgress}. The registry and executor hold `RegisteredTool`s
+ * and are non-generic (only `handle` is generic, over a progress sink's `RProgress`), so any
+ * number of tools — built-in or
+ * third-party/plugin — compose without a shared capability union
+ */
+interface RegisteredTool {
+  readonly definition: AnyToolDef;
+  readonly handler: (params: unknown, ctx: ToolCallContext) => Effect.Effect<unknown, ToolExecutionError, ToolProgress>;
+}
+/** Register a tool whose only requirement is the executor-provided progress service. */
+declare const register: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top>(impl: ToolImpl<Name, Params, Success, Failure, ToolProgress>) => RegisteredTool;
+/**
+ * Discharge a tool's capability requirements into a {@link RegisteredTool}, erasing its `R`
+ * (the executor still provides `ToolProgress`). This is the registration boundary: a
+ * plugin/third-party tool provides its own fully-resolved capability Layer here, so the
+ * registry never has to unify anyone's `R`.
+ */
+declare const provide: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R>(impl: ToolImpl<Name, Params, Success, Failure, R | ToolProgress>, layer: Layer.Layer<R>) => RegisteredTool;
+/**
+ * Derive a provider-safe JSON Schema object from an Effect Schema. This is the
+ * single boundary that crosses into the provider wire; if a provider rejects a
+ * construct, fix it here. Draft-07 inlines the root (no top-level `$ref`).
+ */
+declare const toProviderJsonSchema: (schema: Schema.Top) => Record<string, unknown>;
+/**
+ * Build the aikit `Message.Tool` wire view from a definition. The derived JSON
+ * Schema object satisfies aikit's `parameters` slot structurally at runtime; the
+ * single localized cast keeps aikit untouched (decision 3-A).
+ */
+declare const toAikitTool: (def: AnyToolDef) => Message.Tool;
+//#endregion
+export { IToolProgress as _, RegisteredTool as a, make$1 as b, ToolImpl as c, make as d, provide as f, tool_d_exports as g, toProviderJsonSchema as h, ModelContent as i, define as l, toAikitTool as m, AnyToolImpl as n, ToolCallContext as o, register as p, Handler as r, ToolDef as s, AnyToolDef as t, implement as u, ToolProgress as v, noop as x, ToolProgressPartial as y };
+//# sourceMappingURL=tool-DuYBgiJf.d.mts.map

package/tool.d.mts

@@ -0,0 +1,2 @@
+import { a as RegisteredTool, c as ToolImpl, d as make, f as provide, h as toProviderJsonSchema, i as ModelContent, l as define, m as toAikitTool, n as AnyToolImpl, o as ToolCallContext, p as register, r as Handler, s as ToolDef, t as AnyToolDef, u as implement } from "./tool-DuYBgiJf.mjs";
+export { AnyToolDef, AnyToolImpl, Handler, ModelContent, RegisteredTool, ToolCallContext, ToolDef, ToolImpl, define, implement, make, provide, register, toAikitTool, toProviderJsonSchema };

package/tool.mjs

@@ -0,0 +1,71 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { ToolExecutionError } from "./tool/error.mjs";
+import { Effect, Schema } from "effect";
+//#region src/tool.ts
+var tool_exports = /* @__PURE__ */ __exportAll({
+	ToolCallContext: () => ToolCallContext,
+	define: () => define,
+	implement: () => implement,
+	make: () => make,
+	provide: () => provide,
+	register: () => register,
+	toAikitTool: () => toAikitTool,
+	toProviderJsonSchema: () => toProviderJsonSchema
+});
+/** Per-call metadata handed to a handler instead of positional args. */
+const ToolCallContext = Schema.Struct({
+	callID: Schema.String,
+	toolName: Schema.String,
+	rawArgs: Schema.Record(Schema.String, Schema.Unknown)
+});
+/** Define a pure tool (handler attached later via {@link implement} or a toolkit). */
+const define = (input) => ({ ...input });
+/** Attach a handler to an existing definition (the testable def/exec split). */
+const implement = (definition, handler) => ({
+	definition,
+	handler
+});
+/** Sugar for the co-located case: a definition with its handler in one object. */
+const make = (input) => {
+	const { handler, ...rest } = input;
+	return {
+		definition: define(rest),
+		handler
+	};
+};
+const toRegistered = (definition, handler) => ({
+	definition,
+	handler: (params, ctx) => handler(params, ctx).pipe(Effect.mapError((cause) => new ToolExecutionError({
+		toolName: definition.name,
+		cause
+	})))
+});
+/** Register a tool whose only requirement is the executor-provided progress service. */
+const register = (impl) => toRegistered(impl.definition, impl.handler);
+/**
+* Discharge a tool's capability requirements into a {@link RegisteredTool}, erasing its `R`
+* (the executor still provides `ToolProgress`). This is the registration boundary: a
+* plugin/third-party tool provides its own fully-resolved capability Layer here, so the
+* registry never has to unify anyone's `R`.
+*/
+const provide = (impl, layer) => toRegistered(impl.definition, ((params, ctx) => impl.handler(params, ctx).pipe(Effect.provide(layer))));
+/**
+* Derive a provider-safe JSON Schema object from an Effect Schema. This is the
+* single boundary that crosses into the provider wire; if a provider rejects a
+* construct, fix it here. Draft-07 inlines the root (no top-level `$ref`).
+*/
+const toProviderJsonSchema = (schema) => Schema.toStandardJSONSchemaV1(schema)["~standard"].jsonSchema.input({ target: "draft-07" });
+/**
+* Build the aikit `Message.Tool` wire view from a definition. The derived JSON
+* Schema object satisfies aikit's `parameters` slot structurally at runtime; the
+* single localized cast keeps aikit untouched (decision 3-A).
+*/
+const toAikitTool = (def) => ({
+	name: def.name,
+	description: def.description,
+	parameters: toProviderJsonSchema(def.parameters)
+});
+//#endregion
+export { ToolCallContext, define, implement, make, provide, register, tool_exports as t, toAikitTool, toProviderJsonSchema };
+
+//# sourceMappingURL=tool.mjs.map

package/tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.mjs","names":[],"sources":["../../src/tool.ts"],"sourcesContent":["import type { Message } from \"@codeworksh/aikit\";\nimport { Effect, type Layer, Schema } from \"effect\";\nimport type { TSchema } from \"typebox\";\nimport { ToolExecutionError } from \"./tool/error.ts\";\nimport type { ToolProgress } from \"./tool/progress.ts\";\n\n/**\n * The tool definition + handler model.\n *\n * A tool definition is pure, serializable data: name, description, and Effect\n * Schema for parameters / success / failure. Execution is a separate `Handler`\n * — an `Effect` whose capability dependencies (e.g. `ToolShell`) live in its\n * requirements `R`, provided by a Layer at runtime. Separating the two is the\n * main testing win: assert on the definition as plain data, and run the handler\n * against a stub capability Layer.\n *\n * Effect Schema is the single source of truth. {@link toAikitTool} derives a\n * provider-safe JSON Schema object for the aikit wire view; the harness\n * decode/encodes arguments and results with Effect Schema natively (it does not\n * use aikit's Typebox validators).\n */\n\n/** What the model reads next turn (the `content` side of content/details). */\nexport type ModelContent = ReadonlyArray<Message.TextContent | Message.ImageContent>;\n\n/** Per-call metadata handed to a handler instead of positional args. */\nexport const ToolCallContext = Schema.Struct({\n\tcallID: Schema.String,\n\ttoolName: Schema.String,\n\trawArgs: Schema.Record(Schema.String, Schema.Unknown),\n});\nexport type ToolCallContext = typeof ToolCallContext.Type;\n\n/**\n * A pure tool definition. Parametrised over the *schema* instances so the\n * decoded parameter/success/failure types can be recovered via `[\"Type\"]`.\n */\nexport interface ToolDef<\n\tName extends string = string,\n\tParams extends Schema.Top = Schema.Top,\n\tSuccess extends Schema.Top = Schema.Top,\n\tFailure extends Schema.Top = Schema.Top,\n> {\n\treadonly name: Name;\n\treadonly description: string;\n\t/** Human-readable display label (kept from the previous `AgentTool`). */\n\treadonly label?: string;\n\t/**\n\t * A short one-line summary for compact tool listings (e.g. a system-prompt tool index),\n\t * distinct from the fuller `description`.\n\t */\n\treadonly promptSnippet?: string;\n\t/** Optional guideline bullets appended to the default system prompt Guidelines section when this tool is active. */\n\treadonly promptGuidelines?: ReadonlyArray<string>;\n\treadonly parameters: Params;\n\treadonly success: Success;\n\t/** Declared, model-visible failures (typed). Omit for tools that cannot fail expectedly. */\n\treadonly failure?: Failure;\n\t/** Render success for the model. Omit → executor falls back to JSON text. */\n\treadonly encodeContent?: (success: Success[\"Type\"]) => ModelContent;\n\t/** Render an expected failure for the model. Omit → executor falls back to JSON text. */\n\treadonly encodeFailureContent?: (failure: Failure[\"Type\"]) => ModelContent;\n}\n\n/** A handler: validated params + context → typed success or typed failure. */\nexport type Handler<Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never> = (\n\tparams: Params[\"Type\"],\n\tctx: ToolCallContext,\n) => Effect.Effect<Success[\"Type\"], Failure[\"Type\"], R>;\n\n/** A definition paired with its handler (the unit the executor runs). */\nexport interface ToolImpl<\n\tName extends string = string,\n\tParams extends Schema.Top = Schema.Top,\n\tSuccess extends Schema.Top = Schema.Top,\n\tFailure extends Schema.Top = Schema.Top,\n\tR = never,\n> {\n\treadonly definition: ToolDef<Name, Params, Success, Failure>;\n\treadonly handler: Handler<Params, Success, Failure, R>;\n}\n\n// Heterogeneous-collection aliases. `any` for the schema generics keeps handlers\n// of differing parameter types assignable into one array (the precise generics\n// live on the authoring helpers below).\n// biome-ignore lint/suspicious/noExplicitAny: erased schema generics for storage\nexport type AnyToolDef = ToolDef<string, any, any, any>;\n// biome-ignore lint/suspicious/noExplicitAny: erased schema generics for storage\nexport type AnyToolImpl<R = never> = ToolImpl<string, any, any, any, R>;\n\ninterface DefineInput<\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top,\n> {\n\treadonly name: Name;\n\treadonly description: string;\n\treadonly label?: string;\n\treadonly promptSnippet?: string;\n\treadonly parameters: Params;\n\treadonly success: Success;\n\treadonly failure?: Failure;\n\treadonly encodeContent?: (success: Success[\"Type\"]) => ModelContent;\n\treadonly encodeFailureContent?: (failure: Failure[\"Type\"]) => ModelContent;\n}\n\n/** Define a pure tool (handler attached later via {@link implement} or a toolkit). */\nexport const define = <\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top = Schema.Top,\n>(\n\tinput: DefineInput<Name, Params, Success, Failure>,\n): ToolDef<Name, Params, Success, Failure> => ({\n\t...input,\n});\n\n/** Attach a handler to an existing definition (the testable def/exec split). */\nexport const implement = <\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top,\n\tR = never,\n>(\n\tdefinition: ToolDef<Name, Params, Success, Failure>,\n\thandler: Handler<Params, Success, Failure, R>,\n): ToolImpl<Name, Params, Success, Failure, R> => ({ definition, handler });\n\n/** Sugar for the co-located case: a definition with its handler in one object. */\nexport const make = <\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top = Schema.Top,\n\tR = never,\n>(\n\tinput: DefineInput<Name, Params, Success, Failure> & {\n\t\treadonly handler: Handler<Params, Success, Failure, R>;\n\t},\n): ToolImpl<Name, Params, Success, Failure, R> => {\n\tconst { handler, ...rest } = input;\n\treturn { definition: define(rest), handler };\n};\n\n/**\n * A tool ready to register: its capability requirements have been discharged, leaving only\n * the executor-provided {@link ToolProgress}. The registry and executor hold `RegisteredTool`s\n * and are non-generic (only `handle` is generic, over a progress sink's `RProgress`), so any\n * number of tools — built-in or\n * third-party/plugin — compose without a shared capability union\n */\nexport interface RegisteredTool {\n\treadonly definition: AnyToolDef;\n\treadonly handler: (\n\t\tparams: unknown,\n\t\tctx: ToolCallContext,\n\t) => Effect.Effect<unknown, ToolExecutionError, ToolProgress>;\n}\n\nconst toRegistered = <\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top,\n>(\n\tdefinition: ToolDef<Name, Params, Success, Failure>,\n\thandler: Handler<Params, Success, Failure, ToolProgress>,\n): RegisteredTool => ({\n\tdefinition,\n\t// The executor decodes with `definition.parameters` before invoking this\n\t// erased handler, so restoring the authored parameter type is safe here.\n\thandler: (params, ctx) =>\n\t\thandler(params as Params[\"Type\"], ctx).pipe(\n\t\t\tEffect.mapError((cause) => new ToolExecutionError({ toolName: definition.name, cause })),\n\t\t),\n});\n\n/** Register a tool whose only requirement is the executor-provided progress service. */\nexport const register = <\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top,\n>(\n\timpl: ToolImpl<Name, Params, Success, Failure, ToolProgress>,\n): RegisteredTool => toRegistered(impl.definition, impl.handler);\n\n/**\n * Discharge a tool's capability requirements into a {@link RegisteredTool}, erasing its `R`\n * (the executor still provides `ToolProgress`). This is the registration boundary: a\n * plugin/third-party tool provides its own fully-resolved capability Layer here, so the\n * registry never has to unify anyone's `R`.\n */\nexport const provide = <\n\tName extends string,\n\tParams extends Schema.Top,\n\tSuccess extends Schema.Top,\n\tFailure extends Schema.Top,\n\tR,\n>(\n\timpl: ToolImpl<Name, Params, Success, Failure, R | ToolProgress>,\n\tlayer: Layer.Layer<R>,\n): RegisteredTool =>\n\t// `Effect.provide` discharges `R`, leaving `ToolProgress`. TS can't simplify\n\t// `Exclude<ToolProgress, R>` for a generic `R`, so localize the cast before\n\t// crossing the registered-tool boundary.\n\ttoRegistered(impl.definition, ((params, ctx) => impl.handler(params, ctx).pipe(Effect.provide(layer))) as Handler<\n\t\tParams,\n\t\tSuccess,\n\t\tFailure,\n\t\tToolProgress\n\t>);\n\n/**\n * Derive a provider-safe JSON Schema object from an Effect Schema. This is the\n * single boundary that crosses into the provider wire; if a provider rejects a\n * construct, fix it here. Draft-07 inlines the root (no top-level `$ref`).\n */\nexport const toProviderJsonSchema = (schema: Schema.Top): Record<string, unknown> =>\n\tSchema.toStandardJSONSchemaV1(schema)[\"~standard\"].jsonSchema.input({ target: \"draft-07\" });\n\n/**\n * Build the aikit `Message.Tool` wire view from a definition. The derived JSON\n * Schema object satisfies aikit's `parameters` slot structurally at runtime; the\n * single localized cast keeps aikit untouched (decision 3-A).\n */\nexport const toAikitTool = (def: AnyToolDef): Message.Tool => ({\n\tname: def.name,\n\tdescription: def.description,\n\tparameters: toProviderJsonSchema(def.parameters) as unknown as TSchema,\n});\n"],"mappings":";;;;;;;;;;;;;;;AA0BA,MAAa,kBAAkB,OAAO,OAAO;CAC5C,QAAQ,OAAO;CACf,UAAU,OAAO;CACjB,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO;AACrD,CAAC;;AA8ED,MAAa,UAMZ,WAC8C,EAC9C,GAAG,MACJ;;AAGA,MAAa,aAOZ,YACA,aACkD;CAAE;CAAY;AAAQ;;AAGzE,MAAa,QAOZ,UAGiD;CACjD,MAAM,EAAE,SAAS,GAAG,SAAS;CAC7B,OAAO;EAAE,YAAY,OAAO,IAAI;EAAG;CAAQ;AAC5C;AAiBA,MAAM,gBAML,YACA,aACqB;CACrB;CAGA,UAAU,QAAQ,QACjB,QAAQ,QAA0B,GAAG,CAAC,CAAC,KACtC,OAAO,UAAU,UAAU,IAAI,mBAAmB;EAAE,UAAU,WAAW;EAAM;CAAM,CAAC,CAAC,CACxF;AACF;;AAGA,MAAa,YAMZ,SACoB,aAAa,KAAK,YAAY,KAAK,OAAO;;;;;;;AAQ/D,MAAa,WAOZ,MACA,UAKA,aAAa,KAAK,cAAc,QAAQ,QAAQ,KAAK,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,QAAQ,KAAK,CAAC,EAKnG;;;;;;AAOF,MAAa,wBAAwB,WACpC,OAAO,uBAAuB,MAAM,CAAC,CAAC,YAAY,CAAC,WAAW,MAAM,EAAE,QAAQ,WAAW,CAAC;;;;;;AAO3F,MAAa,eAAe,SAAmC;CAC9D,MAAM,IAAI;CACV,aAAa,IAAI;CACjB,YAAY,qBAAqB,IAAI,UAAU;AAChD"}