@routevn/creator-model 1.10.3 → 1.11.0

package/src/model.js

@@ -42,6 +42,7 @@ const LINE_UPDATE_ACTIONS_PRESERVE_PATHS_SET = new Set(
   LINE_UPDATE_ACTIONS_PRESERVE_PATHS,
 );
 const CURRENT_LAYOUT_SCHEMA_VERSION = 2;
+const FONT_WEIGHT_KEYS = ["minWeight", "defaultWeight", "maxWeight"];
 const isPositiveFiniteNumber = (value) => isFiniteNumber(value) && value > 0;
 const normalizeLayoutSchemaVersion = (value) =>
   Number.isInteger(value) && value >= 1 ? value : 1;
@@ -340,7 +341,7 @@ const ANIMATION_EASING_KEYS = [
   "easeInOutElastic",
 ];
 const VARIABLE_SCOPE_KEYS = ["context", "device", "account"];
-const VARIABLE_TYPE_KEYS = ["string", "number", "boolean"];
+const VARIABLE_TYPE_KEYS = ["string", "number", "boolean", "object"];
 const LAYOUT_TYPE_KEYS = [
   "general",
   "save-load",
@@ -402,7 +403,7 @@ const SAVE_LOAD_DATE_FORMATS = new Set([
   "DD MMM YYYY",
   "YYYY年MM月DD日",
 ]);
-export const SCHEMA_VERSION = 10;
+export const SCHEMA_VERSION = 11;
 const LAYOUT_CONTAINER_ELEMENT_TYPES = [
   "folder",
   "container",
@@ -2388,6 +2389,41 @@ const validateAnimationItems = ({ items, path, errorFactory }) => {
   }
 };
 
+const validateFontWeightFields = ({ value, path, errorFactory }) => {
+  const presentKeys = FONT_WEIGHT_KEYS.filter((key) =>
+    Object.hasOwn(value, key),
+  );
+  if (presentKeys.length === 0) {
+    return;
+  }
+
+  if (presentKeys.length !== FONT_WEIGHT_KEYS.length) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must include minWeight, defaultWeight, and maxWeight together`,
+    );
+  }
+
+  for (const key of FONT_WEIGHT_KEYS) {
+    if (!isFiniteNumber(value[key]) || value[key] < 1 || value[key] > 1000) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.${key} must be a finite number between 1 and 1000`,
+      );
+    }
+  }
+
+  if (
+    value.minWeight > value.defaultWeight ||
+    value.defaultWeight > value.maxWeight
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must satisfy minWeight <= defaultWeight <= maxWeight`,
+    );
+  }
+};
+
 const validateFontItems = ({ items, path, errorFactory }) => {
   for (const [itemId, item] of Object.entries(items)) {
     const itemPath = `${path}.${itemId}`;
@@ -2413,6 +2449,7 @@ const validateFontItems = ({ items, path, errorFactory }) => {
                 "tagIds",
                 "fileId",
                 "fontFamily",
+                ...FONT_WEIGHT_KEYS,
               ],
         path: itemPath,
         errorFactory,
@@ -2476,6 +2513,17 @@ const validateFontItems = ({ items, path, errorFactory }) => {
           `${itemPath}.fontFamily must be a non-empty string`,
         );
       }
+
+      {
+        const result = validateFontWeightFields({
+          value: item,
+          path: itemPath,
+          errorFactory,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
     }
   }
 };
@@ -2817,49 +2865,1122 @@ const validateParticleItems = ({ items, path, errorFactory }) => {
       );
     }
 
-    if (
-      item.thumbnailFileId !== undefined &&
-      !isNonEmptyString(item.thumbnailFileId)
-    ) {
-      return invalidFromErrorFactory(
-        errorFactory,
-        `${itemPath}.thumbnailFileId must be a non-empty string when provided`,
-      );
+    if (
+      item.thumbnailFileId !== undefined &&
+      !isNonEmptyString(item.thumbnailFileId)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.thumbnailFileId must be a non-empty string when provided`,
+      );
+    }
+
+    {
+      const result = validateParticleModules({
+        modules: item.modules,
+        path: `${itemPath}.modules`,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+  }
+};
+
+const validateVariableTypedValue = ({
+  value,
+  variableType,
+  path,
+  errorFactory,
+}) => {
+  if (variableType === "string" && !isString(value)) {
+    return invalidFromErrorFactory(errorFactory, `${path} must be a string`);
+  }
+
+  if (variableType === "number" && !isFiniteNumber(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be a finite number`,
+    );
+  }
+
+  if (variableType === "boolean" && typeof value !== "boolean") {
+    return invalidFromErrorFactory(errorFactory, `${path} must be a boolean`);
+  }
+
+  if (
+    variableType === "object" &&
+    (value === null || typeof value !== "object")
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be a non-null object or array`,
+    );
+  }
+
+  if (variableType === "object") {
+    return validateComputedDataValue({
+      value,
+      path,
+      errorFactory,
+    });
+  }
+};
+
+const COMPUTED_EXPRESSION_FIXED_OPERAND_COUNTS = Object.freeze({
+  add: 2,
+  sub: 2,
+  mul: 2,
+  div: 2,
+  mod: 2,
+  neg: 1,
+  round: 1,
+  floor: 1,
+  ceil: 1,
+  min: 2,
+  max: 2,
+  clamp: 3,
+  eq: 2,
+  neq: 2,
+  gt: 2,
+  gte: 2,
+  lt: 2,
+  lte: 2,
+  in: 2,
+  not: 1,
+  length: 1,
+  includes: 2,
+});
+const COMPUTED_EXPRESSION_VARIADIC_OPERATORS = new Set([
+  "and",
+  "or",
+  "all",
+  "any",
+]);
+const COMPUTED_EXPRESSION_NUMERIC_OPERAND_OPERATORS = new Set([
+  "add",
+  "sub",
+  "mul",
+  "div",
+  "mod",
+  "neg",
+  "round",
+  "floor",
+  "ceil",
+  "min",
+  "max",
+  "clamp",
+]);
+const COMPUTED_EXPRESSION_NUMERIC_RESULT_OPERATORS = new Set([
+  ...COMPUTED_EXPRESSION_NUMERIC_OPERAND_OPERATORS,
+  "length",
+]);
+const COMPUTED_EXPRESSION_BOOLEAN_RESULT_OPERATORS = new Set([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "and",
+  "or",
+  "all",
+  "any",
+  "not",
+  "includes",
+]);
+const COMPUTED_CONDITION_FIXED_OPERAND_COUNTS = Object.freeze({
+  eq: 2,
+  neq: 2,
+  gt: 2,
+  gte: 2,
+  lt: 2,
+  lte: 2,
+  in: 2,
+  add: 2,
+  sub: 2,
+});
+const COMPUTED_CONDITION_VARIADIC_OPERATORS = new Set(["all", "any"]);
+
+const getComputedValueType = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "object") {
+    return "object";
+  }
+  return typeof value;
+};
+
+const validComputedResult = (valueType) => ({
+  valid: true,
+  valueType,
+});
+
+const validateComputedDataValue = ({
+  value,
+  path,
+  errorFactory,
+  ancestors = new Set(),
+}) => {
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean"
+  ) {
+    return VALID_RESULT;
+  }
+
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) {
+      return VALID_RESULT;
+    }
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must use finite numeric values`,
+    );
+  }
+
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path} must not contain cyclic data`,
+      );
+    }
+    ancestors.add(value);
+
+    for (const [index, item] of value.entries()) {
+      const result = validateComputedDataValue({
+        value: item,
+        path: `${path}[${index}]`,
+        errorFactory,
+        ancestors,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+    ancestors.delete(value);
+    return VALID_RESULT;
+  }
+
+  if (
+    !isPlainObject(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must contain JSON-compatible data`,
+    );
+  }
+
+  if (ancestors.has(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must not contain cyclic data`,
+    );
+  }
+  ancestors.add(value);
+
+  for (const [key, item] of Object.entries(value)) {
+    const result = validateComputedDataValue({
+      value: item,
+      path: `${path}.${key}`,
+      errorFactory,
+      ancestors,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  ancestors.delete(value);
+  return VALID_RESULT;
+};
+
+const invalidComputedReferenceParseResult = Object.freeze({
+  valid: false,
+});
+
+const decodeComputedReferenceQuotedPart = (rawValue) => {
+  if (rawValue[0] === '"') {
+    try {
+      return {
+        valid: true,
+        value: JSON.parse(rawValue),
+      };
+    } catch {
+      return invalidComputedReferenceParseResult;
+    }
+  }
+
+  let value = "";
+  const escapedValues = {
+    "\\": "\\",
+    '"': '"',
+    "'": "'",
+    "/": "/",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+    b: "\b",
+    f: "\f",
+  };
+
+  for (let index = 1; index < rawValue.length - 1; index += 1) {
+    const character = rawValue[index];
+    if (character !== "\\") {
+      if (character.charCodeAt(0) < 0x20) {
+        return invalidComputedReferenceParseResult;
+      }
+      value += character;
+      continue;
+    }
+
+    index += 1;
+    if (index >= rawValue.length - 1) {
+      return invalidComputedReferenceParseResult;
+    }
+
+    const escapedCharacter = rawValue[index];
+    if (escapedCharacter === "u") {
+      const hexValue = rawValue.slice(index + 1, index + 5);
+      if (hexValue.length !== 4 || !/^[0-9a-fA-F]{4}$/.test(hexValue)) {
+        return invalidComputedReferenceParseResult;
+      }
+      value += String.fromCharCode(Number.parseInt(hexValue, 16));
+      index += 4;
+      continue;
+    }
+
+    if (!Object.hasOwn(escapedValues, escapedCharacter)) {
+      return invalidComputedReferenceParseResult;
+    }
+    value += escapedValues[escapedCharacter];
+  }
+
+  return {
+    valid: true,
+    value,
+  };
+};
+
+const parseComputedReferencePath = (value) => {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.trim() !== value
+  ) {
+    return invalidComputedReferenceParseResult;
+  }
+
+  const parts = [];
+  let index = 0;
+
+  const readBarePart = () => {
+    const startIndex = index;
+    while (
+      index < value.length &&
+      value[index] !== "." &&
+      value[index] !== "[" &&
+      value[index] !== "]"
+    ) {
+      index += 1;
+    }
+
+    const part = value.slice(startIndex, index);
+    if (part.length === 0 || part.trim() !== part || /\s/.test(part)) {
+      return false;
+    }
+    parts.push(part);
+    return true;
+  };
+
+  const readBracketPart = () => {
+    index += 1;
+    while (index < value.length && /\s/.test(value[index])) {
+      index += 1;
+    }
+
+    const firstCharacter = value[index];
+    if (/\d/.test(firstCharacter ?? "")) {
+      const startIndex = index;
+      while (index < value.length && /\d/.test(value[index])) {
+        index += 1;
+      }
+      const rawPart = value.slice(startIndex, index);
+      while (index < value.length && /\s/.test(value[index])) {
+        index += 1;
+      }
+      if (
+        value[index] !== "]" ||
+        (rawPart.length > 1 && rawPart.startsWith("0"))
+      ) {
+        return false;
+      }
+      index += 1;
+      parts.push(rawPart);
+      return true;
+    }
+
+    if (firstCharacter !== '"' && firstCharacter !== "'") {
+      return false;
+    }
+
+    const quote = firstCharacter;
+    const startIndex = index;
+    index += 1;
+    let escaped = false;
+    while (index < value.length) {
+      const character = value[index];
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === quote) {
+        const decodedPart = decodeComputedReferenceQuotedPart(
+          value.slice(startIndex, index + 1),
+        );
+        if (!decodedPart.valid) {
+          return false;
+        }
+
+        index += 1;
+        while (index < value.length && /\s/.test(value[index])) {
+          index += 1;
+        }
+        if (value[index] !== "]") {
+          return false;
+        }
+        index += 1;
+        parts.push(decodedPart.value);
+        return true;
+      }
+      index += 1;
+    }
+
+    return false;
+  };
+
+  if (!readBarePart()) {
+    return invalidComputedReferenceParseResult;
+  }
+
+  while (index < value.length) {
+    if (value[index] === ".") {
+      index += 1;
+      if (!readBarePart()) {
+        return invalidComputedReferenceParseResult;
+      }
+      continue;
+    }
+
+    if (value[index] === "[") {
+      if (!readBracketPart()) {
+        return invalidComputedReferenceParseResult;
+      }
+      continue;
+    }
+
+    return invalidComputedReferenceParseResult;
+  }
+
+  return {
+    valid: true,
+    parts,
+  };
+};
+
+const validateComputedReferencePath = ({
+  value,
+  path,
+  errorFactory,
+  variables,
+  dependencies,
+}) => {
+  if (!isNonEmptyString(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be a non-empty string path`,
+    );
+  }
+
+  const parsedPath = parseComputedReferencePath(value);
+  if (!parsedPath.valid) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} has an invalid reference path`,
+    );
+  }
+
+  const [root, referencedId, ...nestedPath] = parsedPath.parts;
+  if (root !== "variables" && root !== "runtime") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must reference a concrete variables.* or runtime.* path`,
+    );
+  }
+
+  if (!isNonEmptyString(referencedId)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must reference a concrete ${root} member`,
+    );
+  }
+
+  if (root === "runtime" || variables === undefined) {
+    return validComputedResult(undefined);
+  }
+
+  const referencedVariable = Object.hasOwn(variables, referencedId)
+    ? variables[referencedId]
+    : undefined;
+  if (
+    !isPlainObject(referencedVariable) ||
+    referencedVariable.type !== "variable"
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} references unknown variable '${referencedId}'`,
+    );
+  }
+
+  if (Object.hasOwn(referencedVariable, "computed")) {
+    dependencies?.add(referencedId);
+  }
+
+  return validComputedResult(
+    nestedPath.length === 0 ? referencedVariable.variableType : undefined,
+  );
+};
+
+const validateComputedExpression = ({
+  expression,
+  path,
+  errorFactory,
+  variables,
+  dependencies,
+  ancestors = new Set(),
+}) => {
+  if (expression === null) {
+    return validComputedResult("null");
+  }
+
+  if (typeof expression !== "object") {
+    if (typeof expression === "number") {
+      if (Number.isFinite(expression)) {
+        return validComputedResult("number");
+      }
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path} must use finite numeric literals`,
+      );
+    }
+
+    if (
+      typeof expression === "string" ||
+      typeof expression === "boolean"
+    ) {
+      return validComputedResult(typeof expression);
+    }
+
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must use JSON-compatible primitive literals`,
+    );
+  }
+
+  if (Array.isArray(expression)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} arrays must be wrapped in a literal operator or authored as value`,
+    );
+  }
+
+  if (ancestors.has(expression)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must not contain cyclic expression data`,
+    );
+  }
+  const nextAncestors = new Set(ancestors);
+  nextAncestors.add(expression);
+
+  const entries = Object.entries(expression);
+  if (entries.length !== 1) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must contain exactly one expression operator`,
+    );
+  }
+
+  const [[operator, operands]] = entries;
+  if (operator === "var") {
+    const result = validateComputedReferencePath({
+      value: operands,
+      path: `${path}.var`,
+      errorFactory,
+      variables,
+      dependencies,
+    });
+    return result;
+  }
+
+  if (operator === "literal") {
+    const result = validateComputedDataValue({
+      value: operands,
+      path: `${path}.literal`,
+      errorFactory,
+    });
+    return result?.valid === false
+      ? result
+      : validComputedResult(getComputedValueType(operands));
+  }
+
+  const fixedOperandCount = COMPUTED_EXPRESSION_FIXED_OPERAND_COUNTS[operator];
+  const isVariadic = COMPUTED_EXPRESSION_VARIADIC_OPERATORS.has(operator);
+  if (fixedOperandCount === undefined && !isVariadic) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} contains unsupported expression operator '${operator}'`,
+    );
+  }
+
+  if (!Array.isArray(operands)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.${operator} must be an operand array`,
+    );
+  }
+
+  if (
+    (fixedOperandCount !== undefined &&
+      operands.length !== fixedOperandCount) ||
+    (isVariadic && operands.length === 0)
+  ) {
+    const operandRequirement = isVariadic
+      ? "at least one operand"
+      : `exactly ${fixedOperandCount} operands`;
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.${operator} requires ${operandRequirement}`,
+    );
+  }
+
+  const operandTypes = [];
+  for (const [index, operand] of operands.entries()) {
+    const result = validateComputedExpression({
+      expression: operand,
+      path: `${path}.${operator}[${index}]`,
+      errorFactory,
+      variables,
+      dependencies,
+      ancestors: nextAncestors,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+    operandTypes.push(result.valueType);
+  }
+
+  if (
+    COMPUTED_EXPRESSION_NUMERIC_OPERAND_OPERATORS.has(operator) &&
+    operandTypes.some(
+      (operandType) => operandType !== undefined && operandType !== "number",
+    )
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.${operator} requires numeric operands`,
+    );
+  }
+
+  if (COMPUTED_EXPRESSION_NUMERIC_RESULT_OPERATORS.has(operator)) {
+    return validComputedResult("number");
+  }
+  if (COMPUTED_EXPRESSION_BOOLEAN_RESULT_OPERATORS.has(operator)) {
+    return validComputedResult("boolean");
+  }
+  return validComputedResult(undefined);
+};
+
+const validateComputedCondition = ({
+  condition,
+  path,
+  errorFactory,
+  variables,
+  dependencies,
+  isRoot = true,
+  ancestors = new Set(),
+}) => {
+  if (isRoot && typeof condition === "string") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} string conditions are not supported`,
+    );
+  }
+
+  if (condition === null) {
+    return validComputedResult("null");
+  }
+
+  if (typeof condition !== "object") {
+    if (typeof condition === "number") {
+      if (Number.isFinite(condition)) {
+        return validComputedResult("number");
+      }
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path} must use finite numeric literals`,
+      );
+    }
+
+    if (
+      typeof condition === "string" ||
+      typeof condition === "boolean"
+    ) {
+      return validComputedResult(typeof condition);
+    }
+
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must use JSON-compatible primitive literals`,
+    );
+  }
+
+  if (Array.isArray(condition)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} arrays must be wrapped in a condition operator or literal`,
+    );
+  }
+
+  if (ancestors.has(condition)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must not contain cyclic condition data`,
+    );
+  }
+  const nextAncestors = new Set(ancestors);
+  nextAncestors.add(condition);
+
+  const entries = Object.entries(condition);
+  if (entries.length !== 1) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must contain exactly one condition operator`,
+    );
+  }
+
+  const [[operator, operands]] = entries;
+  if (operator === "var") {
+    const result = validateComputedReferencePath({
+      value: operands,
+      path: `${path}.var`,
+      errorFactory,
+      variables,
+      dependencies,
+    });
+    return result;
+  }
+  if (operator === "literal") {
+    const result = validateComputedDataValue({
+      value: operands,
+      path: `${path}.literal`,
+      errorFactory,
+    });
+    return result?.valid === false
+      ? result
+      : validComputedResult(getComputedValueType(operands));
+  }
+  if (operator === "call") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} function calls are not supported`,
+    );
+  }
+  if (operator === "not") {
+    const result = validateComputedCondition({
+      condition: operands,
+      path: `${path}.not`,
+      errorFactory,
+      variables,
+      dependencies,
+      isRoot: false,
+      ancestors: nextAncestors,
+    });
+    return result?.valid === false ? result : validComputedResult("boolean");
+  }
+
+  const fixedOperandCount = COMPUTED_CONDITION_FIXED_OPERAND_COUNTS[operator];
+  const isVariadic = COMPUTED_CONDITION_VARIADIC_OPERATORS.has(operator);
+  if (fixedOperandCount === undefined && !isVariadic) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} contains unsupported condition operator '${operator}'`,
+    );
+  }
+  if (!Array.isArray(operands)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.${operator} must be an operand array`,
+    );
+  }
+  if (
+    (fixedOperandCount !== undefined &&
+      operands.length !== fixedOperandCount) ||
+    (isVariadic && operands.length === 0)
+  ) {
+    const operandRequirement = isVariadic
+      ? "at least one operand"
+      : `exactly ${fixedOperandCount} operands`;
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.${operator} requires ${operandRequirement}`,
+    );
+  }
+
+  const operandTypes = [];
+  for (const [index, operand] of operands.entries()) {
+    const result = validateComputedCondition({
+      condition: operand,
+      path: `${path}.${operator}[${index}]`,
+      errorFactory,
+      variables,
+      dependencies,
+      isRoot: false,
+      ancestors: nextAncestors,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+    operandTypes.push(result.valueType);
+  }
+
+  if (
+    (operator === "add" || operator === "sub") &&
+    operandTypes.some(
+      (operandType) => operandType !== undefined && operandType !== "number",
+    )
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.${operator} requires numeric operands`,
+    );
+  }
+
+  return validComputedResult(
+    operator === "add" || operator === "sub" ? "number" : "boolean",
+  );
+};
+
+const validateComputedResultConfig = ({
+  resultConfig,
+  variableType,
+  path,
+  errorFactory,
+  variables,
+  dependencies,
+  allowedKeys = ["expr", "value"],
+}) => {
+  if (!isPlainObject(resultConfig)) {
+    return invalidFromErrorFactory(errorFactory, `${path} must be an object`);
+  }
+
+  {
+    const result = validateAllowedKeys({
+      value: resultConfig,
+      allowedKeys,
+      path,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  const hasExpression = Object.hasOwn(resultConfig, "expr");
+  const hasValue = Object.hasOwn(resultConfig, "value");
+  if (hasExpression === hasValue) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must contain exactly one of expr or value`,
+    );
+  }
+
+  if (hasValue) {
+    const dataResult = validateComputedDataValue({
+      value: resultConfig.value,
+      path: `${path}.value`,
+      errorFactory,
+    });
+    if (dataResult?.valid === false) {
+      return dataResult;
+    }
+    return validateVariableTypedValue({
+      value: resultConfig.value,
+      variableType,
+      path: `${path}.value`,
+      errorFactory,
+    });
+  }
+
+  const expressionResult = validateComputedExpression({
+    expression: resultConfig.expr,
+    path: `${path}.expr`,
+    errorFactory,
+    variables,
+    dependencies,
+  });
+  if (expressionResult?.valid === false) {
+    return expressionResult;
+  }
+  if (
+    expressionResult.valueType !== undefined &&
+    expressionResult.valueType !== variableType
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.expr must resolve to ${variableType}`,
+    );
+  }
+  return VALID_RESULT;
+};
+
+const validateVariableComputedConfig = ({
+  computed,
+  variableType,
+  path,
+  errorFactory,
+  variables,
+  dependencies,
+}) => {
+  if (!isPlainObject(computed)) {
+    return invalidFromErrorFactory(errorFactory, `${path} must be an object`);
+  }
+
+  if (Object.hasOwn(computed, "branches")) {
+    {
+      const result = validateAllowedKeys({
+        value: computed,
+        allowedKeys: ["branches", "default"],
+        path,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+    if (!Array.isArray(computed.branches) || computed.branches.length === 0) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.branches must be a non-empty array`,
+      );
+    }
+    if (!isPlainObject(computed.default)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.default must be an object`,
+      );
+    }
+
+    for (const [index, branch] of computed.branches.entries()) {
+      const branchPath = `${path}.branches[${index}]`;
+      if (!isPlainObject(branch)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${branchPath} must be an object`,
+        );
+      }
+      if (!Object.hasOwn(branch, "when")) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${branchPath}.when is required`,
+        );
+      }
+      const conditionResult = validateComputedCondition({
+        condition: branch.when,
+        path: `${branchPath}.when`,
+        errorFactory,
+        variables,
+        dependencies,
+      });
+      if (conditionResult?.valid === false) {
+        return conditionResult;
+      }
+      const branchResult = validateComputedResultConfig({
+        resultConfig: branch,
+        variableType,
+        path: branchPath,
+        errorFactory,
+        variables,
+        dependencies,
+        allowedKeys: ["when", "expr", "value"],
+      });
+      if (branchResult?.valid === false) {
+        return branchResult;
+      }
+    }
+
+    return validateComputedResultConfig({
+      resultConfig: computed.default,
+      variableType,
+      path: `${path}.default`,
+      errorFactory,
+      variables,
+      dependencies,
+    });
+  }
+
+  return validateComputedResultConfig({
+    resultConfig: computed,
+    variableType,
+    path,
+    errorFactory,
+    variables,
+    dependencies,
+  });
+};
+
+const validateComputedVariableGraph = ({
+  items,
+  path,
+  errorFactory,
+}) => {
+  const dependencyGraph = new Map();
+
+  for (const [variableId, variable] of Object.entries(items)) {
+    if (
+      variable?.type !== "variable" ||
+      !Object.hasOwn(variable, "computed")
+    ) {
+      continue;
+    }
+
+    const dependencies = new Set();
+    const result = validateVariableComputedConfig({
+      computed: variable.computed,
+      variableType: variable.variableType,
+      path: `${path}.${variableId}.computed`,
+      errorFactory,
+      variables: items,
+      dependencies,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+    dependencyGraph.set(variableId, dependencies);
+  }
+
+  const visited = new Set();
+  for (const startVariableId of dependencyGraph.keys()) {
+    if (visited.has(startVariableId)) {
+      continue;
     }
 
-    {
-      const result = validateParticleModules({
-        modules: item.modules,
-        path: `${itemPath}.modules`,
-        errorFactory,
-      });
-      if (result?.valid === false) {
-        return result;
+    const frames = [
+      {
+        variableId: startVariableId,
+        dependencies: [...(dependencyGraph.get(startVariableId) ?? [])],
+        nextDependencyIndex: 0,
+      },
+    ];
+    const activeIndexes = new Map([[startVariableId, 0]]);
+
+    while (frames.length > 0) {
+      const frame = frames.at(-1);
+      if (frame.nextDependencyIndex >= frame.dependencies.length) {
+        frames.pop();
+        activeIndexes.delete(frame.variableId);
+        visited.add(frame.variableId);
+        continue;
+      }
+
+      const dependencyId = frame.dependencies[frame.nextDependencyIndex];
+      frame.nextDependencyIndex += 1;
+      if (visited.has(dependencyId)) {
+        continue;
+      }
+
+      const cycleStartIndex = activeIndexes.get(dependencyId);
+      if (cycleStartIndex !== undefined) {
+        const cycle = [
+          ...frames
+            .slice(cycleStartIndex)
+            .map(({ variableId }) => variableId),
+          dependencyId,
+        ].join(" -> ");
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${path} contains computed variable cycle: ${cycle}`,
+        );
+      }
+
+      if (!dependencyGraph.has(dependencyId)) {
+        visited.add(dependencyId);
+        continue;
       }
