@reactionary/core 0.0.31 → 0.0.33

package/index.js

@@ -109,245 +109,108 @@ function createCache() {
   return new RedisCache();
 }
 
-// otel/src/trpc-middleware.ts
-import { TRPCError } from "@trpc/server";
-import {
-  SpanKind as SpanKind2,
-  SpanStatusCode as SpanStatusCode3
-} from "@opentelemetry/api";
-
-// otel/src/tracer.ts
-import {
-  trace,
-  SpanStatusCode,
-  context as otelContext
-} from "@opentelemetry/api";
-
-// otel/src/sdk.ts
-import { NodeSDK } from "@opentelemetry/sdk-node";
-var sdk = null;
-var isInitialized = false;
-var initializationPromise = null;
-function isBrowser() {
-  return typeof window !== "undefined" && typeof process === "undefined";
-}
-function ensureInitialized() {
-  if (isInitialized || initializationPromise) {
-    return;
-  }
-  if (isBrowser()) {
-    isInitialized = true;
-    return;
-  }
-  initializationPromise = Promise.resolve().then(() => {
-    sdk = new NodeSDK();
-    sdk.start();
-    isInitialized = true;
-    process.on("SIGTERM", async () => {
-      try {
-        await shutdownOtel();
-        if (process.env["OTEL_LOG_LEVEL"] === "debug") {
-          console.log("OpenTelemetry terminated successfully");
-        }
-      } catch (error) {
-        console.error("Error terminating OpenTelemetry", error);
+// core/src/client/client-builder.ts
+var ClientBuilder = class _ClientBuilder {
+  constructor() {
+    this.factories = [];
+  }
+  withCapability(factory) {
+    const newBuilder = new _ClientBuilder();
+    newBuilder.factories = [...this.factories, factory];
+    newBuilder.cache = this.cache;
+    return newBuilder;
+  }
+  withCache(cache) {
+    const newBuilder = new _ClientBuilder();
+    newBuilder.factories = [...this.factories];
+    newBuilder.cache = cache;
+    return newBuilder;
+  }
+  build() {
+    let client = {};
+    const sharedCache = this.cache || new NoOpCache();
+    const mergedAnalytics = [];
+    for (const factory of this.factories) {
+      const provider = factory(sharedCache);
+      client = {
+        ...client,
+        ...provider
+      };
+      if (provider.analytics) {
+        mergedAnalytics.push(...provider.analytics);
       }
-    });
-  });
-}
-async function shutdownOtel() {
-  if (sdk) {
-    await sdk.shutdown();
-    sdk = null;
-    isInitialized = false;
+    }
+    if (mergedAnalytics.length > 0) {
+      client["analytics"] = mergedAnalytics;
+    }
+    const completeClient = {
+      ...client,
+      cache: sharedCache
+    };
+    return completeClient;
   }
-}
-function isOtelInitialized() {
-  ensureInitialized();
-  return isInitialized;
-}
+};
 
-// otel/src/tracer.ts
-import { SpanKind, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
-var TRACER_NAME = "@reactionary/otel";
-var TRACER_VERSION = "0.0.1";
-var globalTracer = null;
-function getTracer() {
-  if (!globalTracer) {
-    isOtelInitialized();
-    globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
-  }
-  return globalTracer;
+// core/src/decorators/trpc.decorators.ts
+import "reflect-metadata";
+var TRPC_QUERY_METADATA_KEY = Symbol("trpc:query");
+var TRPC_MUTATION_METADATA_KEY = Symbol("trpc:mutation");
+function trpcQuery(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      methodName: String(propertyKey),
+      isQuery: true,
+      isMutation: false,
+      options
+    };
+    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, metadata, target, propertyKey);
+    const existingMethods = Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target.constructor) || [];
+    existingMethods.push({ propertyKey, metadata });
+    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, existingMethods, target.constructor);
+  };
 }
-function withSpan(name, fn, options) {
-  const tracer = getTracer();
-  return tracer.startActiveSpan(name, options || {}, async (span) => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      if (error instanceof Error) {
-        span.recordException(error);
-      }
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
+function trpcMutation(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      methodName: String(propertyKey),
+      isQuery: false,
+      isMutation: true,
+      options
+    };
+    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, metadata, target, propertyKey);
+    const existingMethods = Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target.constructor) || [];
+    existingMethods.push({ propertyKey, metadata });
+    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, existingMethods, target.constructor);
+  };
 }
