opinionated-machine 5.1.0 → 5.2.0

package/dist/lib/sse/sseTypes.d.ts

@@ -0,0 +1,164 @@
+import type { FastifyReply, FastifyRequest } from 'fastify';
+import type { z } from 'zod';
+import type { AnySSERouteDefinition } from './sseContracts.ts';
+/**
+ * Minimal logger interface for SSE route error handling.
+ * Compatible with CommonLogger from @lokalise/node-core and pino loggers.
+ */
+export type SSELogger = {
+    error: (obj: Record<string, unknown>, msg: string) => void;
+};
+/**
+ * Async preHandler hook for SSE routes.
+ *
+ * IMPORTANT: SSE route preHandlers MUST return a Promise. This is required
+ * for proper integration with @fastify/sse. Synchronous handlers will cause
+ * connection issues.
+ *
+ * For rejection (auth failure), return the reply after sending:
+ * ```typescript
+ * preHandler: (request, reply) => {
+ *   if (!validAuth) {
+ *     return reply.code(401).send({ error: 'Unauthorized' })
+ *   }
+ *   return Promise.resolve()
+ * }
+ * ```
+ */
+export type SSEPreHandler = (request: FastifyRequest, reply: FastifyReply) => Promise<unknown>;
+/**
+ * Represents an active SSE connection with typed context.
+ *
+ * @template Context - Custom context data stored per connection
+ */
+export type SSEConnection<Context = unknown> = {
+    /** Unique identifier for this connection */
+    id: string;
+    /** The original Fastify request */
+    request: FastifyRequest;
+    /** The Fastify reply with SSE capabilities from @fastify/sse */
+    reply: FastifyReply;
+    /** Custom context data for this connection */
+    context: Context;
+    /** Timestamp when the connection was established */
+    connectedAt: Date;
+};
+/**
+ * SSE message format compatible with @fastify/sse.
+ *
+ * @template T - Type of the event data
+ */
+export type SSEMessage<T = unknown> = {
+    /** Event name (maps to EventSource 'event' field) */
+    event?: string;
+    /** Event data (will be JSON serialized) */
+    data: T;
+    /** Event ID for client reconnection via Last-Event-ID */
+    id?: string;
+    /** Reconnection delay hint in milliseconds */
+    retry?: number;
+};
+/**
+ * Handler called when an SSE connection is established.
+ *
+ * @template Params - Path parameters type
+ * @template Query - Query string parameters type
+ * @template Headers - Request headers type
+ * @template Body - Request body type (for POST/PUT/PATCH)
+ * @template Context - Connection context type
+ */
+export type SSERouteHandler<Params = unknown, Query = unknown, Headers = unknown, Body = unknown, Context = unknown> = (request: FastifyRequest<{
+    Params: Params;
+    Querystring: Query;
+    Headers: Headers;
+    Body: Body;
+}>, connection: SSEConnection<Context>) => void | Promise<void>;
+/**
+ * Options for configuring an SSE route.
+ */
+export type SSERouteOptions = {
+    /**
+     * Async preHandler hook for authentication/authorization.
+     * Runs BEFORE the SSE connection is established.
+     *
+     * MUST return a Promise - synchronous handlers will cause connection issues.
+     * Return `reply.code(401).send(...)` for rejection, or `Promise.resolve()` for success.
+     *
+     * @see SSEPreHandler for usage examples
+     */
+    preHandler?: SSEPreHandler;
+    /**
+     * Called when client connects (after SSE handshake).
+     */
+    onConnect?: (connection: SSEConnection) => void | Promise<void>;
+    /**
+     * Called when client disconnects.
+     */
+    onDisconnect?: (connection: SSEConnection) => void | Promise<void>;
+    /**
+     * Handler for Last-Event-ID reconnection.
+     * Return an iterable of events to replay, or handle replay manually.
+     * Supports both sync iterables (arrays, generators) and async iterables.
+     */
+    onReconnect?: (connection: SSEConnection, lastEventId: string) => Iterable<SSEMessage> | AsyncIterable<SSEMessage> | void | Promise<void>;
+    /**
+     * Optional logger for SSE route errors.
+     * If not provided, errors will be logged to console.error.
+     * Compatible with CommonLogger from @lokalise/node-core and pino loggers.
+     */
+    logger?: SSELogger;
+};
+/**
+ * Route configuration returned by buildSSERoutes().
+ *
+ * @template Contract - The SSE route definition
+ */
+export type SSEHandlerConfig<Contract extends AnySSERouteDefinition> = {
+    /** The SSE route contract */
+    contract: Contract;
+    /** Handler called when connection is established */
+    handler: SSERouteHandler<z.infer<Contract['params']>, z.infer<Contract['query']>, z.infer<Contract['requestHeaders']>, Contract['body'] extends z.ZodTypeAny ? z.infer<Contract['body']> : undefined, unknown>;
+    /** Optional route configuration */
+    options?: SSERouteOptions;
+};
+/**
+ * Maps SSE contracts to handler configurations for type checking.
+ */
+export type BuildSSERoutesReturnType<APIContracts extends Record<string, AnySSERouteDefinition>> = {
+    [K in keyof APIContracts]: SSEHandlerConfig<APIContracts[K]>;
+};
+/**
+ * Infer the FastifyRequest type from an SSE contract.
+ *
+ * Use this to get properly typed request parameters in handlers without
+ * manually spelling out the types.
+ *
+ * @example
+ * ```typescript
+ * const handler = async (
+ *   request: InferSSERequest<typeof chatCompletionContract>,
+ *   connection: SSEConnection,
+ * ) => {
+ *   // request.body is typed as { message: string; stream: true }
+ *   const { message } = request.body
+ * }
+ * ```
+ */
+export type InferSSERequest<Contract extends AnySSERouteDefinition> = FastifyRequest<{
+    Params: z.infer<Contract['params']>;
+    Querystring: z.infer<Contract['query']>;
+    Headers: z.infer<Contract['requestHeaders']>;
+    Body: Contract['body'] extends z.ZodTypeAny ? z.infer<Contract['body']> : undefined;
+}>;
+/**
+ * Configuration options for SSE controllers.
+ */
+export type SSEControllerConfig = {
+    /**
+     * Enable connection spying for testing.
+     * When enabled, the controller tracks connections and allows waiting for them.
+     * Only enable this in test environments.
+     * @default false
+     */
+    enableConnectionSpy?: boolean;
+};

