convex-tracer 0.1.1 → 0.1.2

package/dist/client/types.d.ts

@@ -0,0 +1,168 @@
+import type { FunctionReference, FunctionType, GenericActionCtx, GenericDatabaseReader, GenericDataModel, GenericMutationCtx, GenericQueryCtx, StorageReader } from "convex/server";
+import type { ObjectType, OptionalProperty, PropertyValidators, Validator } from "convex/values";
+import type { EmptyObject } from "../react/types";
+import type { TraceAPI } from "./tracer-api/types";
+export type AnyFunctionReference = FunctionReference<any, any>;
+export type OptionalArgsObject<Args extends PropertyValidators> = keyof Args extends never ? EmptyObject : ObjectType<Args>;
+export type IfArgs<Args extends PropertyValidators, T, F> = keyof Args extends never ? F : T;
+export type ExtractOutput<T> = T extends (ctx: any, args: any) => Promise<infer R> ? R : never;
+export interface TraceContext extends Required<TracerConfig> {
+    traceId: string;
+    spanId: string;
+}
+export type ArgsWithTraceContext<Args> = Args & {
+    __traceContext?: TraceContext;
+};
+export interface TracerConfig {
+    /**
+     * The sample rate for the trace.
+     * This is used to determine whether to sample the trace or not.
+     * @default - 0.1
+     */
+    sampleRate?: number;
+    /**
+     * Whether to preserve errors.
+     * If true, the trace will be preserved on error.
+     * If false, the trace will get sampled.
+     * @default - true
+     */
+    preserveErrors?: boolean;
+    /**
+     * The amount of time to wait before sampling or deleting the trace.
+     * This is used to prevent tracing of long-running functions.
+     * @default - 120
+     */
+    retentionMinutes?: number;
+}
+export type LogArgs<Args extends PropertyValidators> = IfArgs<Args, boolean | Array<keyof ObjectType<Args>> | undefined, EmptyObject>;
+export interface TracedFunctionOptions<Ctx, Args extends PropertyValidators, Output> {
+    /**
+     * The name of the traced function.
+     * This is used to identify the function in the DB or UI.
+     * @default - anonymous_function
+     */
+    name?: string;
+    /**
+     * Whether to log the arguments of the function.
+     * This can be a boolean or an array of argument names to log.
+     * @default - false
+     * @example
+     * ```ts
+     * logArgs: true, // Logs all arguments
+     * logArgs: ["userId", "title"], // Logs only the userId and title arguments
+     * ```
+     */
+    logArgs?: LogArgs<Args>;
+    /**
+     * Whether to log the return value of the function.
+     * @default - false
+     */
+    logReturn?: boolean;
+    /**
+     * The sample rate for the trace.
+     * This is used to determine whether to sample the trace or not.
+     * If undefined, the Tracer config will be used
+     * @default - 0.1
+     */
+    sampleRate?: number;
+    /** The retention minutes for the trace.
+     * This is used to determine how long to keep the trace.
+     * If undefined, the Tracer config will be used
+     * @default - 120
+     */
+    retentionMinutes?: number;
+    /** Whether to preserve errors.
+     * If true, the trace will be preserved on error.
+     * If undefined, the Tracer config will be used
+     * @default - undefined
+     */
+    preserveErrors?: boolean;
+    /**
+     * A callback to run before the function starts.
+     * @param {any} ctx - The context object.
+     * @param {ObjectType<Args>} args - The arguments object.
+     * @returns {void | Promise<void>}
+     * @example
+     * ```ts
+     * onStart: async (ctx, args) => {
+     *   // do something before the function starts
+     *   await ctx.tracer.info("Starting Processing...");
+     * }
+     * ```
+     */
+    onStart?: (ctx: Ctx, args: OptionalArgsObject<Args>) => void | Promise<void>;
+    /**
+     * A callback to run after the function succeeds.
+     * @param {any} ctx - The context object.
+     * @param {ObjectType<Args>} args - The arguments object.
+     * @param {unknown} result - The result of the function.
+     * @returns {void | Promise<void>}
+     * @example
+     * ```ts
+     * onSuccess: async (ctx, args, result) => {
+     *   // do something with the result
+     *   await ctx.tracer.info("Successfully processed");
+     * }
+     * ```
+     */
+    onSuccess?: (ctx: Ctx, args: OptionalArgsObject<Args>, result: Output) => void | Promise<void>;
+    /**
+     * A callback to run after the function fails.
+     * @param {any} ctx - The context object.
+     * @param {ObjectType<Args>} args - The arguments object.
+     * @param {Error} error - The error that occurred.
+     * @returns {void | Promise<void>}
+     * @example
+     * ```ts
+     * onError: async (ctx, args, error) => {
+     *   // do something to handle the error
+     *   await ctx.tracer.error("Failed to process", { error: error.message });
+     * }
+     * ```
+     */
+    onError?: (ctx: Ctx, args: OptionalArgsObject<Args>, error: Error) => void | Promise<void>;
+}
+export type TracerHandler<Ctx, Args extends PropertyValidators> = (ctx: Ctx, args: OptionalArgsObject<Args>) => Promise<any>;
+export type TracedFunctionConfig<Ctx, Args extends PropertyValidators, Handler extends TracerHandler<Ctx, Args>, Output extends ExtractOutput<Handler>> = TracedFunctionOptions<Ctx, Args, Output> & {
+    args?: Args;
+    handler: Handler;
+    returns?: Validator<Output, OptionalProperty, any>;
+};
+export type TracerArgs<Args extends PropertyValidators> = ObjectType<Args & {
+    __traceContext?: TraceContext;
+}>;
+export type TracedFunctionTypes = Exclude<FunctionType, "query">;
+export type TracedFunction<Type extends TracedFunctionTypes> = <FuncRef extends FunctionReference<Type, any, any, any>>(funcRef: FuncRef, args?: Omit<FuncRef["_args"], "__traceContext">) => Promise<FuncRef["_returnType"]>;
+type RestrictedQueryContext<DataModel extends GenericDataModel> = Omit<GenericMutationCtx<DataModel>, "runMutation" | "scheduler" | "db" | "storage"> & {
+    db: GenericDatabaseReader<DataModel>;
+    storage: StorageReader;
+};
+export type QueryCtxWithTracer<DataModel extends GenericDataModel> = RestrictedQueryContext<DataModel> & {
+    tracer: TraceAPI;
+    runTracedQuery: TracedFunction<"mutation">;
+};
+export type MutationCtxWithTracer<DataModel extends GenericDataModel> = GenericMutationCtx<DataModel> & {
+    tracer: TraceAPI;
+    runTracedQuery: TracedFunction<"mutation">;
+    runTracedMutation: TracedFunction<"mutation">;
+};
+export type ActionCtxWithTracer<DataModel extends GenericDataModel> = GenericActionCtx<DataModel> & {
+    tracer: TraceAPI;
+    runTracedQuery: TracedFunction<"mutation">;
+    runTracedMutation: TracedFunction<"mutation">;
+    runTracedAction: TracedFunction<"action">;
+};
+export type TracedFunctionContext<DataModel extends GenericDataModel> = QueryCtxWithTracer<DataModel> | MutationCtxWithTracer<DataModel> | ActionCtxWithTracer<DataModel>;
+export type StrippedGenericFunctionContext<DataModel extends GenericDataModel> = GenericMutationCtx<DataModel> | GenericActionCtx<DataModel>;
+export type GenericFunctionContext<DataModel extends GenericDataModel> = GenericQueryCtx<DataModel> | StrippedGenericFunctionContext<DataModel>;
+export type TracedResult<Output> = {
+    success: true;
+    data: Output;
+    error: undefined;
+} | {
+    success: false;
+    data: undefined;
+    error: string;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/client/types.js

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

package/dist/client/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":""}

package/dist/component/_generated/api.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as lib from "../lib.js";
+import type * as types from "../types.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    lib: typeof lib;
+    types: typeof types;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {};
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/component/_generated/api.js

@@ -0,0 +1,31 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal = anyApi;
+export const components = componentsGeneric();
+//# sourceMappingURL=api.js.map

package/dist/component/_generated/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../src/component/_generated/api.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;;;;;;GAOG;AAUH,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,OAAO,GAGR,MAAa,CAAC;AAEnB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,GAAG,GAGZ,MAAa,CAAC;AAElB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAGjB,MAAa,CAAC;AAElB,MAAM,CAAC,MAAM,UAAU,GAAG,iBAAiB,EAAmB,CAAC"}

package/dist/component/_generated/dataModel.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { DataModelFromSchemaDefinition, DocumentByName, TableNamesInDataModel, SystemTableNames } from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<DataModel, TableName>;
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;
+//# sourceMappingURL=dataModel.d.ts.map

package/dist/component/_generated/dataModel.js

@@ -0,0 +1,11 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import schema from "../schema.js";
+//# sourceMappingURL=dataModel.js.map

package/dist/component/_generated/dataModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataModel.js","sourceRoot":"","sources":["../../../src/component/_generated/dataModel.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;;;;;;GAOG;AASH,OAAO,MAAM,MAAM,cAAc,CAAC"}

package/dist/component/_generated/server.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
+import type { DataModel } from "./dataModel.js";
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;
+//# sourceMappingURL=server.d.ts.map

package/dist/component/_generated/server.js

@@ -0,0 +1,78 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { actionGeneric, httpActionGeneric, queryGeneric, mutationGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, } from "convex/server";
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;
+//# sourceMappingURL=server.js.map

package/dist/component/_generated/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/component/_generated/server.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;;;;;;GAOG;AAaH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,eAAe,CAAC;AAGvB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,KAAK,GAAsC,YAAY,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GACxB,oBAAoB,CAAC;AAEvB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAyC,eAAe,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAC3B,uBAAuB,CAAC;AAE1B;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,MAAM,GAAuC,aAAa,CAAC;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GACzB,qBAAqB,CAAC;AAExB;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,UAAU,GAAsB,iBAAiB,CAAC"}

package/dist/component/convex.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("convex/server").ComponentDefinition<any>;
+export default _default;
+//# sourceMappingURL=convex.config.d.ts.map

package/dist/component/convex.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convex.config.d.ts","sourceRoot":"","sources":["../../src/component/convex.config.ts"],"names":[],"mappings":";AAEA,wBAAyC"}

package/dist/component/convex.config.js

@@ -0,0 +1,3 @@
+import { defineComponent } from "convex/server";
+export default defineComponent("tracer");
+//# sourceMappingURL=convex.config.js.map

package/dist/component/convex.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convex.config.js","sourceRoot":"","sources":["../../src/component/convex.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,eAAe,eAAe,CAAC,QAAQ,CAAC,CAAC"}