@adcp/sdk 5.23.0

package/dist/lib/server/targeting-helpers.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Inventory list targeting helpers for AdCP sellers.
+ *
+ * AdCP 3.0 carries property and collection targeting as references to
+ * externally-managed lists (`PropertyListReference`, `CollectionListReference`).
+ * The seller resolves those references at serve time and filters its own
+ * inventory against the resolved contents.
+ *
+ * These helpers let a seller handler do that in one line:
+ *
+ * @example
+ * ```typescript
+ * import { resolvePropertyList, matchesPropertyList } from '@adcp/sdk/server';
+ *
+ * if (targeting.property_list) {
+ *   const list = await resolvePropertyList(targeting.property_list);
+ *   inventory = inventory.filter(p => matchesPropertyList(p.identifier, list));
+ * }
+ * ```
+ *
+ * Resolution goes through MCP (`get_property_list` / `get_collection_list`) on
+ * the referenced agent — the same contract a buyer agent uses to fetch the list.
+ * Matching follows the identifier and distribution-id semantics defined by the
+ * AdCP property and collection specs.
+ */
+import type { PropertyListReference, CollectionListReference, GetCollectionListResponse, Identifier } from '../types/tools.generated';
+export interface ResolvedPropertyList {
+    listId: string;
+    agentUrl: string;
+    identifiers: Identifier[];
+    cacheValidUntil?: string;
+}
+/** A collection entry as returned by get_collection_list. */
+export type ResolvedCollection = NonNullable<GetCollectionListResponse['collections']>[number];
+export interface ResolvedCollectionList {
+    listId: string;
+    agentUrl: string;
+    collections: ResolvedCollection[];
+    cacheValidUntil?: string;
+}
+export interface ResolveListOptions {
+    /** Maximum page size when calling get_property_list / get_collection_list. Defaults to 1000. */
+    pageSize?: number;
+}
+/**
+ * Resolve a PropertyListReference to the concrete identifiers it contains.
+ *
+ * Calls `get_property_list` on the referenced agent with `resolve: true`.
+ * Honors `auth_token` on the reference if present.
+ */
+export declare function resolvePropertyList(ref: PropertyListReference, options?: ResolveListOptions): Promise<ResolvedPropertyList>;
+/**
+ * Resolve a CollectionListReference to the concrete collections it contains.
+ *
+ * Calls `get_collection_list` on the referenced agent with `resolve: true`.
+ * Honors `auth_token` on the reference if present.
+ */
+export declare function resolveCollectionList(ref: CollectionListReference, options?: ResolveListOptions): Promise<ResolvedCollectionList>;
+/**
+ * Return true if `property` matches any identifier in the resolved list.
+ *
+ * Domain matching rules (from the AdCP property spec):
+ * - Exact match on the identifier value is always accepted.
+ * - A `domain` entry of `example.com` also matches `www.example.com` and
+ *   `m.example.com` — the two canonical aliases for a base domain.
+ * - A `domain` entry of `*.example.com` matches every subdomain but NOT the
+ *   base domain itself.
+ * - Non-domain identifier types (ios_bundle, network_id, etc.) use exact
+ *   string match on both `type` and `value`.
+ */
+export declare function matchesPropertyList(property: Identifier, list: ResolvedPropertyList): boolean;
+/**
+ * Return true if `collection` matches any entry in the resolved list.
+ *
+ * Matching modes:
+ * - Collections match when `collection_rid` is set on both sides and equal.
+ * - Otherwise, they match when they share at least one `distribution_ids`
+ *   entry with the same `type` and `value`.
+ *
+ * A collection with no collection_rid and no distribution_ids cannot match —
+ * the seller has nothing to match against.
+ */
+export declare function matchesCollectionList(collection: {
+    collection_rid?: string;
+    distribution_ids?: {
+        type: string;
+        value: string;
+    }[];
+}, list: ResolvedCollectionList): boolean;
+//# sourceMappingURL=targeting-helpers.d.ts.map

package/dist/lib/server/targeting-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targeting-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/server/targeting-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EAEvB,yBAAyB,EACzB,UAAU,EACX,MAAM,0BAA0B,CAAC;AAMlC,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/F,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAMD,MAAM,WAAW,kBAAkB;IACjC,gGAAgG;IAChG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,qBAAqB,EAC1B,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAuB/B;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,uBAAuB,EAC5B,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CA0BjC;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAE7F;AAqBD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,EAC7F,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAET"}