package/dist/lib/sse/sseTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sseTypes.js.map

package/dist/lib/sse/sseTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sseTypes.js","sourceRoot":"","sources":["../../../lib/sse/sseTypes.ts"],"names":[],"mappings":""}

package/dist/lib/testing/index.d.ts

@@ -0,0 +1,5 @@
+export { type HasConnectionSpy, SSEHttpClient, type SSEHttpConnectOptions, type SSEHttpConnectResult, type SSEHttpConnectWithSpyOptions, } from './sseHttpClient.js';
+export { SSEInjectClient, SSEInjectConnection } from './sseInjectClient.js';
+export { buildUrl, injectPayloadSSE, injectSSE } from './sseInjectHelpers.js';
+export { SSETestServer } from './sseTestServer.js';
+export type { CreateSSETestServerOptions, InjectPayloadSSEOptions, InjectSSEOptions, InjectSSEResult, SSEConnectOptions, SSEResponse, SSETestConnection, } from './sseTestTypes.js';

package/dist/lib/testing/index.js

@@ -0,0 +1,5 @@
+export { SSEHttpClient, } from './sseHttpClient.js';
+export { SSEInjectClient, SSEInjectConnection } from './sseInjectClient.js';
+export { buildUrl, injectPayloadSSE, injectSSE } from './sseInjectHelpers.js';
+export { SSETestServer } from './sseTestServer.js';
+//# sourceMappingURL=index.js.map

package/dist/lib/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,GAId,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/lib/testing/sseHttpClient.d.ts

