@typespec/spec-api 0.1.0-dev.0 → 0.1.0-dev.1

package/src/match-engine.ts

@@ -0,0 +1,221 @@
+/**
+ * Matcher framework for Spector mock API validation.
+ *
+ * Matchers are special objects that can be placed anywhere in an expected value tree.
+ * The comparison engine recognizes them and delegates to `matcher.check(actual)`
+ * instead of doing strict equality — enabling flexible comparisons for types like
+ * datetime that serialize differently across languages.
+ */
+
+/** Symbol used to identify matcher objects */
+export const MatcherSymbol: unique symbol = Symbol.for("SpectorMatcher");
+
+/** Result of a match operation */
+export type MatchResult = { pass: true } | { pass: false; message: string };
+
+const OK: MatchResult = Object.freeze({ pass: true });
+
+/** Create a passing match result */
+export function ok(): MatchResult {
+  return OK;
+}
+
+/** Create a failing match result with a message */
+export function err(message: string): MatchResult {
+  return { pass: false, message };
+}
+
+/**
+ * Interface for custom value matchers.
+ * Implement this to create new matcher types.
+ */
+export interface MockValueMatcher<T = unknown> {
+  readonly [MatcherSymbol]: true;
+  /** Check whether the actual value matches the expectation */
+  check(actual: unknown, config?: MatcherConfig): MatchResult;
+  /** The raw value to use when serializing */
+  serialize(config?: MatcherConfig): T;
+  /** @internal Delegates to serialize() for JSON.stringify compatibility */
+  toJSON(): T;
+  /** Human-readable description for debugging */
+  toString(): string;
+}
+
+/** Configuration available to matchers at runtime */
+export interface MatcherConfig {
+  baseUrl: string;
+}
+
+const emptyConfig: MatcherConfig = { baseUrl: "" };
+
+interface MatcherImpl<T> {
+  check(actual: unknown): MatchResult;
+  serialize(): T;
+  toString?: () => string;
+}
+
+/** Create a MockValueMatcher with the MatcherSymbol already set.
+ *  Accepts either a plain implementation object (for matchers that don't need config)
+ *  or a factory function `(config) => impl` (for matchers that do).
+ */
+export function createMatcher<T = unknown>(
+  implOrFactory: MatcherImpl<T> | ((config: MatcherConfig) => MatcherImpl<T>),
+): MockValueMatcher<T> {
+  const resolve =
+    typeof implOrFactory === "function"
+      ? (config: MatcherConfig) => implOrFactory(config)
+      : () => implOrFactory;
+  return {
+    [MatcherSymbol]: true,
+    check(actual: unknown, config?: MatcherConfig): MatchResult {
+      return resolve(config ?? emptyConfig).check(actual);
+    },
+    serialize(config?: MatcherConfig): T {
+      return resolve(config ?? emptyConfig).serialize();
+    },
+    toJSON() {
+      return resolve(emptyConfig).serialize();
+    },
+    toString() {
+      const impl = resolve(emptyConfig);
+      return impl.toString?.() ?? String(impl.serialize());
+    },
+  };
+}
+
+/** Type guard to check if a value is a MockValueMatcher */
+export function isMatcher(value: unknown): value is MockValueMatcher {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    MatcherSymbol in value &&
+    (value as any)[MatcherSymbol] === true
+  );
+}
+
+function formatValue(value: unknown): string {
+  if (value === null) return "null";
+  if (value === undefined) return "undefined";
+  if (typeof value === "string") return `"${value}"`;
+  if (Buffer.isBuffer(value)) return `Buffer(${value.length})`;
+  if (Array.isArray(value)) return `Array(${value.length})`;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+function pathErr(message: string, path: string): MatchResult {
+  const prefix = path ? `at ${path}: ` : "";
+  return err(`${prefix}${message}`);
+}
+
+/**
+ * Recursively compares actual vs expected values.
+ * When a MockValueMatcher is encountered in the expected tree, delegates to matcher.check().
+ * Otherwise uses strict equality semantics (same as deep-equal with strict: true).
+ */
+export function matchValues(
+  actual: unknown,
+  expected: unknown,
+  path: string = "$",
+  config: MatcherConfig = emptyConfig,
+): MatchResult {
+  if (expected === actual) {
+    return ok();
+  }
+
+  if (isMatcher(expected)) {
+    const result = expected.check(actual, config);
+    if (!result.pass) {
+      return pathErr(result.message, path);
+    }
+    return result;
+  }
+
+  if (typeof expected !== typeof actual) {
+    return pathErr(
+      `Type mismatch: expected ${typeof expected} but got ${typeof actual} (${formatValue(actual)})`,
+      path,
+    );
+  }
+
+  if (expected === null || actual === null) {
+    return pathErr(`Expected ${formatValue(expected)} but got ${formatValue(actual)}`, path);
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) {
+      return pathErr(`Expected an array but got ${formatValue(actual)}`, path);
+    }
+    if (expected.length !== actual.length) {
+      return pathErr(
+        `Array length mismatch: expected ${expected.length} but got ${actual.length}`,
+        path,
+      );
+    }
+    for (let i = 0; i < expected.length; i++) {
+      const result = matchValues(actual[i], expected[i], `${path}[${i}]`, config);
+      if (!result.pass) {
+        return result;
+      }
+    }
+    return ok();
+  }
+
+  if (Buffer.isBuffer(expected)) {
+    if (!Buffer.isBuffer(actual)) {
+      return pathErr(`Expected a Buffer but got ${typeof actual}`, path);
+    }
+    if (!expected.equals(actual)) {
+      return pathErr(`Buffer contents differ`, path);
+    }
+    return ok();
+  }
+
+  if (typeof expected === "object") {
+    const expectedObj = expected as Record<string, unknown>;
+    const actualObj = actual as Record<string, unknown>;
+
+    // Keys with undefined values in expected mean "must not be present in actual"
+    const expectedPresentKeys = Object.keys(expectedObj).filter(
+      (k) => expectedObj[k] !== undefined,
+    );
+    const expectedAbsentKeys = Object.keys(expectedObj).filter((k) => expectedObj[k] === undefined);
+    const actualKeys = Object.keys(actualObj);
+
+    // Verify keys that should be absent are not in actual
+    for (const key of expectedAbsentKeys) {
+      if (key in actualObj && actualObj[key] !== undefined) {
+        return pathErr(
+          `Key "${key}" should not be present but got ${formatValue(actualObj[key])}`,
+          path,
+        );
+      }
+    }
+
+    if (expectedPresentKeys.length !== actualKeys.length) {
+      const missing = expectedPresentKeys.filter((k) => !(k in actualObj));
+      const extra = actualKeys.filter(
+        (k) => !expectedPresentKeys.includes(k) && !expectedAbsentKeys.includes(k),
+      );
+      const parts: string[] = [
+        `Key count mismatch: expected ${expectedPresentKeys.length} but got ${actualKeys.length}`,
+      ];
+      if (missing.length > 0) parts.push(`missing: [${missing.join(", ")}]`);
+      if (extra.length > 0) parts.push(`extra: [${extra.join(", ")}]`);
+      return pathErr(parts.join(". "), path);
+    }
+
+    for (const key of expectedPresentKeys) {
+      if (!(key in actualObj)) {
+        return pathErr(`Missing key "${key}"`, path);
+      }
+      const result = matchValues(actualObj[key], expectedObj[key], `${path}.${key}`, config);
+      if (!result.pass) {
+        return result;
+      }
+    }
+    return ok();
+  }
+
+  return pathErr(`Expected ${formatValue(expected)} but got ${formatValue(actual)}`, path);
+}