package/dist/lib/server/targeting-helpers.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Inventory list targeting helpers for AdCP sellers.
+ *
+ * AdCP 3.0 carries property and collection targeting as references to
+ * externally-managed lists (`PropertyListReference`, `CollectionListReference`).
+ * The seller resolves those references at serve time and filters its own
+ * inventory against the resolved contents.
+ *
+ * These helpers let a seller handler do that in one line:
+ *
+ * @example
+ * ```typescript
+ * import { resolvePropertyList, matchesPropertyList } from '@adcp/sdk/server';
+ *
+ * if (targeting.property_list) {
+ *   const list = await resolvePropertyList(targeting.property_list);
+ *   inventory = inventory.filter(p => matchesPropertyList(p.identifier, list));
+ * }
+ * ```
+ *
+ * Resolution goes through MCP (`get_property_list` / `get_collection_list`) on
+ * the referenced agent — the same contract a buyer agent uses to fetch the list.
+ * Matching follows the identifier and distribution-id semantics defined by the
+ * AdCP property and collection specs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePropertyList = resolvePropertyList;
+exports.resolveCollectionList = resolveCollectionList;
+exports.matchesPropertyList = matchesPropertyList;
+exports.matchesCollectionList = matchesCollectionList;
+const mcp_1 = require("../protocols/mcp");
+/**
+ * Resolve a PropertyListReference to the concrete identifiers it contains.
+ *
+ * Calls `get_property_list` on the referenced agent with `resolve: true`.
+ * Honors `auth_token` on the reference if present.
+ */
+async function resolvePropertyList(ref, options = {}) {
+    const args = {
+        list_id: ref.list_id,
+        resolve: true,
+    };
+    if (options.pageSize != null)
+        args.page_size = options.pageSize;
+    const raw = (await (0, mcp_1.callMCPTool)(ref.agent_url, 'get_property_list', args, ref.auth_token));
+    if (!raw || typeof raw !== 'object' || !('list' in raw)) {
+        throw new Error(`Invalid get_property_list response from ${ref.agent_url}: missing 'list'. ` +
+            `Got: ${JSON.stringify(raw)?.slice(0, 200)}`);
+    }
+    const response = raw;
+    return {
+        listId: response.list.list_id,
+        agentUrl: ref.agent_url,
+        identifiers: response.identifiers ?? [],
+        cacheValidUntil: response.cache_valid_until ?? undefined,
+    };
+}
+/**
+ * Resolve a CollectionListReference to the concrete collections it contains.
+ *
+ * Calls `get_collection_list` on the referenced agent with `resolve: true`.
+ * Honors `auth_token` on the reference if present.
+ */
+async function resolveCollectionList(ref, options = {}) {
+    const args = {
+        list_id: ref.list_id,
+        resolve: true,
+    };
+    if (options.pageSize != null)
+        args.page_size = options.pageSize;
+    const raw = (await (0, mcp_1.callMCPTool)(ref.agent_url, 'get_collection_list', args, ref.auth_token));
+    if (!raw || typeof raw !== 'object' || !('list' in raw)) {
+        throw new Error(`Invalid get_collection_list response from ${ref.agent_url}: missing 'list'. ` +
+            `Got: ${JSON.stringify(raw)?.slice(0, 200)}`);
+    }
+    const response = raw;
+    return {
+        listId: response.list.list_id,
+        agentUrl: ref.agent_url,
+        collections: response.collections ?? [],
+        cacheValidUntil: response.cache_valid_until ?? undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// matchesPropertyList / matchesCollectionList
+// ---------------------------------------------------------------------------
+/**
+ * Return true if `property` matches any identifier in the resolved list.
+ *
+ * Domain matching rules (from the AdCP property spec):
+ * - Exact match on the identifier value is always accepted.
+ * - A `domain` entry of `example.com` also matches `www.example.com` and
+ *   `m.example.com` — the two canonical aliases for a base domain.
+ * - A `domain` entry of `*.example.com` matches every subdomain but NOT the
+ *   base domain itself.
+ * - Non-domain identifier types (ios_bundle, network_id, etc.) use exact
+ *   string match on both `type` and `value`.
+ */
+function matchesPropertyList(property, list) {
+    return list.identifiers.some(entry => identifiersMatch(property, entry));
+}
+function identifiersMatch(property, entry) {
+    if (property.type !== entry.type)
+        return false;
+    if (property.type !== 'domain') {
+        return property.value === entry.value;
+    }
+    return domainMatches(property.value, entry.value);
+}
+function domainMatches(candidate, pattern) {
+    const c = candidate.toLowerCase();
+    const p = pattern.toLowerCase();
+    if (c === p)
+        return true;
+    if (p.startsWith('*.')) {
+        const suffix = p.slice(1); // ".example.com"
+        return c.endsWith(suffix) && c !== p.slice(2);
+    }
+    return c === `www.${p}` || c === `m.${p}`;
+}
+/**
+ * Return true if `collection` matches any entry in the resolved list.
+ *
+ * Matching modes:
+ * - Collections match when `collection_rid` is set on both sides and equal.
+ * - Otherwise, they match when they share at least one `distribution_ids`
+ *   entry with the same `type` and `value`.
+ *
+ * A collection with no collection_rid and no distribution_ids cannot match —
+ * the seller has nothing to match against.
+ */
+function matchesCollectionList(collection, list) {
+    return list.collections.some(entry => collectionsMatch(collection, entry));
+}
+function collectionsMatch(a, b) {
+    if (a.collection_rid && b.collection_rid && a.collection_rid === b.collection_rid) {
+        return true;
+    }
+    if (!a.distribution_ids?.length || !b.distribution_ids?.length)
+        return false;
+    return a.distribution_ids.some(aid => b.distribution_ids.some(bid => aid.type === bid.type && aid.value === bid.value));
+}
+//# sourceMappingURL=targeting-helpers.js.map

package/dist/lib/server/targeting-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"targeting-helpers.js","sourceRoot":"","sources":["../../../src/lib/server/targeting-helpers.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;AA+CH,kDA0BC;AAQD,sDA6BC;AAkBD,kDAEC;AAgCD,sDAKC;AArKD,0CAA+C;AAuC/C;;;;;GAKG;AACI,KAAK,UAAU,mBAAmB,CACvC,GAA0B,EAC1B,UAA8B,EAAE;IAEhC,MAAM,IAAI,GAA4B;QACpC,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,OAAO,EAAE,IAAI;KACd,CAAC;IACF,IAAI,OAAO,CAAC,QAAQ,IAAI,IAAI;QAAE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;IAEhE,MAAM,GAAG,GAAG,CAAC,MAAM,IAAA,iBAAW,EAAC,GAAG,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,GAAG,CAAC,UAAU,CAAC,CAA4B,CAAC;IAErH,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CACb,2CAA2C,GAAG,CAAC,SAAS,oBAAoB;YAC1E,QAAQ,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAC/C,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,GAAyC,CAAC;IAE3D,OAAO;QACL,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,OAAO;QAC7B,QAAQ,EAAE,GAAG,CAAC,SAAS;QACvB,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,EAAE;QACvC,eAAe,EAAE,QAAQ,CAAC,iBAAiB,IAAI,SAAS;KACzD,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,qBAAqB,CACzC,GAA4B,EAC5B,UAA8B,EAAE;IAEhC,MAAM,IAAI,GAA4B;QACpC,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,OAAO,EAAE,IAAI;KACd,CAAC;IACF,IAAI,OAAO,CAAC,QAAQ,IAAI,IAAI;QAAE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;IAEhE,MAAM,GAAG,GAAG,CAAC,MAAM,IAAA,iBAAW,EAAC,GAAG,CAAC,SAAS,EAAE,qBAAqB,EAAE,IAAI,EAAE,GAAG,CAAC,UAAU,CAAC,CAGzF,CAAC;IAEF,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CACb,6CAA6C,GAAG,CAAC,SAAS,oBAAoB;YAC5E,QAAQ,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAC/C,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,GAA2C,CAAC;IAE7D,OAAO;QACL,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,OAAO;QAC7B,QAAQ,EAAE,GAAG,CAAC,SAAS;QACvB,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,EAAE;QACvC,eAAe,EAAE,QAAQ,CAAC,iBAAiB,IAAI,SAAS;KACzD,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,8CAA8C;AAC9C,8EAA8E;AAE9E;;;;;;;;;;;GAWG;AACH,SAAgB,mBAAmB,CAAC,QAAoB,EAAE,IAA0B;IAClF,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;AAC3E,CAAC;AAED,SAAS,gBAAgB,CAAC,QAAoB,EAAE,KAAiB;IAC/D,IAAI,QAAQ,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IAC/C,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,QAAQ,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAC;IACxC,CAAC;IACD,OAAO,aAAa,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AACpD,CAAC;AAED,SAAS,aAAa,CAAC,SAAiB,EAAE,OAAe;IACvD,MAAM,CAAC,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;IAClC,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAChC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACzB,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB;QAC5C,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,CAAC,KAAK,OAAO,CAAC,EAAE,IAAI,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,qBAAqB,CACnC,UAA6F,EAC7F,IAA4B;IAE5B,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,gBAAgB,CACvB,CAAoF,EACpF,CAAqB;IAErB,IAAI,CAAC,CAAC,cAAc,IAAI,CAAC,CAAC,cAAc,IAAI,CAAC,CAAC,cAAc,KAAK,CAAC,CAAC,cAAc,EAAE,CAAC;QAClF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,CAAC,CAAC,gBAAgB,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,gBAAgB,EAAE,MAAM;QAAE,OAAO,KAAK,CAAC;IAC7E,OAAO,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CACnC,CAAC,CAAC,gBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,CAAC,CAClF,CAAC;AACJ,CAAC"}

package/dist/lib/server/tasks.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Server-side helpers for MCP Tasks protocol support.
+ *
+ * Publishers can use these to add async task support to their AdCP MCP servers.
+ * The MCP SDK handles all protocol plumbing (tasks/get, tasks/result, tasks/cancel,
+ * tasks/list, TTL, _meta injection) — publishers only implement task creation and
+ * result storage logic.
+ *
+ * @example
+ * ```typescript
+ * import { createTaskCapableServer, registerAdcpTaskTool, InMemoryTaskStore } from '@adcp/sdk';
+ *
+ * const server = createTaskCapableServer('My Publisher', '1.0.0');
+ *
+ * registerAdcpTaskTool(server, 'create_media_buy', {
+ *   description: 'Create a media buy (async)',
+ *   inputSchema: { campaign_name: z.string() },
+ *   taskSupport: 'required',
+ * }, {
+ *   createTask: async (args, extra) => {
+ *     const task = await extra.taskStore.createTask({ ttl: 300_000 });
+ *     startBackgroundWork(task.taskId, args);
+ *     return { task };
+ *   },
+ *   getTask: async (_args, extra) => {
+ *     return extra.taskStore.getTask(extra.taskId);
+ *   },
+ *   getTaskResult: async (_args, extra) => {
+ *     return extra.taskStore.getTaskResult(extra.taskId);
+ *   },
+ * });
+ * ```
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AdcpServer } from './adcp-server';
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ZodRawShapeCompat, AnySchema } from '@modelcontextprotocol/sdk/server/zod-compat.js';
+import type { ToolAnnotations, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolTaskHandler } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
+import { InMemoryTaskStore as _InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+export { _InMemoryTaskStore as InMemoryTaskStore };
+export { isTerminal } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
+export type { TaskStore, TaskMessageQueue, CreateTaskOptions, ToolTaskHandler, CreateTaskRequestHandlerExtra, TaskRequestHandlerExtra, } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
+export type { CreateTaskResult, GetTaskResult, Task } from '@modelcontextprotocol/sdk/experimental/tasks/types.js';
+/**
+ * Build a task tool result response.
+ *
+ * Same pattern as `productsResponse()` / `mediaBuyResponse()` but designed for
+ * use in `getTaskResult` handlers where you return the final async result.
+ */
+export declare function taskToolResponse(data: Record<string, unknown>, summary?: string): CallToolResult;
+/**
+ * Configuration for registering an AdCP task tool.
+ */
+export interface AdcpTaskToolConfig {
+    description: string;
+    title?: string;
+    inputSchema?: ZodRawShapeCompat | AnySchema;
+    outputSchema?: ZodRawShapeCompat | AnySchema;
+    annotations?: ToolAnnotations;
+    taskSupport?: 'optional' | 'required';
+}
+/**
+ * Register an AdCP task-based tool on an MCP server.
+ *
+ * Wraps `server.experimental.tasks.registerToolTask()` with AdCP defaults.
+ * Sets `execution.taskSupport` (default: 'optional') and passes through to the SDK.
+ *
+ * Accepts either an `AdcpServer` from `createAdcpServer()` or a raw SDK
+ * `McpServer` from `createTaskCapableServer()` — the helper unwraps the
+ * opaque handle when needed so registration reaches the SDK server.
+ */
+export declare function registerAdcpTaskTool(server: AdcpServer | McpServer, name: string, config: AdcpTaskToolConfig, handler: ToolTaskHandler<any>): RegisteredTool;
+/**
+ * Create an MCP server with task support pre-configured.
+ *
+ * Sets up the server with a `taskStore` (defaults to `InMemoryTaskStore`) and
+ * declares tasks capability. Publishers can then use `registerAdcpTaskTool()`
+ * or `server.experimental.tasks.registerToolTask()` directly.
+ *
+ * This uses the higher-level `McpServer` API. Publishers with complex dispatch
+ * patterns (e.g., custom request routing) can use the lower-level `Server` class
+ * directly by passing `taskStore` in `ServerOptions` and using `setRequestHandler`
+ * for task lifecycle methods. See the MCP SDK docs for that approach.
+ */
+export declare function createTaskCapableServer(name: string, version: string, options?: {
+    taskStore?: import('@modelcontextprotocol/sdk/experimental/tasks/interfaces.js').TaskStore;
+    taskMessageQueue?: import('@modelcontextprotocol/sdk/experimental/tasks/interfaces.js').TaskMessageQueue;
+    instructions?: string;
+}): McpServer;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/lib/server/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../../src/lib/server/tasks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAC;AACnG,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC1F,OAAO,KAAK,EAAE,eAAe,EAAqB,MAAM,4DAA4D,CAAC;AAGrH,OAAO,EAAE,iBAAiB,IAAI,kBAAkB,EAAE,MAAM,kEAAkE,CAAC;AAC3H,OAAO,EAAE,kBAAkB,IAAI,iBAAiB,EAAE,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,4DAA4D,CAAC;AACxF,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,4DAA4D,CAAC;AACpE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,uDAAuD,CAAC;AAEnH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,cAAc,CAKhG;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC5C,YAAY,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC7C,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,WAAW,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,eAAe,CAAC,GAAG,CAAC,GAC5B,cAAc,CAuBhB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,OAAO,4DAA4D,EAAE,SAAS,CAAC;IAC3F,gBAAgB,CAAC,EAAE,OAAO,4DAA4D,EAAE,gBAAgB,CAAC;IACzG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GACA,SAAS,CAmBX"}

package/dist/lib/server/tasks.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Server-side helpers for MCP Tasks protocol support.
+ *
+ * Publishers can use these to add async task support to their AdCP MCP servers.
+ * The MCP SDK handles all protocol plumbing (tasks/get, tasks/result, tasks/cancel,
+ * tasks/list, TTL, _meta injection) — publishers only implement task creation and
+ * result storage logic.
+ *
+ * @example
+ * ```typescript
+ * import { createTaskCapableServer, registerAdcpTaskTool, InMemoryTaskStore } from '@adcp/sdk';
+ *
+ * const server = createTaskCapableServer('My Publisher', '1.0.0');
+ *
+ * registerAdcpTaskTool(server, 'create_media_buy', {
+ *   description: 'Create a media buy (async)',
+ *   inputSchema: { campaign_name: z.string() },
+ *   taskSupport: 'required',
+ * }, {
+ *   createTask: async (args, extra) => {
+ *     const task = await extra.taskStore.createTask({ ttl: 300_000 });
+ *     startBackgroundWork(task.taskId, args);
+ *     return { task };
+ *   },
+ *   getTask: async (_args, extra) => {
+ *     return extra.taskStore.getTask(extra.taskId);
+ *   },
+ *   getTaskResult: async (_args, extra) => {
+ *     return extra.taskStore.getTaskResult(extra.taskId);
+ *   },
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTerminal = exports.InMemoryTaskStore = void 0;
+exports.taskToolResponse = taskToolResponse;
+exports.registerAdcpTaskTool = registerAdcpTaskTool;
+exports.createTaskCapableServer = createTaskCapableServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const adcp_server_1 = require("./adcp-server");
+// Re-export SDK task primitives so publishers don't import from experimental paths
+const in_memory_js_1 = require("@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js");
+Object.defineProperty(exports, "InMemoryTaskStore", { enumerable: true, get: function () { return in_memory_js_1.InMemoryTaskStore; } });
+var interfaces_js_1 = require("@modelcontextprotocol/sdk/experimental/tasks/interfaces.js");
+Object.defineProperty(exports, "isTerminal", { enumerable: true, get: function () { return interfaces_js_1.isTerminal; } });
+/**
+ * Build a task tool result response.
+ *
+ * Same pattern as `productsResponse()` / `mediaBuyResponse()` but designed for
+ * use in `getTaskResult` handlers where you return the final async result.
+ */
+function taskToolResponse(data, summary) {
+    return {
+        content: [{ type: 'text', text: summary ?? 'Task completed' }],
+        structuredContent: data,
+    };
+}
+/**
+ * Register an AdCP task-based tool on an MCP server.
+ *
+ * Wraps `server.experimental.tasks.registerToolTask()` with AdCP defaults.
+ * Sets `execution.taskSupport` (default: 'optional') and passes through to the SDK.
+ *
+ * Accepts either an `AdcpServer` from `createAdcpServer()` or a raw SDK
+ * `McpServer` from `createTaskCapableServer()` — the helper unwraps the
+ * opaque handle when needed so registration reaches the SDK server.
+ */
+function registerAdcpTaskTool(server, name, config, handler) {
+    const mcp = (0, adcp_server_1.getSdkServer)(server) ?? server;
+    const { description, title, inputSchema, outputSchema, annotations, taskSupport = 'optional' } = config;
+    const execution = { taskSupport };
+    const sdkConfig = {
+        description,
+        execution,
+        ...(title != null && { title }),
+        ...(outputSchema != null && { outputSchema }),
+        ...(annotations != null && { annotations }),
+    };
+    if (inputSchema != null) {
+        return mcp.experimental.tasks.registerToolTask(name, { ...sdkConfig, inputSchema }, handler);
+    }
+    return mcp.experimental.tasks.registerToolTask(name, sdkConfig, handler);
+}
+/**
+ * Create an MCP server with task support pre-configured.
+ *
+ * Sets up the server with a `taskStore` (defaults to `InMemoryTaskStore`) and
+ * declares tasks capability. Publishers can then use `registerAdcpTaskTool()`
+ * or `server.experimental.tasks.registerToolTask()` directly.
+ *
+ * This uses the higher-level `McpServer` API. Publishers with complex dispatch
+ * patterns (e.g., custom request routing) can use the lower-level `Server` class
+ * directly by passing `taskStore` in `ServerOptions` and using `setRequestHandler`
+ * for task lifecycle methods. See the MCP SDK docs for that approach.
+ */
+function createTaskCapableServer(name, version, options) {
+    const taskStore = options?.taskStore ?? new in_memory_js_1.InMemoryTaskStore();
+    return new mcp_js_1.McpServer({ name, version }, {
+        capabilities: {
+            tasks: {
+                list: {},
+                cancel: {},
+                requests: {
+                    tools: {
+                        call: {},
+                    },
+                },
+            },
+        },
+        taskStore,
+        taskMessageQueue: options?.taskMessageQueue,
+        instructions: options?.instructions,
+    });
+}
+//# sourceMappingURL=tasks.js.map

package/dist/lib/server/tasks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../../src/lib/server/tasks.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;;AA8BH,4CAKC;AAwBD,oDA4BC;AAcD,0DA2BC;AA9HD,oEAAoE;AAEpE,+CAA6C;AAM7C,mFAAmF;AACnF,mGAA2H;AAC5F,kGADD,gCAAkB,OACA;AAChD,4FAAwF;AAA/E,2GAAA,UAAU,OAAA;AAWnB;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,IAA6B,EAAE,OAAgB;IAC9E,OAAO;QACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,IAAI,gBAAgB,EAAE,CAAC;QAC9D,iBAAiB,EAAE,IAAI;KACxB,CAAC;AACJ,CAAC;AAcD;;;;;;;;;GASG;AACH,SAAgB,oBAAoB,CAClC,MAA8B,EAC9B,IAAY,EACZ,MAA0B,EAC1B,OAA6B;IAE7B,MAAM,GAAG,GAAG,IAAA,0BAAY,EAAC,MAAoB,CAAC,IAAK,MAAoB,CAAC;IACxE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,GAAG,UAAU,EAAE,GAAG,MAAM,CAAC;IAExG,MAAM,SAAS,GAAsB,EAAE,WAAW,EAAE,CAAC;IAErD,MAAM,SAAS,GAAG;QAChB,WAAW;QACX,SAAS;QACT,GAAG,CAAC,KAAK,IAAI,IAAI,IAAI,EAAE,KAAK,EAAE,CAAC;QAC/B,GAAG,CAAC,YAAY,IAAI,IAAI,IAAI,EAAE,YAAY,EAAE,CAAC;QAC7C,GAAG,CAAC,WAAW,IAAI,IAAI,IAAI,EAAE,WAAW,EAAE,CAAC;KAC5C,CAAC;IAEF,IAAI,WAAW,IAAI,IAAI,EAAE,CAAC;QACxB,OAAO,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAE,GAAG,SAAS,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,CAAC;IAC/F,CAAC;IAED,OAAO,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,gBAAgB,CAC5C,IAAI,EACJ,SAA0E,EAC1E,OAAqC,CACtC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,uBAAuB,CACrC,IAAY,EACZ,OAAe,EACf,OAIC;IAED,MAAM,SAAS,GAAG,OAAO,EAAE,SAAS,IAAI,IAAI,gCAAkB,EAAE,CAAC;IAEjE,OAAO,IAAI,kBAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE;QACtC,YAAY,EAAE;YACZ,KAAK,EAAE;gBACL,IAAI,EAAE,EAAE;gBACR,MAAM,EAAE,EAAE;gBACV,QAAQ,EAAE;oBACR,KAAK,EAAE;wBACL,IAAI,EAAE,EAAE;qBACT;iBACF;aACF;SACF;QACD,SAAS;QACT,gBAAgB,EAAE,OAAO,EAAE,gBAAgB;QAC3C,YAAY,EAAE,OAAO,EAAE,YAAY;KACU,CAAC,CAAC;AACnD,CAAC"}

package/dist/lib/server/test-controller-bridge.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Bridge between the `comply_test_controller` seed store and the
+ * `createAdcpServer` spec-tool pipeline.
+ *
+ * Sellers who run the compliance conformance suite seed fixtures via
+ * `comply_test_controller.seed_product`, but those fixtures don't flow into
+ * `get_products` responses unless the seller plumbs it themselves — every
+ * seller ends up rewriting the same "look up seeded products, merge into
+ * handler response, dedupe, sandbox-gate" boilerplate.
+ *
+ * This module exposes a small declarative shape (`TestControllerBridge`)
+ * that the server config accepts; when present, the dispatcher augments
+ * `get_products` responses with seeded products on sandbox requests, and
+ * leaves production traffic untouched.
+ *
+ * The bridge intentionally does NOT know how seeded products are stored.
+ * Sellers provide a `getSeededProducts` callback that returns the list the
+ * SDK should merge — which lets the same wiring work whether the backing
+ * store is in-memory, Postgres, Redis, or a mock.
+ */
+import type { Product, GetProductsResponse } from '../types/tools.generated';
+/**
+ * Context passed to {@link TestControllerBridge.getSeededProducts}.
+ *
+ * `input` is the raw `get_products` request as received over the wire (post
+ * MCP schema validation). `account` is the resolved seller account when
+ * `resolveAccount` is configured on `createAdcpServer`, else `undefined` —
+ * sellers who key seeded fixtures per account read it from here.
+ */
+export interface TestControllerBridgeContext<TAccount = unknown> {
+    input: Record<string, unknown>;
+    account?: TAccount;
+}
+/**
+ * Wiring that connects the `comply_test_controller` seed store to the
+ * spec-tool pipeline.
+ *
+ * Set on `AdcpServerConfig.testController`; when absent, behavior is
+ * unchanged. The bridge is opt-in via the presence of `getSeededProducts`
+ * — omit it to hold seeded state without changing response shape.
+ */
+export interface TestControllerBridge<TAccount = unknown> {
+    /**
+     * Retrieve seeded products for the current request. Return an empty
+     * array (or `undefined`) when nothing is seeded. The returned products
+     * are appended to the handler's `get_products` response; on
+     * `product_id` collision, the seeded entry wins (sellers who seed to
+     * override default inventory expect their fixture to take precedence).
+     *
+     * Scope your implementation to `ctx.account`; the framework's sandbox
+     * check is a namespace selector, not an authority boundary. Your
+     * callback MUST re-verify that `ctx.account` is a sandbox account
+     * before returning fixtures (and the framework additionally skips the
+     * bridge when it has a resolved non-sandbox account, belt-and-suspenders).
+     */
+    getSeededProducts?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<Product[]> | Product[];
+}
+/**
+ * Sandbox-request predicate. Reads the spec's two canonical sandbox markers:
+ *
+ *   1. `account.sandbox === true` on the request (per AccountReference
+ *      discriminator — the brand+operator variant carries the flag).
+ *   2. `context.sandbox === true` — storyboards that don't scope through an
+ *      account still flag the envelope so the server can tell them apart.
+ *
+ * Either match is sufficient. Anything else returns `false` and the seeded
+ * fixtures stay hidden. Keep this conservative — a `true` result opts the
+ * request into test-only code paths, so a permissive predicate leaks
+ * fixture data into production.
+ */
+export declare function isSandboxRequest(input: Record<string, unknown>): boolean;
+/**
+ * Merge seeded products into a `get_products` response payload.
+ *
+ * Existing products from the handler come first; seeded entries append
+ * after deduping by `product_id`. On collision, the seeded entry wins so
+ * storyboards that seed to override default inventory see the fixture.
+ *
+ * Returns a NEW response object — the original is not mutated. The
+ * `sandbox: true` flag is stamped on the merged response unless the
+ * handler explicitly declared `sandbox: false` (which stays authoritative
+ * — a handler that has already decided the request is non-sandbox
+ * shouldn't be overridden by the bridge).
+ */
+export declare function mergeSeededProductsIntoResponse(response: GetProductsResponse, seeded: readonly Product[]): GetProductsResponse;
+/**
+ * Validate and normalize a list of seeded products returned from a
+ * {@link TestControllerBridge.getSeededProducts} callback. Invalid entries
+ * are dropped with a warning rather than thrown — a broken test fixture
+ * shouldn't tank the request under test. Valid entries pass through as-is.
+ *
+ * An entry is considered valid when it's a plain object with a string
+ * `product_id`. Entries missing `product_id` would collide on
+ * `undefined === undefined` when deduping, so we drop them early.
+ */
+export declare function filterValidSeededProducts(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): Product[];
+/**
+ * Bridge the default test-controller store (a `Map<string, unknown>` that
+ * holds seeded fixtures by `product_id`, populated by `seed_product` scenarios)
+ * to a {@link TestControllerBridge}.
+ *
+ * Each stored fixture is merged onto `productDefaults` via
+ * {@link mergeSeedProduct} — sellers pass their canonical baseline (delivery
+ * type, channels, reporting capabilities, ...) once here, and the permissive
+ * merge fills in whatever the storyboard fixture didn't declare. The bridge
+ * then returns the resulting `Product[]` for the dispatcher to merge into
+ * `get_products` responses.
+ *
+ * Accepts any `Map<string, unknown>` so it composes with session-scoped
+ * stores as well as the default process-wide one.
+ *
+ * @example
+ * ```ts
+ * const store = new Map<string, unknown>();
+ * const server = createAdcpServer({
+ *   testController: bridgeFromTestControllerStore(store, {
+ *     delivery_type: 'guaranteed',
+ *     channels: ['display'],
+ *   }),
+ * });
+ * ```
+ */
+export declare function bridgeFromTestControllerStore<TAccount = unknown>(store: Map<string, unknown>, productDefaults?: Partial<Product>): TestControllerBridge<TAccount>;
+/**
+ * Options for {@link bridgeFromSessionStore}.
+ *
+ * Passed as an options object (rather than positional args) so future
+ * additions (logger, sandbox override, cache hooks) land non-breakingly.
+ * `loadSession` here receives the raw `get_products` request — distinct
+ * from any session-loader a seller writes elsewhere that takes `{ context }`.
+ */
+export interface BridgeFromSessionStoreOptions<TSession> {
+    /**
+     * Resolve the session for the current request. Receives the raw
+     * `get_products` request post-schema-validation; pull whatever key
+     * you use (`session_id`, `brand.domain`, `account_id`) out of
+     * `input.context` / `input.account` / `input.brand` and return the
+     * session object. May be async.
+     *
+     * Errors propagate unchanged to the dispatcher — a `loadSession`
+     * rejection fails the bridge call rather than silently producing an
+     * empty seed list (seed loss under DB failure would be worse than a
+     * loud error, and the storyboard runner surfaces the failure).
+     */
+    loadSession: (input: Record<string, unknown>) => Promise<TSession> | TSession;
+    /**
+     * Extract the seeded products from a resolved session. Return a Map,
+     * any `[productId, fixture]` iterable, or a Promise of one — the
+     * bridge awaits the return value so callers with lazy-loaded seed
+     * collections don't have to eagerly hydrate inside `loadSession`.
+     * Return `null` / `undefined` when the session has no seeds.
+     */
+    selectSeededProducts: (session: TSession) => Iterable<readonly [string, unknown]> | Promise<Iterable<readonly [string, unknown]> | null | undefined> | null | undefined;
+    /**
+     * Baseline product fields every seeded fixture is merged onto via
+     * {@link mergeSeedProduct}. Storyboards can then seed sparse
+     * `{ name, targeting }` fixtures and the baseline fills in reporting
+     * / pricing / property fields the response schema requires.
+     */
+    productDefaults?: Partial<Product>;
+}
+/**
+ * Session-scoped variant of {@link bridgeFromTestControllerStore}.
+ *
+ * {@link bridgeFromTestControllerStore} closes over a single `Map` at
+ * construction time — fine for a process-wide seed store, but doesn't
+ * compose with sellers whose seed state is per-tenant / per-brand / per-
+ * `account_id` and loaded from Postgres or Redis on every request. Those
+ * sellers end up rewriting the same "load session, pull the seed Map,
+ * merge into products" glue each time.
+ *
+ * Sandbox gating and dedup happen in the dispatcher (same path as the
+ * default-store bridge); this helper returns fixtures unconditionally
+ * and leaves scoping to the framework.
+ *
+ * @example
+ * ```ts
+ * import { bridgeFromSessionStore } from '@adcp/sdk/server';
+ *
+ * const server = createAdcpServer({
+ *   testController: bridgeFromSessionStore({
+ *     loadSession: (input) => loadComplySession(sessionKeyFromInput(input)),
+ *     selectSeededProducts: (session) => session.complyExtensions.seededProducts,
+ *     productDefaults: SEED_PRODUCT_DEFAULTS,
+ *   }),
+ * });
+ * ```
+ */
+export declare function bridgeFromSessionStore<TSession, TAccount = unknown>(opts: BridgeFromSessionStoreOptions<TSession>): TestControllerBridge<TAccount>;
+//# sourceMappingURL=test-controller-bridge.d.ts.map

package/dist/lib/server/test-controller-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-controller-bridge.d.ts","sourceRoot":"","sources":["../../../src/lib/server/test-controller-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG7E;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B,CAAC,QAAQ,GAAG,OAAO;IAC7D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB,CAAC,QAAQ,GAAG,OAAO;IACtD;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,2BAA2B,CAAC,QAAQ,CAAC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC;CACpG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAUxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,mBAAmB,CAqBrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,EACZ,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CAAE,GAC3E,OAAO,EAAE,CAsBX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,GAAG,OAAO,EAC9D,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3B,eAAe,GAAE,OAAO,CAAC,OAAO,CAAM,GACrC,oBAAoB,CAAC,QAAQ,CAAC,CAchC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,6BAA6B,CAAC,QAAQ;IACrD;;;;;;;;;;;OAWG;IACH,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;IAE9E;;;;;;OAMG;IACH,oBAAoB,EAAE,CACpB,OAAO,EAAE,QAAQ,KAEf,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAChE,IAAI,GACJ,SAAS,CAAC;IAEd;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,EACjE,IAAI,EAAE,6BAA6B,CAAC,QAAQ,CAAC,GAC5C,oBAAoB,CAAC,QAAQ,CAAC,CAkBhC"}