@agentick/core 0.0.1

package/dist/channels/service.d.ts

@@ -0,0 +1,684 @@
+import type { Channel } from "@agentick/kernel";
+import { ChannelSession, type ChannelEvent, type ChannelServiceInterface } from "@agentick/kernel";
+import type { EngineContext } from "../types";
+export { Channel, ChannelSession, type ChannelEvent, type ChannelServiceInterface, type ChannelTarget, } from "@agentick/kernel";
+/**
+ * Connection metadata for routing decisions.
+ * Provided when connecting, used by transport for auto-join and routing.
+ */
+export interface ConnectionMetadata {
+    /** User ID - for auto-joining user rooms */
+    userId?: string;
+    /** Tenant ID - for auto-joining tenant rooms */
+    tenantId?: string;
+    /** Any additional metadata for custom routing */
+    [key: string]: unknown;
+}
+/**
+ * Configuration for ChannelTransport.
+ */
+export interface ChannelTransportConfig {
+    /**
+     * Auto-join rooms based on connection metadata.
+     * Called on connect with the connection's metadata.
+     * Return array of room names to automatically join.
+     *
+     * @example
+     * ```typescript
+     * autoJoinRooms: (meta) => [
+     *   meta.userId && `user:${meta.userId}`,
+     *   meta.tenantId && `tenant:${meta.tenantId}`,
+     * ].filter(Boolean)
+     * ```
+     */
+    autoJoinRooms?: (metadata: ConnectionMetadata) => string[];
+}
+/**
+ * Transport adapter for external communication (e.g., SSE, WebSocket).
+ * Optional add-on layer - channels work without transport.
+ *
+ * Supports room-based routing (inspired by Socket.io):
+ * - Connections can join/leave rooms
+ * - Events can target specific rooms
+ * - excludeSender provides "broadcast" semantics (send to others)
+ */
+export interface ChannelTransport {
+    /**
+     * Transport name (e.g., 'sse', 'websocket')
+     */
+    name: string;
+    /**
+     * Connect a client with optional metadata.
+     * Metadata is used for routing (userId, tenantId, etc.) and auto-join.
+     */
+    connect(connectionId: string, metadata?: ConnectionMetadata): Promise<void>;
+    /**
+     * Disconnect a client (or all if no connectionId).
+     */
+    disconnect(connectionId?: string): Promise<void>;
+    /**
+     * Send an event through the transport.
+     * Routing is determined by event.target:
+     * - No target: broadcast to all
+     * - target.connectionId: send to specific connection
+     * - target.rooms: send to connections in rooms
+     * - target.excludeSender: exclude source connection (broadcast pattern)
+     */
+    send(event: ChannelEvent): Promise<void>;
+    /**
+     * Register handler for events received from transport.
+     */
+    onReceive(handler: (event: ChannelEvent) => void): void;
+    /**
+     * Join a room. Connections in the same room receive room-targeted events.
+     */
+    join?(connectionId: string, room: string): Promise<void>;
+    /**
+     * Leave a room.
+     */
+    leave?(connectionId: string, room: string): Promise<void>;
+    /**
+     * Get rooms a connection has joined.
+     */
+    getConnectionRooms?(connectionId: string): string[];
+    /**
+     * Get connections in a room.
+     */
+    getRoomConnections?(room: string): string[];
+    /**
+     * Close all connections.
+     */
+    closeAll(): void;
+}
+/**
+ * Distribution adapter for multi-instance setups (e.g., Redis pub/sub).
+ * Optional add-on layer - channels work without distribution.
+ *
+ * For room-based routing in distributed setups:
+ * - Adapter subscribes to room channels (e.g., Redis `room:{roomName}`)
+ * - When event.target.rooms is set, adapter publishes to those room channels
+ * - Each instance receives and filters to its local connections
+ */
+export interface ChannelAdapter {
+    /**
+     * Adapter name (e.g., 'redis')
+     */
+    name: string;
+    /**
+     * Publish event to distribution layer.
+     * If event.target.rooms is set, publish to room-specific channels.
+     */
+    publish(event: ChannelEvent): Promise<void>;
+    /**
+     * Subscribe to events from distribution layer.
+     */
+    subscribe(channel: string, handler: (event: ChannelEvent) => void): Promise<() => void>;
+    /**
+     * Subscribe this instance to a room.
+     * Called when a local connection joins a room.
+     * Adapter should subscribe to the room's distribution channel (e.g., Redis `room:{room}`).
+     */
+    joinRoom?(room: string): Promise<void>;
+    /**
+     * Unsubscribe this instance from a room.
+     * Called when no local connections remain in the room.
+     */
+    leaveRoom?(room: string): Promise<void>;
+    /**
+     * Close the adapter connection (cleanup on shutdown).
+     */
+    close?(): Promise<void>;
+}
+/**
+ * Channel service configuration.
+ */
+export interface ChannelServiceConfig {
+    /**
+     * Custom session ID generator.
+     * Default: Uses user context + conversation ID or trace ID.
+     */
+    sessionIdGenerator?: (ctx: EngineContext) => string;
+    /**
+     * Optional transport adapter (e.g., Streamable HTTP, WebSocket).
+     */
+    transport?: ChannelTransport;
+    /**
+     * Optional distribution adapter (e.g., Redis pub/sub).
+     */
+    adapter?: ChannelAdapter;
+    /**
+     * Session timeout in milliseconds (default: 1 hour).
+     * Sessions are cleaned up after inactivity.
+     */
+    sessionTimeout?: number;
+    /**
+     * Channel routers to register.
+     * Enables handleEvent() dispatch by channel name without if-else chains.
+     *
+     * @example
+     * ```typescript
+     * routers: [todoListChannel, scratchpadChannel]
+     * ```
+     */
+    routers?: ChannelRouter<any>[];
+}
+/**
+ * Channel Service - Low-level channel infrastructure.
+ *
+ * ## Architecture
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │  Application Layer (recommended)                                    │
+ * │  └── ChannelRouter - declarative handlers, context registry,       │
+ * │                      auto-notifications, scoped publishing          │
+ * ├─────────────────────────────────────────────────────────────────────┤
+ * │  Service Layer (escape hatch)                                       │
+ * │  └── ChannelService - sessions, direct publish/subscribe,          │
+ * │                       transport & adapter management                │
+ * ├─────────────────────────────────────────────────────────────────────┤
+ * │  Infrastructure Layer                                               │
+ * │  ├── Transport - external communication (SSE, WebSocket)           │
+ * │  └── Adapter - multi-instance distribution (Redis pub/sub)         │
+ * └─────────────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * ## Usage
+ *
+ * **Recommended:** Use `ChannelRouter` for application code.
+ * - Register routers with engine: `createEngine({ channels: { routers: [...] } })`
+ * - Handle events via `channelService.handleEvent()`
+ * - Components register via `router.registerContext()`
+ *
+ * **Escape hatch:** Direct `ChannelService` methods for advanced cases.
+ * - `subscribe()` - low-level channel subscription
+ * - `publish()` - low-level event publishing
+ *
+ * Sessions persist across multiple engine executions.
+ */
+export declare class ChannelService implements ChannelServiceInterface {
+    private sessions;
+    private sessionIdGenerator;
+    private transport?;
+    private adapter?;
+    private sessionTimeout;
+    private cleanupInterval?;
+    private adapterSubscriptions;
+    private routerRegistry;
+    constructor(config?: ChannelServiceConfig);
+    /**
+     * Get the transport adapter (for external access, e.g., HTTP routes).
+     */
+    getTransport(): ChannelTransport | undefined;
+    /**
+     * Get a registered channel router by name.
+     */
+    getRouter<TContext = unknown>(channelName: string): ChannelRouter<TContext> | undefined;
+    /**
+     * Handle an event by delegating to the appropriate registered router.
+     * Eliminates if-else chains in HTTP routes.
+     *
+     * @param channelName - Name of the channel
+     * @param request - Event type and payload
+     * @param context - Context passed to the handler
+     * @returns Result from the handler (for HTTP response body)
+     *
+     * @example
+     * ```typescript
+     * // In HTTP route - no if-else needed
+     * const result = await engine.channels?.handleEvent('todo-list',
+     *   { type: 'create_task', payload },
+     *   { userId, broadcast: true }
+     * );
+     * res.json({ success: true, ...result });
+     * ```
+     */
+    handleEvent<TContext = unknown, TResult = unknown>(channelName: string, request: {
+        type: string;
+        payload: unknown;
+    }, rawContext: Record<string, unknown>): Promise<TResult | undefined>;
+    /**
+     * Get or create a session for the current context.
+     */
+    getSession(ctx: EngineContext): ChannelSession;
+    /**
+     * Get or create a channel within the current session.
+     */
+    getChannel(ctx: EngineContext, channelName: string): Channel;
+    /**
+     * Low-level: Publish an event to a channel.
+     *
+     * **Prefer using ChannelRouter.publisher() for application code.**
+     * This is an escape hatch for advanced use cases.
+     */
+    publish(ctx: EngineContext, channelName: string, event: Omit<ChannelEvent, "channel">): void;
+    /**
+     * Low-level: Subscribe to events on a channel with a handler function.
+     *
+     * **Prefer using ChannelRouter for application code.**
+     * This is an escape hatch for advanced use cases.
+     */
+    subscribe(ctx: EngineContext, channelName: string, handler: (event: ChannelEvent) => void | Promise<void>): () => void;
+    /**
+     * Low-level: Subscribe to multiple channels at once.
+     *
+     * **Prefer using ChannelRouter for application code.**
+     * This is an escape hatch for advanced use cases.
+     *
+     * @param ctx - Engine context
+     * @param channelNames - Array of channel names to subscribe to, or '*' for all channels
+     * @param handler - Handler function that receives events from any subscribed channel
+     * @returns Unsubscribe function
+     */
+    subscribeToChannels(ctx: EngineContext, channelNames: string[] | "*", handler: (event: ChannelEvent) => void): () => void;
+    /**
+     * Low-level: Subscribe to events filtered by session ID.
+     *
+     * **Prefer using ChannelRouter for application code.**
+     * This is an escape hatch for advanced use cases.
+     *
+     * @param ctx - Engine context
+     * @param channelName - Channel name to subscribe to, or '*' for all channels
+     * @param handler - Handler function that receives filtered events
+     * @param options - Optional filter options
+     * @returns Unsubscribe function
+     */
+    subscribeFiltered(ctx: EngineContext, channelName: string | "*", handler: (event: ChannelEvent) => void, options?: {
+        sessionId?: string;
+        channelFilter?: (channelName: string) => boolean;
+    }): () => void;
+    /**
+     * Wait for a response on a channel (for bidirectional communication).
+     */
+    waitForResponse(ctx: EngineContext, channelName: string, requestId: string, timeoutMs?: number): Promise<ChannelEvent>;
+    /**
+     * Setup transport handlers.
+     * Forwards events received from transport to local channels.
+     */
+    private setupTransport;
+    /**
+     * Setup adapter handlers.
+     * Subscribes to channels via adapter and forwards events to local channels.
+     */
+    private setupAdapter;
+    /**
+     * Start cleanup interval for expired sessions.
+     */
+    private startCleanupInterval;
+    /**
+     * Destroy a session and cleanup resources.
+     */
+    destroySession(sessionId: string): void;
+    /**
+     * Cleanup all sessions and resources.
+     */
+    destroy(): void;
+}
+/**
+ * Scope definition for room-based routing and context matching.
+ *
+ * - ScopeMapping: { prefix: fieldName } - derives scope key from context field
+ * - ScopeMapping[]: multiple mappings - registers for all, dedupes on notify
+ * - function: (ctx) => fully qualified scope key(s) like 'user:alice'
+ *
+ * @example
+ * ```typescript
+ * // Mapping - prefix + field name
+ * scope: { user: 'userId' }  // → 'user:alice' from ctx.userId
+ *
+ * // Multiple mappings
+ * scope: [{ user: 'userId' }, { thread: 'threadId' }]
+ *
+ * // Function - returns fully qualified key(s)
+ * scope: (ctx) => `user:${ctx.userId}`
+ * scope: (ctx) => [`user:${ctx.userId}`, `org:${ctx.orgId}`]
+ * ```
+ */
+export type ScopeDefinition = ScopeMapping | ScopeMapping[] | ((ctx: any) => string | string[]);
+/**
+ * Configuration for ChannelRouter.
+ */
+export interface ChannelRouterConfig {
+    /**
+     * Transport for sending events (SSE, WebSocket, etc.)
+     * Can be a transport instance or a getter function.
+     */
+    transport?: ChannelTransport | (() => ChannelTransport);
+    /**
+     * Channel service for subscribing to events.
+     * Typically injected via setChannelService() when router is registered.
+     */
+    channelService?: ChannelService | (() => ChannelService);
+    /**
+     * Scope definition for room-based routing and context matching.
+     * Maps scope names to context field names.
+     *
+     * @example
+     * ```typescript
+     * // Single scope
+     * scope: { user: 'userId' }
+     * // → .to(id) broadcasts to 'user:{id}'
+     * // → registerContext uses ctx.userId for matching
+     *
+     * // Multiple scopes
+     * scope: { user: 'userId', thread: 'threadId' }
+     * // → .scope('user').to(id) broadcasts to 'user:{id}'
+     * // → .scope('thread').to(id) broadcasts to 'thread:{id}'
+     * // → registerContext uses both for matching
+     *
+     * // Function (advanced)
+     * scope: (ctx) => `user:${ctx.userId}`
+     * ```
+     */
+    scope?: ScopeDefinition | (() => ScopeDefinition);
+    /**
+     * Builder function to transform raw context (e.g., from HTTP) into TSubscribeContext.
+     */
+    contextBuilder?: (data: any) => any;
+}
+/**
+ * Scope mapping: { prefix: fieldName }
+ * Used to derive both room names and scope keys from context.
+ *
+ * @example
+ * ```typescript
+ * { user: 'userId' }  // → room 'user:alice', scopeKey 'user:alice'
+ * ```
+ */
+export type ScopeMapping = {
+    [prefix: string]: string;
+};
+/**
+ * Value or getter function.
+ */
+export type ValueOrGetter<T> = T | (() => T);
+/**
+ * Scoped publisher - has scope set, needs .to(id) to complete.
+ */
+export interface ScopedPublisher {
+    /**
+     * Set the target ID and get a bound publisher.
+     * @param id - Target ID (string or getter function)
+     */
+    to(id: ValueOrGetter<string>): BoundPublisher;
+}
+/**
+ * Bound publisher - ready to send/broadcast.
+ */
+export interface BoundPublisher {
+    send(event: {
+        type: string;
+        payload: unknown;
+    }): Promise<void>;
+    broadcast(event: {
+        type: string;
+        payload: unknown;
+    }, options?: {
+        sourceConnectionId?: string;
+    }): Promise<void>;
+}
+/**
+ * Publisher interface for sending events to channel rooms.
+ *
+ * @example
+ * ```typescript
+ * // Given scope config: { user: 'userId', thread: 'threadId' }
+ *
+ * // Select scope and target
+ * publisher.scope('user').to(userId).broadcast(event);    // → room 'user:{userId}'
+ * publisher.scope('thread').to(threadId).broadcast(event); // → room 'thread:{threadId}'
+ *
+ * // Direct .to() uses first scope key from config
+ * publisher.to(userId).broadcast(event);  // → room 'user:{userId}'
+ * ```
+ */
+export interface ChannelPublisher {
+    /**
+     * Select which scope mapping to use for routing.
+     *
+     * @param scopeKey - Key from scope config (e.g., 'user', 'thread')
+     */
+    scope(scopeKey: string): ScopedPublisher;
+    /**
+     * Set the target ID directly (uses first scope key from config).
+     * Returns a BoundPublisher ready to send/broadcast.
+     *
+     * @param id - Target ID (string or getter function)
+     */
+    to(id: ValueOrGetter<string>): BoundPublisher;
+}
+/**
+ * Event handler type for ChannelRouter.
+ * Receives the event and optional subscribe context.
+ *
+ * @template TContext - Type of the subscribe context
+ */
+export type ChannelEventHandler<TContext = unknown> = (event: ChannelEvent, context: TContext) => any | Promise<any>;
+/**
+ * ChannelRouter - Declarative channel event handling and publishing.
+ *
+ * **This is the recommended way to work with channels in application code.**
+ *
+ * ## Features
+ * - Declarative event handlers via `.on(eventType, handler)`
+ * - Scoped publishing via `.publisher().scope('user').to(id).broadcast()`
+ * - Execution context registry with auto-notification after handlers return
+ * - Auto-cleanup when executions end
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * // 1. Define router with scope mapping
+ * const todoChannel = new ChannelRouter<TodoContext>('todo-list', {
+ *   scope: { user: 'userId' },
+ * })
+ *   .on('create_task', async (event, ctx) => {
+ *     return TodoService.createTask(ctx.userId, event.payload);
+ *   });
+ *
+ * // 2. Register with engine (injects ChannelService)
+ * createEngine({ channels: { routers: [todoChannel] } });
+ *
+ * // 3. In components - register for auto-notification
+ * const publisher = channel.registerContext(ctx, { userId }, (event, result) => {
+ *   if (result?.success) ctx.setState('tasks', result.tasks);
+ * });
+ *
+ * // 4. Publish events
+ * publisher.to(userId).broadcast({ type: 'state_changed', payload });
+ *
+ * // 5. Cleanup on unmount
+ * channel.unregisterContext(ctx);
+ * ```
+ *
+ * @template TSubscribeContext - Type of the context passed to handlers
+ */
+/**
+ * Callback invoked when a channel event is handled.
+ * Receives the event and the handler's result.
+ */
+export type ContextEventCallback<TResult = unknown> = (event: ChannelEvent, result: TResult) => void;
+export declare class ChannelRouter<TSubscribeContext = unknown> {
+    readonly channel: string;
+    private config;
+    private handlers;
+    private defaultHandler?;
+    private errorHandler?;
+    /**
+     * Registry of execution contexts.
+     * Key format: `${executionId}:${scopeKey}`
+     * Allows multiple executions to register for same scope, each with own callbacks.
+     */
+    private contextRegistry;
+    constructor(channel: string, config?: ChannelRouterConfig);
+    getTransport(): ChannelTransport;
+    getChannelService(): ChannelService;
+    setChannelService(service: ChannelService): void;
+    setTransport(transport: ChannelTransport): void;
+    setScope(scope: ScopeDefinition): void;
+    setContextBuilder(contextBuilder: (data: any) => any): void;
+    /**
+     * Register a handler for a specific event type.
+     * Handler receives (event, context) where context is built from the request
+     * via contextBuilder or passed directly to handle().
+     */
+    on(eventType: string, handler: ChannelEventHandler<TSubscribeContext>): this;
+    /**
+     * Register a default handler for unmatched event types.
+     */
+    default(handler: ChannelEventHandler<TSubscribeContext>): this;
+    /**
+     * Register an error handler.
+     */
+    onError(handler: (error: Error, event: ChannelEvent) => void): this;
+    /**
+     * Handle an incoming event.
+     * Called by ChannelService.handleEvent() or directly.
+     * Auto-notifies registered execution contexts after handler returns.
+     *
+     * @param event - The channel event to handle
+     * @param context - Context for the handler (required)
+     * @returns Result from the handler, or undefined if no handler matched
+     */
+    handle<TResult = unknown>(event: ChannelEvent, context: TSubscribeContext): Promise<TResult | undefined>;
+    /**
+     * Build the context for the handler.
+     */
+    buildContext(data: any): TSubscribeContext;
+    /**
+     * Check if value is a ScopeMapping (object with string values, not an array or function)
+     */
+    private isScopeMapping;
+    /**
+     * Extract scope keys from channel context based on scope config.
+     * Returns array of fully qualified keys like 'prefix:value'.
+     *
+     * @example
+     * // scope: { user: 'userId' }, ctx: { userId: 'alice' }
+     * // → ['user:alice']
+     *
+     * // scope: [{ user: 'userId' }, { thread: 'threadId' }], ctx: { userId: 'alice', threadId: '123' }
+     * // → ['user:alice', 'thread:123']
+     *
+     * // scope: (ctx) => `user:${ctx.userId}`, ctx: { userId: 'alice' }
+     * // → ['user:alice']
+     */
+    private getScopeKeys;
+    /**
+     * Extract scope keys from a single ScopeMapping.
+     */
+    private extractKeysFromMapping;
+    /**
+     * Register an execution's context with this channel.
+     * When channel events are handled, the onEvent callback is automatically invoked
+     * with the event and handler result.
+     *
+     * @param ctx - Engine context (provides executionHandle for auto-cleanup)
+     * @param channelContext - The context to register (used for scope matching)
+     * @param onEvent - Callback invoked after handler returns (receives event + result)
+     * @returns ChannelPublisher for publishing events
+     *
+     * @example
+     * ```typescript
+     * // In component onMount
+     * const publisher = channel.registerContext(ctx, { userId }, (event, result) => {
+     *   if (result?.success) ctx.setState('tasks', result.tasks);
+     * });
+     * publisher.to(userId).broadcast({ type: 'state_changed', payload });
+     *
+     * // In component onUnmount
+     * channel.unregisterContext(ctx);
+     * ```
+     */
+    registerContext(ctx: EngineContext, channelContext: TSubscribeContext, onEvent?: ContextEventCallback): ChannelPublisher;
+    /**
+     * Unregister all contexts for an execution.
+     * Alternative to storing the returned function from registerContext.
+     *
+     * @param ctx - Engine context to unregister
+     */
+    unregisterContext(ctx: EngineContext): void;
+    /**
+     * Clean up all contexts for a specific execution ID.
+     * Called as a fail-safe when execution ends.
+     *
+     * @param executionId - The execution ID to clean up
+     */
+    cleanupExecution(executionId: string): void;
+    /**
+     * Extract the scope key from a registry key.
+     * Registry keys are formatted as `${executionId}:${scopeKey}`.
+     * We find the first colon and take everything after it as the scopeKey.
+     */
+    private extractScopeKeyFromRegistryKey;
+    /**
+     * Execute a callback for each registered context matching scope(s).
+     * Scope keys are derived from the provided context (or explicit scopeKey).
+     * Deduplicates by executionId - each execution's callback runs at most once.
+     *
+     * @param scopeKeyOrContext - Either explicit scope key or context to derive scope from
+     * @param fn - Callback to execute for each matching context
+     *
+     * @example
+     * ```typescript
+     * // Using context (scope derived automatically, supports multiple scopes)
+     * channel.forEachContext(ctx, (regCtx) => regCtx.onUpdate?.(result.notes));
+     *
+     * // Using explicit scope key (single key)
+     * channel.forEachContext('user:alice', (regCtx) => regCtx.onUpdate?.(result.notes));
+     * ```
+     */
+    forEachContext(scopeKeyOrContext: string | TSubscribeContext, fn: (ctx: TSubscribeContext) => void): void;
+    /**
+     * Notify all registered contexts for matching scopes with an event and result.
+     * Called automatically by handle() after handler returns.
+     * Deduplicates by executionId - each execution's callback runs at most once.
+     *
+     * @param context - Context to derive scope from
+     * @param event - The channel event
+     * @param result - The handler's result
+     */
+    private notifyRegisteredContexts;
+    /**
+     * Get the number of registered contexts (for debugging/monitoring).
+     */
+    getRegisteredContextCount(): number;
+    /**
+     * Resolve a value or getter function.
+     */
+    private resolve;
+    /**
+     * Get the scope prefix for a given scope key.
+     * If scopeKey is provided, uses that key from the mapping.
+     * Otherwise uses the first key from the mapping.
+     *
+     * Note: Function scopes are not supported for publishing via .scope()/.to() -
+     * use mapping syntax instead: { user: 'userId' }
+     */
+    private getScopePrefix;
+    /**
+     * Create a scoped publisher (has scope prefix set, needs .to(id)).
+     */
+    private createScopedPublisherForKey;
+    /**
+     * Create a bound publisher for a specific scope prefix.
+     */
+    private createBoundPublisherForPrefix;
+    /**
+     * Internal send with explicit scope prefix and id.
+     */
+    private sendInternalWithPrefix;
+    /**
+     * Create a publisher interface for this channel.
+     */
+    private createPublisher;
+    /**
+     * Get a publisher without subscribing (for services that only publish).
+     */
+    publisher(): ChannelPublisher;
+}
+/**
+ * Factory function to create a ChannelRouter with common defaults.
+ */
+export declare function createChannelRouter(channel: string, config?: ChannelRouterConfig): ChannelRouter;
+//# sourceMappingURL=service.d.ts.map

package/dist/channels/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/channels/service.ts"],"names":[],"mappings":"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"}