@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/recipes.js

@@ -0,0 +1,1384 @@
+// src/recipes/schema.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var EFFECT_RECIPE_SCHEMA_VERSION = 4;
+var EFFECT_RECIPE_SCOPES = ["story", "battle"];
+var EFFECT_RECIPE_CATEGORIES = ["entrance", "utility"];
+var EFFECT_RECIPE_ID_MAX_LENGTH = 80;
+var EFFECT_RECIPE_TRACK_ID_MAX_LENGTH = 80;
+var EFFECT_RECIPE_PRIMITIVE_ID_MAX_LENGTH = 80;
+var EFFECT_RECIPE_NAME_MAX_CODE_POINTS = 80;
+var EFFECT_RECIPE_DESCRIPTION_MAX_CODE_POINTS = 240;
+var EFFECT_RECIPE_APP_LABEL_MAX_CODE_POINTS = 48;
+var EFFECT_RECIPE_APP_SHORT_DESCRIPTION_MAX_CODE_POINTS = 120;
+var EFFECT_RECIPE_APP_ICON_ID_MAX_LENGTH = 80;
+var EFFECT_RECIPE_MAX_DURATION_MS = 2e4;
+var EFFECT_RECIPE_MAX_TRACKS = 24;
+var EFFECT_RECIPE_VALUE_MAX_STRING_CODE_POINTS = 240;
+var EFFECT_RECIPE_VALUE_MAX_ARRAY_LENGTH = 8;
+var EFFECT_RECIPE_TUNING_PATH_MAX_LENGTH = 160;
+var EFFECT_RECIPE_APP_ORDER_MAX = 9999;
+var EFFECT_RECIPE_STABLE_ID_REGEX = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+var EFFECT_RECIPE_TUNING_PATH_REGEX = /^[A-Za-z][A-Za-z0-9]*(\.[A-Za-z0-9_-]+)+$/;
+var hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var codePointLength = (value) => Array.from(value).length;
+var normalizeText = (value, maxCodePoints, allowEmpty = false) => {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  if (!allowEmpty && !normalized || codePointLength(normalized) > maxCodePoints) {
+    return null;
+  }
+  return normalized;
+};
+var normalizeNonNegativeInteger = (value, maxValue) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > maxValue) {
+    return null;
+  }
+  return value;
+};
+var createError = (code, path, message) => ({ code, path, message });
+var EFFECT_TARGETS = ["main-content", "story-workspace", "full-stage"];
+var v4Migration = {
+  schemaVersion: 4,
+  migrate: (definition) => definition
+};
+var EFFECT_RECIPE_MIGRATIONS = [v4Migration];
+var effectRecipeMigrationMap = new Map(
+  EFFECT_RECIPE_MIGRATIONS.map((migration) => [migration.schemaVersion, migration])
+);
+var effectRecipeMigrationRegistry = Object.freeze({
+  all: () => EFFECT_RECIPE_MIGRATIONS,
+  get: (schemaVersion) => effectRecipeMigrationMap.get(schemaVersion) ?? null
+});
+var isEffectRecipeScope = (value) => value === "story" || value === "battle";
+var isEffectRecipeCategory = (value) => value === "entrance" || value === "utility";
+var isEffectRecipeId = (value) => {
+  const normalized = normalizeText(value, EFFECT_RECIPE_ID_MAX_LENGTH);
+  return normalized !== null && EFFECT_RECIPE_STABLE_ID_REGEX.test(normalized);
+};
+var isEffectRecipeTrackId = (value) => {
+  const normalized = normalizeText(value, EFFECT_RECIPE_TRACK_ID_MAX_LENGTH);
+  return normalized !== null && EFFECT_RECIPE_STABLE_ID_REGEX.test(normalized);
+};
+var isEffectPrimitiveId = (value) => {
+  const normalized = normalizeText(value, EFFECT_RECIPE_PRIMITIVE_ID_MAX_LENGTH);
+  return normalized !== null && EFFECT_RECIPE_STABLE_ID_REGEX.test(normalized);
+};
+var isEffectRecipeTuningPath = (value) => {
+  const normalized = normalizeText(value, EFFECT_RECIPE_TUNING_PATH_MAX_LENGTH);
+  return normalized !== null && EFFECT_RECIPE_TUNING_PATH_REGEX.test(normalized);
+};
+var isEffectRecipeTuningPathReference = (value) => isRecord(value) && Object.keys(value).length === 1 && hasOwn(value, "tuningPath") && isEffectRecipeTuningPath(value.tuningPath);
+var isResolvedRecipeValue = (value) => {
+  if (typeof value === "string" || typeof value === "boolean") {
+    return true;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value);
+  }
+  return Array.isArray(value) && value.length <= EFFECT_RECIPE_VALUE_MAX_ARRAY_LENGTH && value.every((entry) => typeof entry === "number" && Number.isFinite(entry));
+};
+var parseRecipeValue = (value, path, errors) => {
+  if (typeof value === "string") {
+    const normalized = normalizeText(value, EFFECT_RECIPE_VALUE_MAX_STRING_CODE_POINTS);
+    if (normalized === null) {
+      errors.push(
+        createError("invalid_length", path, "\u5B57\u7B26\u4E32\u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E14\u957F\u5EA6\u5FC5\u987B\u5728\u5141\u8BB8\u8303\u56F4\u5185\u3002")
+      );
+      return null;
+    }
+    return normalized;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      errors.push(createError("invalid_recipe_value", path, "\u6570\u503C\u53C2\u6570\u5FC5\u987B\u662F\u6709\u9650\u6570\u5B57\u3002"));
+      return null;
+    }
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > EFFECT_RECIPE_VALUE_MAX_ARRAY_LENGTH) {
+      errors.push(
+        createError(
+          "too_many_items",
+          path,
+          `\u6570\u5B57\u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7 ${EFFECT_RECIPE_VALUE_MAX_ARRAY_LENGTH}\u3002`
+        )
+      );
+      return null;
+    }
+    if (!value.every((entry) => typeof entry === "number" && Number.isFinite(entry))) {
+      errors.push(createError("invalid_recipe_value", path, "\u6570\u5B57\u6570\u7EC4\u53EA\u80FD\u5305\u542B\u6709\u9650\u6570\u5B57\u3002"));
+      return null;
+    }
+    return [...value];
+  }
+  if (isRecord(value)) {
+    if (!hasOwn(value, "tuningPath") || Object.keys(value).length !== 1) {
+      errors.push(
+        createError("invalid_recipe_value", path, "\u5BF9\u8C61\u53C2\u6570\u53EA\u5141\u8BB8\u4F7F\u7528 tuningPath \u5F15\u7528\u3002")
+      );
+      return null;
+    }
+    if (!isEffectRecipeTuningPath(value.tuningPath)) {
+      errors.push(
+        createError("invalid_tuning_path", `${path}.tuningPath`, "tuningPath \u683C\u5F0F\u65E0\u6548\u3002")
+      );
+      return null;
+    }
+    return { tuningPath: value.tuningPath.trim() };
+  }
+  errors.push(
+    createError(
+      "invalid_recipe_value",
+      path,
+      "\u53C2\u6570\u503C\u53EA\u5141\u8BB8 string\u3001number\u3001boolean\u3001number[] \u6216 { tuningPath }\u3002"
+    )
+  );
+  return null;
+};
+var migrateEffectRecipeDefinition = (value) => {
+  if (!isRecord(value)) {
+    return {
+      document: null,
+      errors: [createError("invalid_type", "", "Recipe \u5B9A\u4E49\u5FC5\u987B\u662F\u5BF9\u8C61\u3002")]
+    };
+  }
+  const schemaVersion = value.schemaVersion;
+  if (typeof schemaVersion !== "number" || !Number.isSafeInteger(schemaVersion)) {
+    return {
+      document: null,
+      errors: [
+        createError("invalid_schema_version", "schemaVersion", "schemaVersion \u5FC5\u987B\u662F\u5B89\u5168\u6574\u6570\u3002")
+      ]
+    };
+  }
+  const migration = effectRecipeMigrationMap.get(schemaVersion);
+  if (!migration) {
+    return {
+      document: null,
+      errors: [
+        createError(
+          "unknown_schema_version",
+          "schemaVersion",
+          `\u672A\u6CE8\u518C\u7684 recipe schemaVersion: ${schemaVersion}\u3002`
+        )
+      ]
+    };
+  }
+  if (value.category === "sequence" || value.category === "horror")
+    return {
+      document: null,
+      errors: [createError("invalid_enum", "category", "\u8BE5\u7C7B Story \u6F14\u51FA\u5DF2\u9000\u5F79\u3002")]
+    };
+  const migrated = migration.migrate(value);
+  if (!isRecord(migrated)) {
+    return {
+      document: null,
+      errors: [createError("invalid_type", "", "\u8FC1\u79FB\u540E\u7684 Recipe \u5B9A\u4E49\u5FC5\u987B\u662F\u5BF9\u8C61\u3002")]
+    };
+  }
+  return { document: migrated, errors: [] };
+};
+var validateEffectRecipeDefinition = (value) => {
+  const migrationResult = migrateEffectRecipeDefinition(value);
+  if (!migrationResult.document) {
+    return { definition: null, errors: migrationResult.errors };
+  }
+  const document = migrationResult.document;
+  const errors = [];
+  const schemaVersion = document.schemaVersion;
+  if (schemaVersion !== EFFECT_RECIPE_SCHEMA_VERSION) {
+    errors.push(
+      createError(
+        "invalid_schema_version",
+        "schemaVersion",
+        `schemaVersion \u5FC5\u987B\u4E3A ${EFFECT_RECIPE_SCHEMA_VERSION}\u3002`
+      )
+    );
+  }
+  const id = normalizeText(document.id, EFFECT_RECIPE_ID_MAX_LENGTH);
+  if (!id || !EFFECT_RECIPE_STABLE_ID_REGEX.test(id)) {
+    errors.push(createError("invalid_id", "id", "Recipe id \u5FC5\u987B\u662F\u7A33\u5B9A\u6807\u8BC6\u7B26\u3002"));
+  }
+  const name = normalizeText(document.name, EFFECT_RECIPE_NAME_MAX_CODE_POINTS);
+  if (!name) {
+    errors.push(
+      createError("invalid_length", "name", "Recipe name \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E14\u957F\u5EA6\u5FC5\u987B\u5728\u5141\u8BB8\u8303\u56F4\u5185\u3002")
+    );
+  }
+  const description = normalizeText(
+    document.description,
+    EFFECT_RECIPE_DESCRIPTION_MAX_CODE_POINTS
+  );
+  if (!description) {
+    errors.push(
+      createError(
+        "invalid_length",
+        "description",
+        "Recipe description \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E14\u957F\u5EA6\u5FC5\u987B\u5728\u5141\u8BB8\u8303\u56F4\u5185\u3002"
+      )
+    );
+  }
+  const scope = document.scope;
+  if (!isEffectRecipeScope(scope)) {
+    errors.push(createError("invalid_enum", "scope", "scope \u5FC5\u987B\u662F story \u6216 battle\u3002"));
+  }
+  const category = document.category;
+  if (!isEffectRecipeCategory(category)) {
+    errors.push(createError("invalid_enum", "category", "category \u5FC5\u987B\u662F entrance \u6216 utility\u3002"));
+  }
+  const durationMs = normalizeNonNegativeInteger(
+    document.durationMs,
+    EFFECT_RECIPE_MAX_DURATION_MS
+  );
+  if (durationMs === null) {
+    errors.push(
+      createError(
+        "out_of_range",
+        "durationMs",
+        `durationMs \u5FC5\u987B\u662F 0 \u5230 ${EFFECT_RECIPE_MAX_DURATION_MS} \u7684\u5B89\u5168\u6574\u6570\u3002`
+      )
+    );
+  }
+  const commitAtMs = normalizeNonNegativeInteger(
+    document.commitAtMs,
+    EFFECT_RECIPE_MAX_DURATION_MS
+  );
+  if (commitAtMs === null) {
+    errors.push(
+      createError(
+        "out_of_range",
+        "commitAtMs",
+        `commitAtMs \u5FC5\u987B\u662F 0 \u5230 ${EFFECT_RECIPE_MAX_DURATION_MS} \u7684\u5B89\u5168\u6574\u6570\u3002`
+      )
+    );
+  } else if (durationMs !== null && commitAtMs > durationMs) {
+    errors.push(createError("out_of_range", "commitAtMs", "commitAtMs \u4E0D\u80FD\u5927\u4E8E durationMs\u3002"));
+  }
+  let app = null;
+  if (!isRecord(document.app)) {
+    errors.push(createError("invalid_type", "app", "app \u5143\u6570\u636E\u5FC5\u987B\u662F\u5BF9\u8C61\u3002"));
+  } else {
+    const label = normalizeText(document.app.label, EFFECT_RECIPE_APP_LABEL_MAX_CODE_POINTS);
+    if (!label) {
+      errors.push(
+        createError("invalid_length", "app.label", "app.label \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E14\u957F\u5EA6\u5FC5\u987B\u5728\u5141\u8BB8\u8303\u56F4\u5185\u3002")
+      );
+    }
+    const shortDescription = normalizeText(
+      document.app.shortDescription,
+      EFFECT_RECIPE_APP_SHORT_DESCRIPTION_MAX_CODE_POINTS
+    );
+    if (!shortDescription) {
+      errors.push(
+        createError(
+          "invalid_length",
+          "app.shortDescription",
+          "app.shortDescription \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E14\u957F\u5EA6\u5FC5\u987B\u5728\u5141\u8BB8\u8303\u56F4\u5185\u3002"
+        )
+      );
+    }
+    const iconId = normalizeText(document.app.iconId, EFFECT_RECIPE_APP_ICON_ID_MAX_LENGTH);
+    if (!iconId || !EFFECT_RECIPE_STABLE_ID_REGEX.test(iconId)) {
+      errors.push(createError("invalid_id", "app.iconId", "app.iconId \u5FC5\u987B\u662F\u7A33\u5B9A\u6807\u8BC6\u7B26\u3002"));
+    }
+    const order = normalizeNonNegativeInteger(document.app.order, EFFECT_RECIPE_APP_ORDER_MAX);
+    if (order === null) {
+      errors.push(
+        createError(
+          "out_of_range",
+          "app.order",
+          `app.order \u5FC5\u987B\u662F 0 \u5230 ${EFFECT_RECIPE_APP_ORDER_MAX} \u7684\u5B89\u5168\u6574\u6570\u3002`
+        )
+      );
+    }
+    if (label && shortDescription && iconId && EFFECT_RECIPE_STABLE_ID_REGEX.test(iconId) && order !== null) {
+      app = {
+        label,
+        shortDescription,
+        iconId,
+        order
+      };
+    }
+  }
+  const rawTracks = document.tracks;
+  const tracks = [];
+  const seenTrackIds = /* @__PURE__ */ new Set();
+  if (!Array.isArray(rawTracks)) {
+    errors.push(createError("invalid_type", "tracks", "tracks \u5FC5\u987B\u662F\u6570\u7EC4\u3002"));
+  } else if (rawTracks.length === 0) {
+    errors.push(createError("invalid_length", "tracks", "tracks \u81F3\u5C11\u9700\u8981\u4E00\u4E2A track\u3002"));
+  } else if (rawTracks.length > EFFECT_RECIPE_MAX_TRACKS) {
+    errors.push(
+      createError("too_many_items", "tracks", `tracks \u6570\u91CF\u4E0D\u80FD\u8D85\u8FC7 ${EFFECT_RECIPE_MAX_TRACKS}\u3002`)
+    );
+  } else {
+    rawTracks.forEach((rawTrack, trackIndex) => {
+      const trackPath = `tracks[${trackIndex}]`;
+      if (!isRecord(rawTrack)) {
+        errors.push(createError("invalid_type", trackPath, "track \u5FC5\u987B\u662F\u5BF9\u8C61\u3002"));
+        return;
+      }
+      const trackId = normalizeText(rawTrack.id, EFFECT_RECIPE_TRACK_ID_MAX_LENGTH);
+      if (!trackId || !EFFECT_RECIPE_STABLE_ID_REGEX.test(trackId)) {
+        errors.push(createError("invalid_id", `${trackPath}.id`, "track id \u5FC5\u987B\u662F\u7A33\u5B9A\u6807\u8BC6\u7B26\u3002"));
+      } else if (seenTrackIds.has(trackId)) {
+        errors.push(
+          createError("duplicate_track_id", `${trackPath}.id`, `\u91CD\u590D\u7684 track id: ${trackId}\u3002`)
+        );
+      } else {
+        seenTrackIds.add(trackId);
+      }
+      const atMs = normalizeNonNegativeInteger(rawTrack.atMs, EFFECT_RECIPE_MAX_DURATION_MS);
+      if (atMs === null) {
+        errors.push(
+          createError(
+            "out_of_range",
+            `${trackPath}.atMs`,
+            `track.atMs \u5FC5\u987B\u662F 0 \u5230 ${EFFECT_RECIPE_MAX_DURATION_MS} \u7684\u5B89\u5168\u6574\u6570\u3002`
+          )
+        );
+      }
+      const trackDurationMs = normalizeNonNegativeInteger(
+        rawTrack.durationMs,
+        EFFECT_RECIPE_MAX_DURATION_MS
+      );
+      if (trackDurationMs === null) {
+        errors.push(
+          createError(
+            "out_of_range",
+            `${trackPath}.durationMs`,
+            `track.durationMs \u5FC5\u987B\u662F 0 \u5230 ${EFFECT_RECIPE_MAX_DURATION_MS} \u7684\u5B89\u5168\u6574\u6570\u3002`
+          )
+        );
+      }
+      if (durationMs !== null && atMs !== null && trackDurationMs !== null && atMs + trackDurationMs > durationMs) {
+        errors.push(
+          createError(
+            "out_of_range",
+            `${trackPath}.durationMs`,
+            "track \u6267\u884C\u533A\u95F4\u4E0D\u80FD\u8D85\u51FA recipe.durationMs\u3002"
+          )
+        );
+      }
+      if (rawTrack.target !== void 0 && !EFFECT_TARGETS.some((target) => target === rawTrack.target)) {
+        errors.push(createError("invalid_enum", "tracks.target", "\u975E\u6CD5\u7279\u6548\u4F5C\u7528\u76EE\u6807\u3002"));
+      }
+      const primitiveId = normalizeText(
+        rawTrack.primitiveId,
+        EFFECT_RECIPE_PRIMITIVE_ID_MAX_LENGTH
+      );
+      if (!primitiveId || !EFFECT_RECIPE_STABLE_ID_REGEX.test(primitiveId)) {
+        errors.push(
+          createError(
+            "invalid_id",
+            `${trackPath}.primitiveId`,
+            "track primitiveId \u5FC5\u987B\u662F\u7A33\u5B9A\u6807\u8BC6\u7B26\u3002"
+          )
+        );
+      }
+      if (typeof rawTrack.enabled !== "boolean") {
+        errors.push(
+          createError("invalid_type", `${trackPath}.enabled`, "track.enabled \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002")
+        );
+      }
+      const params = {};
+      if (!isRecord(rawTrack.params)) {
+        errors.push(
+          createError("invalid_type", `${trackPath}.params`, "track.params \u5FC5\u987B\u662F\u5BF9\u8C61\u3002")
+        );
+      } else {
+        Object.entries(rawTrack.params).forEach(([paramName, paramValue]) => {
+          const normalizedValue = parseRecipeValue(
+            paramValue,
+            `${trackPath}.params.${paramName}`,
+            errors
+          );
+          if (normalizedValue !== null) {
+            params[paramName] = normalizedValue;
+          }
+        });
+      }
+      if (trackId && EFFECT_RECIPE_STABLE_ID_REGEX.test(trackId) && atMs !== null && trackDurationMs !== null && primitiveId && EFFECT_RECIPE_STABLE_ID_REGEX.test(primitiveId) && typeof rawTrack.enabled === "boolean" && isRecord(rawTrack.params)) {
+        tracks.push({
+          id: trackId,
+          atMs,
+          durationMs: trackDurationMs,
+          ...rawTrack.target === void 0 ? {} : { target: rawTrack.target },
+          primitiveId,
+          params,
+          enabled: rawTrack.enabled
+        });
+      }
+    });
+  }
+  if (errors.length > 0 || !id || !name || !description || !isEffectRecipeScope(scope) || !isEffectRecipeCategory(category) || durationMs === null || commitAtMs === null || !app) {
+    return { definition: null, errors };
+  }
+  return {
+    definition: {
+      schemaVersion: EFFECT_RECIPE_SCHEMA_VERSION,
+      id,
+      name,
+      description,
+      scope,
+      category,
+      durationMs,
+      commitAtMs,
+      app,
+      tracks
+    },
+    errors
+  };
+};
+var createEffectRecipeValidationError = createError;
+
+// src/recipes/primitives.ts
+var EFFECT_PRIMITIVE_CATEGORIES = [
+  "content",
+  "screen",
+  "camera",
+  "shader",
+  "particle",
+  "ui",
+  "audio"
+];
+var EFFECT_PRIMITIVE_PARAM_TYPES = ["string", "number", "boolean", "number[]"];
+var EFFECT_PRIMITIVE_PREVIEW_SUPPORT = ["full", "milestone", "replay-only"];
+var EffectPrimitiveRegistry = class {
+  descriptors;
+  descriptorById;
+  constructor(descriptors) {
+    const descriptorById = /* @__PURE__ */ new Map();
+    for (const descriptor of descriptors) {
+      if (descriptorById.has(descriptor.id)) {
+        throw new Error(`\u91CD\u590D\u7684 primitive descriptor: ${descriptor.id}`);
+      }
+      descriptorById.set(descriptor.id, descriptor);
+    }
+    this.descriptors = [...descriptors];
+    this.descriptorById = descriptorById;
+  }
+  all() {
+    return this.descriptors;
+  }
+  get(id) {
+    return this.descriptorById.get(id) ?? null;
+  }
+  listByScope(scope) {
+    return this.descriptors.filter((descriptor) => descriptor.scopes.includes(scope));
+  }
+};
+
+// src/recipes/registry.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var hasOwn2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var prefixPath = (prefix, path) => {
+  if (!prefix) {
+    return path;
+  }
+  if (!path) {
+    return prefix;
+  }
+  if (path.startsWith("[")) {
+    return `${prefix}${path}`;
+  }
+  return `${prefix}.${path}`;
+};
+var normalizeString = (value) => value.trim();
+var EffectRecipeRegistryError = class extends Error {
+  constructor(errors) {
+    super(errors.map((error) => `${error.path}: ${error.message}`).join("\n"));
+    this.errors = errors;
+    this.name = "EffectRecipeRegistryError";
+  }
+  errors;
+};
+var buildCatalog = (definition, source) => ({
+  id: definition.id,
+  name: definition.name,
+  description: definition.description,
+  scope: definition.scope,
+  category: definition.category,
+  durationMs: definition.durationMs,
+  commitAtMs: definition.commitAtMs,
+  source,
+  app: definition.app,
+  trackCount: definition.tracks.length
+});
+var sortRegistrations = (entries) => [...entries].sort((left, right) => {
+  if (left.catalog.app.order !== right.catalog.app.order) {
+    return left.catalog.app.order - right.catalog.app.order;
+  }
+  return left.catalog.id.localeCompare(right.catalog.id, "zh-CN");
+});
+var validateStringValue = (value, descriptor, path, errors) => {
+  const normalized = normalizeString(value);
+  if (descriptor.name === "color" && !/^#[0-9a-f]{6}$/i.test(normalized)) {
+    errors.push(
+      createEffectRecipeValidationError("invalid_param_value", path, "\u989C\u8272\u5FC5\u987B\u662F #RRGGBB\u3002")
+    );
+    return null;
+  }
+  if (descriptor.minLength !== void 0 && normalized.length < descriptor.minLength) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u5B57\u7B26\u4E32\u957F\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${descriptor.minLength}\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.maxLength !== void 0 && normalized.length > descriptor.maxLength) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u5B57\u7B26\u4E32\u957F\u5EA6\u4E0D\u80FD\u5927\u4E8E ${descriptor.maxLength}\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.options && !descriptor.options.includes(normalized)) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u5FC5\u987B\u662F ${descriptor.options.join("\u3001")} \u4E4B\u4E00\u3002`
+      )
+    );
+    return null;
+  }
+  return normalized;
+};
+var validateNumberValue = (value, descriptor, path, errors) => {
+  if (!Number.isFinite(value)) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_type",
+        path,
+        `${descriptor.name} \u5FC5\u987B\u662F\u6709\u9650\u6570\u5B57\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.min !== void 0 && value < descriptor.min) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u4E0D\u80FD\u5C0F\u4E8E ${descriptor.min}\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.max !== void 0 && value > descriptor.max) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u4E0D\u80FD\u5927\u4E8E ${descriptor.max}\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.options && !descriptor.options.includes(value)) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u4E0D\u5728\u5141\u8BB8\u7684\u679A\u4E3E\u8303\u56F4\u5185\u3002`
+      )
+    );
+    return null;
+  }
+  return value;
+};
+var validateBooleanValue = (value, descriptor, path, errors) => {
+  if (descriptor.options && !descriptor.options.includes(value)) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u4E0D\u5728\u5141\u8BB8\u7684\u679A\u4E3E\u8303\u56F4\u5185\u3002`
+      )
+    );
+    return null;
+  }
+  return value;
+};
+var validateNumberArrayValue = (value, descriptor, path, errors) => {
+  if (!value.every((entry) => typeof entry === "number" && Number.isFinite(entry))) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_type",
+        path,
+        `${descriptor.name} \u5FC5\u987B\u662F\u6709\u9650\u6570\u5B57\u6570\u7EC4\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.arrayMinLength !== void 0 && value.length < descriptor.arrayMinLength) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${descriptor.arrayMinLength}\u3002`
+      )
+    );
+    return null;
+  }
+  if (descriptor.arrayMaxLength !== void 0 && value.length > descriptor.arrayMaxLength) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u5927\u4E8E ${descriptor.arrayMaxLength}\u3002`
+      )
+    );
+    return null;
+  }
+  if ((descriptor.min !== void 0 || descriptor.max !== void 0) && value.some(
+    (entry) => descriptor.min !== void 0 && entry < descriptor.min || descriptor.max !== void 0 && entry > descriptor.max
+  )) {
+    errors.push(
+      createEffectRecipeValidationError(
+        "invalid_param_value",
+        path,
+        `${descriptor.name} \u6570\u7EC4\u5143\u7D20\u8D85\u51FA\u5141\u8BB8\u8303\u56F4\u3002`
+      )
+    );
+    return null;
+  }
+  return [...value];
+};
+var validateParamValue = (value, descriptor, path, errors, options) => {
+  if (isEffectRecipeTuningPathReference(value)) {
+    if (!options.allowTuningPath || descriptor.tuningPathAllowed !== true) {
+      errors.push(
+        createEffectRecipeValidationError(
+          "invalid_tuning_path",
+          path,
+          `${descriptor.name} \u4E0D\u5141\u8BB8\u4F7F\u7528 tuningPath \u5F15\u7528\u3002`
+        )
+      );
+      return null;
+    }
+    return { tuningPath: value.tuningPath };
+  }
+  switch (descriptor.type) {
+    case "string": {
+      if (typeof value !== "string") {
+        errors.push(
+          createEffectRecipeValidationError(
+            "invalid_param_type",
+            path,
+            `${descriptor.name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002`
+          )
+        );
+        return null;
+      }
+      const normalized = validateStringValue(value, descriptor, path, errors);
+      return normalized;
+    }
+    case "number": {
+      if (typeof value !== "number") {
+        errors.push(
+          createEffectRecipeValidationError(
+            "invalid_param_type",
+            path,
+            `${descriptor.name} \u5FC5\u987B\u662F\u6570\u5B57\u3002`
+          )
+        );
+        return null;
+      }
+      const normalized = validateNumberValue(value, descriptor, path, errors);
+      return normalized;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        errors.push(
+          createEffectRecipeValidationError(
+            "invalid_param_type",
+            path,
+            `${descriptor.name} \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002`
+          )
+        );
+        return null;
+      }
+      const normalized = validateBooleanValue(value, descriptor, path, errors);
+      return normalized;
+    }
+    case "number[]": {
+      if (!Array.isArray(value)) {
+        errors.push(
+          createEffectRecipeValidationError(
+            "invalid_param_type",
+            path,
+            `${descriptor.name} \u5FC5\u987B\u662F\u6570\u5B57\u6570\u7EC4\u3002`
+          )
+        );
+        return null;
+      }
+      const normalized = validateNumberArrayValue(value, descriptor, path, errors);
+      return normalized;
+    }
+  }
+};
+var validatePrimitiveParamsInternal = (descriptor, params, options) => {
+  const errors = [];
+  const pathPrefix = options.pathPrefix ?? "params";
+  if (!isRecord2(params)) {
+    return {
+      params: null,
+      errors: [
+        createEffectRecipeValidationError("invalid_type", pathPrefix, "params \u5FC5\u987B\u662F\u5BF9\u8C61\u3002")
+      ]
+    };
+  }
+  const normalizedParams = {};
+  const descriptorMap = new Map(descriptor.paramsSchema.map((item) => [item.name, item]));
+  Object.keys(params).forEach((key) => {
+    if (!descriptorMap.has(key)) {
+      errors.push(
+        createEffectRecipeValidationError(
+          "unknown_param",
+          `${pathPrefix}.${key}`,
+          `\u672A\u77E5\u53C2\u6570: ${key}\u3002`
+        )
+      );
+    }
+  });
+  for (const paramDescriptor of descriptor.paramsSchema) {
+    const paramPath = `${pathPrefix}.${paramDescriptor.name}`;
+    const exists = hasOwn2(params, paramDescriptor.name);
+    if (!exists) {
+      if (paramDescriptor.required) {
+        errors.push(
+          createEffectRecipeValidationError(
+            "missing_param",
+            paramPath,
+            `\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570: ${paramDescriptor.name}\u3002`
+          )
+        );
+      }
+      continue;
+    }
+    const rawValue = params[paramDescriptor.name];
+    const normalizedValue = validateParamValue(
+      rawValue,
+      paramDescriptor,
+      paramPath,
+      errors,
+      options
+    );
+    if (normalizedValue !== null) {
+      normalizedParams[paramDescriptor.name] = normalizedValue;
+    }
+  }
+  return { params: errors.length === 0 ? normalizedParams : null, errors };
+};
+var validateEffectRecipeTrackParams = (descriptor, params, pathPrefix = "params") => validatePrimitiveParamsInternal(descriptor, params, {
+  allowTuningPath: true,
+  pathPrefix
+});
+var validateResolvedEffectRecipeTrackParams = (descriptor, params, pathPrefix = "params") => validatePrimitiveParamsInternal(descriptor, params, {
+  allowTuningPath: false,
+  pathPrefix
+});
+var validateEffectRecipeManifest = (entries, primitiveRegistry) => {
+  const errors = [];
+  const provisional = [];
+  const seenRecipeIds = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const definitionResult = validateEffectRecipeDefinition(entry.definition);
+    const entryPrefix = `recipes[${index}]`;
+    if (!definitionResult.definition) {
+      errors.push(
+        ...definitionResult.errors.map((error) => ({
+          ...error,
+          path: prefixPath(entryPrefix, error.path)
+        }))
+      );
+      return;
+    }
+    const definition = definitionResult.definition;
+    if (seenRecipeIds.has(definition.id)) {
+      errors.push(
+        createEffectRecipeValidationError(
+          "duplicate_recipe_id",
+          `${entryPrefix}.id`,
+          `\u91CD\u590D\u7684 recipe id: ${definition.id}\u3002`
+        )
+      );
+      return;
+    }
+    seenRecipeIds.add(definition.id);
+    definition.tracks.forEach((track, trackIndex) => {
+      const trackPath = `${entryPrefix}.tracks[${trackIndex}]`;
+      const descriptor = primitiveRegistry.get(track.primitiveId);
+      if (!descriptor) {
+        errors.push(
+          createEffectRecipeValidationError(
+            "unknown_primitive",
+            `${trackPath}.primitiveId`,
+            `\u672A\u77E5 primitive: ${track.primitiveId}\u3002`
+          )
+        );
+        return;
+      }
+      if (!descriptor.scopes.includes(definition.scope)) {
+        errors.push(
+          createEffectRecipeValidationError(
+            "unsupported_scope",
+            `${trackPath}.primitiveId`,
+            `primitive ${track.primitiveId} \u4E0D\u652F\u6301 ${definition.scope} scope\u3002`
+          )
+        );
+      }
+      const paramsResult = validateEffectRecipeTrackParams(
+        descriptor,
+        track.params,
+        `${trackPath}.params`
+      );
+      errors.push(...paramsResult.errors);
+    });
+    if (!errors.some((error) => error.path.startsWith(entryPrefix))) {
+      provisional.push({
+        source: entry.source,
+        definition,
+        catalog: buildCatalog(definition, entry.source)
+      });
+    }
+  });
+  return {
+    entries: sortRegistrations(provisional),
+    errors
+  };
+};
+var EffectRecipeRegistry = class {
+  constructor(manifestEntries, primitiveRegistry) {
+    this.primitiveRegistry = primitiveRegistry;
+    const result = validateEffectRecipeManifest(manifestEntries, primitiveRegistry);
+    if (result.errors.length > 0) {
+      throw new EffectRecipeRegistryError(result.errors);
+    }
+    this.entries = result.entries;
+    this.entryById = new Map(result.entries.map((entry) => [entry.definition.id, entry]));
+  }
+  primitiveRegistry;
+  entries;
+  entryById;
+  all() {
+    return this.entries;
+  }
+  catalog() {
+    return this.entries.map((entry) => entry.catalog);
+  }
+  get(recipeId) {
+    return this.entryById.get(recipeId) ?? null;
+  }
+  listByScope(scope) {
+    return this.entries.filter((entry) => entry.definition.scope === scope);
+  }
+  listByCategory(category) {
+    return this.entries.filter((entry) => entry.definition.category === category);
+  }
+  validate(definition, source = "custom") {
+    const result = validateEffectRecipeManifest(
+      [
+        {
+          source,
+          definition
+        }
+      ],
+      this.primitiveRegistry
+    );
+    return {
+      entry: result.errors.length === 0 ? result.entries[0] ?? null : null,
+      errors: result.errors
+    };
+  }
+};
+var resolveEffectRecipePrimitiveDescriptor = (recipe, trackIndex, primitiveRegistry) => primitiveRegistry.get(recipe.tracks[trackIndex]?.primitiveId ?? "");
+
+// src/recipes/EffectPrimitiveRuntimeRegistry.ts
+var EffectPrimitiveRuntimeRegistry = class {
+  runtimes = /* @__PURE__ */ new Map();
+  register(runtime) {
+    if (this.runtimes.has(runtime.primitiveId)) {
+      throw new Error(`\u91CD\u590D\u7684 effect primitive runtime: ${runtime.primitiveId}`);
+    }
+    this.runtimes.set(runtime.primitiveId, runtime);
+  }
+  get(primitiveId) {
+    return this.runtimes.get(primitiveId) ?? null;
+  }
+  listIds() {
+    return [...this.runtimes.keys()].sort((left, right) => left.localeCompare(right, "zh-CN"));
+  }
+};
+
+// src/recipes/EffectRecipeExecutor.ts
+var compareTracks = (left, right) => {
+  if (left.atMs !== right.atMs) {
+    return left.atMs - right.atMs;
+  }
+  return left.id.localeCompare(right.id, "zh-CN");
+};
+var isRecipeDefinition = (value) => typeof value !== "string";
+var resolveTrackIdFromValidationErrors = (recipe, errors) => {
+  const trackPath = errors.find((error) => /^recipes\[0\]\.tracks\[\d+\]/.test(error.path))?.path;
+  if (!trackPath) {
+    return void 0;
+  }
+  const match = /^recipes\[0\]\.tracks\[(\d+)\]/.exec(trackPath);
+  const trackIndex = match ? Number.parseInt(match[1] ?? "", 10) : Number.NaN;
+  if (!Number.isSafeInteger(trackIndex) || trackIndex < 0) {
+    return void 0;
+  }
+  return recipe.tracks[trackIndex]?.id;
+};
+var EffectRecipeExecutorError = class extends Error {
+  constructor(code, recipeId, message, options = {}) {
+    super(message);
+    this.code = code;
+    this.recipeId = recipeId;
+    this.name = "EffectRecipeExecutorError";
+    this.trackId = options.trackId;
+    this.validationErrors = options.validationErrors ?? [];
+    this.cause = options.cause;
+  }
+  code;
+  recipeId;
+  cause;
+  trackId;
+  validationErrors;
+};
+var EffectRecipeExecutor = class {
+  constructor(options) {
+    this.options = options;
+    this.scheduler = options.scheduler;
+    this.recipeRegistry = options.recipeRegistry;
+    this.primitiveRegistry = options.primitiveRegistry;
+  }
+  options;
+  scheduler;
+  recipeRegistry;
+  primitiveRegistry;
+  buildPlan(recipeInput, runtimeContext) {
+    const recipe = this.resolveRecipe(recipeInput);
+    return recipe.tracks.filter((track) => track.enabled).slice().sort(compareTracks).map((track) => this.resolveTrackPlanItem(recipe, track, runtimeContext));
+  }
+  execute(runOptions) {
+    const recipe = this.resolveRecipe(runOptions.recipe);
+    const plan = this.buildPlan(recipe, runOptions.runtimeContext);
+    const controller = new AbortController();
+    const timerHandles = [];
+    const activeCleanups = /* @__PURE__ */ new Map();
+    const expiredTracks = /* @__PURE__ */ new Set();
+    const trackControllers = /* @__PURE__ */ new Map();
+    const recipeEndTracks = /* @__PURE__ */ new Set();
+    const pendingCleanupPromises = /* @__PURE__ */ new Set();
+    let committed = false;
+    let finished = false;
+    let detachExternalSignal = null;
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve, reject) => {
+      resolveDone = resolve;
+      rejectDone = reject;
+    });
+    const clearTimers = () => {
+      while (timerHandles.length > 0) {
+        this.scheduler.clearTimeout(timerHandles.pop());
+      }
+    };
+    const cleanupTrack = (id) => {
+      expiredTracks.add(id);
+      trackControllers.get(id)?.abort("track-ended");
+      trackControllers.delete(id);
+      const cleanup = activeCleanups.get(id);
+      activeCleanups.delete(id);
+      cleanup?.();
+    };
+    const flushCleanups = () => {
+      for (const id of [...trackControllers.keys()]) {
+        try {
+          cleanupTrack(id);
+        } catch {
+        }
+      }
+    };
+    const finalize = (status, error) => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      clearTimers();
+      detachExternalSignal?.();
+      if (status === "aborted" && !controller.signal.aborted) {
+        controller.abort(error?.message ?? "effect-recipe-aborted");
+      }
+      flushCleanups();
+      const settle = () => {
+        const outcome = {
+          recipeId: recipe.id,
+          status,
+          committed
+        };
+        try {
+          runOptions.onDone?.(outcome);
+        } catch {
+        }
+        if (error) {
+          rejectDone(error);
+          return;
+        }
+        resolveDone(outcome);
+      };
+      if (pendingCleanupPromises.size === 0) {
+        settle();
+        return;
+      }
+      void Promise.allSettled([...pendingCleanupPromises]).then(() => {
+        settle();
+      });
+    };
+    const requestAbort = (reason = "effect-recipe-aborted", error) => {
+      if (!controller.signal.aborted) {
+        controller.abort(reason);
+      }
+      finalize("aborted", error);
+    };
+    const fail = (code, trackId, message, cause) => {
+      requestAbort(
+        message,
+        new EffectRecipeExecutorError(
+          code,
+          recipe.id,
+          cause instanceof Error ? `${message}: ${cause.message}` : message,
+          {
+            trackId,
+            cause
+          }
+        )
+      );
+    };
+    const registerCleanup = (trackId, result) => {
+      const accept = (handle) => {
+        if (!handle) return;
+        const cleanup = typeof handle === "function" ? handle : () => handle.cleanup();
+        if (finished || expiredTracks.has(trackId) || controller.signal.aborted) {
+          cleanup();
+          return;
+        }
+        activeCleanups.set(trackId, cleanup);
+        if (typeof handle !== "function") {
+          if (handle.cleanupPolicy === "recipe-end") recipeEndTracks.add(trackId);
+          void handle.completed?.catch((error) => {
+            if (!finished && !expiredTracks.has(trackId))
+              fail("runtime_error", trackId, "Primitive completion failed", error);
+          });
+        }
+      };
+      if (result instanceof Promise) {
+        const pending = result.then(accept).catch((error) => {
+          if (!finished) fail("runtime_error", trackId, "Primitive start failed", error);
+        });
+        pendingCleanupPromises.add(pending);
+        void pending.finally(() => pendingCleanupPromises.delete(pending));
+      } else accept(result);
+    };
+    const commit = () => {
+      if (committed || finished || controller.signal.aborted) {
+        return;
+      }
+      committed = true;
+      try {
+        runOptions.onCommit?.(recipe);
+      } catch (error) {
+        fail("runtime_error", void 0, "Recipe commit callback failed", error);
+      }
+    };
+    const startTrack = (planItem) => {
+      if (finished || controller.signal.aborted) {
+        return;
+      }
+      try {
+        const trackController = new AbortController();
+        trackControllers.set(planItem.track.id, trackController);
+        const result = planItem.runtime.execute(
+          planItem.executionContext,
+          planItem.params,
+          trackController.signal
+        );
+        registerCleanup(planItem.track.id, result);
+      } catch (error) {
+        fail(
+          "runtime_error",
+          planItem.track.id,
+          `Effect primitive \u540C\u6B65\u6267\u884C\u5931\u8D25: ${planItem.track.id}`,
+          error
+        );
+      }
+    };
+    if (runOptions.signal) {
+      const abortFromCaller = () => {
+        requestAbort(String(runOptions.signal?.reason ?? "effect-recipe-aborted"));
+      };
+      if (runOptions.signal.aborted) {
+        abortFromCaller();
+      } else {
+        runOptions.signal.addEventListener("abort", abortFromCaller, { once: true });
+        detachExternalSignal = () => {
+          runOptions.signal?.removeEventListener("abort", abortFromCaller);
+        };
+      }
+    }
+    if (!finished) {
+      const groupedPlan = /* @__PURE__ */ new Map();
+      for (const item of plan) {
+        const existing = groupedPlan.get(item.track.atMs);
+        if (existing) {
+          existing.push(item);
+        } else {
+          groupedPlan.set(item.track.atMs, [item]);
+        }
+      }
+      const scheduleTimes = [
+        .../* @__PURE__ */ new Set([
+          ...groupedPlan.keys(),
+          ...plan.map((item) => item.track.atMs + item.track.durationMs),
+          recipe.commitAtMs
+        ])
+      ].sort((left, right) => left - right);
+      for (const atMs of scheduleTimes) {
+        timerHandles.push(
+          this.scheduler.setTimeout(() => {
+            if (finished || controller.signal.aborted) {
+              return;
+            }
+            for (const item of groupedPlan.get(atMs) ?? []) startTrack(item);
+            if (atMs === recipe.commitAtMs) commit();
+            for (const item of plan) {
+              if (item.track.atMs + item.track.durationMs === atMs && !recipeEndTracks.has(item.track.id)) {
+                try {
+                  cleanupTrack(item.track.id);
+                } catch (error) {
+                  fail("runtime_error", item.track.id, "Primitive cleanup failed", error);
+                }
+              }
+            }
+          }, atMs)
+        );
+      }
+      timerHandles.push(
+        this.scheduler.setTimeout(() => {
+          finalize("completed");
+        }, recipe.durationMs)
+      );
+    }
+    return {
+      recipe,
+      signal: controller.signal,
+      done,
+      abort: (reason) => {
+        requestAbort(reason ?? "effect-recipe-aborted");
+      }
+    };
+  }
+  resolveRecipe(recipeInput) {
+    if (!isRecipeDefinition(recipeInput)) {
+      const registration = this.recipeRegistry.get(recipeInput);
+      if (!registration) {
+        throw new EffectRecipeExecutorError(
+          "unknown_recipe",
+          recipeInput,
+          `\u672A\u6CE8\u518C\u7684 effect recipe: ${recipeInput}`
+        );
+      }
+      return registration.definition;
+    }
+    const validation = this.recipeRegistry.validate(recipeInput, "custom");
+    if (validation.entry) {
+      return validation.entry.definition;
+    }
+    throw new EffectRecipeExecutorError(
+      validation.errors.some((error) => error.code === "unknown_primitive") ? "unknown_primitive" : "invalid_params",
+      recipeInput.id,
+      `Effect recipe \u5B9A\u4E49\u65E0\u6548: ${recipeInput.id}`,
+      {
+        trackId: resolveTrackIdFromValidationErrors(recipeInput, validation.errors),
+        validationErrors: validation.errors
+      }
+    );
+  }
+  resolveTrackPlanItem(recipe, track, runtimeContext) {
+    const primitive = this.primitiveRegistry.get(track.primitiveId);
+    if (!primitive) {
+      throw new EffectRecipeExecutorError(
+        "unknown_primitive",
+        recipe.id,
+        `\u672A\u6CE8\u518C\u7684 effect primitive descriptor: ${track.primitiveId}`,
+        {
+          trackId: track.id
+        }
+      );
+    }
+    const runtime = this.options.runtimeRegistry.get(track.primitiveId);
+    if (!runtime) {
+      throw new EffectRecipeExecutorError(
+        "unknown_runtime",
+        recipe.id,
+        `\u672A\u6CE8\u518C\u7684 effect primitive runtime: ${track.primitiveId}`,
+        {
+          trackId: track.id
+        }
+      );
+    }
+    const resolvedParams = {};
+    for (const [paramName, rawValue] of Object.entries(track.params)) {
+      if (isEffectRecipeTuningPathReference(rawValue)) {
+        const resolvedValue = this.resolveTuningReference(
+          recipe,
+          track,
+          primitive,
+          paramName,
+          rawValue,
+          runtimeContext
+        );
+        resolvedParams[paramName] = resolvedValue;
+        continue;
+      }
+      if (!isResolvedRecipeValue(rawValue)) {
+        throw new EffectRecipeExecutorError(
+          "invalid_params",
+          recipe.id,
+          `Track \u53C2\u6570\u672A\u901A\u8FC7\u8FD0\u884C\u65F6\u503C\u6821\u9A8C: ${track.id}.${paramName}`,
+          {
+            trackId: track.id
+          }
+        );
+      }
+      resolvedParams[paramName] = rawValue;
+    }
+    const validatedParams = validateResolvedEffectRecipeTrackParams(
+      primitive,
+      resolvedParams,
+      `tracks.${track.id}.params`
+    );
+    if (!validatedParams.params) {
+      throw new EffectRecipeExecutorError(
+        "invalid_params",
+        recipe.id,
+        `Track \u53C2\u6570\u672A\u901A\u8FC7 descriptor \u6821\u9A8C: ${track.id}`,
+        {
+          trackId: track.id,
+          validationErrors: validatedParams.errors
+        }
+      );
+    }
+    return {
+      track,
+      primitive,
+      runtime,
+      params: validatedParams.params,
+      executionContext: {
+        recipeId: recipe.id,
+        recipe,
+        track,
+        primitive,
+        runtimeContext
+      }
+    };
+  }
+  resolveTuningReference(recipe, track, primitive, paramName, reference, runtimeContext) {
+    let resolvedValue;
+    try {
+      resolvedValue = this.options.resolveTuningPath(reference, {
+        recipe,
+        track,
+        primitive,
+        paramName,
+        runtimeContext
+      });
+    } catch (error) {
+      throw new EffectRecipeExecutorError(
+        "tuning_resolution_failed",
+        recipe.id,
+        `tuningPath \u89E3\u6790\u5931\u8D25: ${reference.tuningPath}`,
+        {
+          trackId: track.id,
+          cause: error
+        }
+      );
+    }
+    if (!isResolvedRecipeValue(resolvedValue)) {
+      throw new EffectRecipeExecutorError(
+        "tuning_resolution_failed",
+        recipe.id,
+        `tuningPath \u8FD4\u56DE\u4E86\u65E0\u6548\u503C: ${reference.tuningPath}`,
+        {
+          trackId: track.id
+        }
+      );
+    }
+    return resolvedValue;
+  }
+};
+export {
+  EFFECT_PRIMITIVE_CATEGORIES,
+  EFFECT_PRIMITIVE_PARAM_TYPES,
+  EFFECT_PRIMITIVE_PREVIEW_SUPPORT,
+  EFFECT_RECIPE_APP_ICON_ID_MAX_LENGTH,
+  EFFECT_RECIPE_APP_LABEL_MAX_CODE_POINTS,
+  EFFECT_RECIPE_APP_ORDER_MAX,
+  EFFECT_RECIPE_APP_SHORT_DESCRIPTION_MAX_CODE_POINTS,
+  EFFECT_RECIPE_CATEGORIES,
+  EFFECT_RECIPE_DESCRIPTION_MAX_CODE_POINTS,
+  EFFECT_RECIPE_ID_MAX_LENGTH,
+  EFFECT_RECIPE_MAX_DURATION_MS,
+  EFFECT_RECIPE_MAX_TRACKS,
+  EFFECT_RECIPE_MIGRATIONS,
+  EFFECT_RECIPE_NAME_MAX_CODE_POINTS,
+  EFFECT_RECIPE_PRIMITIVE_ID_MAX_LENGTH,
+  EFFECT_RECIPE_SCHEMA_VERSION,
+  EFFECT_RECIPE_SCOPES,
+  EFFECT_RECIPE_STABLE_ID_REGEX,
+  EFFECT_RECIPE_TRACK_ID_MAX_LENGTH,
+  EFFECT_RECIPE_TUNING_PATH_MAX_LENGTH,
+  EFFECT_RECIPE_TUNING_PATH_REGEX,
+  EFFECT_RECIPE_VALUE_MAX_ARRAY_LENGTH,
+  EFFECT_RECIPE_VALUE_MAX_STRING_CODE_POINTS,
+  EFFECT_TARGETS,
+  EffectPrimitiveRegistry,
+  EffectPrimitiveRuntimeRegistry,
+  EffectRecipeExecutor,
+  EffectRecipeExecutorError,
+  EffectRecipeRegistry,
+  EffectRecipeRegistryError,
+  createEffectRecipeValidationError,
+  effectRecipeMigrationRegistry,
+  isEffectPrimitiveId,
+  isEffectRecipeCategory,
+  isEffectRecipeId,
+  isEffectRecipeScope,
+  isEffectRecipeTrackId,
+  isEffectRecipeTuningPath,
+  isEffectRecipeTuningPathReference,
+  isResolvedRecipeValue,
+  migrateEffectRecipeDefinition,
+  resolveEffectRecipePrimitiveDescriptor,
+  validateEffectRecipeDefinition,
+  validateEffectRecipeManifest,
+  validateEffectRecipeTrackParams,
+  validateResolvedEffectRecipeTrackParams
+};
+//# sourceMappingURL=recipes.js.map