-function setSpanAttributes(span, attributes) {
-  Object.entries(attributes).forEach(([key, value]) => {
-    if (value !== void 0 && value !== null) {
-      span.setAttribute(key, value);
-    }
-  });
+function getTRPCQueryMethods(target) {
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
 }
-
-// otel/src/metrics.ts
-import { metrics } from "@opentelemetry/api";
-var METER_NAME = "@reactionary/otel";
-var METER_VERSION = "0.0.1";
-var globalMeter = null;
-function getMeter() {
-  if (!globalMeter) {
-    isOtelInitialized();
-    globalMeter = metrics.getMeter(METER_NAME, METER_VERSION);
-  }
-  return globalMeter;
+function getTRPCMutationMethods(target) {
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
 }
-var metricsInstance = null;
-function initializeMetrics() {
-  if (metricsInstance) {
-    return metricsInstance;
-  }
-  const meter = getMeter();
-  metricsInstance = {
-    requestCounter: meter.createCounter("reactionary.requests", {
-      description: "Total number of requests"
-    }),
-    requestDuration: meter.createHistogram("reactionary.request.duration", {
-      description: "Request duration in milliseconds",
-      unit: "ms"
-    }),
-    activeRequests: meter.createUpDownCounter("reactionary.requests.active", {
-      description: "Number of active requests"
-    }),
-    errorCounter: meter.createCounter("reactionary.errors", {
-      description: "Total number of errors"
-    }),
-    providerCallCounter: meter.createCounter("reactionary.provider.calls", {
-      description: "Total number of provider calls"
-    }),
-    providerCallDuration: meter.createHistogram("reactionary.provider.duration", {
-      description: "Provider call duration in milliseconds",
-      unit: "ms"
-    }),
-    cacheHitCounter: meter.createCounter("reactionary.cache.hits", {
-      description: "Total number of cache hits"
-    }),
-    cacheMissCounter: meter.createCounter("reactionary.cache.misses", {
-      description: "Total number of cache misses"
-    })
-  };
-  return metricsInstance;
+function getAllTRPCMethods(target) {
+  return [
+    ...getTRPCQueryMethods(target),
+    ...getTRPCMutationMethods(target)
+  ];
 }
-function getMetrics() {
-  if (!metricsInstance) {
-    return initializeMetrics();
-  }
-  return metricsInstance;
+function isTRPCQuery(target, methodName) {
+  return !!Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target, methodName);
 }
-
-// otel/src/provider-instrumentation.ts
-import { SpanKind as SpanKind3 } from "@opentelemetry/api";
-async function withProviderSpan(options, fn) {
-  const { providerName, operationType, operationName, attributes = {} } = options;
-  const metrics2 = getMetrics();
-  const spanName = `provider.${providerName}.${operationType}${operationName ? `.${operationName}` : ""}`;
-  const startTime = Date.now();
-  metrics2.providerCallCounter.add(1, {
-    "provider.name": providerName,
-    "provider.operation.type": operationType,
-    "provider.operation.name": operationName || "unknown"
-  });
-  return withSpan(
-    spanName,
-    async (span) => {
-      setSpanAttributes(span, {
-        "provider.name": providerName,
-        "provider.operation.type": operationType,
-        "provider.operation.name": operationName,
-        ...attributes
-      });
-      try {
-        const result = await fn(span);
-        const duration = Date.now() - startTime;
-        metrics2.providerCallDuration.record(duration, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown",
-          "status": "success"
-        });
-        return result;
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        metrics2.providerCallDuration.record(duration, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown",
-          "status": "error"
-        });
-        metrics2.errorCounter.add(1, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown"
-        });
-        throw error;
-      }
-    },
-    { kind: SpanKind3.CLIENT }
-  );
+function isTRPCMutation(target, methodName) {
+  return !!Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target, methodName);
 }
