@player-tools/json-language-service 0.13.0-next.4 → 0.13.0-next.5

package/dist/cjs/index.cjs

@@ -58,6 +58,7 @@ __export(src_exports, {
   applyTemplateProperty: () => applyTemplateProperty,
   applyValueRefs: () => applyValueRefs,
   containsRange: () => containsRange,
+  findErrorNode: () => findErrorNode,
   formatLikeNode: () => formatLikeNode,
   getContentNode: () => getContentNode,
   getLSLocationOfNode: () => getLSLocationOfNode,
@@ -89,7 +90,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_jsonc_parser4 = require("jsonc-parser");
 var import_tapable_ts = require("tapable-ts");
-var import_vscode_languageserver_types11 = require("vscode-languageserver-types");
+var import_vscode_languageserver_types12 = require("vscode-languageserver-types");
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/asset-wrapper-array-plugin.ts
 var import_vscode_languageserver_types4 = require("vscode-languageserver-types");
@@ -760,6 +761,19 @@ function mapFlowStateToType(flowType) {
   }
   return flowXLR;
 }
+var findErrorNode = (rootNode, nodeToFind) => {
+  const children = [rootNode];
+  while (children.length > 0) {
+    const child = children.pop();
+    if (child.jsonNode === nodeToFind) {
+      return child;
+    }
+    if (child.children) {
+      children.push(...child.children);
+    }
+  }
+  return rootNode;
+};
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/asset-wrapper-array-plugin.ts
 var isInView = (node) => {
@@ -1007,19 +1021,6 @@ var import_vscode_languageserver_types6 = require("vscode-languageserver-types")
 function isError(issue) {
   return issue.severity === import_vscode_languageserver_types6.DiagnosticSeverity.Error;
 }
-var findErrorNode = (rootNode, nodeToFind) => {
-  const children = [rootNode];
-  while (children.length > 0) {
-    const child = children.pop();
-    if (child.jsonNode === nodeToFind) {
-      return child;
-    }
-    if (child.children) {
-      children.push(...child.children);
-    }
-  }
-  return rootNode;
-};
 var translateSeverity = (severity) => {
   return severity;
 };
@@ -1271,8 +1272,409 @@ var XLRPlugin = class {
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/duplicate-id-plugin.ts
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/schema-validation-plugin.ts
 var import_vscode_languageserver_types7 = require("vscode-languageserver-types");
+var import_xlr_utils = require("@player-tools/xlr-utils");
+function formatErrorMessage(message) {
+  return `Schema Validation Error: ${message}`;
+}
+function makeValidationRefObject(baseObject, validationFunction) {
+  return {
+    ...baseObject,
+    properties: {
+      ...baseObject.properties,
+      ...validationFunction.properties
+    },
+    additionalProperties: false
+  };
+}
+function validateSchemaValidations(validationNode, sdk, validationContext) {
+  const claimedValidator = getProperty(validationNode, "type");
+  if (!claimedValidator) {
+    validationContext.addViolation({
+      node: validationNode,
+      message: formatErrorMessage('Validation object missing "type" property'),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  } else if (claimedValidator.valueNode?.type !== "string") {
+    validationContext.addViolation({
+      node: claimedValidator.valueNode ?? validationNode,
+      message: formatErrorMessage("Validation type must be a string"),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  } else {
+    const validationXLR = sdk.getType(claimedValidator.valueNode.value, {
+      getRawType: true
+    });
+    if (!validationXLR) {
+      validationContext.addViolation({
+        node: validationNode,
+        message: formatErrorMessage(
+          `Validation Function ${claimedValidator} is not a registered validator`
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+    } else {
+      const valRef = sdk.getType("Validation.Reference", {
+        getRawType: true
+      });
+      if (valRef) {
+        let validationIssues;
+        const validatorFunctionProps = validationXLR.genericArguments?.[0];
+        if (!validatorFunctionProps || (0, import_xlr_utils.isObjectType)(validatorFunctionProps)) {
+          validationIssues = sdk.validateByType(
+            makeValidationRefObject(
+              valRef,
+              validatorFunctionProps ?? {}
+            ),
+            validationNode.jsonNode
+          );
+          validationIssues.forEach((issue) => {
+            validationContext.addViolation({
+              node: validationNode,
+              message: formatErrorMessage(issue.message),
+              severity: translateSeverity(issue.severity)
+            });
+          });
+        } else {
+          const validationResults = validatorFunctionProps.or.map((node) => {
+            if ((0, import_xlr_utils.isObjectType)(node)) {
+              return sdk.validateByType(
+                makeValidationRefObject(valRef, node),
+                validationNode.jsonNode
+              );
+            } else {
+              validationIssues.forEach((issue) => {
+                validationContext.addViolation({
+                  node: validationNode,
+                  message: formatErrorMessage(
+                    `Internal Error - Validation function ${validationXLR.name} type argument is not an object`
+                  ),
+                  severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+                });
+              });
+              return null;
+            }
+          }).filter((o) => o !== null && Array.isArray(o) && o.length === 0);
+          if (validationResults.length !== 1) {
+            validationContext.addViolation({
+              node: validationNode,
+              message: formatErrorMessage(
+                `Validation function invalid function parameters for type ${validationXLR.name}`
+              ),
+              severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+            });
+          }
+        }
+      } else {
+        validationContext.addViolation({
+          node: validationNode,
+          message: formatErrorMessage(
+            "Validation.Reference from @player-ui/types is not loaded into SDK"
+          ),
+          severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+        });
+      }
+    }
+  }
+}
+function validateSchemaFormat(formatNode, sdk, validationContext) {
+  const claimedFormatter = getProperty(formatNode, "type");
+  if (!claimedFormatter) {
+    validationContext.addViolation({
+      node: formatNode,
+      message: formatErrorMessage('Format object missing "type" property'),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  } else if (claimedFormatter.valueNode?.type !== "string") {
+    validationContext.addViolation({
+      node: claimedFormatter.valueNode ?? claimedFormatter,
+      message: formatErrorMessage("Format type must be a string"),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  } else {
+    const formatterXLR = sdk.getType(claimedFormatter.valueNode.value, {
+      getRawType: true
+    });
+    if (!formatterXLR) {
+      validationContext.addViolation({
+        node: formatNode,
+        message: formatErrorMessage(
+          `Formatter ${claimedFormatter} is not a registered formatter`
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+    } else if (formatterXLR.genericArguments && formatterXLR.genericArguments.length === 3) {
+      const otherArgsXLR = formatterXLR.genericArguments[2];
+      const validationIssues = sdk.validateByType(
+        {
+          ...otherArgsXLR,
+          properties: {
+            ...otherArgsXLR.properties,
+            type: {
+              required: true,
+              node: {
+                type: "string",
+                const: claimedFormatter.valueNode.value
+              }
+            }
+          }
+        },
+        formatNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        validationContext.addViolation({
+          node: formatNode,
+          message: formatErrorMessage(issue.message),
+          severity: translateSeverity(issue.severity)
+        });
+      });
+    }
+  }
+}
+function getSchemaTypeNames(schemaObj) {
+  const names = /* @__PURE__ */ new Set();
+  for (const prop of schemaObj.properties) {
+    const key = prop.keyNode?.value;
+    if (typeof key === "string") {
+      names.add(key);
+    }
+  }
+  return names;
+}
+function validateDataTypeStructure(dataTypeNode, claimedDataType, sdk, validationContext) {
+  const validationProp = getProperty(dataTypeNode, "validation");
+  if (validationProp?.valueNode && validationProp.valueNode.type !== "array") {
+    validationContext.addViolation({
+      node: validationProp.valueNode,
+      message: formatErrorMessage(
+        'Schema.DataType "validation" must be an array.'
+      ),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  } else if (validationProp?.valueNode) {
+    validationProp.valueNode.children?.forEach((valRef) => {
+      if (valRef && valRef.type === "object") {
+        validateSchemaValidations(valRef, sdk, validationContext);
+      } else {
+        validationContext.addViolation({
+          node: validationProp.valueNode ?? dataTypeNode,
+          message: formatErrorMessage(
+            'Schema.DataType "validation" must be an object.'
+          ),
+          severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+        });
+      }
+    });
+  }
+  const formatProp = getProperty(dataTypeNode, "format");
+  if (formatProp?.valueNode?.type === "object") {
+    validateSchemaFormat(formatProp.valueNode, sdk, validationContext);
+  } else {
+    if (formatProp) {
+      validationContext.addViolation({
+        node: formatProp?.valueNode ?? dataTypeNode,
+        message: formatErrorMessage(
+          'Schema.DataType "format" must be an object.'
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+    }
+  }
+  const defaultNode = claimedDataType.properties?.["default"]?.node;
+  const defaultProp = getProperty(dataTypeNode, "default");
+  if (defaultNode && defaultProp?.valueNode) {
+    if ((0, import_xlr_utils.isPrimitiveTypeNode)(defaultNode)) {
+      if (defaultProp.valueNode.type !== defaultNode.type) {
+        validationContext.addViolation({
+          node: defaultProp.valueNode,
+          message: formatErrorMessage(
+            `Default value doesn't match the expected type of ${defaultNode.type} for type ${claimedDataType.name}`
+          ),
+          severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+        });
+      }
+    } else if (defaultNode.type === "or") {
+      if (!defaultNode.or.some((n) => n.type === defaultProp.valueNode?.type)) {
+        validationContext.addViolation({
+          node: defaultProp.valueNode,
+          message: formatErrorMessage(
+            `Default value doesn't match any of the expected types ${defaultNode.or.map((t) => t.type).join(", ")} for type ${claimedDataType.name}`
+          ),
+          severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+        });
+      }
+    } else {
+      validationContext.addViolation({
+        node: defaultProp.valueNode,
+        message: formatErrorMessage(
+          `Unknown default node type ${defaultNode.type}`
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+    }
+  }
+  const isArrayProp = getProperty(dataTypeNode, "isArray");
+  const isRecordProp = getProperty(dataTypeNode, "isRecord");
+  if (isArrayProp?.valueNode && isArrayProp.valueNode.type !== "boolean") {
+    validationContext.addViolation({
+      node: isArrayProp.valueNode,
+      message: formatErrorMessage(
+        'Schema.DataType "isArray" must be a boolean.'
+      ),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  }
+  if (isRecordProp?.valueNode && isRecordProp.valueNode.type !== "boolean") {
+    validationContext.addViolation({
+      node: isRecordProp.valueNode,
+      message: formatErrorMessage(
+        'Schema.DataType "isRecord" must be a boolean.'
+      ),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  }
+  if (isArrayProp?.valueNode && isRecordProp?.valueNode && isArrayProp.valueNode.value === true && isRecordProp.valueNode.value === true) {
+    validationContext.addViolation({
+      node: dataTypeNode,
+      message: formatErrorMessage(
+        'Schema.DataType cannot have both "isArray" and "isRecord" true.'
+      ),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  }
+}
+function validateSchemaNode(node, schemaTypeNames, sdk, validationContext) {
+  for (const prop of node.properties) {
+    const valueNode = prop.valueNode;
+    if (!(valueNode && valueNode.type === "object")) {
+      if (valueNode) {
+        validationContext.addViolation({
+          node: valueNode,
+          message: formatErrorMessage(
+            `Schema property "${prop.keyNode.value}" must be an object (Schema.DataType) with a "type" field.`
+          ),
+          severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+        });
+      }
+      continue;
+    }
+    const dataTypeNode = valueNode;
+    const typeProp = getProperty(dataTypeNode, "type");
+    if (!typeProp) {
+      validationContext.addViolation({
+        node: valueNode,
+        message: formatErrorMessage(
+          'Schema.DataType must have a "type" property (reference to schema or XLR type).'
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+      continue;
+    }
+    const typeValueNode = typeProp.valueNode;
+    if (!typeValueNode || typeValueNode.type !== "string") {
+      validationContext.addViolation({
+        node: typeValueNode ?? typeProp,
+        message: formatErrorMessage(
+          'Schema "type" must be a string (schema type name or XLR type name).'
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+      continue;
+    }
+    const typeName = typeValueNode.value;
+    const isSchemaType = schemaTypeNames.has(typeName);
+    const XLRType = sdk.getType(typeName, { getRawType: true });
+    if (!isSchemaType && !XLRType) {
+      validationContext.addViolation({
+        node: typeValueNode,
+        message: formatErrorMessage(
+          `Unknown schema type "${typeName}". Type must be a schema type (key in this schema) or an XLR type loaded in the SDK.`
+        ),
+        severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+      });
+    } else if (XLRType) {
+      validateDataTypeStructure(
+        dataTypeNode,
+        XLRType,
+        sdk,
+        validationContext
+      );
+    }
+  }
+}
+function validateFlowSchema(contentNode, sdk, validationContext) {
+  const schemaProp = getProperty(contentNode, "schema");
+  if (!schemaProp?.valueNode) {
+    return;
+  }
+  const schemaValue = schemaProp.valueNode;
+  if (schemaValue.type !== "object") {
+    validationContext.addViolation({
+      node: schemaValue,
+      message: formatErrorMessage(
+        'Flow "schema" must be an object with at least a "ROOT" key.'
+      ),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+    return;
+  }
+  const schemaObj = schemaValue;
+  const hasRoot = schemaObj.properties.some((p) => p.keyNode.value === "ROOT");
+  if (!hasRoot) {
+    validationContext.addViolation({
+      node: schemaValue,
+      message: formatErrorMessage('Schema must have a "ROOT" key.'),
+      severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+    });
+  }
+  const schemaTypeNames = getSchemaTypeNames(schemaObj);
+  for (const prop of schemaObj.properties) {
+    const nodeValue = prop.valueNode;
+    if (!nodeValue || nodeValue.type !== "object") {
+      if (nodeValue) {
+        validationContext.addViolation({
+          node: nodeValue,
+          message: formatErrorMessage(
+            `Schema node "${prop.keyNode.value}" must be an object.`
+          ),
+          severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error
+        });
+      }
+      continue;
+    }
+    validateSchemaNode(
+      nodeValue,
+      schemaTypeNames,
+      sdk,
+      validationContext
+    );
+  }
+}
+var SchemaValidationPlugin = class {
+  name = "schema-validation";
+  /** Resolved when CommonTypes have been loaded into the XLR SDK (once per plugin apply) */
+  commonTypesLoaded = null;
+  apply(service) {
+    service.hooks.validate.tap(this.name, async (_ctx, validationContext) => {
+      await this.commonTypesLoaded;
+      validationContext.useASTVisitor(
+        this.createValidationVisitor(service, validationContext)
+      );
+    });
+  }
+  createValidationVisitor(service, validationContext) {
+    const sdk = service.XLRService.XLRSDK;
+    return {
+      ContentNode: (contentNode) => {
+        validateFlowSchema(contentNode, sdk, validationContext);
+      }
+    };
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/duplicate-id-plugin.ts
+var import_vscode_languageserver_types8 = require("vscode-languageserver-types");
 var checkParentTemplate = (node, depth = 0) => {
   if (node.parent) {
     if (isPropertyNode(node.parent) && node.parent.keyNode.value === "template") {
@@ -1303,7 +1705,7 @@ var createViolation = (node) => {
   }
   return {
     node: valueNode,
-    severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error,
+    severity: import_vscode_languageserver_types8.DiagnosticSeverity.Error,
     message: `The id "${node.id?.valueNode?.value}" is already in use in this view.`,
     fix: () => {
       return {
@@ -1345,7 +1747,7 @@ var createValidationVisitor2 = (ctx) => {
         if (missingIndexSegments.length !== 0) {
           ctx.addViolation({
             node: assetNode,
-            severity: import_vscode_languageserver_types7.DiagnosticSeverity.Error,
+            severity: import_vscode_languageserver_types8.DiagnosticSeverity.Error,
             message: `The id for this templated elements is missing the following index segments: ${missingIndexSegments.join(
               ", "
             )}`
@@ -1380,7 +1782,7 @@ var DuplicateIDPlugin = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/missing-asset-wrapper-plugin.ts
-var import_vscode_languageserver_types8 = require("vscode-languageserver-types");
+var import_vscode_languageserver_types9 = require("vscode-languageserver-types");
 var getObjectTarget = (node) => {
   if (isObjectNode(node)) {
     return node;
@@ -1416,7 +1818,7 @@ var MissingAssetWrapperPlugin = class {
             addFixableViolation(d, {
               node: originalNode,
               message: d.message,
-              severity: d.severity ?? import_vscode_languageserver_types8.DiagnosticSeverity.Error,
+              severity: d.severity ?? import_vscode_languageserver_types9.DiagnosticSeverity.Error,
               fix: () => ({
                 name: `Wrap in "asset"`,
                 edit: {
@@ -1440,7 +1842,7 @@ var MissingAssetWrapperPlugin = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/nav-state-plugin.ts
-var import_vscode_languageserver_types9 = require("vscode-languageserver-types");
+var import_vscode_languageserver_types10 = require("vscode-languageserver-types");
 var createValidationVisitor3 = (ctx) => {
   const validTransitions = /* @__PURE__ */ new Map();
   return {
@@ -1467,7 +1869,7 @@ var createValidationVisitor3 = (ctx) => {
           if (!validTransitions.get(flowNodeId)?.has(transitionObjects.valueNode.value)) {
             ctx.addViolation({
               node: transitionObjects.valueNode,
-              severity: import_vscode_languageserver_types9.DiagnosticSeverity.Error,
+              severity: import_vscode_languageserver_types10.DiagnosticSeverity.Error,
               message: `Node "${transitionObjects.valueNode.value}" not found`
             });
           }
@@ -1501,7 +1903,7 @@ var NavStatePlugin = class {
         const flowNode = getFlowNode(ctx.node);
         flowNode?.states.forEach((p) => {
           completionCtx.addCompletionItem({
-            kind: import_vscode_languageserver_types9.CompletionItemKind.Value,
+            kind: import_vscode_languageserver_types10.CompletionItemKind.Value,
             label: p.keyNode.value
           });
         });
@@ -1526,7 +1928,7 @@ var NavStatePlugin = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/view-node-plugin.ts
-var import_vscode_languageserver_types10 = require("vscode-languageserver-types");
+var import_vscode_languageserver_types11 = require("vscode-languageserver-types");
 var createValidationVisitor4 = (ctx, viewInfo) => {
   return {
     FlowStateNode: (flowState) => {
@@ -1542,7 +1944,7 @@ var createValidationVisitor4 = (ctx, viewInfo) => {
         ctx.addViolation({
           node: refNode.valueNode,
           message: `View with id: ${refID} does not exist.`,
-          severity: import_vscode_languageserver_types10.DiagnosticSeverity.Error
+          severity: import_vscode_languageserver_types11.DiagnosticSeverity.Error
         });
       }
     },
@@ -1552,7 +1954,7 @@ var createValidationVisitor4 = (ctx, viewInfo) => {
           ctx.addViolation({
             node: viewNode.id.valueNode,
             message: `View is not reachable`,
-            severity: import_vscode_languageserver_types10.DiagnosticSeverity.Warning
+            severity: import_vscode_languageserver_types11.DiagnosticSeverity.Warning
           });
         }
       }
@@ -1614,14 +2016,14 @@ var ViewNodePlugin = class {
       if (ctx.node.type === "string" && isPropertyNode(ctx.node.parent) && isStateNode(ctx.node.parent.parent) && ctx.node.parent.keyNode.value === "ref") {
         Array.from(viewInfo?.views.keys() ?? []).forEach((vID) => {
           completionCtx.addCompletionItem({
-            kind: import_vscode_languageserver_types10.CompletionItemKind.Value,
+            kind: import_vscode_languageserver_types11.CompletionItemKind.Value,
             label: vID
           });
         });
       } else if (ctx.node.type === "string" && isPropertyNode(ctx.node.parent) && isViewNode(ctx.node.parent.parent) && ctx.node.parent.keyNode.value === "id") {
         Array.from(viewInfo?.nodes.keys() ?? []).forEach((vID) => {
           completionCtx.addCompletionItem({
-            kind: import_vscode_languageserver_types10.CompletionItemKind.Value,
+            kind: import_vscode_languageserver_types11.CompletionItemKind.Value,
             label: vID
           });
         });
@@ -1652,7 +2054,7 @@ var ViewNodePlugin = class {
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/xlr/transforms.ts
 var import_xlr_sdk = require("@player-tools/xlr-sdk");
-var import_xlr_utils = require("@player-tools/xlr-utils");
+var import_xlr_utils2 = require("@player-tools/xlr-utils");
 var applyCommonProps = (node, capability) => {
   return (0, import_xlr_sdk.simpleTransformGenerator)("object", ["Assets", "Views"], (xlrNode) => {
     if (!xlrNode.properties.applicability) {
@@ -1717,7 +2119,7 @@ var applyValueRefs = (node, capability) => {
             type: "ref",
             ref: "BindingRef"
           });
-        } else if ((0, import_xlr_utils.isPrimitiveTypeNode)(value.node)) {
+        } else if ((0, import_xlr_utils2.isPrimitiveTypeNode)(value.node)) {
           const newUnionType = {
             type: "or",
             description: value.node.description,
@@ -1785,6 +2187,7 @@ var PLUGINS = [
   new DuplicateIDPlugin(),
   new ViewNodePlugin(),
   new SchemaInfoPlugin(),
+  new SchemaValidationPlugin(),
   new AssetWrapperArrayPlugin(),
   new NavStatePlugin(),
   new MissingAssetWrapperPlugin(),
@@ -1802,6 +2205,7 @@ var TRANSFORM_FUNCTIONS = [
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/xlr/registry.ts
 var import_xlr_sdk2 = require("@player-tools/xlr-sdk");
+var SINGLE_INSTANCE_CAPABILITIES = ["DataTypes", "Formatters", "Validators"];
 var PlayerXLRRegistry = class extends import_xlr_sdk2.BasicXLRRegistry {
   /** Keeps the mapping of how a type is referenced by Player to the underlying XLR */
   registrationMap;
@@ -1832,7 +2236,7 @@ var PlayerXLRRegistry = class extends import_xlr_sdk2.BasicXLRRegistry {
       this.registrationMap.set(registeredName, type.name);
       registeredName = type.extends.genericArguments[0].const;
     }
-    if (this.registrationMap.has(registeredName)) {
+    if (this.registrationMap.has(registeredName) && !SINGLE_INSTANCE_CAPABILITIES.includes(capability)) {
       const current = this.registrationMap.get(registeredName);
       if (Array.isArray(current)) {
         current.push(registeredName);
@@ -2090,8 +2494,8 @@ var PlayerLanguageService = class {
     }
     return (0, import_jsonc_parser4.format)(document.getText(), formatRange, formattingOptions).map(
       (edit) => {
-        return import_vscode_languageserver_types11.TextEdit.replace(
-          import_vscode_languageserver_types11.Range.create(
+        return import_vscode_languageserver_types12.TextEdit.replace(
+          import_vscode_languageserver_types12.Range.create(
             document.positionAt(edit.offset),
             document.positionAt(edit.offset + edit.length)
           ),
@@ -2160,7 +2564,7 @@ var PlayerLanguageService = class {
   async getCompletionsAtPosition(document, position) {
     const ctxWithPos = await this.updateSourceWithPosition(document, position);
     if (!ctxWithPos) {
-      return import_vscode_languageserver_types11.CompletionList.create();
+      return import_vscode_languageserver_types12.CompletionList.create();
     }
     const completionItems = [];
     const completionContext = {
@@ -2169,7 +2573,7 @@ var PlayerLanguageService = class {
       }
     };
     await this.hooks.complete.call(ctxWithPos, completionContext);
-    return import_vscode_languageserver_types11.CompletionList.create(completionItems);
+    return import_vscode_languageserver_types12.CompletionList.create(completionItems);
   }
   async resolveCompletionItem(completionItem) {
     return completionItem;
@@ -2199,7 +2603,7 @@ var PlayerLanguageService = class {
       }
       actions.push({
         title: fixedAction.name,
-        kind: import_vscode_languageserver_types11.CodeActionKind.QuickFix,
+        kind: import_vscode_languageserver_types12.CodeActionKind.QuickFix,
         edit: {
           changes: {
             [document.uri]: [toTextEdit(document, fixedAction.edit)]
@@ -2283,6 +2687,7 @@ var PlayerLanguageService = class {
   applyTemplateProperty,
   applyValueRefs,
   containsRange,
+  findErrorNode,
   formatLikeNode,
   getContentNode,
   getLSLocationOfNode,