@showwhat/core 2.0.0 → 2.1.0

package/dist/index.js

@@ -74,9 +74,32 @@ var ConditionError = class extends ShowwhatError {
     this.name = "ConditionError";
   }
 };
+var UnknownConditionTypeError = class extends ShowwhatError {
+  constructor(conditionType, condition) {
+    super(`Unknown condition type "${conditionType}".`);
+    this.conditionType = conditionType;
+    this.condition = condition;
+    this.name = "UnknownConditionTypeError";
+  }
+};
+
+// src/conditions/types.ts
+import { z as z2 } from "zod";
+
+// src/schemas/value.ts
+import { z } from "zod";
+var DataPrimitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
+var DataValueSchema = z.union([
+  DataPrimitiveSchema,
+  z.array(DataPrimitiveSchema),
+  z.lazy(() => z.record(z.string(), DataValueSchema))
+]);
 
 // src/conditions/types.ts
+var AnnotationValueSchema = DataValueSchema;
+var AnnotationsSchema = z2.record(z2.string(), AnnotationValueSchema);
 var defaultCreateRegex = (pattern) => new RegExp(pattern);
+var FALLBACK_EVALUATOR_KEY = /* @__PURE__ */ Symbol("fallback");
 var noConditionEvaluator = async () => false;
 
 // src/conditions/string.ts
@@ -93,7 +116,8 @@ async function evaluateString(condition, ctx, createRegex = defaultCreateRegex)
     case "in":
       return condition.value.includes(actual);
     case "nin":