-function createProviderInstrumentation(providerName) {
-  return {
-    traceQuery: (operationName, fn, attributes) => {
-      return withProviderSpan(
-        {
-          providerName,
-          operationType: "query",
-          operationName,
-          attributes
-        },
-        fn
-      );
-    },
-    traceMutation: (operationName, fn, attributes) => {
-      return withProviderSpan(
-        {
-          providerName,
-          operationType: "mutation",
-          operationName,
-          attributes
-        },
-        fn
-      );
-    }
-  };
+function isTRPCMethod(target, methodName) {
+  return isTRPCQuery(target, methodName) || isTRPCMutation(target, methodName);
 }
 
 // core/src/providers/base.provider.ts
-import * as crypto from "crypto";
 var BaseProvider = class {
-  constructor(schema, querySchema, mutationSchema, cache) {
+  constructor(schema, cache) {
     this.schema = schema;
-    this.querySchema = querySchema;
-    this.mutationSchema = mutationSchema;
-    this.instrumentation = createProviderInstrumentation(this.constructor.name);
     this.cache = cache;
   }
   /**
@@ -364,208 +227,41 @@ var BaseProvider = class {
     return this.schema.parse({});
   }
   /**
-   * Retrieves a set of entities matching the list of queries. The size of
-   * the resulting list WILL always match the size of the query list. The
-   * result list will never contain nulls or undefined. The order
-   * of the results will match the order of the queries.
-   */
-  async query(queries, session) {
-    return this.instrumentation.traceQuery(
-      "query",
-      async (span) => {
-        span.setAttribute("provider.query.count", queries.length);
-        let cacheHits = 0;
-        let cacheMisses = 0;
-        const results = [];
-        for (const query of queries) {
-          let result = null;
-          const cacheInfo = this.getCacheEvaluation(query, session);
-          if (cacheInfo.canCache && cacheInfo.key) {
-            try {
-              result = await this.cache.get(cacheInfo.key, this.schema);
-              if (result) {
-                cacheHits++;
-                span.setAttribute("provider.cache.hit", true);
-              }
-            } catch (error) {
-              console.warn(`Cache get error for ${this.constructor.name}:`, error);
-            }
-          }
-          if (!result) {
-            const singleResult = await this.fetch([query], session);
-            result = singleResult[0];
-            cacheMisses++;
-            if (result && cacheInfo.canCache && cacheInfo.key) {
-              try {
-                await this.cache.put(cacheInfo.key, result, cacheInfo.cacheDurationInSeconds);
-              } catch (error) {
-                console.warn(`Cache put error for ${this.constructor.name}:`, error);
-              }
-            }
-          }
-          if (result) {
-            this.assert(result);
-            results.push(result);
-          }
-        }
-        span.setAttribute("provider.result.count", results.length);
-        span.setAttribute("provider.cache.hits", cacheHits);
-        span.setAttribute("provider.cache.misses", cacheMisses);
-        span.setAttribute("provider.cache.hit_ratio", cacheHits / (cacheHits + cacheMisses));
-        return results;
-      },
-      { queryCount: queries.length }
-    );
-  }
-  /**
-   * Executes the listed mutations in order and returns the final state
-   * resulting from that set of operations.
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
    */
-  async mutate(mutations, session) {
-    return this.instrumentation.traceMutation(
-      "mutate",
-      async (span) => {
-        span.setAttribute("provider.mutation.count", mutations.length);
-        const result = await this.process(mutations, session);
-        this.assert(result);
-        return result;
-      },
-      { mutationCount: mutations.length }
-    );
-  }
-  /**
-   * Provider-specific cache evaluation logic.
-   * Returns information about how this query should be cached.
-   * Override this method to enable caching with custom keys and TTL.
-   * Default implementation returns no caching.
-   */
-  getCacheEvaluation(query, session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id || "anonymous";
-    const queryHash = crypto.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
-    const key = `${providerName}:${userId}:${queryHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
+  parseSingle(_body) {
+    const model = this.newModel();
+    return this.assert(model);
   }
 };
 
 // core/src/providers/analytics.provider.ts
-import * as crypto2 from "crypto";
 var AnalyticsProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const relevantFields = {
-      type: typeof query === "object" && query !== null && "type" in query ? query.type : void 0,
-      dateRange: typeof query === "object" && query !== null && "dateRange" in query ? query.dateRange : void 0,
-      filters: typeof query === "object" && query !== null && "filters" in query ? query.filters : void 0
-    };
-    const analyticsHash = crypto2.createHash("md5").update(JSON.stringify(relevantFields)).digest("hex").substring(0, 12);
-    const key = `${providerName}:analytics:${analyticsHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/providers/cart.provider.ts
-import * as crypto3 from "crypto";
 var CartProvider = class extends BaseProvider {
-  getCacheEvaluation(query, session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id || "anonymous";
-    const queryHash = crypto3.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
-    const key = `${providerName}:cart:${userId}:${queryHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/providers/identity.provider.ts
 var IdentityProvider = class extends BaseProvider {
-  getCacheEvaluation(_query, session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id;
-    const key = userId ? `${providerName}:identity:${userId}` : `${providerName}:identity:anonymous`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/providers/inventory.provider.ts
 var InventoryProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const key = `${providerName}:inventory:${query.sku}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/providers/price.provider.ts
-import * as crypto4 from "crypto";
 var PriceProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const skuHash = crypto4.createHash("md5").update(JSON.stringify(query.sku)).digest("hex").substring(0, 12);
-    const key = `${providerName}:price:${skuHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/providers/product.provider.ts
-import * as crypto5 from "crypto";
 var ProductProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    let key;
-    if (query.query === "slug") {
-      key = `${providerName}:product:slug:${query.slug}`;
-    } else if (query.query === "id") {
-      key = `${providerName}:product:id:${query.id}`;
-    } else {
-      const queryHash = crypto5.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
-      key = `${providerName}:product:${queryHash}`;
-    }
-    return {
-      key,
-      cacheDurationInSeconds: 300,
-      // Products are moderately stable - 5 minutes
-      canCache: true
-    };
-  }
 };
 
 // core/src/providers/search.provider.ts
-import * as crypto6 from "crypto";
 var SearchProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const searchHash = crypto6.createHash("md5").update(JSON.stringify(query.search)).digest("hex").substring(0, 12);
-    const key = `${providerName}:search:${searchHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/schemas/capabilities.schema.ts
@@ -913,42 +609,32 @@ var SearchResultSchema = BaseModelSchema.extend({
 
 // core/src/schemas/mutations/base.mutation.ts
 import { z as z12 } from "zod";
-var BaseMutationSchema = z12.looseInterface({
-  mutation: z12.ZodLiteral
-});
+var BaseMutationSchema = z12.looseInterface({});
 
 // core/src/schemas/mutations/cart.mutation.ts
 import { z as z13 } from "zod";
 var CartMutationItemAddSchema = BaseMutationSchema.extend({
-  mutation: z13.literal("add"),
   cart: CartIdentifierSchema.required(),
   product: ProductIdentifierSchema.required(),
   quantity: z13.number()
 });
 var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-  mutation: z13.literal("remove"),
   cart: CartIdentifierSchema.required(),
   item: CartItemIdentifierSchema.required()
 });
 var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-  mutation: z13.literal("adjustQuantity"),
   cart: CartIdentifierSchema.required(),
   item: CartItemIdentifierSchema.required(),
   quantity: z13.number()
 });
-var CartMutationSchema = z13.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
 
 // core/src/schemas/mutations/identity.mutation.ts
 import { z as z14 } from "zod";
 var IdentityMutationLoginSchema = BaseMutationSchema.extend({
-  mutation: z14.literal("login"),
   username: z14.string(),
   password: z14.string()
 });
-var IdentityMutationLogoutSchema = BaseMutationSchema.extend({
-  mutation: z14.literal("logout")
-});
-var IdentityMutationSchema = z14.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
+var IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
 
 // core/src/schemas/mutations/inventory.mutation.ts
 import { z as z15 } from "zod";
@@ -968,59 +654,42 @@ var SearchMutationSchema = z18.union([]);
 
 // core/src/schemas/queries/base.query.ts
 import { z as z19 } from "zod";
-var BaseQuerySchema = z19.looseInterface({
-  query: z19.ZodLiteral
-});
+var BaseQuerySchema = z19.looseInterface({});
 
 // core/src/schemas/queries/cart.query.ts
 import { z as z20 } from "zod";
 var CartQueryByIdSchema = BaseQuerySchema.extend({
-  query: z20.literal("id"),
   cart: CartIdentifierSchema.required()
 });
 var CartQuerySchema = z20.union([CartQueryByIdSchema]);
 
 // core/src/schemas/queries/identity.query.ts
-import { z as z21 } from "zod";
-var IdentityQuerySelfSchema = BaseQuerySchema.extend({
-  query: z21.literal("self")
-});
-var IdentityQuerySchema = z21.union([IdentityQuerySelfSchema]);
+var IdentityQuerySelfSchema = BaseQuerySchema.extend({});
 
 // core/src/schemas/queries/inventory.query.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 var InventoryQuerySchema = BaseQuerySchema.extend({
-  query: z22.literal("sku"),
-  sku: z22.string()
+  sku: z21.string()
 });
 
 // core/src/schemas/queries/price.query.ts
-import { z as z23 } from "zod";
 var PriceQueryBySkuSchema = BaseQuerySchema.extend({
-  query: z23.literal("sku"),
   sku: SKUIdentifierSchema.required()
 });
-var PriceQuerySchema = z23.union([PriceQueryBySkuSchema]);
 
 // core/src/schemas/queries/product.query.ts
-import { z as z24 } from "zod";
+import { z as z22 } from "zod";
 var ProductQueryBySlugSchema = BaseQuerySchema.extend({
-  query: z24.literal("slug"),
-  slug: z24.string()
+  slug: z22.string()
 });
 var ProductQueryByIdSchema = BaseQuerySchema.extend({
-  query: z24.literal("id"),
-  id: z24.string()
+  id: z22.string()
 });
-var ProductQuerySchema = z24.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
 
 // core/src/schemas/queries/search.query.ts
-import { z as z25 } from "zod";
 var SearchQueryByTermSchema = BaseQuerySchema.extend({
-  query: z25.literal("term"),
   search: SearchIdentifierSchema.required()
 });
-var SearchQuerySchema = z25.union([SearchQueryByTermSchema]);
 export {
   AnalyticsProvider,
   BaseModelSchema,
@@ -1035,19 +704,17 @@ export {
   CartMutationItemAddSchema,
   CartMutationItemQuantityChangeSchema,
   CartMutationItemRemoveSchema,
-  CartMutationSchema,
   CartProvider,
   CartQueryByIdSchema,
   CartQuerySchema,
   CartSchema,
+  ClientBuilder,
   CurrencySchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
   IdentityMutationLoginSchema,
   IdentityMutationLogoutSchema,
-  IdentityMutationSchema,
   IdentityProvider,
-  IdentityQuerySchema,
   IdentityQuerySelfSchema,
   IdentitySchema,
   IdentityTypeSchema,
@@ -1062,7 +729,6 @@ export {
   PriceMutationSchema,
   PriceProvider,
   PriceQueryBySkuSchema,
-  PriceQuerySchema,
   PriceSchema,
   ProductAttributeSchema,
   ProductIdentifierSchema,
@@ -1070,7 +736,6 @@ export {
   ProductProvider,
   ProductQueryByIdSchema,
   ProductQueryBySlugSchema,
-  ProductQuerySchema,
   ProductSchema,
   RedisCache,
   SKUIdentifierSchema,
@@ -1079,12 +744,21 @@ export {
   SearchMutationSchema,
   SearchProvider,
   SearchQueryByTermSchema,
-  SearchQuerySchema,
   SearchResultFacetSchema,
   SearchResultFacetValueSchema,
   SearchResultProductSchema,
   SearchResultSchema,
   SessionSchema,
+  TRPC_MUTATION_METADATA_KEY,
+  TRPC_QUERY_METADATA_KEY,
   buildClient,
-  createCache
+  createCache,
+  getAllTRPCMethods,
+  getTRPCMutationMethods,
+  getTRPCQueryMethods,
+  isTRPCMethod,
+  isTRPCMutation,
+  isTRPCQuery,
+  trpcMutation,
+  trpcQuery
 };