@copilotkit/channels-core 0.5.0 → 0.5.1-canary.1785633429

package/dist/channel-identity.test.js

@@ -0,0 +1,297 @@
+import { expect, test, vi } from "vitest";
+import { createChannel } from "./create-channel.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+import { FakeAgent } from "./testing/fake-agent.js";
+test("a Channel rejects construction without an explicit identity strategy", () => {
+    expect(() => createChannel({ adapters: [new FakeAdapter()] })).toThrow('createChannel: `identifyUser` must be "platform" or a callback');
+});
+test("a custom Channel identity callback maps the provider actor once before the message handler", async () => {
+    const identifyUser = vi.fn(() => ({ id: "person-1", name: "Pat Lee" }));
+    const adapter = new FakeAdapter({ platform: "intelligence" });
+    const channel = createChannel({
+        adapters: [adapter],
+        identifyUser,
+    });
+    let received;
+    channel.onMessage(({ message }) => {
+        received = message;
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onTurn({
+        conversationKey: "conversation-1",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+        actor: {
+            id: "U123",
+            kind: "human",
+            name: "Pat on Slack",
+            handle: "pat",
+        },
+        identityContext: {
+            tenant: { id: "T123", name: "Acme" },
+            installation: { id: "I123" },
+            conversation: { id: "C123", kind: "channel" },
+            trigger: "message",
+            event: { id: "E123", occurredAt: "2026-07-31T12:00:00.000Z" },
+            raw: { type: "app_mention" },
+        },
+    });
+    expect(identifyUser).toHaveBeenCalledTimes(1);
+    expect(identifyUser).toHaveBeenCalledWith({
+        provider: "slack",
+        tenant: { id: "T123", name: "Acme" },
+        installation: { id: "I123" },
+        actor: {
+            id: "U123",
+            kind: "human",
+            name: "Pat on Slack",
+            handle: "pat",
+        },
+        conversation: { id: "C123", kind: "channel" },
+        trigger: "message",
+        event: { id: "E123", occurredAt: "2026-07-31T12:00:00.000Z" },
+        raw: { type: "app_mention" },
+    });
+    expect(received).toEqual(expect.objectContaining({
+        user: { id: "person-1", name: "Pat Lee" },
+        actor: {
+            id: "U123",
+            kind: "human",
+            name: "Pat on Slack",
+            handle: "pat",
+        },
+    }));
+    expect(Object.isFrozen(received.user)).toBe(true);
+    expect(Object.isFrozen(received.actor)).toBe(true);
+});
+test("a command resolves identity once and exposes the canonical user and provider actor", async () => {
+    const identifyUser = vi.fn(() => ({ id: "person-2", name: "Jo Kim" }));
+    const adapter = new FakeAdapter({ platform: "intelligence" });
+    const channel = createChannel({
+        adapters: [adapter],
+        identifyUser,
+    });
+    let received;
+    channel.onCommand("who", (context) => {
+        received = context;
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onCommand({
+        command: "who",
+        conversationKey: "conversation-2",
+        replyTarget: {},
+        text: "",
+        platform: "teams",
+        actor: { id: "29:actor", kind: "human", name: "Jo on Teams" },
+        identityContext: {
+            tenant: { id: "tenant-2" },
+            installation: { id: "install-2" },
+            conversation: { id: "conversation-2", kind: "channel" },
+            trigger: "command",
+            event: { id: "event-2" },
+            raw: { name: "who" },
+        },
+    });
+    expect(identifyUser).toHaveBeenCalledTimes(1);
+    expect(received).toEqual(expect.objectContaining({
+        user: { id: "person-2", name: "Jo Kim" },
+        actor: { id: "29:actor", kind: "human", name: "Jo on Teams" },
+    }));
+});
+test("an agent interrupt handler receives the event's canonical user and provider actor", async () => {
+    const identifyUser = vi.fn(() => ({ id: "person-3", name: "Sam Rao" }));
+    const adapter = new FakeAdapter({ platform: "intelligence" });
+    const agent = new FakeAgent([
+        (subscriber) => {
+            subscriber.onCustomEvent?.({
+                event: { name: "approval", value: { requestId: "request-1" } },
+            });
+            subscriber.onRunFinishedEvent?.({ event: {} });
+        },
+    ]);
+    const channel = createChannel({
+        adapters: [adapter],
+        identifyUser,
+        agent,
+    });
+    let received;
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent();
+    });
+    channel.onInterrupt("approval", (context) => {
+        received = context;
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onTurn({
+        conversationKey: "conversation-3",
+        replyTarget: {},
+        userText: "approve",
+        platform: "slack",
+        actor: { id: "U3", kind: "human", name: "Sam on Slack" },
+        identityContext: {
+            tenant: { id: "T3" },
+            installation: { id: "I3" },
+            conversation: { id: "C3", kind: "channel" },
+            trigger: "message",
+            event: { id: "E3" },
+            raw: {},
+        },
+    });
+    expect(identifyUser).toHaveBeenCalledTimes(1);
+    expect(received).toEqual(expect.objectContaining({
+        payload: { requestId: "request-1" },
+        user: { id: "person-3", name: "Sam Rao" },
+        actor: { id: "U3", kind: "human", name: "Sam on Slack" },
+    }));
+});
+test("every non-message Channel trigger resolves identity once before its handler", async () => {
+    const identifyUser = vi.fn(({ actor }) => ({
+        id: `person:${actor.id}`,
+        name: actor.id,
+    }));
+    const adapter = new FakeAdapter({ platform: "intelligence" });
+    const channel = createChannel({
+        adapters: [adapter],
+        identifyUser,
+    });
+    const received = [];
+    channel.onThreadStarted((context) => {
+        received.push(context);
+    });
+    channel.onInteraction("approve", (context) => {
+        received.push(context);
+    });
+    channel.onReaction((context) => {
+        received.push(context);
+    });
+    channel.onModalSubmit("submit", (context) => {
+        received.push(context);
+    });
+    channel.onModalClose("close", (context) => {
+        received.push(context);
+    });
+    await channel.ɵruntime.start();
+    const sink = adapter.getSink();
+    const facts = (id, trigger) => ({
+        actor: { id, kind: "human" },
+        identityContext: {
+            tenant: { id: "tenant" },
+            installation: { id: "installation" },
+            conversation: { id: "conversation", kind: "channel" },
+            trigger,
+            event: { id: `event:${id}` },
+            raw: { trigger },
+        },
+    });
+    await sink.onThreadStarted({
+        conversationKey: "conversation",
+        replyTarget: {},
+        platform: "slack",
+        ...facts("thread-actor", "thread-start"),
+    });
+    await sink.onInteraction({
+        id: "approve",
+        conversationKey: "conversation",
+        replyTarget: {},
+        platform: "slack",
+        ...facts("interaction-actor", "interaction"),
+    });
+    await sink.onReaction({
+        added: true,
+        conversationKey: "conversation",
+        messageId: "message",
+        raw: {},
+        rawEmoji: "+1",
+        replyTarget: {},
+        platform: "slack",
+        ...facts("reaction-actor", "reaction"),
+    });
+    await sink.onModalSubmit({
+        callbackId: "submit",
+        values: {},
+        conversationKey: "conversation",
+        replyTarget: {},
+        platform: "slack",
+        raw: {},
+        ...facts("submit-actor", "modal-submit"),
+    });
+    await sink.onModalClose({
+        callbackId: "close",
+        conversationKey: "conversation",
+        replyTarget: {},
+        platform: "slack",
+        raw: {},
+        ...facts("close-actor", "modal-close"),
+    });
+    expect(identifyUser).toHaveBeenCalledTimes(5);
+    expect(received).toHaveLength(5);
+    expect(received).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+            user: { id: "person:thread-actor", name: "thread-actor" },
+            actor: { id: "thread-actor", kind: "human" },
+        }),
+        expect.objectContaining({
+            user: { id: "person:interaction-actor", name: "interaction-actor" },
+            actor: { id: "interaction-actor", kind: "human" },
+        }),
+        expect.objectContaining({
+            user: { id: "person:reaction-actor", name: "reaction-actor" },
+            actor: { id: "reaction-actor", kind: "human" },
+        }),
+        expect.objectContaining({
+            user: { id: "person:submit-actor", name: "submit-actor" },
+            actor: { id: "submit-actor", kind: "human" },
+        }),
+        expect.objectContaining({
+            user: { id: "person:close-actor", name: "close-actor" },
+            actor: { id: "close-actor", kind: "human" },
+        }),
+    ]));
+});
+test("parallel actors in one conversation keep their own immutable identity", async () => {
+    const releases = new Map();
+    const identifyUser = vi.fn(async ({ actor }) => {
+        await new Promise((resolve) => releases.set(actor.id, resolve));
+        return { id: `person:${actor.id}`, name: actor.name ?? actor.id };
+    });
+    const adapter = new FakeAdapter({ platform: "intelligence" });
+    const channel = createChannel({ adapters: [adapter], identifyUser });
+    const received = [];
+    channel.onMessage(({ message }) => {
+        received.push(message);
+    });
+    await channel.ɵruntime.start();
+    const sink = adapter.getSink();
+    const event = (actorId) => ({
+        conversationKey: "shared-conversation",
+        replyTarget: {},
+        userText: `hello from ${actorId}`,
+        platform: "slack",
+        actor: { id: actorId, kind: "human", name: actorId.toUpperCase() },
+        identityContext: {
+            tenant: { id: "T1" },
+            installation: { id: "I1" },
+            conversation: { id: "C1", kind: "channel" },
+            trigger: "message",
+            event: { id: `event:${actorId}` },
+            raw: { actorId },
+        },
+    });
+    const first = sink.onTurn(event("ada"));
+    const second = sink.onTurn(event("grace"));
+    await vi.waitFor(() => expect(identifyUser).toHaveBeenCalledTimes(2));
+    releases.get("grace")?.();
+    releases.get("ada")?.();
+    await Promise.all([first, second]);
+    expect(received).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+            user: { id: "person:ada", name: "ADA" },
+            actor: { id: "ada", kind: "human", name: "ADA" },
+        }),
+        expect.objectContaining({
+            user: { id: "person:grace", name: "GRACE" },
+            actor: { id: "grace", kind: "human", name: "GRACE" },
+        }),
+    ]));
+});