-      return !condition.value.includes(actual);
+      const incl = condition.value.includes(actual);
+      return !incl;
     case "regex": {
       const pattern = condition.value;
       let regex;
@@ -141,8 +165,8 @@ async function evaluateNumber(condition, ctx) {
 var numberEvaluator = ({ condition, context }) => evaluateNumber(condition, context);
 
 // src/conditions/utils.ts
-import { z } from "zod";
-var IsoUtcDatetime = z.iso.datetime();
+import { z as z3 } from "zod";
+var IsoUtcDatetime = z3.iso.datetime();
 function parseDate(key, raw) {
   if (!IsoUtcDatetime.safeParse(raw).success) {
     throw new InvalidContextError(key, raw);
@@ -152,9 +176,13 @@ function parseDate(key, raw) {
 
 // src/conditions/datetime.ts
 async function evaluateDatetime(condition, ctx) {
-  if (!Object.hasOwn(ctx, condition.key)) return false;
+  if (!Object.hasOwn(ctx, condition.key)) {
+    return false;
+  }
   const raw = ctx[condition.key];
-  if (typeof raw !== "string") return false;
+  if (typeof raw !== "string") {
+    return false;
+  }
   const actual = parseDate(condition.key, raw);
   const expected = new Date(condition.value);
   switch (condition.op) {
@@ -174,14 +202,21 @@ var datetimeEvaluator = ({ condition, context }) => evaluateDatetime(condition,
 
 // src/conditions/bool.ts
 async function evaluateBool(condition, ctx) {
-  if (!Object.hasOwn(ctx, condition.key)) return false;
+  if (!Object.hasOwn(ctx, condition.key)) {
+    return false;
+  }
   const raw = ctx[condition.key];
   if (typeof raw === "boolean") {
     return raw === condition.value;
   }
-  if (typeof raw === "string") {
-    if (raw === "true") return condition.value === true;
-    if (raw === "false") return condition.value === false;
+  if (typeof raw !== "string") {
+    return false;
+  }
+  if (raw === "true") {
+    return condition.value === true;
+  }
+  if (raw === "false") {
+    return condition.value === false;
   }
   return false;
 }
@@ -224,139 +259,6 @@ async function evaluateEndAt(condition, ctx) {
 }
 var endAtEvaluator = ({ condition, context }) => evaluateEndAt(condition, context);
 
-// src/schemas/condition.ts
-import { z as z2 } from "zod";
-var PRIMITIVE_CONDITION_TYPES = {
-  string: "string",
-  number: "number",
-  bool: "bool",
-  datetime: "datetime"
-};
-var CONDITION_TYPES = {
-  ...PRIMITIVE_CONDITION_TYPES,
-  env: "env",
-  startAt: "startAt",
-  endAt: "endAt",
-  and: "and",
-  or: "or"
-};
-var CONTEXT_KEYS = {
-  env: "env",
-  at: "at"
-};
-var StringConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("string"),
-  key: z2.string().min(1),
-  op: z2.enum(["eq", "neq", "in", "nin", "regex"]),
-  value: z2.union([z2.string(), z2.array(z2.string())])
-}).superRefine((val, ctx) => {
-  const isArrayOp = val.op === "in" || val.op === "nin";
-  const isArray = Array.isArray(val.value);
-  if (isArrayOp && !isArray) {
-    ctx.addIssue({
-      code: "custom",
-      message: `"${val.op}" operator requires an array value`,
-      path: ["value"]
-    });
-  }
-  if (!isArrayOp && isArray) {
-    ctx.addIssue({
-      code: "custom",
-      message: `"${val.op}" operator requires a string value`,
-      path: ["value"]
-    });
-  }
-});
-var NumberConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("number"),
-  key: z2.string().min(1),
-  op: z2.enum(["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]),
-  value: z2.union([z2.number(), z2.array(z2.number())])
-}).superRefine((val, ctx) => {
-  const isArrayOp = val.op === "in" || val.op === "nin";
-  const isArray = Array.isArray(val.value);
-  if (isArrayOp && !isArray) {
-    ctx.addIssue({
-      code: "custom",
-      message: `"${val.op}" operator requires an array value`,
-      path: ["value"]
-    });
-  }
-  if (!isArrayOp && isArray) {
-    ctx.addIssue({
-      code: "custom",
-      message: `"${val.op}" operator requires a number value`,
-      path: ["value"]
-    });
-  }
-});
-var DatetimeConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("datetime"),
-  key: z2.string().min(1),
-  op: z2.enum(["eq", "gt", "gte", "lt", "lte"]),
-  value: z2.iso.datetime({ message: '"datetime" must be a valid ISO 8601 datetime' })
-});
-var BoolConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("bool"),
-  key: z2.string().min(1),
-  op: z2.literal("eq").optional(),
-  value: z2.boolean()
-});
-var EnvConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("env"),
-  op: z2.literal("eq").optional(),
-  value: z2.union([z2.string(), z2.array(z2.string())])
-});
-var StartAtConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("startAt"),
-  value: z2.iso.datetime({ message: '"startAt" must be a valid ISO 8601 datetime' })
-});
-var EndAtConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("endAt"),
-  value: z2.iso.datetime({ message: '"endAt" must be a valid ISO 8601 datetime' })
-});
-var BuiltinConditionSchema = z2.discriminatedUnion("type", [
-  StringConditionSchema,
-  NumberConditionSchema,
-  DatetimeConditionSchema,
-  BoolConditionSchema,
-  EnvConditionSchema,
-  StartAtConditionSchema,
-  EndAtConditionSchema
-]);
-var AndConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("and"),
-  conditions: z2.array(z2.lazy(() => ConditionSchema)).min(1)
-});
-var OrConditionSchema = z2.object({
-  id: z2.string().optional(),
-  type: z2.literal("or"),
-  conditions: z2.array(z2.lazy(() => ConditionSchema)).min(1)
-});
-var BLOCKED_OPEN_UNION_TYPES = new Set(Object.values(CONDITION_TYPES));
-var ConditionSchema = z2.union([
-  BuiltinConditionSchema,
-  AndConditionSchema,
-  OrConditionSchema,
-  z2.looseObject({ type: z2.string() }).refine((val) => !BLOCKED_OPEN_UNION_TYPES.has(val.type), {
-    message: "Reserved condition type"
-  })
-]);
-function isAndCondition(c) {
-  return c.type === CONDITION_TYPES.and;
-}
-function isOrCondition(c) {
-  return c.type === CONDITION_TYPES.or;
-}
-
 // src/logger.ts
 var noopLogger = {
   debug() {
@@ -369,7 +271,7 @@ var noopLogger = {
   }
 };
 
-// src/conditions/composite.ts
+// src/conditions/evaluate.ts
 async function evaluateCondition({
   condition,
   context,
@@ -378,71 +280,22 @@ async function evaluateCondition({
   deps = {},
   depth = "",
   logger = noopLogger,
-  fallback,
   createRegex = defaultCreateRegex
 }) {
-  if (isAndCondition(condition)) {
-    for (let i = 0; i < condition.conditions.length; i++) {
-      const childDepth = depth === "" ? `${i}` : `${depth}.${i}`;
-      const result2 = await evaluateCondition({
-        condition: condition.conditions[i],
-        context,
-        evaluators,
-        annotations,
-        deps,
-        depth: childDepth,
-        logger,
-        fallback,
-        createRegex
-      });
-      if (!result2) {
-        logger.debug("and condition short-circuited (child returned false)", {
-          childType: condition.conditions[i].type,
-          depth: childDepth
-        });
-        return false;
-      }
-    }
-    return true;
-  }
-  if (isOrCondition(condition)) {
-    for (let i = 0; i < condition.conditions.length; i++) {
-      const childDepth = depth === "" ? `${i}` : `${depth}.${i}`;
-      const result2 = await evaluateCondition({
-        condition: condition.conditions[i],
-        context,
-        evaluators,
-        annotations,
-        deps,
-        depth: childDepth,
-        logger,
-        fallback,
-        createRegex
-      });
-      if (result2) {
-        logger.debug("or condition short-circuited (child returned true)", {
-          childType: condition.conditions[i].type,
-          depth: childDepth
-        });
-        return true;
-      }
-    }
-    return false;
-  }
-  const evaluator = evaluators[condition.type];
+  const evaluator = evaluators[condition.type] ?? evaluators[FALLBACK_EVALUATOR_KEY];
   if (!evaluator) {
-    if (fallback) {
-      const result2 = await fallback({ condition, context, annotations, deps, depth, createRegex });
-      logger.debug("condition evaluated (fallback)", {
-        type: condition.type,
-        depth,
-        result: result2
-      });
-      return result2;
-    }
-    throw new ShowwhatError(`Unknown condition type "${condition.type}".`);
+    throw new UnknownConditionTypeError(condition.type, condition);
   }
-  const result = await evaluator({ condition, context, annotations, deps, depth, createRegex });
+  const result = await evaluator({
+    condition,
+    context,
+    annotations,
+    deps,
+    depth,
+    createRegex,
+    logger,
+    evaluators
+  });
   logger.debug("condition evaluated", {
     type: condition.type,
     depth,
@@ -451,6 +304,74 @@ async function evaluateCondition({
   return result;
 }
 
+// src/conditions/and.ts
+var andEvaluator = async (args) => {
+  const { conditions } = args.condition;
+  const { depth } = args;
+  for (let i = 0; i < conditions.length; i++) {
+    const childDepth = depth === "" ? `${i}` : `${depth}.${i}`;
+    const result = await evaluateCondition({
+      ...args,
+      condition: conditions[i],
+      depth: childDepth
+    });
+    if (!result) {
+      args.logger?.debug("and condition short-circuited (child returned false)", {
+        childType: conditions[i].type,
+        depth: childDepth
+      });
+      return false;
+    }
+  }
+  return true;
+};
+
+// src/conditions/or.ts
+var orEvaluator = async (args) => {
+  const { conditions } = args.condition;
+  const { depth } = args;
+  for (let i = 0; i < conditions.length; i++) {
+    const childDepth = depth === "" ? `${i}` : `${depth}.${i}`;
+    const result = await evaluateCondition({
+      ...args,
+      condition: conditions[i],
+      depth: childDepth
+    });
+    if (result) {
+      args.logger?.debug("or condition short-circuited (child returned true)", {
+        childType: conditions[i].type,
+        depth: childDepth
+      });
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/conditions/check-annotations.ts
+var checkAnnotationsEvaluator = async (args) => {
+  const { conditions } = args.condition;
+  const { depth, annotations: annotationsAsContext } = args;
+  for (let i = 0; i < conditions.length; i++) {
+    const childDepth = depth === "" ? `${i}` : `${depth}.${i}`;
+    const result = await evaluateCondition({
+      ...args,
+      condition: conditions[i],
+      context: annotationsAsContext,
+      annotations: {},
+      depth: childDepth
+    });
+    if (!result) {
+      args.logger?.debug("checkAnnotations condition short-circuited (child returned false)", {
+        childType: conditions[i].type,
+        depth: childDepth
+      });
+      return false;
+    }
+  }
+  return true;
+};
+
 // src/conditions/index.ts
 var builtinEvaluators = {
   string: stringEvaluator,
@@ -459,7 +380,10 @@ var builtinEvaluators = {
   bool: boolEvaluator,
   env: envEvaluator,
   startAt: startAtEvaluator,
-  endAt: endAtEvaluator
+  endAt: endAtEvaluator,
+  and: andEvaluator,
+  or: orEvaluator,
+  checkAnnotations: checkAnnotationsEvaluator
 };
 
 // src/resolver.ts
@@ -467,6 +391,9 @@ function getEvaluators(options) {
   if (!options?.evaluators) {
     throw new ShowwhatError("No evaluators registered. Pass evaluators via options.");
   }
+  if (options.fallback) {
+    return { ...options.evaluators, [FALLBACK_EVALUATOR_KEY]: options.fallback };
+  }
   return options.evaluators;
 }
 function getLogger(options) {
@@ -476,61 +403,44 @@ async function resolveVariation({
   variations,
   context,
   deps,
-  options
+  options,
+  definitionKey
 }) {
   const evaluators = getEvaluators(options);
   const logger = getLogger(options);
   for (let i = 0; i < variations.length; i++) {
     const variation = variations[i];
-    const conditionList = Array.isArray(variation.conditions) ? variation.conditions : [];
-    if (conditionList.length === 0) {
+    const conditions = Array.isArray(variation.conditions) ? variation.conditions : [];
+    const annotations = options?.createAnnotations?.(definitionKey) ?? {};
+    if (conditions.length === 0) {
       logger.debug("variation matched (no conditions)", { variationIndex: i });
-      return { variation, variationIndex: i, annotations: {} };
+      return { variation, variationIndex: i, annotations };
     }
-    const annotations = {};
     const rulesMatch = await evaluateCondition({
-      condition: { type: "and", conditions: conditionList },
+      condition: { type: "and", conditions },
       context,
       evaluators,
       annotations,
       deps: deps ?? {},
       logger,
-      fallback: options?.fallback,
-      createRegex: options?.createRegex
+      createRegex: options?.createRegex ?? defaultCreateRegex
     });
     if (!rulesMatch) {
       logger.debug("variation did not match", {
         variationIndex: i,
-        conditionCount: conditionList.length
+        conditionCount: conditions.length
       });
       continue;
     }
     logger.debug("variation matched", {
       variationIndex: i,
-      conditionCount: conditionList.length
+      conditionCount: conditions.length
     });
     return { variation, variationIndex: i, annotations };
   }
   logger.debug("no variation matched", { variationCount: variations.length });
   return null;
 }
-function toResolution(key, result) {
-  const conditionCount = Array.isArray(result.variation.conditions) ? result.variation.conditions.length : 0;
-  return {
-    success: true,
-    key,
-    value: result.variation.value,
-    meta: {
-      variation: {
-        index: result.variationIndex,
-        id: result.variation.id,
-        description: result.variation.description,
-        conditionCount
-      },
-      annotations: result.annotations
-    }
-  };
-}
 async function resolveKey(key, definitions, context, deps, options) {
   const logger = getLogger(options);
   const definition = definitions[key];
@@ -550,7 +460,8 @@ async function resolveKey(key, definitions, context, deps, options) {
     variations: definition.variations,
     context,
     deps,
-    options
+    options,
+    definitionKey: key
   });
   if (!result) {
     logger.warn("no matching variation", { key });
@@ -561,7 +472,21 @@ async function resolveKey(key, definitions, context, deps, options) {
     variationIndex: result.variationIndex,
     value: result.variation.value
   });
-  return toResolution(key, result);
+  const conditionCount = Array.isArray(result.variation.conditions) ? result.variation.conditions.length : 0;
+  return {
+    success: true,
+    key,
+    value: result.variation.value,
+    meta: {
+      variation: {
+        index: result.variationIndex,
+        id: result.variation.id,
+        description: result.variation.description,
+        conditionCount
+      },
+      annotations: result.annotations
+    }
+  };
 }
 async function resolve({
   definitions,
@@ -587,36 +512,175 @@ async function resolve({
 // src/parsers.ts
 import yaml from "js-yaml";
 
-// src/schemas/context.ts
-import { z as z3 } from "zod";
-var ContextPrimitiveSchema = z3.union([z3.string(), z3.number(), z3.boolean()]);
-var ContextValueSchema = z3.union([
-  ContextPrimitiveSchema,
-  z3.array(ContextPrimitiveSchema),
-  z3.lazy(() => z3.record(z3.string(), ContextValueSchema))
+// src/schemas/condition.ts
+import { z as z4 } from "zod";
+var PRIMITIVE_CONDITION_TYPES = {
+  string: "string",
+  number: "number",
+  bool: "bool",
+  datetime: "datetime"
+};
+var CONDITION_TYPES = {
+  ...PRIMITIVE_CONDITION_TYPES,
+  env: "env",
+  startAt: "startAt",
+  endAt: "endAt",
+  and: "and",
+  or: "or",
+  checkAnnotations: "checkAnnotations"
+};
+var CONTEXT_KEYS = {
+  env: "env",
+  at: "at"
+};
+var StringConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("string"),
+  key: z4.string().min(1),
+  op: z4.enum(["eq", "neq", "in", "nin", "regex"]),
+  value: z4.union([z4.string(), z4.array(z4.string())])
+}).superRefine((val, ctx) => {
+  const isArrayOp = val.op === "in" || val.op === "nin";
+  const isArray = Array.isArray(val.value);
+  if (isArrayOp && !isArray) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${val.op}" operator requires an array value`,
+      path: ["value"]
+    });
+  }
+  if (!isArrayOp && isArray) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${val.op}" operator requires a string value`,
+      path: ["value"]
+    });
+  }
+});
+var NumberConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("number"),
+  key: z4.string().min(1),
+  op: z4.enum(["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]),
+  value: z4.union([z4.number(), z4.array(z4.number())])
+}).superRefine((val, ctx) => {
+  const isArrayOp = val.op === "in" || val.op === "nin";
+  const isArray = Array.isArray(val.value);
+  if (isArrayOp && !isArray) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${val.op}" operator requires an array value`,
+      path: ["value"]
+    });
+  }
+  if (!isArrayOp && isArray) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${val.op}" operator requires a number value`,
+      path: ["value"]
+    });
+  }
+});
+var DatetimeConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("datetime"),
+  key: z4.string().min(1),
+  op: z4.enum(["eq", "gt", "gte", "lt", "lte"]),
+  value: z4.iso.datetime({ message: '"datetime" must be a valid ISO 8601 datetime' })
+});
+var BoolConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("bool"),
+  key: z4.string().min(1),
+  op: z4.literal("eq").optional(),
+  value: z4.boolean()
+});
+var EnvConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("env"),
+  op: z4.literal("eq").optional(),
+  value: z4.union([z4.string(), z4.array(z4.string())])
+});
+var StartAtConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("startAt"),
+  value: z4.iso.datetime({ message: '"startAt" must be a valid ISO 8601 datetime' })
+});
+var EndAtConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("endAt"),
+  value: z4.iso.datetime({ message: '"endAt" must be a valid ISO 8601 datetime' })
+});
+var BuiltinConditionSchema = z4.discriminatedUnion("type", [
+  StringConditionSchema,
+  NumberConditionSchema,
+  DatetimeConditionSchema,
+  BoolConditionSchema,
+  EnvConditionSchema,
+  StartAtConditionSchema,
+  EndAtConditionSchema
 ]);