@@ -0,0 +1,203 @@
+import type { SSEConnectionSpy } from '../sse/SSEConnectionSpy.ts';
+import { type ParsedSSEEvent } from '../sse/sseParser.ts';
+import type { SSEConnection } from '../sse/sseTypes.ts';
+/**
+ * Interface for objects that have a connectionSpy (e.g., SSE controllers in test mode).
+ */
+export type HasConnectionSpy = {
+    connectionSpy: SSEConnectionSpy;
+};
+/**
+ * Options for connecting to an SSE endpoint via HTTP.
+ */
+export type SSEHttpConnectOptions = {
+    /** Query parameters to add to the URL */
+    query?: Record<string, string | undefined>;
+    /** Additional headers to send with the request */
+    headers?: Record<string, string>;
+};
+/**
+ * Options for connecting with automatic server-side connection waiting.
+ */
+export type SSEHttpConnectWithSpyOptions = SSEHttpConnectOptions & {
+    /**
+     * Wait for server-side connection registration after HTTP headers are received.
+     * This eliminates the race condition between `connect()` returning and the
+     * server-side handler completing connection registration.
+     */
+    awaitServerConnection: {
+        /** The SSE controller (must have connectionSpy enabled via isTestMode) */
+        controller: HasConnectionSpy;
+        /** Timeout in milliseconds (default: 5000) */
+        timeout?: number;
+    };
+};
+/**
+ * Result when connecting with awaitServerConnection option.
+ */
+export type SSEHttpConnectResult = {
+    client: SSEHttpClient;
+    serverConnection: SSEConnection;
+};
+/**
+ * SSE client for testing long-lived connections using real HTTP.
+ *
+ * This client uses the native `fetch()` API to establish a real HTTP connection
+ * to an SSE endpoint. Events are streamed incrementally as the server sends them,
+ * making it suitable for testing:
+ *
+ * - **Long-lived connections** that stay open indefinitely
+ * - **Real-time notifications** where events arrive over time
+ * - **Push-based streaming** where the client waits for server-initiated events
+ *
+ * **When to use SSEHttpClient vs SSEInjectClient:**
+ *
+ * | SSEHttpClient (this class)          | SSEInjectClient                      |
+ * |-------------------------------------|--------------------------------------|
+ * | Real HTTP connection via fetch()    | Fastify's inject() (no network)     |
+ * | Events arrive incrementally         | All events returned at once         |
+ * | Connection can stay open            | Response must complete              |
+ * | Requires running server (listen())  | Works without starting server       |
+ * | Use for: notifications, chat, feeds | Use for: OpenAI-style streaming     |
+ *
+ * @example
+ * ```typescript
+ * // 1. Start a real HTTP server
+ * await app.listen({ port: 0 })
+ * const address = app.server.address() as { port: number }
+ * const baseUrl = `http://localhost:${address.port}`
+ *
+ * // 2. Connect to SSE endpoint (returns when headers are received)
+ * const client = await SSEHttpClient.connect(baseUrl, '/api/notifications', {
+ *   headers: { authorization: 'Bearer token' },
+ * })
+ *
+ * // 3. Server can now send events at any time
+ * controller.sendEvent(connectionId, { event: 'notification', data: { msg: 'Hello' } })
+ *
+ * // 4. Collect events as they arrive
+ * const events = await client.collectEvents(3) // wait for 3 events
+ * // or: collect until a specific event
+ * const events = await client.collectEvents(e => e.event === 'done')
+ *
+ * // 5. Alternative: use async iterator for manual control
+ * for await (const event of client.events()) {
+ *   console.log('Received:', event.event, event.data)
+ *   if (event.event === 'done') break
+ * }
+ *
+ * // 6. Cleanup
+ * client.close()
+ * await app.close()
+ * ```
+ */
+export declare class SSEHttpClient {
+    /** The fetch Response object. Available immediately after connect() returns. */
+    readonly response: Response;
+    private readonly abortController;
+    private readonly reader;
+    private readonly decoder;
+    private buffer;
+    private closed;
+    private constructor();
+    /**
+     * Connect to an SSE endpoint.
+     *
+     * The returned promise resolves as soon as HTTP headers are received,
+     * indicating the connection is established. Events can then be consumed
+     * via `events()` or `collectEvents()`.
+     *
+     * @param baseUrl - Base URL of the server (e.g., 'http://localhost:3000')
+     * @param path - SSE endpoint path (e.g., '/api/notifications')
+     * @param options - Connection options (query params, headers)
+     * @returns Connected SSE client ready to receive events
+     *
+     * @example
+     * ```typescript
+     * // Basic connection (returns when HTTP headers received)
+     * const client = await SSEHttpClient.connect(
+     *   'http://localhost:3000',
+     *   '/api/stream',
+     *   { query: { userId: '123' }, headers: { authorization: 'Bearer token' } }
+     * )
+     *
+     * // With awaitServerConnection (waits for server-side registration)
+     * const { client, serverConnection } = await SSEHttpClient.connect(
+     *   'http://localhost:3000',
+     *   '/api/stream',
+     *   { awaitServerConnection: { controller } }
+     * )
+     * // serverConnection is ready to use immediately
+     * await controller.sendEvent(serverConnection.id, { event: 'test', data: {} })
+     * ```
+     */
+    static connect(baseUrl: string, path: string, options: SSEHttpConnectWithSpyOptions): Promise<SSEHttpConnectResult>;
+    static connect(baseUrl: string, path: string, options?: SSEHttpConnectOptions): Promise<SSEHttpClient>;
+    /**
+     * Async generator that yields parsed SSE events as they arrive.
+     *
+     * Use this for full control over event processing. The generator
+     * completes when the server closes the connection or the abort signal fires.
+     *
+     * @param signal - Optional AbortSignal to stop the generator early
+     *
+     * @example
+     * ```typescript
+     * for await (const event of client.events()) {
+     *   const data = JSON.parse(event.data)
+     *   console.log(`[${event.event}]`, data)
+     *
+     *   if (event.event === 'done') {
+     *     break // Stop consuming, connection stays open until close()
+     *   }
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With abort signal for timeout control
+     * const controller = new AbortController()
+     * setTimeout(() => controller.abort(), 5000)
+     *
+     * for await (const event of client.events(controller.signal)) {
+     *   console.log(event)
+     * }
+     * ```
+     */
+    events(signal?: AbortSignal): AsyncGenerator<ParsedSSEEvent, void, unknown>;
+    /**
+     * Read from the stream with abort signal support.
+     * Returns 'aborted' if the signal fires before read completes.
+     */
+    private readWithAbort;
+    /**
+     * Collect events until a count is reached or predicate returns true.
+     *
+     * @param countOrPredicate - Either a number of events to collect,
+     *   or a predicate function that returns true when collection should stop.
+     *   The event that matches the predicate IS included in the result.
+     * @param timeout - Maximum time to wait in milliseconds (default: 5000)
+     * @returns Array of collected events
+     * @throws Error if timeout is reached before condition is met
+     *
+     * @example
+     * ```typescript
+     * // Collect exactly 5 events
+     * const events = await client.collectEvents(5)
+     *
+     * // Collect until 'done' event is received
+     * const events = await client.collectEvents(e => e.event === 'done')
+     *
+     * // Collect with custom timeout
+     * const events = await client.collectEvents(10, 30000) // 30s timeout
+     * ```
+     */
+    collectEvents(countOrPredicate: number | ((event: ParsedSSEEvent) => boolean), timeout?: number): Promise<ParsedSSEEvent[]>;
+    /**
+     * Close the connection from the client side.
+     *
+     * This aborts the underlying fetch request. Call this when done
+     * consuming events to clean up resources.
+     */
+    close(): void;
+}