package/dist/channel-memory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=channel-memory.test.d.ts.map

package/dist/channel-memory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-memory.test.d.ts","sourceRoot":"","sources":["../src/channel-memory.test.ts"],"names":[],"mappings":""}

package/dist/channel-memory.test.js

@@ -0,0 +1,199 @@
+import { expect, test, vi } from "vitest";
+import { createChannel } from "./create-channel.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+import { FakeAgent } from "./testing/fake-agent.js";
+test("an omitted Memory grant runs on a direct Channel without Intelligence", async () => {
+    const adapter = new FakeAdapter();
+    const agent = new FakeAgent();
+    const channel = createChannel({
+        identifyUser: "platform",
+        adapters: [adapter],
+        agent: () => agent,
+    });
+    let ran = false;
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent();
+        ran = true;
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onTurn({
+        conversationKey: "conversation",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+    });
+    expect(ran).toBe(true);
+});
+test("an explicit Memory grant fails before a direct Channel agent runs without Intelligence", async () => {
+    const adapter = new FakeAdapter();
+    const agent = new FakeAgent();
+    const channel = createChannel({
+        identifyUser: "platform",
+        adapters: [adapter],
+        agent: () => agent,
+    });
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent({ memory: { project: "read" } });
+    });
+    await channel.ɵruntime.start();
+    await expect(adapter.getSink().onTurn({
+        conversationKey: "conversation",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+    })).rejects.toMatchObject({ code: "channel_memory_unavailable" });
+    expect(agent.runAgentCalls).toBe(0);
+});
+test("project-only Memory works when Channel identity is null", async () => {
+    const adapter = new FakeAdapter();
+    const lifecycle = vi.fn(async (args) => args.execute({}, undefined));
+    adapter.supportsIntelligenceMemory = true;
+    adapter.runAgentLifecycle = lifecycle;
+    const channel = createChannel({
+        identifyUser: () => null,
+        adapters: [adapter],
+        agent: () => new FakeAgent(),
+    });
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent({ memory: { project: "read-write" } });
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onTurn({
+        conversationKey: "conversation",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+    });
+    expect(lifecycle).toHaveBeenCalledWith(expect.objectContaining({
+        memory: {
+            grant: { user: "none", project: "read-write" },
+            user: null,
+        },
+    }));
+});
+test("a custom identity callback may map a non-human actor to personal Memory", async () => {
+    const adapter = new FakeAdapter();
+    const lifecycle = vi.fn(async (args) => args.execute({}, undefined));
+    adapter.supportsIntelligenceMemory = true;
+    adapter.runAgentLifecycle = lifecycle;
+    const channel = createChannel({
+        identifyUser: ({ actor }) => ({
+            id: `service:${actor.id}`,
+            name: actor.name ?? actor.id,
+        }),
+        adapters: [adapter],
+        agent: () => new FakeAgent(),
+    });
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent({ memory: { user: "read" } });
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onTurn({
+        conversationKey: "conversation",
+        replyTarget: {},
+        userText: "refresh",
+        platform: "slack",
+        actor: { id: "sync-bot", kind: "bot", name: "Sync Bot" },
+    });
+    expect(lifecycle).toHaveBeenCalledWith(expect.objectContaining({
+        memory: {
+            grant: { user: "read", project: "none" },
+            user: { id: "service:sync-bot", name: "Sync Bot" },
+        },
+    }));
+});
+test("personal Memory fails before execution when Channel identity is null", async () => {
+    const adapter = new FakeAdapter();
+    adapter.supportsIntelligenceMemory = true;
+    adapter.runAgentLifecycle = vi.fn();
+    const channel = createChannel({
+        identifyUser: () => null,
+        adapters: [adapter],
+        agent: () => new FakeAgent(),
+    });
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent({ memory: { user: "read", project: "none" } });
+    });
+    await channel.ɵruntime.start();
+    await expect(adapter.getSink().onTurn({
+        conversationKey: "conversation",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+    })).rejects.toMatchObject({ code: "channel_memory_user_required" });
+    expect(adapter.runAgentLifecycle).not.toHaveBeenCalled();
+});
+test("an invalid JavaScript Memory grant fails before agent execution", async () => {
+    const adapter = new FakeAdapter();
+    adapter.supportsIntelligenceMemory = true;
+    adapter.runAgentLifecycle = vi.fn();
+    const channel = createChannel({
+        identifyUser: "platform",
+        adapters: [adapter],
+        agent: () => new FakeAgent(),
+    });
+    channel.onMessage(async ({ thread }) => {
+        await thread.runAgent({
+            memory: { user: "admin" },
+        });
+    });
+    await channel.ɵruntime.start();
+    await expect(adapter.getSink().onTurn({
+        conversationKey: "conversation",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+        actor: { id: "alice", kind: "human" },
+    })).rejects.toMatchObject({ code: "channel_memory_grant_invalid" });
+    expect(adapter.runAgentLifecycle).not.toHaveBeenCalled();
+});
+test("runAgent snapshots its Memory grant before queued execution", async () => {
+    const adapter = new FakeAdapter();
+    adapter.supportsIntelligenceMemory = true;
+    let release;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    const queuedAdapter = adapter;
+    queuedAdapter.trackThreadOperation = (_target, operation) => gate.then(operation);
+    const lifecycle = vi.fn(async (args) => args.execute(args.renderer.subscriber, undefined));
+    adapter.runAgentLifecycle = lifecycle;
+    const channel = createChannel({
+        identifyUser: "platform",
+        adapters: [adapter],
+        agent: new FakeAgent(),
+    });
+    let thread;
+    channel.onMessage((context) => {
+        thread = context.thread;
+    });
+    await channel.ɵruntime.start();
+    await adapter.getSink().onTurn({
+        conversationKey: "thread-queued",
+        replyTarget: {},
+        userText: "hello",
+        platform: "slack",
+        actor: { id: "U1", kind: "human" },
+        identityContext: {
+            tenant: { id: "T1" },
+            installation: { id: "I1" },
+            conversation: { id: "C1" },
+            trigger: "message",
+            event: { id: "E1" },
+            raw: {},
+        },
+    });
+    if (!thread)
+        throw new Error("message handler did not receive a Thread");
+    const memory = { user: "read", project: "none" };
+    const run = thread.runAgent({ memory });
+    memory.user = "none";
+    release();
+    await run;
+    expect(lifecycle).toHaveBeenCalledWith(expect.objectContaining({
+        memory: {
+            grant: { user: "read", project: "none" },
+            user: { id: "slack:T1:U1", name: "U1" },
+        },
+    }));
+});