package/src/matchers/datetime.ts

@@ -0,0 +1,66 @@
+import { createMatcher, err, type MockValueMatcher, ok } from "../match-engine.js";
+
+const rfc3339Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/i;
+const utcRfc3339Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/i;
+const rfc7231Pattern =
+  /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT$/i;
+
+function createDateTimeMatcher(
+  value: string,
+  label: string,
+  formatName: string,
+  formatPattern: RegExp,
+): MockValueMatcher<string> {
+  const expectedMs = Date.parse(value);
+  if (isNaN(expectedMs)) {
+    throw new Error(`${label}: invalid datetime value: ${value}`);
+  }
+  return createMatcher({
+    check(actual: unknown) {
+      if (typeof actual !== "string") {
+        return err(
+          `${label}: expected a string but got ${typeof actual} (${JSON.stringify(actual)})`,
+        );
+      }
+      if (!formatPattern.test(actual)) {
+        return err(`${label}: expected ${formatName} format but got "${actual}"`);
+      }
+      const actualMs = Date.parse(actual);
+      if (isNaN(actualMs)) {
+        return err(
+          `${label}: value "${actual}" matches ${formatName} format but is not a valid date`,
+        );
+      }
+      if (actualMs !== expectedMs) {
+        return err(
+          `${label}: timestamps differ \u2014 expected ${new Date(expectedMs).toISOString()} but got ${new Date(actualMs).toISOString()}`,
+        );
+      }
+      return ok();
+    },
+    serialize() {
+      return value;
+    },
+    toString() {
+      return `${label}(${value})`;
+    },
+  });
+}
+
+export const dateTimeMatcher = {
+  rfc3339(value: string): MockValueMatcher<string> {
+    return createDateTimeMatcher(value, "match.dateTime.rfc3339", "rfc3339", rfc3339Pattern);
+  },
+  /** Like rfc3339 but rejects timezone offsets — only Z (UTC) suffix is allowed. */
+  utcRfc3339(value: string): MockValueMatcher<string> {
+    return createDateTimeMatcher(
+      value,
+      "match.dateTime.utcRfc3339",
+      "utcRfc3339",
+      utcRfc3339Pattern,
+    );
+  },
+  rfc7231(value: string): MockValueMatcher<string> {
+    return createDateTimeMatcher(value, "match.dateTime.rfc7231", "rfc7231", rfc7231Pattern);
+  },
+};