package/dist/lib/testing/sseHttpClient.js

@@ -0,0 +1,262 @@
+import { stringify } from 'fast-querystring';
+import { parseSSEBuffer } from "../sse/sseParser.js";
+/**
+ * SSE client for testing long-lived connections using real HTTP.
+ *
+ * This client uses the native `fetch()` API to establish a real HTTP connection
+ * to an SSE endpoint. Events are streamed incrementally as the server sends them,
+ * making it suitable for testing:
+ *
+ * - **Long-lived connections** that stay open indefinitely
+ * - **Real-time notifications** where events arrive over time
+ * - **Push-based streaming** where the client waits for server-initiated events
+ *
+ * **When to use SSEHttpClient vs SSEInjectClient:**
+ *
+ * | SSEHttpClient (this class)          | SSEInjectClient                      |
+ * |-------------------------------------|--------------------------------------|
+ * | Real HTTP connection via fetch()    | Fastify's inject() (no network)     |
+ * | Events arrive incrementally         | All events returned at once         |
+ * | Connection can stay open            | Response must complete              |
+ * | Requires running server (listen())  | Works without starting server       |
+ * | Use for: notifications, chat, feeds | Use for: OpenAI-style streaming     |
+ *
+ * @example
+ * ```typescript
+ * // 1. Start a real HTTP server
+ * await app.listen({ port: 0 })
+ * const address = app.server.address() as { port: number }
+ * const baseUrl = `http://localhost:${address.port}`
+ *
+ * // 2. Connect to SSE endpoint (returns when headers are received)
+ * const client = await SSEHttpClient.connect(baseUrl, '/api/notifications', {
+ *   headers: { authorization: 'Bearer token' },
+ * })
+ *
+ * // 3. Server can now send events at any time
+ * controller.sendEvent(connectionId, { event: 'notification', data: { msg: 'Hello' } })
+ *
+ * // 4. Collect events as they arrive
+ * const events = await client.collectEvents(3) // wait for 3 events
+ * // or: collect until a specific event
+ * const events = await client.collectEvents(e => e.event === 'done')
+ *
+ * // 5. Alternative: use async iterator for manual control
+ * for await (const event of client.events()) {
+ *   console.log('Received:', event.event, event.data)
+ *   if (event.event === 'done') break
+ * }
+ *
+ * // 6. Cleanup
+ * client.close()
+ * await app.close()
+ * ```
+ */
+export class SSEHttpClient {
+    /** The fetch Response object. Available immediately after connect() returns. */
+    response;
+    abortController;
+    reader;
+    decoder = new TextDecoder();
+    buffer = '';
+    closed = false;
+    constructor(response, abortController) {
+        this.response = response;
+        this.abortController = abortController;
+        if (!response.body) {
+            throw new Error('SSE response has no body');
+        }
+        this.reader = response.body.getReader();
+    }
+    static async connect(baseUrl, path, options) {
+        // Build path with query string
+        let pathWithQuery = path;
+        if (options?.query) {
+            const queryString = stringify(options.query);
+            if (queryString) {
+                pathWithQuery = `${path}?${queryString}`;
+            }
+        }
+        // Connect - fetch() returns when headers are received
+        const abortController = new AbortController();
+        const response = await fetch(`${baseUrl}${pathWithQuery}`, {
+            headers: {
+                Accept: 'text/event-stream',
+                ...options?.headers,
+            },
+            signal: abortController.signal,
+        });
+        const client = new SSEHttpClient(response, abortController);
+        // If awaitServerConnection is specified, wait for server-side registration
+        if (options && 'awaitServerConnection' in options && options.awaitServerConnection) {
+            const { controller, timeout } = options.awaitServerConnection;
+            const serverConnection = await controller.connectionSpy.waitForConnection({
+                timeout: timeout ?? 5000,
+                predicate: (conn) => conn.request.url === pathWithQuery,
+            });
+            return { client, serverConnection };
+        }
+        return client;
+    }
+    /**
+     * Async generator that yields parsed SSE events as they arrive.
+     *
+     * Use this for full control over event processing. The generator
+     * completes when the server closes the connection or the abort signal fires.
+     *
+     * @param signal - Optional AbortSignal to stop the generator early
+     *
+     * @example
+     * ```typescript
+     * for await (const event of client.events()) {
+     *   const data = JSON.parse(event.data)
+     *   console.log(`[${event.event}]`, data)
+     *
+     *   if (event.event === 'done') {
+     *     break // Stop consuming, connection stays open until close()
+     *   }
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With abort signal for timeout control
+     * const controller = new AbortController()
+     * setTimeout(() => controller.abort(), 5000)
+     *
+     * for await (const event of client.events(controller.signal)) {
+     *   console.log(event)
+     * }
+     * ```
+     */
+    async *events(signal) {
+        while (!this.closed) {
+            if (signal?.aborted) {
+                return;
+            }
+            const readResult = await this.readWithAbort(signal);
+            if (readResult === 'aborted') {
+                return;
+            }
+            if (readResult.done) {
+                this.closed = true;
+                break;
+            }
+            this.buffer += this.decoder.decode(readResult.value, { stream: true });
+            const parseResult = parseSSEBuffer(this.buffer);
+            this.buffer = parseResult.remaining;
+            for (const event of parseResult.events) {
+                if (signal?.aborted) {
+                    return;
+                }
+                yield event;
+            }
+        }
+    }
+    /**
+     * Read from the stream with abort signal support.
+     * Returns 'aborted' if the signal fires before read completes.
+     */
+    async readWithAbort(signal) {
+        const readPromise = this.reader.read();
+        if (!signal) {
+            return readPromise;
+        }
+        let raceSettled = false;
+        const abortPromise = new Promise((resolve) => {
+            const onAbort = () => {
+                if (!raceSettled) {
+                    resolve('aborted');
+                }
+            };
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+        });
+        const result = await Promise.race([readPromise, abortPromise]);
+        raceSettled = true;
+        if (result === 'aborted') {
+            // Prevent unhandled rejection when connection closes
+            readPromise.catch(() => { });
+        }
+        return result;
+    }
+    /**
+     * Collect events until a count is reached or predicate returns true.
+     *
+     * @param countOrPredicate - Either a number of events to collect,
+     *   or a predicate function that returns true when collection should stop.
+     *   The event that matches the predicate IS included in the result.
+     * @param timeout - Maximum time to wait in milliseconds (default: 5000)
+     * @returns Array of collected events
+     * @throws Error if timeout is reached before condition is met
+     *
+     * @example
+     * ```typescript
+     * // Collect exactly 5 events
+     * const events = await client.collectEvents(5)
+     *
+     * // Collect until 'done' event is received
+     * const events = await client.collectEvents(e => e.event === 'done')
+     *
+     * // Collect with custom timeout
+     * const events = await client.collectEvents(10, 30000) // 30s timeout
+     * ```
+     */
+    async collectEvents(countOrPredicate, timeout = 5000) {
+        const collected = [];
+        const isCount = typeof countOrPredicate === 'number';
+        const abortController = new AbortController();
+        const iterator = this.events(abortController.signal);
+        let timedOut = false;
+        const timeoutId = setTimeout(() => {
+            timedOut = true;
+            abortController.abort(new Error(`Timeout collecting events (got ${collected.length})`));
+        }, timeout);
+        try {
+            for await (const event of iterator) {
+                collected.push(event);
+                if (isCount && collected.length >= countOrPredicate) {
+                    break;
+                }
+                if (!isCount && countOrPredicate(event)) {
+                    break;
+                }
+            }
+            // Check if loop exited due to timeout (generator returns cleanly on abort)
+            if (timedOut) {
+                throw abortController.signal.reason;
+            }
+        }
+        catch (err) {
+            // Re-throw abort errors with our timeout message
+            if (timedOut && abortController.signal.aborted) {
+                throw abortController.signal.reason;
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+            abortController.abort(); // Signal generator to stop on early break
+        }
+        return collected;
+    }
+    /**
+     * Close the connection from the client side.
+     *
+     * This aborts the underlying fetch request. Call this when done
+     * consuming events to clean up resources.
+     */
+    close() {
+        this.closed = true;
+        // Cancel the reader first to prevent unhandled rejections from pending reads
+        this.reader.cancel().catch(() => {
+            // Expected: may already be closed or errored
+        });
+        this.abortController.abort();
+    }
+}
+//# sourceMappingURL=sseHttpClient.js.map

package/dist/lib/testing/sseHttpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sseHttpClient.js","sourceRoot":"","sources":["../../../lib/testing/sseHttpClient.ts"],"names":[],"mappings":"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"}