+
+      activeIndexes.set(dependencyId, frames.length);
+      frames.push({
+        variableId: dependencyId,
+        dependencies: [...(dependencyGraph.get(dependencyId) ?? [])],
+        nextDependencyIndex: 0,
+      });
     }
   }
+
+  return VALID_RESULT;
 };
 
-const validateVariableTypedValue = ({
-  value,
+const validateVariableStoredOrComputedData = ({
+  data,
   variableType,
   path,
   errorFactory,
 }) => {
-  if (variableType === "string" && !isString(value)) {
-    return invalidFromErrorFactory(errorFactory, `${path} must be a string`);
-  }
-
-  if (variableType === "number" && !isFiniteNumber(value)) {
-    return invalidFromErrorFactory(
+  const isComputed = Object.hasOwn(data, "computed");
+  if (isComputed) {
+    if (Object.hasOwn(data, "default") || Object.hasOwn(data, "value")) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path} computed variables must not contain default or value`,
+      );
+    }
+    if (data.isEnum !== undefined || data.enumValues !== undefined) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path} computed variables must not contain enum metadata`,
+      );
+    }
+    return validateVariableComputedConfig({
+      computed: data.computed,
+      variableType,
+      path: `${path}.computed`,
       errorFactory,
-      `${path} must be a finite number`,
-    );
+    });
   }
 
-  if (variableType === "boolean" && typeof value !== "boolean") {
-    return invalidFromErrorFactory(errorFactory, `${path} must be a boolean`);
+  {
+    const result = validateVariableTypedValue({
+      value: data.default,
+      variableType,
+      path: `${path}.default`,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
   }
+  return validateVariableTypedValue({
+    value: data.value,
+    variableType,
+    path: `${path}.value`,
+    errorFactory,
+  });
 };
 
 const normalizeVariableEnumValues = (values = []) => {
@@ -2947,6 +4068,13 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
     const itemType = item?.type;
     const variableType = item?.variableType;
 
+    if (itemId === "__proto__") {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath} uses reserved variable id '__proto__'`,
+      );
+    }
+
     if (itemType !== "folder" && itemType !== "variable") {
       return invalidFromErrorFactory(
         errorFactory,
@@ -2972,6 +4100,7 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
                 "value",
                 "isEnum",
                 "enumValues",
+                "computed",
               ],
         path: itemPath,
         errorFactory,
@@ -3013,7 +4142,7 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
       if (!VARIABLE_TYPE_KEYS.includes(variableType)) {
         return invalidFromErrorFactory(
           errorFactory,
-          `${itemPath}.variableType must be 'string', 'number', or 'boolean'`,
+          `${itemPath}.variableType must be 'string', 'number', 'boolean', or 'object'`,
         );
       }
 
@@ -3041,7 +4170,14 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
         }
       }
 
-      if (!VARIABLE_SCOPE_KEYS.includes(item.scope)) {
+      if (item.computed !== undefined) {
+        if (item.scope !== undefined) {
+          return invalidFromErrorFactory(
+            errorFactory,
+            `${itemPath}.scope must be omitted for computed variables`,
+          );
+        }
+      } else if (!VARIABLE_SCOPE_KEYS.includes(item.scope)) {
         return invalidFromErrorFactory(
           errorFactory,
           `${itemPath}.scope must be 'context', 'device', or 'account'`,
@@ -3049,21 +4185,10 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
       }
 
       {
-        const result = validateVariableTypedValue({
-          value: item.default,
-          variableType,
-          path: `${itemPath}.default`,
-          errorFactory,
-        });
-        if (result?.valid === false) {
-          return result;
-        }
-      }
-      {
-        const result = validateVariableTypedValue({
-          value: item.value,
+        const result = validateVariableStoredOrComputedData({
+          data: item,
           variableType,
-          path: `${itemPath}.value`,
+          path: itemPath,
           errorFactory,
         });
         if (result?.valid === false) {
@@ -3072,6 +4197,12 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
       }
     }
   }
+
+  return validateComputedVariableGraph({
+    items,
+    path,
+    errorFactory,
+  });
 };
 
 const validateTextStyleShadow = ({ shadow, path, errorFactory }) => {
@@ -3216,11 +4347,15 @@ const validateTextStyleItems = ({ items, path, errorFactory }) => {
         }
       }
 
-      if (!isNonEmptyString(item.fontId)) {
-        return invalidFromErrorFactory(
+      {
+        const result = validateRequiredStringOrUniqueIdArray({
+          value: item.fontId,
+          path: `${itemPath}.fontId`,
           errorFactory,
-          `${itemPath}.fontId must be a non-empty string`,
-        );
+        });
+        if (result?.valid === false) {
+          return result;
+        }
       }
 
       if (!isNonEmptyString(item.colorId)) {
@@ -7192,15 +8327,17 @@ export const assertInvariants = ({ state }) => {
       continue;
     }
 
-    const font = state.fonts.items[textStyle.fontId];
-    if (!isPlainObject(font) || font.type === "folder") {
-      return invalidInvariant(
-        "textStyle.fontId must reference an existing non-folder font",
-        {
-          textStyleId,
-          fontId: textStyle.fontId,
-        },
-      );
+    for (const fontId of toIdArray(textStyle.fontId)) {
+      const font = state.fonts.items[fontId];
+      if (!isPlainObject(font) || font.type === "folder") {
+        return invalidInvariant(
+          "textStyle.fontId must reference an existing non-folder font",
+          {
+            textStyleId,
+            fontId,
+          },
+        );
+      }
     }
 
     const color = state.colors.items[textStyle.colorId];
@@ -8689,6 +9826,27 @@ const validateRequiredUniqueIdArray = ({ value, path, errorFactory }) => {
   }
 };
 
+const validateRequiredStringOrUniqueIdArray = ({
+  value,
+  path,
+  errorFactory,
+}) => {
+  if (isNonEmptyString(value)) {
+    return VALID_RESULT;
+  }
+
+  if (!Array.isArray(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be a non-empty string or a non-empty array of strings`,
+    );
+  }
+
+  return validateRequiredUniqueIdArray({ value, path, errorFactory });
+};
+
+const toIdArray = (value) => (Array.isArray(value) ? value : [value]);
+
 const validateOptionalUniqueIdArray = ({
   value,
   path,
@@ -9978,7 +11136,15 @@ const validateFontCreateData = ({ data, errorFactory }) => {
       allowedKeys:
         data.type === "folder"
           ? ["type", "name", "description"]
-          : ["type", "name", "description", "tagIds", "fileId", "fontFamily"],
+          : [
+              "type",
+              "name",
+              "description",
+              "tagIds",
+              "fileId",
+              "fontFamily",
+              ...FONT_WEIGHT_KEYS,
+            ],
       path: "payload.data",
       errorFactory,
     });
@@ -10026,6 +11192,17 @@ const validateFontCreateData = ({ data, errorFactory }) => {
         "payload.data.fontFamily must be a non-empty string",
       );
     }
+
+    {
+      const result = validateFontWeightFields({
+        value: data,
+        path: "payload.data",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
   }
 };
 
@@ -10033,7 +11210,14 @@ const validateFontUpdateData = ({ data, errorFactory }) => {
   {
     const result = validateAllowedKeys({
       value: data,
-      allowedKeys: ["name", "description", "tagIds", "fileId", "fontFamily"],
+      allowedKeys: [
+        "name",
+        "description",
+        "tagIds",
+        "fileId",
+        "fontFamily",
+        ...FONT_WEIGHT_KEYS,
+      ],
       path: "payload.data",
       errorFactory,
     });
@@ -10087,6 +11271,17 @@ const validateFontUpdateData = ({ data, errorFactory }) => {
       "payload.data.fontFamily must be a non-empty string when provided",
     );
   }
+
+  {
+    const result = validateFontWeightFields({
+      value: data,
+      path: "payload.data",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
 };
 
 const validateFileCreateData = ({ data, errorFactory }) => {
@@ -10958,6 +12153,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
               "value",
               "isEnum",
               "enumValues",
+              "computed",
             ],
       path: "payload.data",
       errorFactory,
@@ -10985,7 +12181,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     if (!VARIABLE_TYPE_KEYS.includes(data.variableType)) {
       return invalidFromErrorFactory(
         errorFactory,
-        "payload.data.variableType must be 'string', 'number', or 'boolean'",
+        "payload.data.variableType must be 'string', 'number', 'boolean', or 'object'",
       );
     }
 
@@ -11012,7 +12208,14 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
       }
     }
 
-    if (!VARIABLE_SCOPE_KEYS.includes(data.scope)) {
+    if (data.computed !== undefined) {
+      if (data.scope !== undefined) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          "payload.data.scope must be omitted for computed variables",
+        );
+      }
+    } else if (!VARIABLE_SCOPE_KEYS.includes(data.scope)) {
       return invalidFromErrorFactory(
         errorFactory,
         "payload.data.scope must be 'context', 'device', or 'account'",
@@ -11020,21 +12223,10 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     }
 
     {
-      const result = validateVariableTypedValue({
-        value: data.default,
-        variableType: data.variableType,
-        path: "payload.data.default",
-        errorFactory,
-      });
-      if (result?.valid === false) {
-        return result;
-      }
-    }
-    {
-      const result = validateVariableTypedValue({
-        value: data.value,
+      const result = validateVariableStoredOrComputedData({
+        data,
         variableType: data.variableType,
-        path: "payload.data.value",
+        path: "payload.data",
         errorFactory,
       });
       if (result?.valid === false) {
@@ -11057,6 +12249,7 @@ const validateVariableUpdateData = ({ data, errorFactory }) => {
         "value",
         "isEnum",
         "enumValues",
+        "computed",
       ],
       path: "payload.data",
       errorFactory,
@@ -11105,6 +12298,15 @@ const validateVariableUpdateData = ({ data, errorFactory }) => {
     }
   }
 
+  if (data.computed !== undefined) {
+    if (!isPlainObject(data.computed)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.computed must be an object when provided",
+      );
+    }
+  }
+
   if (data.scope !== undefined && !VARIABLE_SCOPE_KEYS.includes(data.scope)) {
     return invalidFromErrorFactory(
       errorFactory,
@@ -11283,7 +12485,18 @@ const validateTextStyleUpdateData = ({ data, errorFactory }) => {
     }
   }
 
-  for (const key of ["fontId", "colorId", "strokeColorId"]) {
+  if (data.fontId !== undefined) {
+    const result = validateRequiredStringOrUniqueIdArray({
+      value: data.fontId,
+      path: "payload.data.fontId",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  for (const key of ["colorId", "strokeColorId"]) {
     if (data[key] !== undefined && !isNonEmptyString(data[key])) {
       return invalidFromErrorFactory(
         errorFactory,
@@ -12915,6 +14128,7 @@ const createFolderedCollectionCommandDefinitions = ({
   validateDeleteState = () => {},
   afterDelete = () => {},
   includeUpdate = true,
+  reservedItemIds = [],
 }) => {
   const existingMessage = `payload.${idField} must reference an existing ${itemLabel}`;
   const duplicateMessage = `payload.${idField} must not already exist`;
@@ -12955,6 +14169,12 @@ const createFolderedCollectionCommandDefinitions = ({
           );
         }
 
+        if (reservedItemIds.includes(payload[idField])) {
+          return invalidPayload(
+            `payload.${idField} must not use reserved id '${payload[idField]}'`,
+          );
+        }
+
         if (
           payload.parentId !== undefined &&
           payload.parentId !== null &&
@@ -17421,6 +18641,11 @@ const COMMAND_DEFINITIONS = [
         });
         nextFont.fileId = payload.data.fileId;
         nextFont.fontFamily = payload.data.fontFamily;
+        for (const key of FONT_WEIGHT_KEYS) {
+          if (payload.data[key] !== undefined) {
+            nextFont[key] = payload.data[key];
+          }
+        }
       }
 
       state.fonts.items[payload.fontId] = nextFont;
@@ -17481,7 +18706,8 @@ const COMMAND_DEFINITIONS = [
         currentFont.type === "folder" &&
         (payload.data.tagIds !== undefined ||
           payload.data.fileId !== undefined ||
-          payload.data.fontFamily !== undefined)
+          payload.data.fontFamily !== undefined ||
+          FONT_WEIGHT_KEYS.some((key) => payload.data[key] !== undefined))
       ) {
         return invalidPrecondition(
           "folder font items cannot update font fields",
@@ -18385,6 +19611,7 @@ const COMMAND_DEFINITIONS = [
     itemLabel: "variable item",
     createDataValidator: validateVariableCreateData,
     updateDataValidator: validateVariableUpdateData,
+    reservedItemIds: ["__proto__"],
     createItem: ({ payload }) => {
       const data = structuredClone(payload.data);
       if (!Array.isArray(data.tagIds) || data.tagIds.length === 0) {
@@ -18409,7 +19636,7 @@ const COMMAND_DEFINITIONS = [
         return;
       }
 
-      return validateTagIdsAgainstScope({
+      const tagResult = validateTagIdsAgainstScope({
         state,
         tagIds: payload.data.tagIds,
         scopeKey: "variables",
@@ -18418,6 +19645,25 @@ const COMMAND_DEFINITIONS = [
           variableId: payload.variableId,
         },
       });
+      if (!tagResult.valid) {
+        return tagResult;
+      }
+
+      if (!Object.hasOwn(payload.data, "computed")) {
+        return VALID_RESULT;
+      }
+
+      return validateComputedVariableGraph({
+        items: {
+          ...state.variables.items,
+          [payload.variableId]: {
+            id: payload.variableId,
+            ...payload.data,
+          },
+        },
+        path: "state.variables.items",
+        errorFactory: createPreconditionValidationError,
+      });
     },
     validateUpdateState: ({ state, payload, currentItem }) => {
       if (
@@ -18441,6 +19687,36 @@ const COMMAND_DEFINITIONS = [
         );
       }
 
+      const currentItemIsComputed = Object.hasOwn(currentItem, "computed");
+      if (
+        currentItemIsComputed &&
+        ["scope", "default", "value", "isEnum", "enumValues"].some((key) =>
+          Object.hasOwn(payload.data, key),
+        )
+      ) {
+        return invalidPrecondition(
+          "computed variables cannot update scope, stored value, or enum fields",
+        );
+      }
+
+      if (!currentItemIsComputed && Object.hasOwn(payload.data, "computed")) {
+        return invalidPrecondition(
+          "stored variables cannot be converted to computed variables",
+        );
+      }
+
+      if (currentItemIsComputed && Object.hasOwn(payload.data, "computed")) {
+        const result = validateVariableComputedConfig({
+          computed: payload.data.computed,
+          variableType: currentItem.variableType,
+          path: "payload.data.computed",
+          errorFactory: createPreconditionValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
       if (currentItem.type !== "folder") {
         {
           const result = validateTagIdsAgainstScope({
@@ -18485,6 +19761,49 @@ const COMMAND_DEFINITIONS = [
           }
         }
       }
+
+      if (currentItemIsComputed && Object.hasOwn(payload.data, "computed")) {
+        return validateComputedVariableGraph({
+          items: {
+            ...state.variables.items,
+            [payload.variableId]: applyVariableUpdate({
+              currentItem,
+              data: payload.data,
+            }),
+          },
+          path: "state.variables.items",
+          errorFactory: createPreconditionValidationError,
+        });
+      }
+
+      return VALID_RESULT;
+    },
+    validateDeleteState: ({ state, payload }) => {
+      const deletedIds = new Set();
+      for (const variableId of payload.variableIds) {
+        const node = findTreeNode({
+          nodes: state.variables.tree,
+          nodeId: variableId,
+        });
+        if (!node) {
+          deletedIds.add(variableId);
+          continue;
+        }
+        for (const descendantId of collectTreeDescendantIds({ node })) {
+          deletedIds.add(descendantId);
+        }
+      }
+
+      const remainingItems = Object.fromEntries(
+        Object.entries(state.variables.items).filter(
+          ([variableId]) => !deletedIds.has(variableId),
+        ),
+      );
+      return validateComputedVariableGraph({
+        items: remainingItems,
+        path: "state.variables.items",
+        errorFactory: createPreconditionValidationError,
+      });
     },
   }),
   ...createFolderedCollectionCommandDefinitions({
@@ -18531,16 +19850,24 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      for (const field of ["fontId", "colorId", "strokeColorId"]) {
+      for (const fontId of toIdArray(data.fontId)) {
+        const item = state.fonts.items[fontId];
+        if (!isPlainObject(item) || item.type === "folder") {
+          return invalidPrecondition(
+            "payload.data.fontId must reference an existing non-folder font",
+          );
+        }
+      }
+
+      for (const field of ["colorId", "strokeColorId"]) {
         if (data[field] === undefined) {
           continue;
         }
 
-        const collectionKey = field === "fontId" ? "fonts" : "colors";
-        const item = state[collectionKey].items[data[field]];
+        const item = state.colors.items[data[field]];
         if (!isPlainObject(item) || item.type === "folder") {
           return invalidPrecondition(
-            `payload.data.${field} must reference an existing non-folder ${collectionKey.slice(0, -1)}`,
+            `payload.data.${field} must reference an existing non-folder color`,
           );
         }
       }
@@ -18583,16 +19910,26 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      for (const field of ["fontId", "colorId", "strokeColorId"]) {
+      if (payload.data.fontId !== undefined) {
+        for (const fontId of toIdArray(payload.data.fontId)) {
+          const item = state.fonts.items[fontId];
+          if (!isPlainObject(item) || item.type === "folder") {
+            return invalidPrecondition(
+              "payload.data.fontId must reference an existing non-folder font",
+            );
+          }
+        }
+      }
+
+      for (const field of ["colorId", "strokeColorId"]) {
         if (payload.data[field] === undefined) {
           continue;
         }
 
-        const collectionKey = field === "fontId" ? "fonts" : "colors";
-        const item = state[collectionKey].items[payload.data[field]];
+        const item = state.colors.items[payload.data[field]];
         if (!isPlainObject(item) || item.type === "folder") {
           return invalidPrecondition(
-            `payload.data.${field} must reference an existing non-folder ${collectionKey.slice(0, -1)}`,
+            `payload.data.${field} must reference an existing non-folder color`,
           );
         }
       }