package/dist/commands.d.ts

@@ -1,5 +1,5 @@
 import type { InferSchemaOutput, ObjectSchema } from "./standard-schema.js";
-import type { Thread, PlatformUser, ModalView } from "@copilotkit/channels-ui";
+import type { ApplicationUser, ModalView, ProviderActor, Thread } from "@copilotkit/channels-ui";
 /**
  * Context handed to a slash-command handler. `text` is the raw argument string
  * (the form Slack delivers); `options` is the parsed, typed form, populated by
@@ -15,8 +15,10 @@ export interface CommandContext<TOptions = Record<string, never>> {
     text: string;
     /** Parsed, typed options (empty on surfaces that only deliver `text`). */
     options: TOptions;
-    /** The invoking user, when the surface provides it. */
-    user?: PlatformUser;
+    /** Canonical application user selected for this event. */
+    user: ApplicationUser | null;
+    /** Provider account that invoked the command. */
+    actor: ProviderActor;
     platform: string;
     /** Open a modal in response to this command (requires the surface's trigger; `undefined` when unavailable). */
     openModal?(view: ModalView): Promise<{

package/dist/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAC9D,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,OAAO,EAAE,QAAQ,CAAC;IAClB,uDAAuD;IACvD,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,+GAA+G;IAC/G,SAAS,CAAC,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,YAAY,GAAG,YAAY;IACxE,4FAA4F;IAC5F,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,GAAG,EAAE,cAAc,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,YAAY,EAC9D,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC,GAC9B,cAAc,CAAC,MAAM,CAAC,CAExB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAUlE"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,KAAK,EACV,eAAe,EACf,SAAS,EACT,aAAa,EACb,MAAM,EACP,MAAM,yBAAyB,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAC9D,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,OAAO,EAAE,QAAQ,CAAC;IAClB,0DAA0D;IAC1D,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7B,iDAAiD;IACjD,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,+GAA+G;IAC/G,SAAS,CAAC,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,YAAY,GAAG,YAAY;IACxE,4FAA4F;IAC5F,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,GAAG,EAAE,cAAc,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,YAAY,EAC9D,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC,GAC9B,cAAc,CAAC,MAAM,CAAC,CAExB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAUlE"}