braintrust 0.0.98 → 0.0.100

package/dist/index.js

@@ -1973,41 +1973,35 @@ var require_ansi_styles = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+// ../../node_modules/supports-color/node_modules/has-flag/index.js
 var require_has_flag2 = __commonJS({
-  "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module2) {
+  "../../node_modules/supports-color/node_modules/has-flag/index.js"(exports, module2) {
     "use strict";
-    module2.exports = (flag, argv = process.argv) => {
+    module2.exports = (flag, argv) => {
+      argv = argv || process.argv;
       const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-      const position = argv.indexOf(prefix + flag);
-      const terminatorPosition = argv.indexOf("--");
-      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+      const pos = argv.indexOf(prefix + flag);
+      const terminatorPos = argv.indexOf("--");
+      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
     };
   }
 });
 
-// ../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
+// ../../node_modules/supports-color/index.js
 var require_supports_color2 = __commonJS({
-  "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module2) {
+  "../../node_modules/supports-color/index.js"(exports, module2) {
     "use strict";
     var os = require("os");
-    var tty = require("tty");
     var hasFlag = require_has_flag2();
-    var { env } = process;
+    var env = process.env;
     var forceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      forceColor = 0;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
+      forceColor = false;
     } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      forceColor = 1;
+      forceColor = true;
     }
     if ("FORCE_COLOR" in env) {
-      if (env.FORCE_COLOR === "true") {
-        forceColor = 1;
-      } else if (env.FORCE_COLOR === "false") {
-        forceColor = 0;
-      } else {
-        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
-      }
+      forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
     }
     function translateLevel(level) {
       if (level === 0) {
@@ -2020,8 +2014,8 @@ var require_supports_color2 = __commonJS({
         has16m: level >= 3
       };
     }
-    function supportsColor(haveStream, streamIsTTY) {
-      if (forceColor === 0) {
+    function supportsColor(stream) {
+      if (forceColor === false) {
         return 0;
       }
       if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
@@ -2030,22 +2024,19 @@ var require_supports_color2 = __commonJS({
       if (hasFlag("color=256")) {
         return 2;
       }
-      if (haveStream && !streamIsTTY && forceColor === void 0) {
+      if (stream && !stream.isTTY && forceColor !== true) {
         return 0;
       }
-      const min = forceColor || 0;
-      if (env.TERM === "dumb") {
-        return min;
-      }
+      const min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
         const osRelease = os.release().split(".");
-        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
         return 1;
       }
       if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -2074,16 +2065,19 @@ var require_supports_color2 = __commonJS({
       if ("COLORTERM" in env) {
         return 1;
       }
+      if (env.TERM === "dumb") {
+        return min;
+      }
       return min;
     }
     function getSupportLevel(stream) {
-      const level = supportsColor(stream, stream && stream.isTTY);
+      const level = supportsColor(stream);
       return translateLevel(level);
     }
     module2.exports = {
       supportsColor: getSupportLevel,
-      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+      stdout: getSupportLevel(process.stdout),
+      stderr: getSupportLevel(process.stderr)
     };
   }
 });
@@ -8053,10 +8047,11 @@ function isEmpty(a) {
   return a === void 0 || a === null;
 }
 var LazyValue = class {
+  callable;
+  value = {
+    hasComputed: false
+  };
   constructor(callable) {
-    this.value = {
-      hasComputed: false
-    };
     this.callable = callable;
   }
   async get() {
@@ -8070,8 +8065,11 @@ var LazyValue = class {
 
 // src/logger.ts
 var NoopSpan = class {
+  id;
+  span_id;
+  root_span_id;
+  kind = "span";
   constructor() {
-    this.kind = "span";
     this.id = "";
     this.span_id = "";
     this.root_span_id = "";
@@ -8095,15 +8093,22 @@ var NoopSpan = class {
 };
 var NOOP_SPAN = new NoopSpan();
 var BraintrustState = class {
+  id;
+  currentExperiment;
+  // Note: the value of IsAsyncFlush doesn't really matter here, since we
+  // (safely) dynamically cast it whenever retrieving the logger.
+  currentLogger;
+  currentSpan;
+  appUrl = null;
+  loginToken = null;
+  orgId = null;
+  orgName = null;
+  logUrl = null;
+  loggedIn = false;
+  gitMetadataSettings;
+  _apiConn = null;
+  _logConn = null;
   constructor() {
-    this.appUrl = null;
-    this.loginToken = null;
-    this.orgId = null;
-    this.orgName = null;
-    this.logUrl = null;
-    this.loggedIn = false;
-    this._apiConn = null;
-    this._logConn = null;
     this.id = v4_default();
     this.currentExperiment = void 0;
     this.currentLogger = void 0;
@@ -8150,6 +8155,9 @@ function _internalSetInitialState() {
 }
 var _internalGetGlobalState = () => _state;
 var FailedHTTPResponse = class extends Error {
+  status;
+  text;
+  data;
   constructor(status, text, data = null) {
     super(`${status}: ${text}`);
     this.status = status;
@@ -8169,6 +8177,9 @@ async function checkResponse(resp) {
   }
 }
 var HTTPConnection = class _HTTPConnection {
+  base_url;
+  token;
+  headers;
   constructor(base_url) {
     this.base_url = base_url;
     this.token = null;
@@ -8320,9 +8331,13 @@ function logFeedbackImpl(bgLogger, parentIds, {
   }
 }
 var Logger = class {
+  lazyMetadata;
+  logOptions;
+  bgLogger;
+  lastStartTime;
+  // For type identification.
+  kind = "logger";
   constructor(lazyMetadata, logOptions = {}) {
-    // For type identification.
-    this.kind = "logger";
     this.lazyMetadata = lazyMetadata;
     this.logOptions = logOptions;
     const logConn = new LazyValue(
@@ -8356,9 +8371,19 @@ var Logger = class {
    * @param event.metadata: (Optional) a dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
    * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically: "start", "end".
    * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
+   * @param options Additional logging options
+   * @param options.allowLogConcurrentWithActiveSpan in rare cases where you need to log at the top level separately from an active span on the logger, set this to true.
    * :returns: The `id` of the logged event.
    */
-  log(event) {
+  log(event, options) {
+    if (!options?.allowLogConcurrentWithActiveSpan) {
+      const checkCurrentSpan = currentSpan();
+      if (checkCurrentSpan instanceof SpanImpl && checkCurrentSpan.parentObject === this) {
+        throw new Error(
+          "Cannot run toplevel Logger.log method while there is an active span. To log to the span, use Span.log"
+        );
+      }
+    }
     const span = this.startSpan({ startTime: this.lastStartTime, event });
     this.lastStartTime = span.end();
     const ret = span.id;
@@ -8417,6 +8442,7 @@ var Logger = class {
   startSpan(args) {
     const { name, ...argsRest } = args ?? {};
     return new SpanImpl({
+      parentObject: this,
       parentIds: new LazyValue(() => this.lazyParentIds()),
       bgLogger: this.bgLogger,
       name: name ?? "root",
@@ -8474,10 +8500,11 @@ function now() {
   return (/* @__PURE__ */ new Date()).getTime();
 }
 var BackgroundLogger = class {
+  logConn;
+  items = [];
+  active_flush = Promise.resolve([]);
+  active_flush_resolved = true;
   constructor(logConn) {
-    this.items = [];
-    this.active_flush = Promise.resolve([]);
-    this.active_flush_resolved = true;
     this.logConn = logConn;
     isomorph_default.processOn("beforeExit", async () => {
       await this.flush();
@@ -8526,12 +8553,12 @@ var BackgroundLogger = class {
       }
       postPromises.push(
         (async () => {
-          const dataS = constructLogs3Data(items);
+          const dataStr = constructLogs3Data(items);
           for (let i = 0; i < NumRetries; i++) {
             const startTime = now();
             try {
               try {
-                return (await (await this.logConn.get()).post_json("logs3", dataS)).ids.map((res) => res.id);
+                return (await (await this.logConn.get()).post_json("logs3", dataStr)).ids.map((res) => res.id);
               } catch (e) {
                 const legacyDataS = constructJsonArray(
                   items.map(
@@ -8550,7 +8577,7 @@ var BackgroundLogger = class {
                 }
               })();
               console.warn(
-                `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${dataS.length}. Error: ${errMsg}.${retryingText}`
+                `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${dataStr.length}. Error: ${errMsg}.${retryingText}`
               );
             }
           }
@@ -8918,9 +8945,12 @@ async function login(options = {}) {
       }
     };
     var checkUpdatedParam = checkUpdatedParam2;
-    ;
     checkUpdatedParam2("appUrl", options.appUrl, _state.appUrl);
-    checkUpdatedParam2("apiKey", options.apiKey ? HTTPConnection.sanitize_token(options.apiKey) : void 0, _state.loginToken);
+    checkUpdatedParam2(
+      "apiKey",
+      options.apiKey ? HTTPConnection.sanitize_token(options.apiKey) : void 0,
+      _state.loginToken
+    );
     checkUpdatedParam2("orgName", options.orgName, _state.orgName);
     return;
   }
@@ -9141,8 +9171,8 @@ var ObjectFetcher = class {
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
-    this._fetchedData = void 0;
   }
+  _fetchedData = void 0;
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
   }
@@ -9202,10 +9232,14 @@ var ObjectFetcher = class {
   }
 };
 var Experiment = class extends ObjectFetcher {
+  lazyMetadata;
+  dataset;
+  bgLogger;
+  lastStartTime;
+  // For type identification.
+  kind = "experiment";
   constructor(lazyMetadata, dataset) {
     super("experiment", void 0);
-    // For type identification.
-    this.kind = "experiment";
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
     const logConn = new LazyValue(
@@ -9246,9 +9280,19 @@ var Experiment = class extends ObjectFetcher {
    * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
    * @param event.dataset_record_id: (Optional) the id of the dataset record that this event is associated with. This field is required if and only if the experiment is associated with a dataset.
    * @param event.inputs: (Deprecated) the same as `input` (will be removed in a future version).
+   * @param options Additional logging options
+   * @param options.allowLogConcurrentWithActiveSpan in rare cases where you need to log at the top level separately from an active span on the experiment, set this to true.
    * :returns: The `id` of the logged event.
    */
-  log(event) {
+  log(event, options) {
+    if (!options?.allowLogConcurrentWithActiveSpan) {
+      const checkCurrentSpan = currentSpan();
+      if (checkCurrentSpan instanceof SpanImpl && checkCurrentSpan.parentObject === this) {
+        throw new Error(
+          "Cannot run toplevel Experiment.log method while there is an active span. To log to the span, use Span.log"
+        );
+      }
+    }
     event = validateAndSanitizeExperimentLogFullArgs(event, !!this.dataset);
     const span = this.startSpan({ startTime: this.lastStartTime, event });
     this.lastStartTime = span.end();
@@ -9290,6 +9334,7 @@ var Experiment = class extends ObjectFetcher {
   startSpan(args) {
     const { name, ...argsRest } = args ?? {};
     return new SpanImpl({
+      parentObject: this,
       parentIds: new LazyValue(() => this.lazyParentIds()),
       bgLogger: this.bgLogger,
       name: name ?? "root",
@@ -9444,10 +9489,21 @@ var ReadonlyExperiment = class extends ObjectFetcher {
 };
 var executionCounter = 0;
 var SpanImpl = class _SpanImpl {
+  bgLogger;
+  // `internalData` contains fields that are not part of the "user-sanitized"
+  // set of fields which we want to log in just one of the span rows.
+  internalData;
+  isMerge;
+  loggedEndTime;
+  // For internal use only.
+  parentObject;
+  // These fields are logged to every span row.
+  parentIds;
+  rowIds;
+  kind = "span";
   // root_experiment should only be specified for a root span. parent_span
   // should only be specified for non-root spans.
   constructor(args) {
-    this.kind = "span";
     this.loggedEndTime = void 0;
     this.bgLogger = args.bgLogger;
     const callerLocation = isomorph_default.getCallerLocation();
@@ -9475,6 +9531,7 @@ var SpanImpl = class _SpanImpl {
       },
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
+    this.parentObject = args.parentObject;
     this.parentIds = args.parentIds;
     const id = args.event?.id ?? v4_default();
     const span_id = v4_default();
@@ -9546,6 +9603,7 @@ var SpanImpl = class _SpanImpl {
   }
   startSpan(args) {
     return new _SpanImpl({
+      parentObject: this.parentObject,
       parentIds: this.parentIds,
       bgLogger: this.bgLogger,
       parentSpanInfo: {
@@ -9571,6 +9629,8 @@ var SpanImpl = class _SpanImpl {
   }
 };
 var Dataset = class extends ObjectFetcher {
+  lazyMetadata;
+  bgLogger;
   constructor(lazyMetadata, pinnedVersion, legacy) {
     const isLegacyDataset = legacy ?? DEFAULT_IS_LEGACY_DATASET;
     if (isLegacyDataset) {
@@ -9742,8 +9802,9 @@ function fitNameToSpaces(name, length) {
   return padded.substring(0, length - 3) + "...";
 }
 var BarProgressReporter = class {
+  multiBar;
+  bars = {};
   constructor() {
-    this.bars = {};
     this.multiBar = new cliProgress.MultiBar(
       {
         clearOnComplete: false,
@@ -9787,9 +9848,9 @@ function initExperiment2(projectName, options = {}) {
 }
 globalThis._evals = {};
 async function Eval(name, evaluator) {
-  const evalName = makeEvalName(name, evaluator.experimentName);
+  let evalName = makeEvalName(name, evaluator.experimentName);
   if (_evals[evalName]) {
-    throw new Error(`Evaluator ${evalName} already exists`);
+    evalName = `${evalName}_${Object.keys(_evals).length}`;
   }
   if (globalThis._lazy_load) {
     _evals[evalName] = { evalName, projectName: name, ...evaluator };
@@ -9845,6 +9906,9 @@ function evaluateFilter(object, filter) {
   }
   return pattern.test(serializeJSONWithPlainString(key));
 }
+function scorerName(scorer, scorer_idx) {
+  return scorer.name || `scorer_${scorer_idx}`;
+}
 async function runEvaluator(experiment, evaluator, progressReporter, filters) {
   if (typeof evaluator.data === "string") {
     throw new Error("Unimplemented: string data paths");
@@ -9888,11 +9952,13 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
   );
   progressReporter.start(evaluator.evalName, data.length);
   const evals = data.map(async (datum) => {
-    let metadata = { ..."metadata" in datum ? datum.metadata : {} };
-    let output = void 0;
-    let error2 = void 0;
-    let scores = {};
     const callback = async (rootSpan) => {
+      let metadata = {
+        ..."metadata" in datum ? datum.metadata : {}
+      };
+      let output = void 0;
+      let error2 = void 0;
+      let scores = {};
       try {
         const meta = (o) => metadata = { ...metadata, ...o };
         await rootSpan.traced(
@@ -9909,42 +9975,55 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
         );
         rootSpan.log({ output });
         const scoringArgs = { ...datum, metadata, output };
+        const scorerNames = evaluator.scores.map(scorerName);
         const scoreResults = await Promise.all(
           evaluator.scores.map(async (score, score_idx) => {
-            return rootSpan.traced(
-              async (span) => {
-                const scoreResult = score(scoringArgs);
-                const result = scoreResult instanceof Promise ? await scoreResult : scoreResult;
-                const {
-                  metadata: resultMetadata,
-                  name: _,
-                  ...resultRest
-                } = result;
-                span.log({
-                  output: resultRest,
-                  metadata: resultMetadata
-                });
-                return result;
-              },
-              {
-                name: score.name || `scorer_${score_idx}`,
-                spanAttributes: {
-                  type: SpanTypeAttribute.SCORE
+            try {
+              const result = await rootSpan.traced(
+                async (span) => {
+                  const scoreResult = score(scoringArgs);
+                  const result2 = scoreResult instanceof Promise ? await scoreResult : scoreResult;
+                  const {
+                    metadata: resultMetadata,
+                    name: _,
+                    ...resultRest
+                  } = result2;
+                  span.log({
+                    output: resultRest,
+                    metadata: resultMetadata
+                  });
+                  return result2;
                 },
-                event: { input: scoringArgs }
-              }
-            );
+                {
+                  name: scorerNames[score_idx],
+                  spanAttributes: {
+                    type: SpanTypeAttribute.SCORE
+                  },
+                  event: { input: scoringArgs }
+                }
+              );
+              return { kind: "score", value: result };
+            } catch (e) {
+              return { kind: "error", value: e };
+            }
           })
         );
+        const passingScorersAndResults = [];
+        const failingScorersAndResults = [];
+        scoreResults.forEach((result, i) => {
+          const name = scorerNames[i];
+          if (result.kind === "score") {
+            passingScorersAndResults.push({ name, score: result.value });
+          } else {
+            failingScorersAndResults.push({ name, error: result.value });
+          }
+        });
         const scoreMetadata = {};
-        for (const scoreResult of scoreResults) {
+        for (const { score: scoreResult } of passingScorersAndResults) {
           scores[scoreResult.name] = scoreResult.score;
           const metadata2 = {
             ...scoreResult.metadata
           };
-          if (scoreResult.error !== void 0) {
-            metadata2.error = scoreResult.error;
-          }
           if (Object.keys(metadata2).length > 0) {
             scoreMetadata[scoreResult.name] = metadata2;
           }
@@ -9953,6 +10032,21 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
           meta({ scores: scoreMetadata });
         }
         rootSpan.log({ scores, metadata });
+        if (failingScorersAndResults.length) {
+          const scorerErrors = Object.fromEntries(
+            failingScorersAndResults.map(({ name, error: error3 }) => [
+              name,
+              error3 instanceof Error ? error3.stack : `${error3}`
+            ])
+          );
+          metadata["scorer_errors"] = scorerErrors;
+          const names = Object.keys(scorerErrors).join(", ");
+          const errors = failingScorersAndResults.map((item) => item.error);
+          throw new AggregateError(
+            errors,
+            `Found exceptions for the following scorers: ${names}`
+          );
+        }
       } catch (e) {
         error2 = e;
       } finally {
@@ -10031,7 +10125,8 @@ function reportEvaluatorResult(evaluatorName, evaluatorResult, {
     if (!verbose && !jsonl) {
       console.error(warning("Add --verbose to see full stack traces."));
     }
-  } else if (summary) {
+  }
+  if (summary) {
     console.log(jsonl ? JSON.stringify(summary) : summary);
   } else {
     const scoresByName = {};
@@ -10259,6 +10354,9 @@ function wrapEmbeddings(create) {
   };
 }
 var WrapperStream = class {
+  span;
+  iter;
+  startTime;
   constructor(span, startTime, iter) {
     this.span = span;
     this.iter = iter;

package/dist/logger.d.ts

@@ -186,9 +186,13 @@ export declare class Logger<IsAsyncFlush extends boolean> {
      * @param event.metadata: (Optional) a dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
      * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically: "start", "end".
      * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
+     * @param options Additional logging options
+     * @param options.allowLogConcurrentWithActiveSpan in rare cases where you need to log at the top level separately from an active span on the logger, set this to true.
      * :returns: The `id` of the logged event.
      */
-    log(event: Readonly<StartSpanEventArgs>): PromiseUnless<IsAsyncFlush, string>;
+    log(event: Readonly<StartSpanEventArgs>, options?: {
+        allowLogConcurrentWithActiveSpan?: boolean;
+    }): PromiseUnless<IsAsyncFlush, string>;
     /**
      * Create a new toplevel span underneath the logger. The name defaults to "root".
      *
@@ -501,9 +505,13 @@ export declare class Experiment extends ObjectFetcher<ExperimentEvent> {
      * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
      * @param event.dataset_record_id: (Optional) the id of the dataset record that this event is associated with. This field is required if and only if the experiment is associated with a dataset.
      * @param event.inputs: (Deprecated) the same as `input` (will be removed in a future version).
+     * @param options Additional logging options
+     * @param options.allowLogConcurrentWithActiveSpan in rare cases where you need to log at the top level separately from an active span on the experiment, set this to true.
      * :returns: The `id` of the logged event.
      */
-    log(event: Readonly<ExperimentLogFullArgs>): string;
+    log(event: Readonly<ExperimentLogFullArgs>, options?: {
+        allowLogConcurrentWithActiveSpan?: boolean;
+    }): string;
     /**
      * Create a new toplevel span underneath the experiment. The name defaults to "root".
      *
@@ -577,10 +585,12 @@ export declare class SpanImpl implements Span {
     private internalData;
     private isMerge;
     private loggedEndTime;
+    parentObject: Experiment | Logger<any>;
     private parentIds;
     private readonly rowIds;
     kind: "span";
     constructor(args: {
+        parentObject: Experiment | Logger<any>;
         parentIds: LazyValue<ParentExperimentIds | ParentProjectLogIds>;
         bgLogger: BackgroundLogger;
     } & Omit<StartSpanArgs, "parentId"> & ({