-var ContextSchema = z3.record(z3.string(), ContextValueSchema);
+var AndConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("and"),
+  conditions: z4.array(z4.lazy(() => ConditionSchema)).min(1)
+});
+var OrConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("or"),
+  conditions: z4.array(z4.lazy(() => ConditionSchema)).min(1)
+});
+var CheckAnnotationsConditionSchema = z4.object({
+  id: z4.string().optional(),
+  type: z4.literal("checkAnnotations"),
+  conditions: z4.array(z4.lazy(() => ConditionSchema)).min(1)
+});
+var BLOCKED_OPEN_UNION_TYPES = new Set(Object.values(CONDITION_TYPES));
+var ConditionSchema = z4.union([
+  BuiltinConditionSchema,
+  AndConditionSchema,
+  OrConditionSchema,
+  CheckAnnotationsConditionSchema,
+  z4.looseObject({ type: z4.string() }).refine((val) => !BLOCKED_OPEN_UNION_TYPES.has(val.type), {
+    message: "Reserved condition type"
+  })
+]);
+function isAndCondition(c) {
+  return c.type === CONDITION_TYPES.and;
+}
+function isOrCondition(c) {
+  return c.type === CONDITION_TYPES.or;
+}
+function isCheckAnnotationsCondition(c) {
+  return c.type === CONDITION_TYPES.checkAnnotations;
+}
+
+// src/schemas/context.ts
+import { z as z5 } from "zod";
+var ContextValueSchema = DataValueSchema;
+var ContextSchema = z5.record(z5.string(), ContextValueSchema);
 
 // src/schemas/variation.ts