package/src/matchers/index.ts

@@ -0,0 +1,48 @@
+import { dateTimeMatcher } from "./datetime.js";
+import { baseUrlMatcher } from "./local-url.js";
+
+export {
+  createMatcher,
+  err,
+  isMatcher,
+  MatcherSymbol,
+  matchValues,
+  ok,
+  type MatcherConfig,
+  type MatchResult,
+  type MockValueMatcher,
+} from "../match-engine.js";
+export { dateTimeMatcher } from "./datetime.js";
+
+/**
+ * Namespace for built-in matchers.
+ */
+export const match = {
+  /**
+   * Matchers for comparing datetime values semantically.
+   * Validates that the actual value is in the correct format and represents
+   * the same point in time as the expected value.
+   *
+   * @example
+   * ```ts
+   * match.dateTime.rfc3339("2022-08-26T18:38:00.000Z")
+   * match.dateTime.utcRfc3339("2022-08-26T18:38:00.000Z") // rejects offsets, only Z
+   * match.dateTime.rfc7231("Fri, 26 Aug 2022 14:38:00 GMT")
+   * ```
+   */
+  dateTime: dateTimeMatcher,
+
+  /**
+   * Matcher for URL values that include the server's base URL.
+   *
+   * The matcher is created with just the path portion. At runtime, `expandDyns()`
+   * resolves it by injecting the server's actual base URL (e.g. `http://localhost:3000`).
+   * The resolved matcher validates that the actual value equals `baseUrl + path`.
+   *
+   * @example
+   * ```ts
+   * match.localUrl("/payload/pageable/next-page")
+   * ```
+   */
+  localUrl: baseUrlMatcher,
+};

package/src/matchers/local-url.ts

@@ -0,0 +1,24 @@
+import { createMatcher, err, type MockValueMatcher, ok } from "../match-engine.js";
+
+export function baseUrlMatcher(path: string): MockValueMatcher<string> {
+  return createMatcher((config) => ({
+    check(actual: unknown) {
+      if (typeof actual !== "string") {
+        return err(
+          `match.localUrl: expected a string but got ${typeof actual} (${JSON.stringify(actual)})`,
+        );
+      }
+      const expected = config.baseUrl + path;
+      if (actual !== expected) {
+        return err(`match.localUrl: expected "${expected}" but got "${actual}"`);
+      }
+      return ok();
+    },
+    serialize() {
+      return config.baseUrl + path;
+    },
+    toString() {
+      return `match.localUrl("${path}")`;
+    },
+  }));
+}

package/src/request-validations.ts

@@ -1,7 +1,7 @@
 import deepEqual from "deep-equal";
-import * as prettier from "prettier";
 import { parseString } from "xml2js";
