@player-lang/functional-dsl-generator 0.0.2-next.0

package/dist/index.legacy-esm.js

@@ -0,0 +1,2075 @@
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/generator.ts
+import { isGenericNamedType as isGenericNamedType2 } from "@xlr-lib/xlr-utils";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/utils.ts
+import {
+  isStringType,
+  isNumberType,
+  isBooleanType,
+  isObjectType,
+  isArrayType,
+  isRefType,
+  isOrType,
+  isAndType,
+  isRecordType,
+  isNamedType
+} from "@xlr-lib/xlr-utils";
+function isTupleType(node) {
+  return node.type === "tuple";
+}
+function isPrimitiveConst(node) {
+  return (isStringType(node) || isNumberType(node) || isBooleanType(node)) && "const" in node && node.const !== void 0;
+}
+function isAssetWrapperRef(node) {
+  return isRefType(node) && node.ref.startsWith("AssetWrapper");
+}
+function extendsAssetWrapper(node, typeRegistry, visited = /* @__PURE__ */ new Set()) {
+  if (isObjectType(node) && node.extends) {
+    if (node.extends.ref.startsWith("AssetWrapper")) return true;
+    return extendsAssetWrapper(node.extends, typeRegistry, visited);
+  }
+  if (isRefType(node)) {
+    const typeName = extractBaseName(node.ref);
+    if (visited.has(typeName)) return false;
+    visited.add(typeName);
+    const resolved = typeRegistry.get(typeName);
+    if (!resolved?.extends) return false;
+    if (resolved.extends.ref.startsWith("AssetWrapper")) return true;
+    return extendsAssetWrapper(resolved.extends, typeRegistry, visited);
+  }
+  return false;
+}
+function getAssetWrapperExtendsRef(node, typeRegistry, visited = /* @__PURE__ */ new Set()) {
+  if (isObjectType(node) && node.extends) {
+    if (node.extends.ref.startsWith("AssetWrapper")) return node.extends;
+    return getAssetWrapperExtendsRef(node.extends, typeRegistry, visited);
+  }
+  if (isRefType(node)) {
+    const typeName = extractBaseName(node.ref);
+    if (visited.has(typeName)) return void 0;
+    visited.add(typeName);
+    const resolved = typeRegistry.get(typeName);
+    if (!resolved?.extends) return void 0;
+    if (resolved.extends.ref.startsWith("AssetWrapper"))
+      return resolved.extends;
+    return getAssetWrapperExtendsRef(resolved.extends, typeRegistry, visited);
+  }
+  return void 0;
+}
+function getAssetWrapperExtendsRefByName(typeName, typeRegistry) {
+  return getAssetWrapperExtendsRef(
+    { type: "ref", ref: typeName },
+    typeRegistry
+  );
+}
+function isExpressionRef(node) {
+  return isRefType(node) && node.ref === "Expression";
+}
+function isBindingRef(node) {
+  return isRefType(node) && node.ref === "Binding";
+}
+function sanitizePropertyName(name) {
+  return name.replace(/^['"]|['"]$/g, "");
+}
+function toPascalCase(str) {
+  const sanitized = sanitizePropertyName(str);
+  return sanitized.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toFactoryName(typeName) {
+  const name = typeName.replace(/Asset$/, "");
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function toBuilderClassName(typeName) {
+  return `${typeName}Builder`;
+}
+function isComplexObjectType(obj) {
+  const props = Object.values(obj.properties);
+  const hasSlots = props.some((p) => isAssetWrapperRef(p.node));
+  if (hasSlots) return true;
+  if (props.length > 3) return true;
+  const hasNestedObjects = props.some(
+    (p) => isObjectType(p.node) && !isPrimitiveConst(p.node)
+  );
+  if (hasNestedObjects) return true;
+  return false;
+}
+function getAssetTypeFromExtends(obj) {
+  if (!obj.extends) return void 0;
+  const ref = obj.extends;
+  if (ref.genericArguments && ref.genericArguments.length > 0) {
+    const typeArg = ref.genericArguments[0];
+    if (isStringType(typeArg) && typeArg.const) {
+      return typeArg.const;
+    }
+  }
+  return void 0;
+}
+function getPropertiesInfo(obj) {
+  return Object.entries(obj.properties).map(([name, prop]) => {
+    const isSlot = isAssetWrapperRef(prop.node);
+    const isArray = isArrayType(prop.node);
+    const isArraySlot = isArray && isAssetWrapperRef(prop.node.elementType);
+    return {
+      name,
+      node: prop.node,
+      required: prop.required,
+      isSlot,
+      isArraySlot,
+      isArray
+    };
+  });
+}
+function containsArrayType(node) {
+  if (isArrayType(node)) {
+    return true;
+  }
+  if (isOrType(node)) {
+    return node.or.some(containsArrayType);
+  }
+  if (isAndType(node)) {
+    return node.and.some(containsArrayType);
+  }
+  return false;
+}
+function splitAtTopLevelCommas(str) {
+  const result = [];
+  let current = "";
+  let depth = 0;
+  for (const char of str) {
+    if (char === "<") {
+      depth++;
+      current += char;
+    } else if (char === ">") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    result.push(current.trim());
+  }
+  return result;
+}
+function extractGenericUsage(genericParams) {
+  if (!genericParams) {
+    return "";
+  }
+  const params = splitAtTopLevelCommas(genericParams).map((p) => p.trim().split(" ")[0]).join(", ");
+  return `<${params}>`;
+}
+var TYPESCRIPT_BUILTINS = /* @__PURE__ */ new Set([
+  // Primitive wrappers
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt",
+  // Collections
+  "Array",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "ReadonlyArray",
+  "ReadonlyMap",
+  "ReadonlySet",
+  // Object types
+  "Object",
+  "Function",
+  "Date",
+  "RegExp",
+  "Error",
+  "Promise",
+  "PromiseLike",
+  // Utility types
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ConstructorParameters",
+  "ReturnType",
+  "InstanceType",
+  "ThisParameterType",
+  "OmitThisParameter",
+  "ThisType",
+  "Awaited",
+  "Record",
+  // Iterable types
+  "Iterable",
+  "Iterator",
+  "IterableIterator",
+  "Generator",
+  "AsyncIterator",
+  "AsyncIterable",
+  "AsyncIterableIterator",
+  "AsyncGenerator",
+  "GeneratorFunction",
+  "AsyncGeneratorFunction",
+  // Array-like types
+  "ArrayLike",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "TypedArray",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Other built-ins
+  "JSON",
+  "Math",
+  "Console",
+  "Proxy",
+  "Reflect",
+  "WeakRef",
+  "FinalizationRegistry"
+]);
+var PLAYER_BUILTINS = /* @__PURE__ */ new Set([
+  "Asset",
+  "AssetWrapper",
+  "Binding",
+  "Expression"
+]);
+function isBuiltinType(typeName) {
+  return TYPESCRIPT_BUILTINS.has(typeName) || PLAYER_BUILTINS.has(typeName);
+}
+function extractBaseName(ref) {
+  const bracketIndex = ref.indexOf("<");
+  return bracketIndex === -1 ? ref : ref.substring(0, bracketIndex);
+}
+function parseNamespacedType(typeName) {
+  const dotIndex = typeName.indexOf(".");
+  if (dotIndex === -1) return null;
+  return {
+    namespace: typeName.substring(0, dotIndex),
+    member: typeName.substring(dotIndex + 1)
+  };
+}
+function findAssetWrapperPaths(node, typeRegistry) {
+  const context = {
+    typeRegistry,
+    visited: /* @__PURE__ */ new Set(),
+    currentPath: []
+  };
+  return findPathsRecursive(node, context);
+}
+function findPathsRecursive(node, context) {
+  const paths = [];
+  if (isObjectType(node)) {
+    if (isNamedType(node)) {
+      if (context.visited.has(node.name)) {
+        return [];
+      }
+      context.visited.add(node.name);
+    }
+    for (const [propName, prop] of Object.entries(node.properties)) {
+      const propPaths = findPathsForProperty(propName, prop.node, context);
+      paths.push(...propPaths);
+    }
+    if (isNamedType(node)) {
+      context.visited.delete(node.name);
+    }
+  }
+  return paths;
+}
+function recurseIntoExtendingType(targetNode, context, propName) {
+  const newContext = {
+    ...context,
+    currentPath: [...context.currentPath, propName]
+  };
+  if (isObjectType(targetNode)) {
+    return findPathsRecursive(targetNode, newContext);
+  }
+  if (isRefType(targetNode)) {
+    const typeName = extractBaseName(targetNode.ref);
+    const resolvedType = context.typeRegistry.get(typeName);
+    if (resolvedType && !context.visited.has(typeName)) {
+      context.visited.add(typeName);
+      const nestedPaths = findPathsRecursive(resolvedType, newContext);
+      context.visited.delete(typeName);
+      return nestedPaths;
+    }
+  }
+  return [];
+}
+function findPathsForProperty(propName, node, context) {
+  const paths = [];
+  if (isAssetWrapperRef(node)) {
+    paths.push([...context.currentPath, propName]);
+    return paths;
+  }
+  if (isArrayType(node) && isAssetWrapperRef(node.elementType)) {
+    paths.push([...context.currentPath, propName]);
+    return paths;
+  }
+  if (extendsAssetWrapper(node, context.typeRegistry, new Set(context.visited))) {
+    paths.push([...context.currentPath, propName]);
+    paths.push(...recurseIntoExtendingType(node, context, propName));
+    return paths;
+  }
+  if (isArrayType(node) && extendsAssetWrapper(
+    node.elementType,
+    context.typeRegistry,
+    new Set(context.visited)
+  )) {
+    paths.push([...context.currentPath, propName]);
+    paths.push(
+      ...recurseIntoExtendingType(node.elementType, context, propName)
+    );
+    return paths;
+  }
+  if (isArrayType(node)) {
+    paths.push(
+      ...recurseIntoExtendingType(node.elementType, context, propName)
+    );
+    return paths;
+  }
+  if (isRefType(node)) {
+    const typeName = extractBaseName(node.ref);
+    const resolvedType = context.typeRegistry.get(typeName);
+    if (resolvedType && !context.visited.has(typeName)) {
+      context.visited.add(typeName);
+      const newContext = {
+        ...context,
+        currentPath: [...context.currentPath, propName]
+      };
+      const nestedPaths = findPathsRecursive(resolvedType, newContext);
+      paths.push(...nestedPaths);
+      context.visited.delete(typeName);
+    }
+    return paths;
+  }
+  if (isObjectType(node)) {
+    const newContext = {
+      ...context,
+      currentPath: [...context.currentPath, propName]
+    };
+    const nestedPaths = findPathsRecursive(node, newContext);
+    paths.push(...nestedPaths);
+    return paths;
+  }
+  if (isOrType(node)) {
+    for (const variant of node.or) {
+      const variantPaths = findPathsForProperty(propName, variant, {
+        ...context,
+        currentPath: context.currentPath
+      });
+      for (const path3 of variantPaths) {
+        const pathStr = path3.join(".");
+        if (!paths.some((p) => p.join(".") === pathStr)) {
+          paths.push(path3);
+        }
+      }
+    }
+    return paths;
+  }
+  if (isAndType(node)) {
+    for (const part of node.and) {
+      const partPaths = findPathsForProperty(propName, part, {
+        ...context,
+        currentPath: context.currentPath
+      });
+      for (const path3 of partPaths) {
+        const pathStr = path3.join(".");
+        if (!paths.some((p) => p.join(".") === pathStr)) {
+          paths.push(path3);
+        }
+      }
+    }
+    return paths;
+  }
+  return paths;
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/type-collector.ts
+import { isGenericNamedType } from "@xlr-lib/xlr-utils";
+var TypeCollector = class {
+  typeTracker;
+  genericParamSymbols;
+  mainTypeName;
+  namespaceMemberMap;
+  typeRegistry;
+  constructor(typeTracker, genericParamSymbols, mainTypeName, namespaceMemberMap, typeRegistry) {
+    this.typeTracker = typeTracker;
+    this.genericParamSymbols = genericParamSymbols;
+    this.mainTypeName = mainTypeName;
+    this.namespaceMemberMap = namespaceMemberMap;
+    this.typeRegistry = typeRegistry;
+  }
+  /**
+   * Collect generic parameter symbols (e.g., T, U) from the type definition.
+   * These should not be imported as they are type parameters, not concrete types.
+   *
+   * Also handles the case where a non-generic type extends a generic base without
+   * passing type arguments. In that scenario, XLR copies properties from the base
+   * (including references to the base's generic params like `AnyAsset`) but does
+   * NOT propagate `genericTokens` to the child type. We scan the type registry for
+   * generic parameter symbols that should be excluded from imports.
+   */
+  collectGenericParamSymbols(namedType) {
+    if (isGenericNamedType(namedType)) {
+      for (const token of namedType.genericTokens) {
+        this.genericParamSymbols.add(token.symbol);
+      }
+    }
+    if (this.typeRegistry) {
+      for (const registeredType of this.typeRegistry.values()) {
+        if (isGenericNamedType(registeredType)) {
+          for (const token of registeredType.genericTokens) {
+            if (!this.typeRegistry.has(token.symbol)) {
+              this.genericParamSymbols.add(token.symbol);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Collect type references from generic parameter constraints and defaults.
+   * This ensures types used in generics like "T extends Foo = Bar<X>" have
+   * Foo, Bar, and X added to referencedTypes for import generation.
+   */
+  collectTypesFromGenericTokens(namedType) {
+    if (!isGenericNamedType(namedType)) {
+      return;
+    }
+    for (const token of namedType.genericTokens) {
+      if (token.constraints) {
+        this.collectTypeReferencesFromNode(token.constraints);
+      }
+      if (token.default) {
+        this.collectTypeReferencesFromNode(token.default);
+      }
+    }
+  }
+  /**
+   * Collect all referenced types from an object type for imports.
+   */
+  collectReferencedTypes(objType) {
+    for (const prop of Object.values(objType.properties)) {
+      this.collectReferencedTypesFromNode(prop.node);
+    }
+  }
+  /**
+   * Collect referenced types from a node type.
+   */
+  collectReferencedTypesFromNode(node) {
+    if (isObjectType(node)) {
+      if (isNamedType(node)) {
+        if (node.name !== this.mainTypeName && !isBuiltinType(node.name) && !this.genericParamSymbols.has(node.name)) {
+          this.typeTracker.trackReferencedType(node.name);
+        }
+      } else {
+        for (const prop of Object.values(node.properties)) {
+          this.collectReferencedTypesFromNode(prop.node);
+        }
+      }
+    } else if (isArrayType(node)) {
+      this.collectReferencedTypesFromNode(node.elementType);
+    } else if (isOrType(node)) {
+      for (const variant of node.or) {
+        this.collectReferencedTypesFromNode(variant);
+      }
+    } else if (isAndType(node)) {
+      for (const part of node.and) {
+        this.collectReferencedTypesFromNode(part);
+      }
+    } else if (isRefType(node)) {
+      const baseName = extractBaseName(node.ref);
+      const namespaced = parseNamespacedType(baseName);
+      if (namespaced) {
+        this.typeTracker.trackNamespaceImport(namespaced.namespace);
+        this.namespaceMemberMap.set(namespaced.member, baseName);
+      } else {
+        if (!isBuiltinType(baseName) && !this.genericParamSymbols.has(baseName)) {
+          this.typeTracker.trackReferencedType(baseName);
+        }
+      }
+      if (node.genericArguments) {
+        for (const arg of node.genericArguments) {
+          if (isRefType(arg)) {
+            const argName = extractBaseName(arg.ref);
+            if (this.isTypeParamOfRef(argName, node.ref)) {
+              continue;
+            }
+          }
+          this.collectReferencedTypesFromNode(arg);
+        }
+      }
+    }
+  }
+  /**
+   * Recursively collect type references from any NodeType.
+   * This handles refs, arrays, unions, intersections, and objects.
+   */
+  collectTypeReferencesFromNode(node) {
+    if (isRefType(node)) {
+      const baseName = extractBaseName(node.ref);
+      const namespaced = parseNamespacedType(baseName);
+      if (namespaced) {
+        this.typeTracker.trackNamespaceImport(namespaced.namespace);
+        this.namespaceMemberMap.set(namespaced.member, baseName);
+      } else if (!isBuiltinType(baseName) && !this.genericParamSymbols.has(baseName)) {
+        this.typeTracker.trackReferencedType(baseName);
+      }
+      if (node.genericArguments) {
+        for (const arg of node.genericArguments) {
+          if (isRefType(arg)) {
+            const argName = extractBaseName(arg.ref);
+            if (this.isTypeParamOfRef(argName, node.ref)) {
+              continue;
+            }
+          }
+          this.collectTypeReferencesFromNode(arg);
+        }
+      }
+    } else if (isArrayType(node)) {
+      this.collectTypeReferencesFromNode(node.elementType);
+    } else if (isOrType(node)) {
+      for (const variant of node.or) {
+        this.collectTypeReferencesFromNode(variant);
+      }
+    } else if (isAndType(node)) {
+      for (const part of node.and) {
+        this.collectTypeReferencesFromNode(part);
+      }
+    } else if (isObjectType(node)) {
+      if (isNamedType(node)) {
+        const importName = extractBaseName(node.name);
+        if (!this.genericParamSymbols.has(importName) && !isBuiltinType(importName)) {
+          this.typeTracker.trackReferencedType(importName);
+        }
+      }
+      for (const prop of Object.values(node.properties)) {
+        this.collectTypeReferencesFromNode(prop.node);
+      }
+    }
+  }
+  /**
+   * Check if a type name appears to be a generic type parameter of the referenced type.
+   * This detects cases like ref="Bar<AnyAsset>" where "AnyAsset" is Bar's type parameter,
+   * not a concrete type to import.
+   *
+   * @param argName - The name of the type argument being checked
+   * @param parentRef - The parent ref string that contains the generic usage
+   * @returns true if argName appears to be a type parameter in parentRef
+   */
+  isTypeParamOfRef(argName, parentRef) {
+    const genericMatch = parentRef.match(/<(.+)>/);
+    if (!genericMatch) {
+      return false;
+    }
+    const genericPart = genericMatch[1];
+    let depth = 0;
+    let current = "";
+    const params = [];
+    for (const char of genericPart) {
+      if (char === "<") {
+        depth++;
+        current += char;
+      } else if (char === ">") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        params.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      params.push(current.trim());
+    }
+    return params.some(
+      (param) => param === argName || param.startsWith(`${argName} `)
+    );
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/type-transformer.ts
+var TypeTransformer = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Determines if a type name should be tracked for import.
+   * A type should be tracked if it's not a generic parameter and not a builtin type.
+   * Note: PLAYER_BUILTINS (Asset, AssetWrapper, Binding, Expression) are filtered
+   * by isBuiltinType(), so no explicit Asset check is needed here.
+   */
+  shouldTrackTypeForImport(typeName) {
+    return !this.context.getGenericParamSymbols().has(typeName) && !isBuiltinType(typeName);
+  }
+  /**
+   * Transform an XLR type to a TypeScript type string.
+   * This is the core recursive transformation that adds TaggedTemplateValue support.
+   */
+  transformType(node, forParameter = false) {
+    if (isStringType(node)) {
+      if (isPrimitiveConst(node)) {
+        return `"${node.const}"`;
+      }
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if (isNumberType(node)) {
+      if (isPrimitiveConst(node)) {
+        return `${node.const}`;
+      }
+      return forParameter ? "number | TaggedTemplateValue<number>" : "number";
+    }
+    if (isBooleanType(node)) {
+      if (isPrimitiveConst(node)) {
+        return `${node.const}`;
+      }
+      return forParameter ? "boolean | TaggedTemplateValue<boolean>" : "boolean";
+    }
+    if (isRefType(node)) {
+      return this.transformRefType(node, forParameter);
+    }
+    if (isArrayType(node)) {
+      const elementType = this.transformType(node.elementType, forParameter);
+      return `Array<${elementType}>`;
+    }
+    if (isOrType(node)) {
+      const variants = node.or.map((v) => this.transformType(v, forParameter));
+      return variants.join(" | ");
+    }
+    if (isAndType(node)) {
+      const parts = node.and.map((p) => this.transformType(p, forParameter));
+      return parts.join(" & ");
+    }
+    if (isRecordType(node)) {
+      const keyType = this.transformType(node.keyType, false);
+      const valueType = this.transformType(node.valueType, forParameter);
+      return `Record<${keyType}, ${valueType}>`;
+    }
+    if (isObjectType(node)) {
+      if (isNamedType(node)) {
+        const typeName = this.resolveTypeName(node.name);
+        const inlineExtendsRef = node.extends?.ref.startsWith("AssetWrapper") ? node.extends : null;
+        const extendsRef = inlineExtendsRef ?? this.context.getAssetWrapperExtendsRef(node.name);
+        if (extendsRef) {
+          return this.transformAssetWrapperExtension(
+            typeName,
+            node.name,
+            extendsRef
+          );
+        }
+        return `${typeName} | FunctionalBuilder<${typeName}, BaseBuildContext> | FunctionalPartial<${typeName}, BaseBuildContext>`;
+      }
+      const inlineType = this.generateInlineObjectType(node, forParameter);
+      return `${inlineType} | FunctionalBuilder<${inlineType}, BaseBuildContext> | FunctionalPartial<${inlineType}, BaseBuildContext>`;
+    }
+    if (isTupleType(node)) {
+      const elements = node.elementTypes.map((member) => {
+        const elementType = this.transformType(member.type, forParameter);
+        return member.optional ? `${elementType}?` : elementType;
+      });
+      if (node.additionalItems) {
+        const restType = this.transformType(node.additionalItems, forParameter);
+        elements.push(`...${restType}[]`);
+      }
+      return `[${elements.join(", ")}]`;
+    }
+    if (node.type === "null") return "null";
+    if (node.type === "undefined") return "undefined";
+    if (node.type === "any") return "any";
+    if (node.type === "unknown") return "unknown";
+    if (node.type === "never") return "never";
+    if (node.type === "void") return "void";
+    return "unknown";
+  }
+  /**
+   * Transform a type for use in generic constraints and defaults.
+   * Unlike transformType(), this returns raw type names without FunctionalBuilder unions,
+   * since constraints define type bounds, not parameter types that accept builders.
+   *
+   * @param node - The type node to transform
+   * @returns The raw TypeScript type string
+   */
+  transformTypeForConstraint(node) {
+    if (isRefType(node)) {
+      const baseName = extractBaseName(node.ref);
+      const namespaced = parseNamespacedType(baseName);
+      if (namespaced) {
+        this.context.trackNamespaceImport(namespaced.namespace);
+        this.context.getNamespaceMemberMap().set(namespaced.member, baseName);
+      } else if (baseName === "Asset" || node.ref.startsWith("Asset<")) {
+        this.context.setNeedsAssetImport(true);
+      } else if (this.shouldTrackTypeForImport(baseName)) {
+        this.context.trackReferencedType(baseName);
+      }
+      const resolvedName = this.resolveTypeName(baseName);
+      if (node.genericArguments && node.genericArguments.length > 0) {
+        const args = node.genericArguments.map(
+          (a) => this.transformTypeForConstraint(a)
+        );
+        return `${resolvedName}<${args.join(", ")}>`;
+      }
+      if (node.ref.includes("<")) {
+        return this.resolveTypeName(extractBaseName(node.ref)) + node.ref.substring(node.ref.indexOf("<"));
+      }
+      return resolvedName;
+    }
+    if (isObjectType(node) && isNamedType(node)) {
+      if (node.name === "Asset") {
+        this.context.setNeedsAssetImport(true);
+      } else if (this.shouldTrackTypeForImport(node.name)) {
+        this.context.trackReferencedType(node.name);
+      }
+      return this.resolveTypeName(node.name);
+    }
+    if (isArrayType(node)) {
+      const elementType = this.transformTypeForConstraint(node.elementType);
+      return `Array<${elementType}>`;
+    }
+    if (isOrType(node)) {
+      const variants = node.or.map((v) => this.transformTypeForConstraint(v));
+      return variants.join(" | ");
+    }
+    if (isAndType(node)) {
+      const parts = node.and.map((p) => this.transformTypeForConstraint(p));
+      return parts.join(" & ");
+    }
+    if (isTupleType(node)) {
+      const elements = node.elementTypes.map((member) => {
+        const elementType = this.transformTypeForConstraint(member.type);
+        return member.optional ? `${elementType}?` : elementType;
+      });
+      if (node.additionalItems) {
+        const restType = this.transformTypeForConstraint(node.additionalItems);
+        elements.push(`...${restType}[]`);
+      }
+      return `[${elements.join(", ")}]`;
+    }
+    return this.transformType(node, false);
+  }
+  /**
+   * Transform a reference type to TypeScript.
+   */
+  transformRefType(node, forParameter) {
+    const ref = node.ref;
+    if (ref.startsWith("AssetWrapper")) {
+      this.context.setNeedsAssetImport(true);
+      let innerType = "Asset";
+      let isIntersectionType = false;
+      if (node.genericArguments && node.genericArguments.length > 0) {
+        const genericArg = node.genericArguments[0];
+        const argType = this.transformTypeForConstraint(genericArg);
+        innerType = this.context.getGenericParamSymbols().has(argType) ? "Asset" : argType;
+        isIntersectionType = isAndType(genericArg);
+      } else if (ref.includes("<")) {
+        const match = ref.match(/AssetWrapper<(.+)>/);
+        if (match) {
+          const extractedType = match[1].trim();
+          if (extractedType.includes(" & ")) {
+            isIntersectionType = true;
+            innerType = extractedType;
+            const parts = extractedType.split(" & ").map((p) => p.trim());
+            for (const part of parts) {
+              const partName = extractBaseName(part);
+              if (this.shouldTrackTypeForImport(partName)) {
+                this.context.trackReferencedType(partName);
+              }
+            }
+          } else {
+            const baseName2 = extractBaseName(extractedType);
+            innerType = this.context.getGenericParamSymbols().has(baseName2) ? "Asset" : baseName2;
+          }
+        }
+      }
+      if (!isIntersectionType && this.shouldTrackTypeForImport(innerType)) {
+        this.context.trackReferencedType(innerType);
+      }
+      return `${innerType} | FunctionalBuilder<${innerType}, BaseBuildContext>`;
+    }
+    if (ref === "Expression") {
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if (ref === "Binding") {
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if (ref === "Asset" || ref.startsWith("Asset<")) {
+      this.context.setNeedsAssetImport(true);
+      return "Asset";
+    }
+    {
+      const refBaseName = extractBaseName(ref);
+      const extendsRef = this.context.getAssetWrapperExtendsRef(refBaseName);
+      if (extendsRef) {
+        return this.transformAssetWrapperExtension(
+          this.resolveTypeName(refBaseName),
+          refBaseName,
+          extendsRef
+        );
+      }
+    }
+    const baseName = extractBaseName(ref);
+    const resolvedName = this.resolveTypeName(baseName);
+    if (node.genericArguments && node.genericArguments.length > 0) {
+      const args = node.genericArguments.map(
+        (a) => this.transformType(a, forParameter)
+      );
+      const fullType = `${resolvedName}<${args.join(", ")}>`;
+      return `${fullType} | FunctionalBuilder<${fullType}, BaseBuildContext> | FunctionalPartial<${fullType}, BaseBuildContext>`;
+    }
+    if (ref.includes("<")) {
+      const resolvedRef = this.resolveTypeName(extractBaseName(ref)) + ref.substring(ref.indexOf("<"));
+      return `${resolvedRef} | FunctionalBuilder<${resolvedRef}, BaseBuildContext> | FunctionalPartial<${resolvedRef}, BaseBuildContext>`;
+    }
+    return `${resolvedName} | FunctionalBuilder<${resolvedName}, BaseBuildContext> | FunctionalPartial<${resolvedName}, BaseBuildContext>`;
+  }
+  /**
+   * Transform a type that extends AssetWrapper into a combined union.
+   * Produces: InnerType | FunctionalBuilder<InnerType> | TypeName | FunctionalBuilder<TypeName> | FunctionalPartial<TypeName>
+   */
+  transformAssetWrapperExtension(resolvedTypeName, rawTypeName, extendsRef) {
+    this.context.setNeedsAssetImport(true);
+    let innerType = "Asset";
+    if (extendsRef.genericArguments && extendsRef.genericArguments.length > 0) {
+      const genericArg = extendsRef.genericArguments[0];
+      const argType = this.transformTypeForConstraint(genericArg);
+      innerType = this.context.getGenericParamSymbols().has(argType) ? "Asset" : argType;
+    } else if (extendsRef.ref.includes("<")) {
+      const match = extendsRef.ref.match(/AssetWrapper<(.+)>/);
+      if (match) {
+        const extracted = extractBaseName(match[1].trim());
+        innerType = this.context.getGenericParamSymbols().has(extracted) ? "Asset" : extracted;
+      }
+    }
+    if (innerType !== "Asset" && this.shouldTrackTypeForImport(innerType)) {
+      this.context.trackReferencedType(innerType);
+    }
+    if (this.shouldTrackTypeForImport(rawTypeName)) {
+      this.context.trackReferencedType(rawTypeName);
+    }
+    return `${innerType} | FunctionalBuilder<${innerType}, BaseBuildContext> | ${resolvedTypeName} | FunctionalBuilder<${resolvedTypeName}, BaseBuildContext> | FunctionalPartial<${resolvedTypeName}, BaseBuildContext>`;
+  }
+  /**
+   * Generate an inline object type for anonymous objects.
+   */
+  generateInlineObjectType(node, forParameter) {
+    const props = Object.entries(node.properties).map(([propName, prop]) => {
+      const propType = this.transformType(prop.node, forParameter);
+      const optional = prop.required ? "" : "?";
+      const quotedName = this.needsQuoting(propName) ? `"${propName}"` : propName;
+      return `${quotedName}${optional}: ${propType}`;
+    }).join("; ");
+    return `{ ${props} }`;
+  }
+  /**
+   * Check if a property name needs to be quoted in TypeScript.
+   * Property names with special characters like hyphens must be quoted.
+   */
+  needsQuoting(name) {
+    return !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+  }
+  /**
+   * Get the full qualified name for a type if it's a namespace member.
+   * For example, "CrossfieldReference" -> "Validation.CrossfieldReference"
+   * if we've seen "Validation.CrossfieldReference" in the source.
+   * Returns the original name if no namespace mapping exists.
+   */
+  resolveTypeName(typeName) {
+    return this.context.getNamespaceMemberMap().get(typeName) ?? typeName;
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/import-generator.ts
+import path2 from "path";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/type-resolver.ts
+import ts2 from "typescript";
+import path from "path";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/ts-morph-type-finder.ts
+import { Project, ts } from "ts-morph";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+var TsMorphTypeDefinitionFinder = class {
+  project;
+  typeLocationCache = /* @__PURE__ */ new Map();
+  unexportedTypes = /* @__PURE__ */ new Map();
+  /**
+   * Finds the source file for a type by searching the codebase.
+   * Recursively follows imports to find where a type is actually defined.
+   * Supports both relative imports and node_modules packages.
+   *
+   * @param typeName - The name of the type to find
+   * @param startingFile - The file to start searching from
+   * @returns The path to the file containing the type definition, or null if not found
+   */
+  findTypeSourceFile(typeName, startingFile) {
+    if (!typeName || !startingFile) return null;
+    const cacheKey = `${typeName}:${startingFile}`;
+    if (this.typeLocationCache.has(cacheKey)) {
+      return this.typeLocationCache.get(cacheKey) || null;
+    }
+    try {
+      if (!this.project) {
+        this.project = new Project({
+          useInMemoryFileSystem: false,
+          // Enable module resolution for node_modules support
+          skipFileDependencyResolution: false,
+          compilerOptions: {
+            moduleResolution: ts.ModuleResolutionKind.Node16,
+            resolveJsonModule: true
+          }
+        });
+      }
+      const visitedFiles = /* @__PURE__ */ new Set();
+      const result = this.searchForType(typeName, startingFile, visitedFiles);
+      this.typeLocationCache.set(cacheKey, result);
+      return result;
+    } catch {
+      this.typeLocationCache.set(cacheKey, null);
+      return null;
+    }
+  }
+  /**
+   * Recursively searches for a type definition through imports.
+   * Handles both relative imports and node_modules packages.
+   */
+  searchForType(typeName, filePath, visitedFiles) {
+    if (!existsSync(filePath) || visitedFiles.has(filePath)) return null;
+    visitedFiles.add(filePath);
+    try {
+      const sourceFile = this.project.addSourceFileAtPath(filePath);
+      if (this.fileDefinesType(sourceFile, typeName)) {
+        return filePath;
+      }
+      const typeCheck = this.fileHasTypeDeclaration(sourceFile, typeName);
+      if (typeCheck.found && !typeCheck.exported) {
+        this.trackUnexportedType(typeName, typeCheck.filePath);
+      }
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        const importedType = this.getImportedTypeFromDeclaration(
+          importDecl,
+          typeName
+        );
+        if (importedType) {
+          const resolvedSourceFile = importDecl.getModuleSpecifierSourceFile();
+          if (resolvedSourceFile) {
+            const resolvedPath = resolvedSourceFile.getFilePath();
+            if (this.fileDefinesType(resolvedSourceFile, typeName)) {
+              return resolvedPath;
+            }
+            const deeperResult = this.searchForType(
+              typeName,
+              resolvedPath,
+              visitedFiles
+            );
+            if (deeperResult) return deeperResult;
+            return resolvedPath;
+          }
+          if (moduleSpecifier.startsWith(".")) {
+            const resolvedPath = this.resolveImportPath(
+              filePath,
+              moduleSpecifier
+            );
+            if (resolvedPath) {
+              const result = this.searchForType(
+                typeName,
+                resolvedPath,
+                visitedFiles
+              );
+              if (result) return result;
+            }
+          }
+        }
+        if (moduleSpecifier.startsWith(".")) {
+          const resolvedPath = this.resolveImportPath(
+            filePath,
+            moduleSpecifier
+          );
+          if (resolvedPath) {
+            const result = this.searchForType(
+              typeName,
+              resolvedPath,
+              visitedFiles
+            );
+            if (result) return result;
+          }
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Checks if an import declaration imports a specific type.
+   * Handles named imports, default imports, and namespace imports.
+   */
+  getImportedTypeFromDeclaration(importDecl, typeName) {
+    for (const namedImport of importDecl.getNamedImports()) {
+      const name = namedImport.getAliasNode()?.getText() || namedImport.getName();
+      if (name === typeName) return true;
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport?.getText() === typeName) return true;
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport?.getText() === typeName) return true;
+    return false;
+  }
+  /**
+   * Checks if a source file defines and exports a specific type.
+   * Handles interfaces, type aliases, classes, and re-exported types.
+   * Only returns true if the type is publicly exported.
+   */
+  fileDefinesType(sourceFile, typeName) {
+    for (const decl of [
+      ...sourceFile.getInterfaces(),
+      ...sourceFile.getTypeAliases(),
+      ...sourceFile.getClasses()
+    ]) {
+      if (decl.getName() === typeName && decl.isExported()) {
+        return true;
+      }
+    }
+    for (const exportDecl of sourceFile.getExportDeclarations()) {
+      for (const namedExport of exportDecl.getNamedExports()) {
+        if (namedExport.getName() === typeName) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Resolves a relative import path to an actual file path.
+   * Handles TypeScript extensions and index files.
+   */
+  resolveImportPath(fromFile, importPath) {
+    const dir = dirname(fromFile);
+    const extensions = [".ts", ".tsx", ".d.ts"];
+    for (const ext of extensions) {
+      const fullPath = resolve(dir, `${importPath}${ext}`);
+      if (existsSync(fullPath)) return fullPath;
+    }
+    for (const ext of extensions) {
+      const fullPath = resolve(dir, `${importPath}/index${ext}`);
+      if (existsSync(fullPath)) return fullPath;
+    }
+    if (importPath.endsWith(".js")) {
+      const tsPath = resolve(dir, importPath.replace(/\.js$/, ".ts"));
+      if (existsSync(tsPath)) return tsPath;
+      const dtsPath = resolve(dir, importPath.replace(/\.js$/, ".d.ts"));
+      if (existsSync(dtsPath)) return dtsPath;
+    }
+    return null;
+  }
+  /**
+   * Get all types that were found to exist but are not exported.
+   * Call this after searching to get the list of types that need to be exported.
+   */
+  getUnexportedTypes() {
+    return Array.from(this.unexportedTypes.entries()).map(
+      ([typeName, filePath]) => ({
+        typeName,
+        filePath
+      })
+    );
+  }
+  /**
+   * Check if a file declares a type (regardless of export status).
+   * Used internally to track unexported types.
+   */
+  fileHasTypeDeclaration(sourceFile, typeName) {
+    const filePath = sourceFile.getFilePath();
+    for (const decl of [
+      ...sourceFile.getInterfaces(),
+      ...sourceFile.getTypeAliases(),
+      ...sourceFile.getClasses()
+    ]) {
+      if (decl.getName() === typeName) {
+        return {
+          found: true,
+          exported: decl.isExported(),
+          filePath
+        };
+      }
+    }
+    return { found: false, exported: false, filePath };
+  }
+  /**
+   * Track an unexported type for later reporting.
+   */
+  trackUnexportedType(typeName, filePath) {
+    if (!this.unexportedTypes.has(typeName)) {
+      this.unexportedTypes.set(typeName, filePath);
+    }
+  }
+  /**
+   * Disposes of internal resources and clears caches.
+   * Should be called when the finder is no longer needed.
+   */
+  dispose() {
+    this.typeLocationCache.clear();
+    this.unexportedTypes.clear();
+    this.project = void 0;
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/type-resolver.ts
+function isBuiltInDeclarationPath(filePath) {
+  if (filePath.includes("/typescript/lib/lib.")) return true;
+  if (filePath.includes("/@types/node/")) return true;
+  return false;
+}
+function isDeclarationExported(node, typescript) {
+  const modifiers = typescript.canHaveModifiers(node) ? typescript.getModifiers(node) : void 0;
+  if (modifiers) {
+    for (const modifier of modifiers) {
+      if (modifier.kind === typescript.SyntaxKind.ExportKeyword) {
+        return true;
+      }
+    }
+  }
+  const parent = node.parent;
+  if (parent && typescript.isExportDeclaration(parent)) {
+    return true;
+  }
+  return false;
+}
+function createTypeScriptResolver(tsContext) {
+  const { program, sourceFile, outputDir } = tsContext;
+  const typeChecker = program.getTypeChecker();
+  const finder = new TsMorphTypeDefinitionFinder();
+  const resolvedCache = /* @__PURE__ */ new Map();
+  const unexportedTypes = [];
+  function resolveTypePath(typeName) {
+    if (resolvedCache.has(typeName)) {
+      return resolvedCache.get(typeName);
+    }
+    const typeFilePath = finder.findTypeSourceFile(
+      typeName,
+      sourceFile.fileName
+    );
+    if (typeFilePath) {
+      if (typeFilePath === sourceFile.fileName) {
+        resolvedCache.set(typeName, "sameFile");
+        return "sameFile";
+      }
+      if (isBuiltInDeclarationPath(typeFilePath)) {
+        resolvedCache.set(typeName, "sameFile");
+        return "sameFile";
+      }
+      if (typeFilePath.includes("node_modules")) {
+        const nodeModulesIdx = typeFilePath.lastIndexOf("node_modules/");
+        const afterNodeModules = typeFilePath.slice(
+          nodeModulesIdx + "node_modules/".length
+        );
+        let packageName;
+        if (afterNodeModules.startsWith("@")) {
+          const parts = afterNodeModules.split("/");
+          packageName = `${parts[0]}/${parts[1]}`;
+        } else {
+          packageName = afterNodeModules.split("/")[0];
+        }
+        resolvedCache.set(typeName, packageName);
+        return packageName;
+      }
+      let relativePath2 = path.relative(outputDir, typeFilePath);
+      relativePath2 = relativePath2.replace(/\.tsx?$/, ".js");
+      if (!relativePath2.startsWith(".")) {
+        relativePath2 = "./" + relativePath2;
+      }
+      resolvedCache.set(typeName, relativePath2);
+      return relativePath2;
+    }
+    const symbols = typeChecker.getSymbolsInScope(
+      sourceFile,
+      ts2.SymbolFlags.Type | ts2.SymbolFlags.Interface | ts2.SymbolFlags.TypeAlias
+    );
+    const matchingSymbols = symbols.filter((s) => s.getName() === typeName);
+    let symbol;
+    let validDeclaration;
+    let unexportedDeclarationFile;
+    for (const s of matchingSymbols) {
+      const declarations = s.getDeclarations();
+      if (declarations && declarations.length > 0) {
+        const decl = declarations[0];
+        const declFile = decl.getSourceFile().fileName;
+        if (isBuiltInDeclarationPath(declFile)) {
+          continue;
+        }
+        const isFromNodeModules = declFile.includes("node_modules");
+        const isExported = isFromNodeModules || isDeclarationExported(decl, ts2);
+        if (isExported) {
+          symbol = s;
+          validDeclaration = decl;
+          break;
+        } else {
+          unexportedDeclarationFile = declFile;
+        }
+      }
+    }
+    if (!symbol || !validDeclaration) {
+      if (unexportedDeclarationFile) {
+        const alreadyTracked = unexportedTypes.some(
+          (t) => t.typeName === typeName && t.filePath === unexportedDeclarationFile
+        );
+        if (!alreadyTracked) {
+          unexportedTypes.push({
+            typeName,
+            filePath: unexportedDeclarationFile
+          });
+        }
+        resolvedCache.set(typeName, "sameFile");
+        return "sameFile";
+      }
+      resolvedCache.set(typeName, "notFound");
+      return "notFound";
+    }
+    const declSourceFile = validDeclaration.getSourceFile();
+    const declFilePath = declSourceFile.fileName;
+    if (declFilePath === sourceFile.fileName) {
+      resolvedCache.set(typeName, "sameFile");
+      return "sameFile";
+    }
+    if (declFilePath.includes("node_modules")) {
+      const nodeModulesIdx = declFilePath.lastIndexOf("node_modules/");
+      const afterNodeModules = declFilePath.slice(
+        nodeModulesIdx + "node_modules/".length
+      );
+      let packageName;
+      if (afterNodeModules.startsWith("@")) {
+        const parts = afterNodeModules.split("/");
+        packageName = `${parts[0]}/${parts[1]}`;
+      } else {
+        packageName = afterNodeModules.split("/")[0];
+      }
+      resolvedCache.set(typeName, packageName);
+      return packageName;
+    }
+    let relativePath = path.relative(outputDir, declFilePath);
+    relativePath = relativePath.replace(/\.tsx?$/, ".js");
+    if (!relativePath.startsWith(".")) {
+      relativePath = "./" + relativePath;
+    }
+    resolvedCache.set(typeName, relativePath);
+    return relativePath;
+  }
+  function getUnexportedTypes() {
+    return [...unexportedTypes];
+  }
+  return { resolveTypePath, getUnexportedTypes };
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/import-generator.ts
+var ImportGenerator = class {
+  config;
+  /** Track all type references that need to be imported, grouped by source file */
+  referencedTypesBySource = /* @__PURE__ */ new Map();
+  /** Track types that should be imported from the main type's source file */
+  referencedTypes = /* @__PURE__ */ new Set();
+  /** Track whether Asset type is needed for imports */
+  needsAssetImport = false;
+  /** Track generic parameter symbols (e.g., T, U) that should not be imported */
+  genericParamSymbols = /* @__PURE__ */ new Set();
+  /** TypeScript resolver for automatic import path resolution */
+  tsResolver;
+  /** Track types that couldn't be resolved - will cause errors if used */
+  unresolvedTypes = /* @__PURE__ */ new Set();
+  /** Track namespaces that need to be imported (e.g., "Validation" from @player-ui/types) */
+  namespaceImports = /* @__PURE__ */ new Set();
+  /** Map short type names to their full qualified names (e.g., "CrossfieldReference" -> "Validation.CrossfieldReference") */
+  namespaceMemberMap = /* @__PURE__ */ new Map();
+  /** Effective sameFileTypes - computed from tsContext or provided directly */
+  effectiveSameFileTypes;
+  constructor(config = {}) {
+    this.config = config;
+    if (config.tsContext) {
+      this.tsResolver = createTypeScriptResolver(config.tsContext);
+    }
+    this.effectiveSameFileTypes = config.sameFileTypes;
+  }
+  // TypeTransformContext implementation
+  setNeedsAssetImport(value) {
+    this.needsAssetImport = value;
+  }
+  getNeedsAssetImport() {
+    return this.needsAssetImport;
+  }
+  getNamespaceMemberMap() {
+    return this.namespaceMemberMap;
+  }
+  getGenericParamSymbols() {
+    return this.genericParamSymbols;
+  }
+  getAssetWrapperExtendsRef(typeName) {
+    const registry = this.config.typeRegistry;
+    if (!registry) return void 0;
+    return getAssetWrapperExtendsRefByName(typeName, registry);
+  }
+  /**
+   * Get list of types that exist but need to be exported.
+   */
+  getUnexportedTypes() {
+    return this.tsResolver?.getUnexportedTypes() ?? [];
+  }
+  /**
+   * Get list of types that couldn't be resolved at all.
+   */
+  getUnresolvedTypes() {
+    return Array.from(this.unresolvedTypes);
+  }
+  /**
+   * Track a referenced type for import generation.
+   */
+  trackReferencedType(typeName) {
+    const { externalTypes, typeImportPathGenerator } = this.config;
+    const importName = extractBaseName(typeName);
+    if (PLAYER_BUILTINS.has(importName)) {
+      return;
+    }
+    const namespaced = parseNamespacedType(importName);
+    if (namespaced) {
+      const namespaceName = namespaced.namespace;
+      if (externalTypes?.has(namespaceName)) {
+        const packageName = externalTypes.get(namespaceName);
+        if (!this.referencedTypesBySource.has(packageName)) {
+          this.referencedTypesBySource.set(packageName, /* @__PURE__ */ new Set());
+        }
+        this.referencedTypesBySource.get(packageName).add(namespaceName);
+        return;
+      }
+      const typesImportPath = this.config.typesImportPath ?? "@player-ui/types";
+      if (!this.referencedTypesBySource.has(typesImportPath)) {
+        this.referencedTypesBySource.set(typesImportPath, /* @__PURE__ */ new Set());
+      }
+      this.referencedTypesBySource.get(typesImportPath).add(namespaceName);
+      return;
+    }
+    if (externalTypes?.has(importName)) {
+      const packageName = externalTypes.get(importName);
+      if (!this.referencedTypesBySource.has(packageName)) {
+        this.referencedTypesBySource.set(packageName, /* @__PURE__ */ new Set());
+      }
+      this.referencedTypesBySource.get(packageName).add(importName);
+      return;
+    }
+    if (this.tsResolver) {
+      const result = this.tsResolver.resolveTypePath(importName);
+      if (result === "notFound") {
+        this.unresolvedTypes.add(importName);
+        return;
+      }
+      if (result === "sameFile") {
+        this.referencedTypes.add(importName);
+      } else {
+        if (!this.referencedTypesBySource.has(result)) {
+          this.referencedTypesBySource.set(result, /* @__PURE__ */ new Set());
+        }
+        this.referencedTypesBySource.get(result).add(importName);
+      }
+      return;
+    }
+    const sameFileTypes = this.effectiveSameFileTypes;
+    if (sameFileTypes) {
+      if (sameFileTypes.has(importName)) {
+        this.referencedTypes.add(importName);
+      } else if (typeImportPathGenerator) {
+        const importPath = typeImportPathGenerator(importName);
+        if (importPath) {
+          if (!this.referencedTypesBySource.has(importPath)) {
+            this.referencedTypesBySource.set(importPath, /* @__PURE__ */ new Set());
+          }
+          this.referencedTypesBySource.get(importPath).add(importName);
+        }
+      } else {
+        this.referencedTypes.add(importName);
+      }
+    } else {
+      this.referencedTypes.add(importName);
+    }
+  }
+  /**
+   * Track a namespace that needs to be imported.
+   */
+  trackNamespaceImport(namespaceName) {
+    this.namespaceImports.add(namespaceName);
+    if (this.tsResolver) {
+      const result = this.tsResolver.resolveTypePath(namespaceName);
+      if (result === "sameFile") {
+        this.referencedTypes.add(namespaceName);
+      } else if (result !== "notFound") {
+        if (!this.referencedTypesBySource.has(result)) {
+          this.referencedTypesBySource.set(result, /* @__PURE__ */ new Set());
+        }
+        this.referencedTypesBySource.get(result).add(namespaceName);
+      } else {
+        this.unresolvedTypes.add(namespaceName);
+      }
+      return;
+    }
+    const { externalTypes, typeImportPathGenerator } = this.config;
+    if (externalTypes?.has(namespaceName)) {
+      const packageName = externalTypes.get(namespaceName);
+      if (!this.referencedTypesBySource.has(packageName)) {
+        this.referencedTypesBySource.set(packageName, /* @__PURE__ */ new Set());
+      }
+      this.referencedTypesBySource.get(packageName).add(namespaceName);
+      return;
+    }
+    if (typeImportPathGenerator) {
+      const importPath = typeImportPathGenerator(namespaceName);
+      if (importPath) {
+        if (!this.referencedTypesBySource.has(importPath)) {
+          this.referencedTypesBySource.set(importPath, /* @__PURE__ */ new Set());
+        }
+        this.referencedTypesBySource.get(importPath).add(namespaceName);
+        return;
+      }
+    }
+    this.referencedTypes.add(namespaceName);
+  }
+  /**
+   * Generate import statements.
+   */
+  generateImports(mainTypeName) {
+    let typeImportPath;
+    if (this.config.tsContext) {
+      const { sourceFile, outputDir } = this.config.tsContext;
+      let relativePath = path2.relative(outputDir, sourceFile.fileName);
+      relativePath = relativePath.replace(/\.tsx?$/, ".js");
+      if (!relativePath.startsWith(".")) {
+        relativePath = "./" + relativePath;
+      }
+      typeImportPath = relativePath;
+    } else if (this.config.typeImportPathGenerator) {
+      typeImportPath = this.config.typeImportPathGenerator(mainTypeName);
+    } else {
+      typeImportPath = `../types/${this.getTypeFileName(mainTypeName)}`;
+    }
+    const typesToImport = /* @__PURE__ */ new Set([mainTypeName]);
+    Array.from(this.referencedTypes).forEach((name) => {
+      typesToImport.add(name);
+    });
+    const typesImportPath = this.config.typesImportPath ?? "@player-ui/types";
+    const functionalImportPath = this.config.functionalImportPath ?? "@player-lang/functional-dsl";
+    const lines = [];
+    const typeImportStatement = `import type { ${Array.from(typesToImport).join(", ")} } from "${typeImportPath}";`;
+    lines.push(typeImportStatement);
+    for (const [importPath, types] of this.referencedTypesBySource) {
+      const typeNames = Array.from(types).join(", ");
+      lines.push(`import type { ${typeNames} } from "${importPath}";`);
+    }
+    if (this.needsAssetImport) {
+      lines.push(`import type { Asset } from "${typesImportPath}";`);
+    }
+    lines.push(
+      `import { type FunctionalBuilder, type BaseBuildContext, type FunctionalPartial, FunctionalBuilderBase, createInspectMethod, type TaggedTemplateValue } from "${functionalImportPath}";`
+    );
+    return lines.join("\n");
+  }
+  getTypeFileName(typeName) {
+    return typeName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "").replace(/asset$/, "");
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/default-value-generator.ts
+var DEFAULT_CONFIG = {
+  maxDepth: 3,
+  skipTypes: /* @__PURE__ */ new Set(["Asset", "AssetWrapper"])
+};
+var DefaultValueGenerator = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      skipTypes: config.skipTypes ?? DEFAULT_CONFIG.skipTypes
+    };
+  }
+  /**
+   * Generate default values for an ObjectType.
+   *
+   * @param objectType - The XLR ObjectType to generate defaults for
+   * @param assetType - Optional asset type string for Asset types
+   * @returns Record of property names to default values
+   */
+  generateDefaults(objectType, assetType) {
+    const defaults = {};
+    if (assetType) {
+      defaults["type"] = assetType;
+    }
+    if (objectType.extends?.ref.startsWith("Asset")) {
+      defaults["id"] = "";
+    } else if ("id" in objectType.properties) {
+      defaults["id"] = "";
+    }
+    const context = {
+      depth: 0,
+      config: this.config
+    };
+    for (const [propName, prop] of Object.entries(objectType.properties)) {
+      if (isPrimitiveConst(prop.node)) {
+        defaults[propName] = prop.node.const;
+        continue;
+      }
+      if (!prop.required) {
+        continue;
+      }
+      if (propName in defaults) {
+        continue;
+      }
+      const defaultValue = this.getDefaultForType(prop.node, context);
+      if (defaultValue !== void 0) {
+        defaults[propName] = defaultValue;
+      }
+    }
+    return defaults;
+  }
+  /**
+   * Get the default value for a specific type node.
+   *
+   * @param node - The type node
+   * @param context - Generation context for tracking depth
+   * @returns The default value, or undefined if the type should be skipped
+   */
+  getDefaultForType(node, context) {
+    if (isAssetWrapperRef(node)) {
+      return void 0;
+    }
+    if (isRefType(node)) {
+      const baseName = node.ref.split("<")[0];
+      if (context.config.skipTypes.has(baseName)) {
+        return void 0;
+      }
+    }
+    if (isStringType(node)) {
+      return "";
+    }
+    if (isNumberType(node)) {
+      return 0;
+    }
+    if (isBooleanType(node)) {
+      return false;
+    }
+    if (isExpressionRef(node) || isBindingRef(node)) {
+      return "";
+    }
+    if (isArrayType(node)) {
+      return [];
+    }
+    if (isOrType(node)) {
+      return this.getDefaultForUnion(node.or, context);
+    }
+    if (isAndType(node)) {
+      return this.getDefaultForIntersection(node.and, context);
+    }
+    if (isObjectType(node)) {
+      if (context.depth >= context.config.maxDepth) {
+        return {};
+      }
+      return this.getDefaultForObject(node, {
+        ...context,
+        depth: context.depth + 1
+      });
+    }
+    if (node.type === "null") {
+      return null;
+    }
+    if (node.type === "undefined") {
+      return void 0;
+    }
+    if (isRefType(node)) {
+      return {};
+    }
+    return void 0;
+  }
+  /**
+   * Get default for a union type by picking the first non-null/undefined variant.
+   */
+  getDefaultForUnion(variants, context) {
+    for (const variant of variants) {
+      if (variant.type === "null" || variant.type === "undefined") {
+        continue;
+      }
+      const defaultValue = this.getDefaultForType(variant, context);
+      if (defaultValue !== void 0) {
+        return defaultValue;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get default for an intersection type by attempting to merge.
+   */
+  getDefaultForIntersection(parts, context) {
+    const merged = {};
+    for (const part of parts) {
+      const partDefault = this.getDefaultForType(part, context);
+      if (partDefault !== void 0 && typeof partDefault === "object" && partDefault !== null && !Array.isArray(partDefault)) {
+        Object.assign(merged, partDefault);
+      }
+    }
+    return Object.keys(merged).length > 0 ? merged : {};
+  }
+  /**
+   * Get default for an object type by processing required properties.
+   */
+  getDefaultForObject(node, context) {
+    const result = {};
+    for (const [propName, prop] of Object.entries(node.properties)) {
+      if (isPrimitiveConst(prop.node)) {
+        result[propName] = prop.node.const;
+        continue;
+      }
+      if (!prop.required) {
+        continue;
+      }
+      const defaultValue = this.getDefaultForType(prop.node, context);
+      if (defaultValue !== void 0) {
+        result[propName] = defaultValue;
+      }
+    }
+    return result;
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/builder-class-generator.ts
+var BuilderClassGenerator = class {
+  typeTransformer;
+  defaultValueGenerator;
+  typeRegistry;
+  /** Track array properties for __arrayProperties__ */
+  arrayProperties = /* @__PURE__ */ new Set();
+  /** Track asset wrapper paths for __assetWrapperPaths__ */
+  assetWrapperPaths = [];
+  constructor(typeTransformer, typeRegistry) {
+    this.typeTransformer = typeTransformer;
+    this.typeRegistry = typeRegistry ?? /* @__PURE__ */ new Map();
+    this.defaultValueGenerator = new DefaultValueGenerator({
+      maxDepth: 3,
+      skipTypes: /* @__PURE__ */ new Set(["Asset", "AssetWrapper"])
+    });
+  }
+  /**
+   * Generate the builder class code.
+   */
+  generateBuilderClass(info) {
+    const {
+      name,
+      className,
+      factoryName,
+      objectType,
+      assetType,
+      genericParams
+    } = info;
+    this.arrayProperties.clear();
+    this.assetWrapperPaths = [];
+    const genericPart = genericParams ? `<${genericParams}>` : "";
+    const genericUsage = extractGenericUsage(genericParams);
+    const interfaceCode = this.generateInterfaceMethods(info);
+    const classMethods = this.generateClassMethods(info);
+    const defaults = this.generateDefaults(objectType, assetType);
+    this.assetWrapperPaths = findAssetWrapperPaths(
+      objectType,
+      this.typeRegistry
+    );
+    const arrayPropsCode = this.arrayProperties.size > 0 ? `  private static readonly __arrayProperties__: ReadonlySet<string> = new Set([${Array.from(
+      this.arrayProperties
+    ).map((p) => `"${p}"`).join(", ")}]);
+` : "";
+    const assetWrapperPathsCode = this.assetWrapperPaths.length > 0 ? `  private static readonly __assetWrapperPaths__: ReadonlyArray<ReadonlyArray<string>> = ${JSON.stringify(this.assetWrapperPaths)};
+` : "";
+    const classCode = `
+${interfaceCode}
+
+/**
+ * A builder for ${name}
+ */
+export class ${className}${genericPart} extends FunctionalBuilderBase<${name}${genericUsage}> implements ${className}Methods${genericUsage}, FunctionalBuilder<${name}${genericUsage}, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = ${defaults};
+${arrayPropsCode}${assetWrapperPathsCode}
+${classMethods}
+
+  /**
+   * Builds the final ${name} object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): ${name}${genericUsage} {
+    return this.buildWithDefaults(${className}.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("${className}", this.values);
+  }
+}
+
+/**
+ * Creates a new ${name} builder
+ * @param initial Optional initial values
+ * @returns A functional builder for ${name}
+ */
+export function ${factoryName}${genericPart}(initial?: FunctionalPartial<${name}${genericUsage}>): ${className}${genericUsage} {
+  return new ${className}${genericUsage}(initial);
+}`;
+    return classCode.trim();
+  }
+  /**
+   * Generate interface methods for the builder.
+   */
+  generateInterfaceMethods(info) {
+    const { className, objectType, genericParams, isAsset } = info;
+    const genericUsage = extractGenericUsage(genericParams);
+    const properties = this.collectPropertiesForMethods(objectType, isAsset);
+    const methods = properties.map(({ propName, propType, description }) => {
+      const methodName = `with${toPascalCase(propName)}`;
+      const paramType = this.typeTransformer.transformType(propType, true);
+      return `  /** ${description} */
+  ${methodName}(value: ${paramType}): ${className}${genericUsage};`;
+    }).join("\n");
+    return `export interface ${className}Methods${genericParams ? `<${genericParams}>` : ""} {
+${methods}
+}`;
+  }
+  /**
+   * Collect properties that need methods generated.
+   */
+  collectPropertiesForMethods(objectType, isAsset) {
+    const properties = [];
+    const seenProps = /* @__PURE__ */ new Set();
+    if (isAsset && !("id" in objectType.properties)) {
+      properties.push({
+        propName: "id",
+        propType: { type: "string" },
+        description: "A unique identifier for this asset"
+      });
+      seenProps.add("id");
+    }
+    for (const [propName, prop] of Object.entries(objectType.properties)) {
+      if (seenProps.has(propName)) {
+        continue;
+      }
+      seenProps.add(propName);
+      properties.push({
+        propName,
+        propType: prop.node,
+        description: prop.node.description || `Sets the ${propName} property`
+      });
+    }
+    return properties;
+  }
+  /**
+   * Generate class methods for the builder.
+   */
+  generateClassMethods(info) {
+    const { className, objectType, genericParams, isAsset } = info;
+    const genericUsage = extractGenericUsage(genericParams);
+    const properties = this.collectPropertiesForMethods(objectType, isAsset);
+    return properties.map(({ propName, propType, description }) => {
+      const methodName = `with${toPascalCase(propName)}`;
+      const paramType = this.typeTransformer.transformType(propType, true);
+      if (containsArrayType(propType)) {
+        this.arrayProperties.add(propName);
+      }
+      return `  /** ${description} */
+  ${methodName}(value: ${paramType}): ${className}${genericUsage} {
+    return this.set("${propName}", value);
+  }`;
+    }).join("\n\n");
+  }
+  /**
+   * Generate default values object using DefaultValueGenerator.
+   */
+  generateDefaults(objectType, assetType) {
+    const defaults = this.defaultValueGenerator.generateDefaults(
+      objectType,
+      assetType
+    );
+    return JSON.stringify(defaults);
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/generator.ts
+var FunctionalBuilderGenerator = class {
+  namedType;
+  config;
+  /** Import generator handles import tracking and generation */
+  importGenerator;
+  /** Type transformer handles XLR to TypeScript type conversion */
+  typeTransformer;
+  /** Type collector handles collecting type references */
+  typeCollector;
+  /** Builder class generator handles class code generation */
+  builderClassGenerator;
+  /** Map short type names to their full qualified names */
+  namespaceMemberMap = /* @__PURE__ */ new Map();
+  constructor(namedType, config = {}) {
+    this.namedType = namedType;
+    this.config = config;
+    const importConfig = {
+      functionalImportPath: config.functionalImportPath,
+      typesImportPath: config.typesImportPath,
+      tsContext: config.tsContext,
+      typeImportPathGenerator: config.typeImportPathGenerator,
+      sameFileTypes: config.sameFileTypes,
+      externalTypes: config.externalTypes,
+      typeRegistry: config.typeRegistry
+    };
+    this.importGenerator = new ImportGenerator(importConfig);
+    this.typeTransformer = new TypeTransformer(this.importGenerator);
+    this.typeCollector = new TypeCollector(
+      this.importGenerator,
+      this.importGenerator.getGenericParamSymbols(),
+      namedType.name,
+      this.importGenerator.getNamespaceMemberMap(),
+      config.typeRegistry
+    );
+    this.builderClassGenerator = new BuilderClassGenerator(
+      this.typeTransformer,
+      config.typeRegistry
+    );
+  }
+  /**
+   * Get list of types that exist but need to be exported.
+   * Call this after generate() to get warnings for the user.
+   */
+  getUnexportedTypes() {
+    return this.importGenerator.getUnexportedTypes();
+  }
+  /**
+   * Get list of types that couldn't be resolved at all.
+   * These types are used in the generated code but won't be imported,
+   * causing type errors. Often these are namespaced types (e.g., Validation.CrossfieldReference).
+   */
+  getUnresolvedTypes() {
+    return this.importGenerator.getUnresolvedTypes();
+  }
+  /**
+   * Generate the builder code
+   */
+  generate() {
+    this.typeCollector.collectGenericParamSymbols(this.namedType);
+    const mainBuilder = this.createBuilderInfo(this.namedType);
+    this.typeCollector.collectTypesFromGenericTokens(this.namedType);
+    this.typeCollector.collectReferencedTypes(this.namedType);
+    const mainBuilderCode = this.builderClassGenerator.generateBuilderClass(mainBuilder);
+    const imports = this.importGenerator.generateImports(mainBuilder.name);
+    return [imports, mainBuilderCode].filter(Boolean).join("\n\n");
+  }
+  createBuilderInfo(namedType) {
+    const assetType = getAssetTypeFromExtends(namedType);
+    const isAsset = !!assetType;
+    let genericParams;
+    if (isGenericNamedType2(namedType)) {
+      const seenParams = /* @__PURE__ */ new Set();
+      genericParams = namedType.genericTokens.filter((t) => {
+        if (seenParams.has(t.symbol)) {
+          return false;
+        }
+        seenParams.add(t.symbol);
+        return true;
+      }).map((t) => {
+        let param = t.symbol;
+        if (t.constraints) {
+          const constraintType = this.typeTransformer.transformTypeForConstraint(t.constraints);
+          if (constraintType !== "any") {
+            param += ` extends ${constraintType}`;
+          }
+        }
+        if (t.default) {
+          param += ` = ${this.typeTransformer.transformTypeForConstraint(t.default)}`;
+        }
+        return param;
+      }).join(", ");
+    }
+    return {
+      name: namedType.name,
+      className: toBuilderClassName(namedType.name),
+      factoryName: toFactoryName(namedType.name),
+      objectType: namedType,
+      assetType,
+      genericParams,
+      isAsset
+    };
+  }
+};
+function generateFunctionalBuilder(namedType, config = {}) {
+  const generator = new FunctionalBuilderGenerator(namedType, config);
+  return generator.generate();
+}
+function generateFunctionalBuilderWithWarnings(namedType, config = {}) {
+  const generator = new FunctionalBuilderGenerator(namedType, config);
+  const code = generator.generate();
+  const unexportedTypes = generator.getUnexportedTypes();
+  return { code, unexportedTypes };
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/path-utils.ts
+import { normalize, sep, dirname as dirname2, relative, resolve as resolve2 } from "path";
+function normalizeAndSplitPath(filePath) {
+  return normalize(filePath).split(sep);
+}
+function isPackageDirectory(part) {
+  return part === "node_modules" || part.startsWith(".pnpm");
+}
+function isNodeModulesPath(filePath) {
+  const parts = normalizeAndSplitPath(filePath);
+  return parts.some(isPackageDirectory);
+}
+function extractPackageNameFromPath(filePath) {
+  const parts = normalizeAndSplitPath(filePath);
+  let lastNodeModulesIndex = -1;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if (parts[i] === "node_modules") {
+      lastNodeModulesIndex = i;
+      break;
+    }
+  }
+  if (lastNodeModulesIndex === -1 || lastNodeModulesIndex >= parts.length - 1) {
+    return null;
+  }
+  const afterNodeModules = parts.slice(lastNodeModulesIndex + 1);
+  if (afterNodeModules[0]?.startsWith("@")) {
+    if (afterNodeModules.length >= 2) {
+      return `${afterNodeModules[0]}/${afterNodeModules[1]}`;
+    }
+    return null;
+  }
+  return afterNodeModules[0] || null;
+}
+function createRelativeImportPath(fromFile, toFile) {
+  const fromDir = dirname2(fromFile);
+  let relativePath = relative(fromDir, toFile);
+  relativePath = relativePath.replace(/\.tsx?$/, ".js");
+  relativePath = relativePath.replace(/\.d\.ts$/, ".js");
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
+function resolveRelativeImportPath(fromFile, importSpecifier) {
+  const fromDir = dirname2(fromFile);
+  let actualSpecifier = importSpecifier;
+  if (importSpecifier.endsWith(".js")) {
+    actualSpecifier = importSpecifier.replace(/\.js$/, ".ts");
+  }
+  let resolvedPath = resolve2(fromDir, actualSpecifier);
+  if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".tsx") && !resolvedPath.endsWith(".d.ts")) {
+    resolvedPath += ".ts";
+  }
+  return resolvedPath;
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/generators/javascript/src/type-categorizer.ts
+function categorizeTypes(referencedTypes, finder, options) {
+  const { mainSourceFile, sameFileTypes } = options;
+  const result = {
+    localTypes: /* @__PURE__ */ new Set(),
+    relativeImports: /* @__PURE__ */ new Map(),
+    externalTypes: /* @__PURE__ */ new Map()
+  };
+  for (const typeName of referencedTypes) {
+    if (sameFileTypes?.has(typeName)) {
+      result.localTypes.add(typeName);
+      continue;
+    }
+    const sourceFile = finder.findTypeSourceFile(typeName, mainSourceFile);
+    if (!sourceFile) {
+      result.localTypes.add(typeName);
+      continue;
+    }
+    const normalizedSource = normalizePath(sourceFile);
+    const normalizedMain = normalizePath(mainSourceFile);
+    if (normalizedSource === normalizedMain) {
+      result.localTypes.add(typeName);
+    } else if (isNodeModulesPath(sourceFile)) {
+      const packageName = extractPackageNameFromPath(sourceFile);
+      if (packageName) {
+        result.externalTypes.set(typeName, packageName);
+      } else {
+        result.localTypes.add(typeName);
+      }
+    } else {
+      const relativePath = createRelativeImportPath(mainSourceFile, sourceFile);
+      if (!result.relativeImports.has(relativePath)) {
+        result.relativeImports.set(relativePath, /* @__PURE__ */ new Set());
+      }
+      result.relativeImports.get(relativePath).add(typeName);
+    }
+  }
+  return result;
+}
+function groupExternalTypesByPackage(externalTypes) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [typeName, packageName] of externalTypes) {
+    if (!grouped.has(packageName)) {
+      grouped.set(packageName, /* @__PURE__ */ new Set());
+    }
+    grouped.get(packageName).add(typeName);
+  }
+  return grouped;
+}
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/\/$/, "");
+}
+export {
+  PLAYER_BUILTINS,
+  TYPESCRIPT_BUILTINS,
+  TsMorphTypeDefinitionFinder,
+  categorizeTypes,
+  containsArrayType,
+  createRelativeImportPath,
+  createTypeScriptResolver,
+  extendsAssetWrapper,
+  extractBaseName,
+  extractGenericUsage,
+  extractPackageNameFromPath,
+  findAssetWrapperPaths,
+  generateFunctionalBuilder,
+  generateFunctionalBuilderWithWarnings,
+  getAssetTypeFromExtends,
+  getAssetWrapperExtendsRef,
+  getAssetWrapperExtendsRefByName,
+  getPropertiesInfo,
+  groupExternalTypesByPackage,
+  isAndType,
+  isArrayType,
+  isAssetWrapperRef,
+  isBindingRef,
+  isBooleanType,
+  isBuiltInDeclarationPath,
+  isBuiltinType,
+  isComplexObjectType,
+  isDeclarationExported,
+  isExpressionRef,
+  isNamedType,
+  isNodeModulesPath,
+  isNumberType,
+  isObjectType,
+  isOrType,
+  isPrimitiveConst,
+  isRecordType,
+  isRefType,
+  isStringType,
+  isTupleType,
+  parseNamespacedType,
+  resolveRelativeImportPath,
+  sanitizePropertyName,
+  splitAtTopLevelCommas,
+  toBuilderClassName,
+  toFactoryName,
+  toPascalCase
+};
+//# sourceMappingURL=index.mjs.map