-import { z as z4 } from "zod";
-var VariationValueSchema = z4.unknown();
-var VariationSchema = z4.object({
-  id: z4.string().optional(),
+import { z as z6 } from "zod";
+var VariationValueSchema = z6.unknown();
+var VariationSchema = z6.object({
+  id: z6.string().optional(),
   value: VariationValueSchema,
-  conditions: z4.array(ConditionSchema).optional(),
-  description: z4.string().optional()
+  conditions: z6.array(ConditionSchema).optional(),
+  description: z6.string().optional()
 });
 
 // src/schemas/definition.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 
 // src/schemas/preset.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 var PRIMITIVE_TYPES = new Set(Object.values(PRIMITIVE_CONDITION_TYPES));
-var PresetDefinitionSchema = z5.object({
-  type: z5.string().min(1),
-  key: z5.string().min(1).optional(),
-  overrides: z5.record(z5.string(), z5.unknown()).optional()
+var COMPOSITE_TYPES = /* @__PURE__ */ new Set(["and", "or", "checkAnnotations"]);
+var PresetDefinitionSchema = z7.object({
+  type: z7.string().min(1),
+  key: z7.string().min(1).optional(),
+  overrides: z7.record(z7.string(), z7.unknown()).optional()
 }).superRefine((val, ctx) => {
   if (PRIMITIVE_TYPES.has(val.type) && !val.key) {
     ctx.addIssue({
@@ -625,35 +689,57 @@ var PresetDefinitionSchema = z5.object({
       path: ["key"]
     });
   }
+  if (COMPOSITE_TYPES.has(val.type)) {
+    const conditions = val.overrides?.conditions;
+    if (!Array.isArray(conditions) || conditions.length === 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: `"overrides.conditions" must be a non-empty array for composite type ("${val.type}")`,
+        path: ["overrides", "conditions"]
+      });
+      return;
+    }
+    for (let i = 0; i < conditions.length; i++) {
+      const result = ConditionSchema.safeParse(conditions[i]);
+      if (!result.success) {
+        for (const issue of result.error.issues) {
+          ctx.addIssue({
+            ...issue,
+            path: ["overrides", "conditions", i, ...issue.path]
+          });
+        }
+      }
+    }
+  }
 });
-var PresetsSchema = z5.record(z5.string(), PresetDefinitionSchema);
+var PresetsSchema = z7.record(z7.string(), PresetDefinitionSchema);
 
 // src/schemas/definition.ts
-var DefinitionSchema = z6.object({
-  id: z6.string().optional(),
-  active: z6.boolean().optional(),
-  description: z6.string().optional(),
-  variations: z6.array(VariationSchema).min(1)
+var DefinitionSchema = z8.object({
+  id: z8.string().optional(),
+  active: z8.boolean().optional(),
+  description: z8.string().optional(),
+  variations: z8.array(VariationSchema).min(1)
 });
-var DefinitionsSchema = z6.record(z6.string().min(1), DefinitionSchema);
-var FileFormatSchema = z6.object({
+var DefinitionsSchema = z8.record(z8.string().min(1), DefinitionSchema);
+var FileFormatSchema = z8.object({
   definitions: DefinitionsSchema,
   presets: PresetsSchema.optional()
 }).strict();
 
 // src/schemas/resolution.ts
-import { z as z7 } from "zod";
-var ResolutionSchema = z7.object({
-  key: z7.string(),
+import { z as z9 } from "zod";
+var ResolutionSchema = z9.object({
+  key: z9.string(),
   value: VariationValueSchema,
-  meta: z7.object({
-    variation: z7.object({
-      index: z7.number().int().nonnegative(),
-      id: z7.string().optional(),
-      description: z7.string().optional(),
-      conditionCount: z7.number().int().nonnegative()
+  meta: z9.object({
+    variation: z9.object({
+      index: z9.number().int().nonnegative(),
+      id: z9.string().optional(),
+      description: z9.string().optional(),
+      conditionCount: z9.number().int().nonnegative()
     }),
-    annotations: z7.record(z7.string(), z7.unknown())
+    annotations: z9.record(z9.string(), z9.unknown())
   })
 });
 
@@ -731,47 +817,44 @@ var MemoryData = class _MemoryData {
   async listKeys() {
     return Object.keys(this.#flags);
   }
-  async getPresets() {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async getPresets(_key) {
     return structuredClone(this.#presets);
   }
 };
 
 // src/presets.ts
 var RESERVED_CONDITION_TYPES = /* @__PURE__ */ new Set([...Object.values(CONDITION_TYPES), "__custom"]);
-var BUILTIN_EVALUATORS = {
-  string: stringEvaluator,
-  number: numberEvaluator,
-  bool: boolEvaluator,
-  datetime: datetimeEvaluator
-};
 function createPresetConditions(presets) {
   const result = {};
   for (const [name, preset] of Object.entries(presets)) {
     if (RESERVED_CONDITION_TYPES.has(name)) {
       throw new Error(`Preset name "${name}" collides with a built-in or reserved condition type`);
     }
-    if (!PRIMITIVE_TYPES.has(preset.type)) {
-      continue;
-    }
-    const primitiveType = preset.type;
-    const delegateEvaluator = BUILTIN_EVALUATORS[primitiveType];
-    const presetKey = preset.key;
     const overrides = preset.overrides ?? {};
-    const evaluator = ({
+    const evaluator = async ({
       condition,
       context,
       annotations,
       deps,
       depth,
-      createRegex
+      createRegex,
+      evaluators,
+      logger
     }) => {
       const rec = condition;
-      return delegateEvaluator({
-        condition: { ...rec, ...overrides, type: primitiveType, key: presetKey },
+      const rewritten = { ...rec, ...overrides, type: preset.type };
+      if (preset.key) {
+        rewritten.key = preset.key;
+      }
+      return evaluateCondition({
+        condition: rewritten,
         context,
+        evaluators,
         annotations,
         deps,
         depth,
+        logger,
         createRegex
       });
     };
@@ -780,6 +863,8 @@ function createPresetConditions(presets) {
   return result;
 }
 export {
+  AnnotationValueSchema,
+  AnnotationsSchema,
   BoolConditionSchema,
   BuiltinConditionSchema,
   CONDITION_TYPES,
@@ -787,7 +872,9 @@ export {
   ConditionError,
   ConditionSchema,
   ContextSchema,
+  ContextValueSchema,
   DataError,
+  DataValueSchema,
   DatetimeConditionSchema,
   DefinitionInactiveError,
   DefinitionNotFoundError,
@@ -795,12 +882,12 @@ export {
   DefinitionsSchema,
   EndAtConditionSchema,
   EnvConditionSchema,
+  FALLBACK_EVALUATOR_KEY,
   FileFormatSchema,
   InvalidContextError,
   MemoryData,
   NumberConditionSchema,
   PRIMITIVE_CONDITION_TYPES,
-  PRIMITIVE_TYPES,
   ParseError,
   PresetsSchema,
   ResolutionSchema,
@@ -808,6 +895,7 @@ export {
   ShowwhatError,
   StartAtConditionSchema,
   StringConditionSchema,
+  UnknownConditionTypeError,
   ValidationError,
   VariationNotFoundError,
   VariationSchema,
@@ -817,6 +905,7 @@ export {
   defaultCreateRegex,
   evaluateCondition,
   isAndCondition,
+  isCheckAnnotationsCondition,
   isOrCondition,
   isWritable,
   noConditionEvaluator,