-import { CollectionFormat, RequestExt } from "./types.js";
+import { matchValues, type MockValueMatcher } from "./match-engine.js";
+import { CollectionFormat, RequestExt, Resolver, ResolverConfig } from "./types.js";
 import { ValidationError } from "./validation-error.js";
 
 export const BODY_NOT_EQUAL_ERROR_MESSAGE = "Body provided doesn't match expected body";
@@ -37,43 +37,89 @@ export const validateBodyEquals = (
     return;
   }
 
-  if (!deepEqual(request.body, expectedBody, { strict: true })) {
-    throw new ValidationError(BODY_NOT_EQUAL_ERROR_MESSAGE, expectedBody, request.body);
+  const result = matchValues(request.body, expectedBody);
+  if (!result.pass) {
+    throw new ValidationError(
+      `${BODY_NOT_EQUAL_ERROR_MESSAGE}: ${result.message}`,
+      expectedBody,
+      request.body,
+    );
   }
 };
 
-export const validateXmlBodyEquals = (request: RequestExt, expectedBody: string): void => {
+export const validateXmlBodyEquals = (
+  request: RequestExt,
+  expectedBody: string | Resolver,
+  config?: ResolverConfig,
+): void => {
+  const resolvedConfig = config ?? { baseUrl: "" };
+  // When expectedBody is a Resolver (e.g. from xml`...`), serialize() already includes the XML declaration.
+  // When it's a plain string, we need to prepend it.
+  const expectedXml =
+    typeof expectedBody === "string"
+      ? `<?xml version='1.0' encoding='UTF-8'?>` + expectedBody
+      : expectedBody.serialize(resolvedConfig);
+
   if (request.rawBody === undefined || isBodyEmpty(request.rawBody)) {
-    throw new ValidationError(BODY_EMPTY_ERROR_MESSAGE, expectedBody, request.rawBody);
+    throw new ValidationError(BODY_EMPTY_ERROR_MESSAGE, expectedXml, request.rawBody);
   }
 
-  expectedBody = `<?xml version='1.0' encoding='UTF-8'?>` + expectedBody;
-
-  let actualParsedBody = "";
+  let actualParsed: unknown;
   parseString(request.rawBody, (err: Error | null, result: any): void => {
-    if (err !== null) {
-      throw err;
-    }
-    actualParsedBody = result;
+    if (err !== null) throw err;
+    actualParsed = result;
   });
 
-  let expectedParsedBody = "";
-  parseString(expectedBody, (err: Error | null, result: any): void => {
-    if (err !== null) {
-      throw err;
-    }
-    expectedParsedBody = result;
+  let expectedParsed: unknown;
+  parseString(expectedXml, (err: Error | null, result: any): void => {
+    if (err !== null) throw err;
+    expectedParsed = result;
   });
 
-  if (!deepEqual(actualParsedBody, expectedParsedBody, { strict: true })) {
-    throw new ValidationError(
-      BODY_NOT_EQUAL_ERROR_MESSAGE,
-      prettier.format(expectedBody),
-      prettier.format(request.body),
-    );
+  // If the expected body is a DynValue with matchers, use matcher-aware comparison
+  const matchers =
+    typeof expectedBody !== "string" && "getMatchers" in expectedBody
+      ? (expectedBody as any).getMatchers(resolvedConfig)
+      : [];
+
+  if (matchers.length > 0) {
+    const matcherMap = new Map<string, MockValueMatcher>();
+    for (const { serialized, matcher } of matchers) {
+      matcherMap.set(serialized, matcher);
+    }
+    expectedParsed = substituteMatchers(expectedParsed, matcherMap);
+
+    const result = matchValues(actualParsed, expectedParsed);
+    if (!result.pass) {
+      throw new ValidationError(
+        `${BODY_NOT_EQUAL_ERROR_MESSAGE}: ${result.message}`,
+        expectedXml,
+        request.rawBody,
+      );
+    }
+  } else {
+    if (!deepEqual(actualParsed, expectedParsed, { strict: true })) {
+      throw new ValidationError(BODY_NOT_EQUAL_ERROR_MESSAGE, expectedXml, request.rawBody);
+    }
   }
 };
 
+function substituteMatchers(value: unknown, matcherMap: Map<string, MockValueMatcher>): unknown {
+  if (typeof value === "string") {
+    return matcherMap.get(value) ?? value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => substituteMatchers(v, matcherMap));
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value as Record<string, unknown>;
+    return Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [k, substituteMatchers(v, matcherMap)]),
+    );
+  }
+  return value;
+}
+
 export const validateCoercedDateBodyEquals = (
   request: RequestExt,
   expectedBody: unknown | undefined,
@@ -85,8 +131,13 @@ export const validateCoercedDateBodyEquals = (
     return;
   }
 
-  if (!deepEqual(coerceDate(request.body), expectedBody, { strict: true })) {
-    throw new ValidationError(BODY_NOT_EQUAL_ERROR_MESSAGE, expectedBody, request.body);
+  const result = matchValues(coerceDate(request.body), expectedBody);
+  if (!result.pass) {
+    throw new ValidationError(
+      `${BODY_NOT_EQUAL_ERROR_MESSAGE}: ${result.message}`,
+      expectedBody,
+      request.body,
+    );
   }
 };
 

package/src/response-utils.ts

@@ -1,3 +1,4 @@
+import { isMatcher, type MockValueMatcher } from "./match-engine.js";
 import { MockBody, MockMultipartBody, Resolver, ResolverConfig } from "./types.js";
 
 /**
@@ -18,19 +19,47 @@ function createResolver(content: unknown): Resolver {
       const expanded = expandDyns(content, config);
       return JSON.stringify(expanded);
     },
+    resolve: (config: ResolverConfig) => {
+      // Preserve matchers so matchValues can use them for flexible validation
+      return expandDyns(content, config, { resolveMatchers: false });
+    },
   };
 }
 
+const XML_DECLARATION = `<?xml version='1.0' encoding='UTF-8'?>`;
+
 /**
- * Sends the provided XML string in a MockResponse body.
- * The XML declaration prefix will automatically be added to xmlString.
- * @content Object to return as XML.
+ * Sends the provided XML content in a MockResponse body.
+ * The XML declaration prefix is automatically prepended.
+ *
+ * Can be used as a plain function or as a tagged template literal.
+ * When used as a tagged template, interpolated matchers (e.g. `match.localUrl`)
+ * are resolved at serialization time via `expandDyns`.
+ *
+ * @example
+ * ```ts
+ * // Plain string
+ * xml("<Root>hello</Root>")
+ *
+ * // Tagged template with matcher
+ * xml`<Root><Link>${match.localUrl("/next")}</Link></Root>`
+ * ```
+ *
  * @returns {MockBody} response body with application/xml content type.
  */
-export function xml(xmlString: string): MockBody {
+export function xml(content: string): MockBody;
+export function xml(strings: TemplateStringsArray, ...values: unknown[]): MockBody;
+export function xml(content: string | TemplateStringsArray, ...values: unknown[]): MockBody {
+  if (typeof content !== "string") {
+    return {
+      contentType: "application/xml",
+      rawContent: dyn`${XML_DECLARATION}${dyn(content, ...values)}`,
+    };
+  }
+
   return {
     contentType: "application/xml",
-    rawContent: `<?xml version='1.0' encoding='UTF-8'?>` + xmlString,
+    rawContent: XML_DECLARATION + content,
   };
 }
 
@@ -44,10 +73,11 @@ export function multipart(
   };
 }
 
-export interface DynValue<T extends string[]> {
+export interface DynValue extends Resolver {
   readonly isDyn: true;
-  readonly keys: T;
-  (dict: Record<T[number], string>): string;
+  (config: ResolverConfig): string;
+  /** Returns all matchers embedded in this template with their serialized values. */
+  getMatchers(config: ResolverConfig): Array<{ serialized: string; matcher: MockValueMatcher }>;
 }
 
 export interface DynItem<T extends keyof ResolverConfig> {
@@ -62,47 +92,89 @@ export function dynItem<const T extends keyof ResolverConfig>(name: T): DynItem<
   };
 }
 
-/** Specify that this value is dynamic and needs to be interpolated with the given keys */
-export function dyn<const T extends (keyof ResolverConfig)[]>(
-  strings: readonly string[],
-  ...keys: (DynItem<T[number]> | string)[]
-): DynValue<T> {
-  const dynKeys: T = [] as any;
-  const template = (dict: Record<T[number], string>) => {
-    const result = [strings[0]];
-    keys.forEach((key, i) => {
-      if (typeof key === "string") {
-        result.push(key);
-      } else {
-        dynKeys.push(key.name);
-        const value = (dict as any)[key.name];
-        if (value !== undefined) {
-          result.push(value);
-        }
-      }
-      result.push(strings[i + 1]);
+/**
+ * Tagged template for building strings with deferred resolution.
+ * Interpolated values can be:
+ * - `dynItem("baseUrl")` — resolved from `ResolverConfig`
+ * - Matchers (e.g. `match.localUrl(...)`) — resolved via `expandDyns`
+ * - Other `dyn` templates — recursively resolved
+ * - Plain strings/numbers — used as-is
+ */
+export function dyn(strings: readonly string[], ...values: unknown[]): DynValue {
+  const template = (config: ResolverConfig) => {
+    let result = strings[0];
+    values.forEach((v, i) => {
+      result += String(expandDyns(v, config));
+      result += strings[i + 1];
     });
-    return result.join("");
+    return result;
   };
-  template.keys = dynKeys;
   template.isDyn = true as const;
+  template.serialize = template;
+  template.resolve = template;
+  template.getMatchers = (config: ResolverConfig) => {
+    const result: Array<{ serialized: string; matcher: MockValueMatcher }> = [];
+    for (const v of values) {
+      collectMatchers(v, config, result);
+    }
+    return result;
+  };
   return template;
 }
 
-export function expandDyns<T>(value: T, config: ResolverConfig): T {
+function collectMatchers(
+  value: unknown,
+  config: ResolverConfig,
+  out: Array<{ serialized: string; matcher: MockValueMatcher }>,
+): void {
+  if (isMatcher(value)) {
+    out.push({ serialized: String(value.serialize(config)), matcher: value });
+  } else if (typeof value === "function" && "isDyn" in value && value.isDyn) {
+    const dynVal = value as DynValue;
+    if (dynVal.getMatchers) {
+      out.push(...dynVal.getMatchers(config));
+    }
+  }
+}
+
+export interface ExpandDynsOptions {
+  /** When true, matchers are resolved to their `toJSON()` value. Default: true. */
+  resolveMatchers?: boolean;
+}
+
+/**
+ * Recursively expands all dynamic values.
+ * - Dyn functions are called with the config.
+ * - Resolvable matchers (e.g. `match.localUrl`) are resolved via `resolve(config)`.
+ * - By default, matchers are resolved to their `toJSON()` plain value.
+ *   Pass `{ resolveMatchers: false }` to preserve matchers for use with `matchValues`.
+ */
+export function expandDyns<T>(value: T, config: ResolverConfig, options?: ExpandDynsOptions): T {
+  const resolve = options?.resolveMatchers ?? true;
+  return _expandDyns(value, config, resolve);
+}
+
+function _expandDyns<T>(value: T, config: ResolverConfig, resolveMatchers: boolean): T {
   if (typeof value === "string") {
     return value;
   } else if (Array.isArray(value)) {
-    return value.map((v) => expandDyns(v, config)) as any;
+    return value.map((v) => _expandDyns(v, config, resolveMatchers)) as any;
   } else if (typeof value === "object" && value !== null) {
+    // DynItem — resolve from config
+    if ("isDyn" in value && (value as any).isDyn && "name" in value) {
+      return (config as any)[(value as any).name] as any;
+    }
+    if (isMatcher(value)) {
+      return resolveMatchers ? (value.serialize(config) as any) : (value as any);
+    }
     const obj = value as Record<string, unknown>;
     return Object.fromEntries(
-      Object.entries(obj).map(([key, v]) => [key, expandDyns(v, config)]),
+      Object.entries(obj).map(([key, v]) => [key, _expandDyns(v, config, resolveMatchers)]),
     ) as any;
   } else if (typeof value === "function") {
     if ("isDyn" in value && value.isDyn) {
-      const dynValue = value as any as DynValue<string[]>;
-      return dynValue(config as any) as any;
+      const dynValue = value as any as DynValue;
+      return dynValue(config) as any;
     } else {
       throw new Error("Invalid function value");
     }