@player-tools/fluent 0.12.1--canary.241.6077

package/dist/cjs/index.cjs

@@ -0,0 +1,2396 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AND: () => and,
+  BranchTypes: () => BranchTypes,
+  ErrorCodes: () => ErrorCodes,
+  FLUENT_BUILDER_SYMBOL: () => FLUENT_BUILDER_SYMBOL,
+  FluentBuilderBase: () => FluentBuilderBase,
+  FluentError: () => FluentError,
+  IDRegistry: () => IDRegistry,
+  NAND: () => nand,
+  NOR: () => nor,
+  NOT: () => not,
+  OR: () => or,
+  PropertyKeys: () => PropertyKeys,
+  SchemaGenerator: () => SchemaGenerator,
+  SchemaTypeName: () => SchemaTypeName,
+  StorageKeys: () => StorageKeys,
+  TEMPLATE_MARKER: () => TEMPLATE_MARKER,
+  TaggedTemplateValueSymbol: () => TaggedTemplateValueSymbol,
+  XOR: () => xor,
+  add: () => add,
+  and: () => and,
+  binding: () => binding,
+  call: () => call,
+  conditional: () => conditional,
+  createFluentError: () => createFluentError,
+  createIdRegistry: () => createIdRegistry,
+  createInspectMethod: () => createInspectMethod,
+  createNestedContext: () => createNestedContext,
+  createSwitchContext: () => createSwitchContext,
+  createTemplateContext: () => createTemplateContext,
+  determineSlotName: () => determineSlotName,
+  div: () => divide,
+  divide: () => divide,
+  eq: () => equal,
+  equal: () => equal,
+  expression: () => expression,
+  extractBindingsFromSchema: () => extractBindingsFromSchema,
+  extractValue: () => extractValue,
+  flow: () => flow,
+  genId: () => genId,
+  generateAssetId: () => generateAssetId,
+  globalIdRegistry: () => globalIdRegistry,
+  greaterThan: () => greaterThan,
+  greaterThanOrEqual: () => greaterThanOrEqual,
+  gt: () => greaterThan,
+  gte: () => greaterThanOrEqual,
+  ifElse: () => conditional,
+  isAsset: () => isAsset,
+  isAssetWrapper: () => isAssetWrapper,
+  isAssetWrapperValue: () => isAssetWrapperValue,
+  isAssetWrapperWithAsset: () => isAssetWrapperWithAsset,
+  isBuilderArray: () => isBuilderArray,
+  isFluentBuilder: () => isFluentBuilder,
+  isPlainObject: () => isPlainObject,
+  isStringOrUndefined: () => isStringOrUndefined,
+  isSwitchResult: () => isSwitchResult,
+  isTaggedTemplateValue: () => isTaggedTemplateValue,
+  isTemplate: () => isTemplate,
+  lessThan: () => lessThan,
+  lessThanOrEqual: () => lessThanOrEqual,
+  literal: () => literal,
+  lt: () => lessThan,
+  lte: () => lessThanOrEqual,
+  minus: () => subtract,
+  mod: () => modulo,
+  modulo: () => modulo,
+  multiply: () => multiply,
+  nand: () => nand,
+  needsAssetWrapper: () => needsAssetWrapper,
+  neq: () => notEqual,
+  nor: () => nor,
+  not: () => not,
+  notEqual: () => notEqual,
+  or: () => or,
+  peekId: () => peekId,
+  plus: () => add,
+  resetGlobalIdSet: () => resetGlobalIdSet,
+  resolveAndWrapAsset: () => resolveAndWrapAsset,
+  resolveValue: () => resolveValue,
+  safeFromMixedType: () => safeFromMixedType,
+  safeToArray: () => safeToArray,
+  safeToBoolean: () => safeToBoolean,
+  safeToNumber: () => safeToNumber,
+  safeToObject: () => safeToObject,
+  safeToString: () => safeToString,
+  strictEq: () => strictEqual,
+  strictEqual: () => strictEqual,
+  strictNeq: () => strictNotEqual,
+  strictNotEqual: () => strictNotEqual,
+  subtract: () => subtract,
+  switch_: () => switch_,
+  template: () => template,
+  ternary: () => conditional,
+  times: () => multiply,
+  xor: () => xor
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/types.ts
+var FLUENT_BUILDER_SYMBOL = Symbol.for("fluent-builder");
+var BranchTypes = {
+  SLOT: "slot",
+  ARRAY_ITEM: "array-item",
+  TEMPLATE: "template",
+  SWITCH: "switch",
+  CUSTOM: "custom"
+};
+var StorageKeys = {
+  TEMPLATES: "__templates__",
+  SWITCHES: "__switches__"
+};
+var PropertyKeys = {
+  ID: "id",
+  TYPE: "type",
+  VALUE: "value",
+  BINDING: "binding"
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/guards.ts
+function isFluentBuilder(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (!(FLUENT_BUILDER_SYMBOL in value)) {
+    return false;
+  }
+  const obj = value;
+  return obj[FLUENT_BUILDER_SYMBOL] === true && typeof obj.build === "function";
+}
+function isBuilderArray(value) {
+  return Array.isArray(value) && value.every(isFluentBuilder);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isAsset(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return "type" in obj && typeof obj.type === "string";
+}
+function isAssetWrapper(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return "asset" in obj && typeof obj.asset === "object" && obj.asset !== null;
+}
+function isAssetWrapperWithAsset(value) {
+  return isAssetWrapper(value) && isAsset(value.asset);
+}
+function isAssetWrapperValue(value) {
+  return typeof value === "object" && value !== null && "asset" in value && Object.keys(value).length === 1;
+}
+function needsAssetWrapper(value) {
+  if (isAssetWrapper(value)) return false;
+  if (isFluentBuilder(value)) return false;
+  return isAsset(value);
+}
+function isSwitchResult(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return "staticSwitch" in obj || "dynamicSwitch" in obj;
+}
+function isStringOrUndefined(value) {
+  return value === void 0 || typeof value === "string";
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/id/registry.ts
+var IDRegistry = class {
+  usedIds;
+  isEnabled;
+  constructor(enabled = true) {
+    this.usedIds = /* @__PURE__ */ new Set();
+    this.isEnabled = enabled;
+  }
+  /**
+   * Ensures the given ID is unique, modifying it if necessary.
+   * If the ID already exists, appends a numeric suffix (-1, -2, etc.)
+   * until a unique ID is found.
+   *
+   * Special handling for template placeholders:
+   * - IDs ending with `_index_`, `_row_`, etc. are allowed as duplicates
+   * - IDs with placeholders followed by segments (e.g., `_index_.field`) enforce uniqueness
+   *
+   * @param baseId - The desired ID
+   * @returns A unique ID (either the original or modified with suffix)
+   *
+   * @example
+   * ```typescript
+   * const registry = new IDRegistry();
+   * registry.ensureUnique("my-id");         // "my-id"
+   * registry.ensureUnique("my-id");         // "my-id-1"
+   * registry.ensureUnique("list-_index_");  // "list-_index_" (allowed duplicate)
+   * registry.ensureUnique("list-_index_");  // "list-_index_" (allowed duplicate)
+   * ```
+   */
+  ensureUnique(baseId) {
+    if (!this.isEnabled) {
+      return baseId;
+    }
+    if (this.isTemplatePlaceholderID(baseId)) {
+      return baseId;
+    }
+    if (!this.usedIds.has(baseId)) {
+      this.usedIds.add(baseId);
+      return baseId;
+    }
+    let counter = 1;
+    let uniqueId = `${baseId}-${counter}`;
+    while (this.usedIds.has(uniqueId)) {
+      counter++;
+      uniqueId = `${baseId}-${counter}`;
+    }
+    this.usedIds.add(uniqueId);
+    return uniqueId;
+  }
+  /**
+   * Checks if an ID has already been used.
+   *
+   * @param id - The ID to check
+   * @returns true if the ID has been used, false otherwise
+   */
+  has(id) {
+    return this.usedIds.has(id);
+  }
+  /**
+   * Clears all registered IDs from the registry.
+   * Useful for resetting state between test runs or separate flows.
+   */
+  reset() {
+    this.usedIds.clear();
+  }
+  /**
+   * Enables or disables the uniqueness checking.
+   * When disabled, all IDs pass through unchanged.
+   *
+   * @param enabled - Whether to enable uniqueness checking
+   */
+  setEnabled(enabled) {
+    this.isEnabled = enabled;
+  }
+  /**
+   * Returns the number of unique IDs currently registered.
+   *
+   * @returns The count of registered IDs
+   */
+  size() {
+    return this.usedIds.size;
+  }
+  /**
+   * Returns a snapshot of all registered IDs.
+   * Useful for debugging and testing.
+   *
+   * @returns An array of all registered IDs
+   */
+  getRegisteredIds() {
+    return Array.from(this.usedIds);
+  }
+  /**
+   * Checks if an ID contains template placeholders that should be exempt from uniqueness checks.
+   * Template placeholders are patterns like `_index_`, `_index1_`, `_row_` that are replaced at runtime.
+   *
+   * IDs ending with just a placeholder (e.g., "parent-_index_") are allowed as duplicates.
+   * IDs with placeholders followed by additional segments (e.g., "parent-_index_-field") are not.
+   *
+   * @param id - The ID to check
+   * @returns true if the ID should be exempt from uniqueness checks
+   */
+  isTemplatePlaceholderID(id) {
+    const templatePlaceholderPattern = /_(?:index|row|item)\d*_$/;
+    return templatePlaceholderPattern.test(id);
+  }
+};
+var globalIdRegistry = new IDRegistry();
+function createIdRegistry(enabled = true) {
+  return new IDRegistry(enabled);
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/id/generator.ts
+var resetGlobalIdSet = () => {
+  globalIdRegistry.reset();
+};
+var _generateBaseId = (context, functionName) => {
+  if (!context) {
+    throw new Error(
+      `${functionName}: Context is undefined. Please provide a valid BaseBuildContext object.`
+    );
+  }
+  const { parentId, branch } = context;
+  let baseId;
+  if (!branch) {
+    baseId = parentId || "";
+  } else {
+    switch (branch.type) {
+      case "custom":
+        baseId = parentId || "";
+        break;
+      case "slot":
+        if (!branch.name) {
+          throw new Error(
+            `${functionName}: Slot branch requires a 'name' property. Context: ${JSON.stringify(context)}`
+          );
+        }
+        baseId = `${parentId ? `${parentId}-` : ""}${branch.name}`;
+        break;
+      case "array-item":
+        if (typeof branch.index !== "number") {
+          throw new Error(
+            `${functionName}: Array-item branch requires a numeric 'index' property. Got: ${typeof branch.index}. Context: ${JSON.stringify(context)}`
+          );
+        }
+        if (branch.index < 0) {
+          throw new Error(
+            `${functionName}: Array-item index must be non-negative. Got: ${branch.index}. Context: ${JSON.stringify(context)}`
+          );
+        }
+        baseId = `${parentId}-${branch.index}`;
+        break;
+      case "template":
+        if (branch.depth !== void 0 && branch.depth < 0) {
+          throw new Error(
+            `${functionName}: Template depth must be non-negative. Got: ${branch.depth}. Context: ${JSON.stringify(context)}`
+          );
+        }
+        baseId = `${parentId}-_index${branch.depth || ""}_`;
+        break;
+      case "switch":
+        if (typeof branch.index !== "number") {
+          throw new Error(
+            `${functionName}: Switch branch requires a numeric 'index' property. Got: ${typeof branch.index}. Context: ${JSON.stringify(context)}`
+          );
+        }
+        if (branch.index < 0) {
+          throw new Error(
+            `${functionName}: Switch index must be non-negative. Got: ${branch.index}. Context: ${JSON.stringify(context)}`
+          );
+        }
+        if (!branch.kind || !["static", "dynamic"].includes(branch.kind)) {
+          throw new Error(
+            `${functionName}: Switch branch requires 'kind' to be 'static' or 'dynamic'. Got: ${branch.kind}. Context: ${JSON.stringify(context)}`
+          );
+        }
+        baseId = `${parentId}-${branch.kind}Switch-${branch.index}`;
+        break;
+      default: {
+        const exhaustiveCheck = branch;
+        throw new Error(
+          `${functionName}: Unhandled branch type: ${JSON.stringify(exhaustiveCheck)}`
+        );
+      }
+    }
+  }
+  return baseId;
+};
+var peekId = (context) => {
+  return _generateBaseId(context, "peekId");
+};
+var genId = (context) => {
+  const baseId = _generateBaseId(context, "genId");
+  const { parentId, branch } = context;
+  if (process.env.NODE_ENV !== "production" && !parentId && !branch) {
+    console.warn(
+      "genId: Context appears incomplete (no parentId or branch). This may result in an empty or invalid ID. Consider using context helper functions from 'fluent/utils/context'."
+    );
+  }
+  if (process.env.NODE_ENV !== "production" && parentId === "") {
+    console.warn(
+      "genId: parentId is an empty string. This may indicate a missing or improperly initialized context."
+    );
+  }
+  const uniqueId = globalIdRegistry.ensureUnique(baseId);
+  if (process.env.NODE_ENV !== "production" && uniqueId !== baseId) {
+    console.warn(
+      `genId: ID collision detected. Original: "${baseId}", Modified to: "${uniqueId}". Consider providing more specific IDs to avoid collisions.`
+    );
+  }
+  return uniqueId;
+};
+function determineSlotName(parameterName, assetMetadata) {
+  if (!assetMetadata) {
+    return parameterName;
+  }
+  const { type, binding: binding2, value } = assetMetadata;
+  if (type === "action" && value) {
+    const cleanValue = value.replace(/^\{\{|\}\}$/g, "");
+    const segments = cleanValue.split(".");
+    const lastSegment = segments[segments.length - 1];
+    return lastSegment ? `${type}-${lastSegment}` : type;
+  }
+  if (type !== "action" && binding2) {
+    const cleanBinding = binding2.replace(/^\{\{|\}\}$/g, "");
+    const segments = cleanBinding.split(".");
+    const lastSegment = segments[segments.length - 1];
+    if (lastSegment) {
+      return `${type || parameterName}-${lastSegment}`;
+    }
+  }
+  return type || parameterName;
+}
+function generateAssetId(params) {
+  const {
+    context,
+    parameterName = "asset",
+    assetMetadata,
+    explicitId
+  } = params;
+  if (explicitId) {
+    return explicitId;
+  }
+  if (context && "parentId" in context) {
+    const slotName2 = determineSlotName(parameterName, assetMetadata);
+    if (context.branch) {
+      const baseId = genId(context);
+      return genId({
+        ...context,
+        parentId: baseId,
+        branch: { type: BranchTypes.SLOT, name: slotName2 }
+      });
+    }
+    if (context.parentId) {
+      return genId({
+        ...context,
+        branch: { type: BranchTypes.SLOT, name: slotName2 }
+      });
+    }
+  }
+  const slotName = determineSlotName(parameterName, assetMetadata);
+  return slotName;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/context.ts
+function buildContextParams(parentContext, parameterName, index) {
+  const params = {
+    parentContext,
+    parameterName
+  };
+  if (index !== void 0) {
+    return { ...params, index };
+  }
+  return params;
+}
+function createNestedContext({
+  parentContext,
+  parameterName,
+  index,
+  assetMetadata
+}) {
+  if (parentContext.nestedContextGenerator) {
+    const contextParams = buildContextParams(
+      parentContext,
+      parameterName,
+      index
+    );
+    const generated = parentContext.nestedContextGenerator(contextParams);
+    return generated;
+  }
+  const slotName = determineSlotName(parameterName, assetMetadata);
+  let generatedId;
+  let branch;
+  if (parentContext && "parentId" in parentContext) {
+    if (index !== void 0) {
+      generatedId = peekId({
+        parentId: parentContext.parentId,
+        branch: { type: BranchTypes.SLOT, name: slotName }
+      });
+      branch = { type: BranchTypes.ARRAY_ITEM, index };
+    } else {
+      generatedId = genId({
+        parentId: parentContext.parentId,
+        branch: { type: BranchTypes.SLOT, name: slotName }
+      });
+    }
+  }
+  const newContext = index !== void 0 ? {
+    ...parentContext,
+    parameterName,
+    index,
+    ...generatedId ? { parentId: generatedId } : {},
+    ...assetMetadata ? { assetMetadata } : {},
+    ...branch ? { branch } : {}
+  } : {
+    ...parentContext,
+    parameterName,
+    ...generatedId ? { parentId: generatedId } : {},
+    ...assetMetadata ? { assetMetadata } : {}
+  };
+  return newContext;
+}
+function createTemplateContext({
+  parentContext,
+  depth = 0
+}) {
+  const parentId = genId(parentContext);
+  const templateContext = {
+    ...parentContext,
+    parentId,
+    branch: {
+      type: BranchTypes.TEMPLATE,
+      depth
+    }
+  };
+  return templateContext;
+}
+function createSwitchContext({
+  parentContext,
+  index,
+  kind
+}) {
+  const switchContext = {
+    ...parentContext,
+    branch: {
+      type: BranchTypes.SWITCH,
+      index,
+      kind
+    }
+  };
+  return switchContext;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/tagged-template/types.ts
+var TaggedTemplateValueSymbol = Symbol(
+  "TaggedTemplateValue"
+);
+function isTaggedTemplateValue(value) {
+  return typeof value === "object" && value !== null && TaggedTemplateValueSymbol in value;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/tagged-template/binding.ts
+function binding(strings, ...expressions) {
+  let indexCounter = 0;
+  const processValue = (val) => {
+    if (!val.includes("_index_")) return val;
+    return val.replace(/_index_/g, () => {
+      const suffix = indexCounter > 0 ? indexCounter : "";
+      indexCounter++;
+      return `_index${suffix}_`;
+    });
+  };
+  let result = "";
+  const len = strings.length;
+  for (let i = 0; i < len; i++) {
+    result += processValue(strings[i]);
+    if (i < expressions.length) {
+      const expr = expressions[i];
+      if (isTaggedTemplateValue(expr)) {
+        const refStr = expr.toRefString();
+        if (refStr.startsWith("@[")) {
+          result += expr.toRefString({ nestedContext: "binding" });
+        } else {
+          result += expr.toString();
+        }
+      } else if (typeof expr === "string") {
+        result += processValue(expr);
+      } else {
+        result += String(expr);
+      }
+    }
+  }
+  const templateValue = {
+    [TaggedTemplateValueSymbol]: true,
+    _phantomType: void 0,
+    toValue() {
+      return result;
+    },
+    toRefString(options) {
+      if (options?.nestedContext === "binding") {
+        return result;
+      }
+      return `{{${result}}}`;
+    },
+    toString() {
+      return `{{${result}}}`;
+    }
+  };
+  return templateValue;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/tagged-template/expression.ts
+function expression(strings, ...expressions) {
+  const validateSyntax = (expr) => {
+    let openParens = 0;
+    let position = 0;
+    for (const char of expr) {
+      if (char === "(") openParens++;
+      if (char === ")") openParens--;
+      position++;
+      if (openParens < 0) {
+        throw new Error(
+          `Error: Unexpected ) at character ${position} in expression: 
+ ${expr.slice(
+            0,
+            position
+          )}\u2588${expr.slice(position)}`
+        );
+      }
+    }
+    if (openParens > 0) {
+      throw new Error(
+        `Error: Expected ) at character ${position} in expression: 
+ ${expr}\u2588`
+      );
+    }
+  };
+  let result = "";
+  const len = strings.length;
+  for (let i = 0; i < len; i++) {
+    result += strings[i];
+    if (i < expressions.length) {
+      const expr = expressions[i];
+      if (isTaggedTemplateValue(expr)) {
+        result += expr.toRefString({ nestedContext: "expression" });
+      } else {
+        result += String(expr);
+      }
+    }
+  }
+  validateSyntax(result);
+  return {
+    [TaggedTemplateValueSymbol]: true,
+    toValue() {
+      return result;
+    },
+    toRefString(options) {
+      if (options?.nestedContext === "binding") {
+        return `\`${result}\``;
+      } else if (options?.nestedContext === "expression") {
+        return result;
+      }
+      return `@[${result}]@`;
+    },
+    toString() {
+      return `@[${result}]@`;
+    }
+  };
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/tagged-template/extract-bindings-from-schema.ts
+function extractBindingsFromSchema(schema) {
+  const primitiveTypes = /* @__PURE__ */ new Set(["StringType", "NumberType", "BooleanType"]);
+  const isPrimitive = (typeName) => {
+    return primitiveTypes.has(typeName);
+  };
+  const createBinding = (typeName, path) => {
+    if (typeName === "StringType") {
+      return binding`${path}`;
+    }
+    if (typeName === "NumberType") {
+      return binding`${path}`;
+    }
+    if (typeName === "BooleanType") {
+      return binding`${path}`;
+    }
+    return binding`${path}`;
+  };
+  const processDataType = (dataType, schema2, path, visited = /* @__PURE__ */ new Set()) => {
+    const typeName = dataType.type;
+    if (visited.has(typeName)) {
+      return createBinding("StringType", path);
+    }
+    if ("isArray" in dataType && dataType.isArray) {
+      const arrayPath = path ? `${path}._current_` : "_current_";
+      if (isPrimitive(typeName)) {
+        if (typeName === "StringType") {
+          return { name: createBinding(typeName, arrayPath) };
+        } else {
+          return { value: createBinding(typeName, arrayPath) };
+        }
+      } else {
+        const typeNode2 = schema2[typeName];
+        if (typeNode2) {
+          const newVisited = new Set(visited);
+          newVisited.add(typeName);
+          return processNode(
+            typeNode2,
+            schema2,
+            arrayPath,
+            newVisited
+          );
+        }
+        return createBinding("StringType", arrayPath);
+      }
+    }
+    if ("isRecord" in dataType && dataType.isRecord) {
+      const typeNode2 = schema2[typeName];
+      if (typeNode2) {
+        const newVisited = new Set(visited);
+        newVisited.add(typeName);
+        return processNode(typeNode2, schema2, path, newVisited);
+      }
+      return createBinding("StringType", path);
+    }
+    if (isPrimitive(typeName)) {
+      return createBinding(typeName, path);
+    }
+    const typeNode = schema2[typeName];
+    if (typeNode) {
+      const newVisited = new Set(visited);
+      newVisited.add(typeName);
+      return processNode(typeNode, schema2, path, newVisited);
+    }
+    return createBinding("StringType", path);
+  };
+  const processNode = (node, schema2, basePath, visited = /* @__PURE__ */ new Set()) => {
+    const result = {};
+    Object.entries(node).forEach(([key, dataType]) => {
+      const path = basePath ? `${basePath}.${key}` : key;
+      result[key] = processDataType(dataType, schema2, path, visited);
+    });
+    return result;
+  };
+  return processNode(schema.ROOT, schema, "");
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/tagged-template/std.ts
+function and(...args) {
+  const expressions = args.map((arg) => {
+    if (isTaggedTemplateValue(arg)) {
+      const expr = arg.toRefString({ nestedContext: "expression" });
+      if (expr.includes(" || ") && !expr.startsWith("(")) {
+        return `(${expr})`;
+      }
+      return expr;
+    }
+    return String(arg);
+  });
+  return expression`${expressions.join(" && ")}`;
+}
+function or(...args) {
+  const expressions = args.map((arg) => {
+    if (isTaggedTemplateValue(arg)) {
+      return arg.toRefString({ nestedContext: "expression" });
+    }
+    return String(arg);
+  });
+  return expression`${expressions.join(" || ")}`;
+}
+function not(value) {
+  const expr = isTaggedTemplateValue(value) ? value.toRefString({ nestedContext: "expression" }) : String(value);
+  return expression`!${expr}`;
+}
+function nor(...args) {
+  return not(or(...args));
+}
+function nand(...args) {
+  return not(and(...args));
+}
+function xor(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : String(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : String(right);
+  return expression`(${leftExpr} && !${rightExpr}) || (!${leftExpr} && ${rightExpr})`;
+}
+function equal(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} == ${rightExpr}`;
+}
+function strictEqual(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} === ${rightExpr}`;
+}
+function notEqual(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} != ${rightExpr}`;
+}
+function strictNotEqual(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} !== ${rightExpr}`;
+}
+function greaterThan(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} > ${rightExpr}`;
+}
+function greaterThanOrEqual(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} >= ${rightExpr}`;
+}
+function lessThan(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} < ${rightExpr}`;
+}
+function lessThanOrEqual(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : JSON.stringify(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : JSON.stringify(right);
+  return expression`${leftExpr} <= ${rightExpr}`;
+}
+function add(...args) {
+  const expressions = args.map((arg) => {
+    if (isTaggedTemplateValue(arg)) {
+      return arg.toRefString({ nestedContext: "expression" });
+    }
+    return String(arg);
+  });
+  return expression`${expressions.join(" + ")}`;
+}
+function subtract(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : String(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : String(right);
+  return expression`${leftExpr} - ${rightExpr}`;
+}
+function multiply(...args) {
+  const expressions = args.map((arg) => {
+    if (isTaggedTemplateValue(arg)) {
+      return arg.toRefString({ nestedContext: "expression" });
+    }
+    return String(arg);
+  });
+  return expression`${expressions.join(" * ")}`;
+}
+function divide(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : String(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : String(right);
+  return expression`${leftExpr} / ${rightExpr}`;
+}
+function modulo(left, right) {
+  const leftExpr = isTaggedTemplateValue(left) ? left.toRefString({ nestedContext: "expression" }) : String(left);
+  const rightExpr = isTaggedTemplateValue(right) ? right.toRefString({ nestedContext: "expression" }) : String(right);
+  return expression`${leftExpr} % ${rightExpr}`;
+}
+function conditional(condition, ifTrue, ifFalse) {
+  const conditionExpr = isTaggedTemplateValue(condition) ? condition.toRefString({ nestedContext: "expression" }) : String(condition);
+  const trueExpr = isTaggedTemplateValue(ifTrue) ? ifTrue.toRefString({ nestedContext: "expression" }) : JSON.stringify(ifTrue);
+  const falseExpr = isTaggedTemplateValue(ifFalse) ? ifFalse.toRefString({ nestedContext: "expression" }) : JSON.stringify(ifFalse);
+  return expression`${conditionExpr} ? ${trueExpr} : ${falseExpr}`;
+}
+function call(functionName, ...args) {
+  const argExpressions = args.map((arg) => {
+    if (isTaggedTemplateValue(arg)) {
+      return arg.toRefString({
+        nestedContext: "expression"
+      });
+    }
+    return JSON.stringify(arg);
+  });
+  return expression`${functionName}(${argExpressions.join(", ")})`;
+}
+function literal(value) {
+  return expression`${JSON.stringify(value)}`;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/value-resolver.ts
+function extractObject(value, options) {
+  const visited = options.visited ?? /* @__PURE__ */ new WeakSet();
+  if (visited.has(value)) {
+    return value;
+  }
+  visited.add(value);
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    result[key] = extractValue(val, { propertyKey: key, visited });
+  }
+  return result;
+}
+function extractValue(value, options = {}) {
+  const { propertyKey, visited = /* @__PURE__ */ new WeakSet() } = options;
+  if (isTaggedTemplateValue(value)) {
+    if (propertyKey === "data" || propertyKey === "binding") {
+      return value.toValue();
+    }
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) {
+      return value;
+    }
+    visited.add(value);
+    return value.map((item) => extractValue(item, { visited }));
+  }
+  if (isPlainObject(value) && !isFluentBuilder(value) && !isAssetWrapper(value)) {
+    return extractObject(value, { visited });
+  }
+  return value;
+}
+function wrapAsset(asset, context, slotName) {
+  if (!context) {
+    return { asset };
+  }
+  if (asset.id) {
+    return { asset: { ...asset } };
+  }
+  const parentId = peekId(context);
+  const slotCtx = {
+    parentId,
+    branch: { type: BranchTypes.SLOT, name: slotName }
+  };
+  return {
+    asset: {
+      ...asset,
+      id: genId(slotCtx)
+    }
+  };
+}
+function resolveValue(value, options = {}) {
+  const { context, propertyName, visited = /* @__PURE__ */ new WeakSet() } = options;
+  if (isTaggedTemplateValue(value)) {
+    if (propertyName === "data" || propertyName === "binding") {
+      return value.toValue();
+    }
+    return value.toString();
+  }
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (isFluentBuilder(value)) {
+    return value.build(context);
+  }
+  if (isAssetWrapper(value)) {
+    if (visited.has(value)) return value;
+    visited.add(value);
+    const innerAsset = value.asset;
+    const resolvedAsset = resolveValue(innerAsset, {
+      context,
+      propertyName,
+      visited
+    });
+    return { asset: resolvedAsset };
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) return value;
+    visited.add(value);
+    return value.filter((item) => item !== null && item !== void 0).map((item, index) => {
+      const arrayContext = context ? createNestedContext({
+        parentContext: context,
+        parameterName: propertyName || "array",
+        index
+      }) : void 0;
+      return resolveValue(item, {
+        context: arrayContext,
+        propertyName: String(index),
+        visited
+      });
+    });
+  }
+  if (isPlainObject(value) && !isAsset(value)) {
+    if (visited.has(value)) return value;
+    visited.add(value);
+    const resolved = {};
+    for (const [key, val] of Object.entries(value)) {
+      const nestedContext = context ? createNestedContext({ parentContext: context, parameterName: key }) : void 0;
+      resolved[key] = resolveValue(val, {
+        context: nestedContext,
+        propertyName: key,
+        visited
+      });
+    }
+    return resolved;
+  }
+  return value;
+}
+function resolveAndWrapAsset(value, options) {
+  const { context, slotName, visited = /* @__PURE__ */ new WeakSet() } = options;
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (isAssetWrapper(value)) {
+    if (visited.has(value)) return value;
+    visited.add(value);
+    const resolvedAsset = resolveValue(value.asset, {
+      context,
+      propertyName: slotName,
+      visited
+    });
+    return { asset: resolvedAsset };
+  }
+  if (isFluentBuilder(value)) {
+    if (!context) {
+      const built2 = value.build(void 0);
+      if (isAssetWrapper(built2)) {
+        return built2;
+      }
+      if (isAsset(built2)) {
+        return { asset: built2 };
+      }
+      return built2;
+    }
+    const parentId = peekId(context);
+    const slotContext = {
+      ...context,
+      parentId,
+      branch: { type: BranchTypes.SLOT, name: slotName }
+    };
+    const built = value.build(slotContext);
+    if (isAssetWrapper(built)) {
+      return built;
+    }
+    if (isAsset(built)) {
+      return { asset: built };
+    }
+    return built;
+  }
+  if (isAsset(value)) {
+    return wrapAsset(value, context, slotName);
+  }
+  return resolveValue(value, { context, propertyName: slotName, visited });
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/storage/value-storage.ts
+var ValueStorage = class _ValueStorage {
+  values = {};
+  builders = /* @__PURE__ */ new Map();
+  mixedArrays = /* @__PURE__ */ new Map();
+  constructor(initial) {
+    if (initial) {
+      Object.entries(initial).forEach(([key, value]) => {
+        this.set(key, value);
+      });
+    }
+  }
+  /**
+   * Sets a property value, intelligently routing it to the appropriate storage
+   *
+   * This method performs runtime type checking to determine how to store the value:
+   * - FluentBuilder instances → builders Map
+   * - Arrays with builders → mixedArrays Map
+   * - Objects with builders → builders Map
+   * - Everything else → values (static storage)
+   */
+  set(key, value) {
+    const keyStr = String(key);
+    if (isFluentBuilder(value)) {
+      this.builders.set(keyStr, value);
+      delete this.values[key];
+      this.mixedArrays.delete(keyStr);
+    } else if (Array.isArray(value)) {
+      this.handleArrayValue(key, keyStr, value);
+    } else if (typeof value === "object" && value !== null && this.containsBuilder(value)) {
+      this.builders.set(keyStr, value);
+      delete this.values[key];
+      this.mixedArrays.delete(keyStr);
+    } else {
+      this.setStaticValue(key, keyStr, value);
+    }
+  }
+  /**
+   * Handles array value storage, detecting mixed arrays with builders
+   */
+  handleArrayValue(key, keyStr, value) {
+    const builderIndices = /* @__PURE__ */ new Set();
+    const objectIndices = /* @__PURE__ */ new Set();
+    value.forEach((item, index) => {
+      if (isFluentBuilder(item)) {
+        builderIndices.add(index);
+      } else if (typeof item === "object" && item !== null && this.containsBuilder(item)) {
+        objectIndices.add(index);
+      }
+    });
+    const hasBuilders = builderIndices.size > 0 || objectIndices.size > 0;
+    if (hasBuilders) {
+      this.mixedArrays.set(keyStr, {
+        array: value,
+        builderIndices,
+        objectIndices
+      });
+      delete this.values[key];
+    } else {
+      this.setStaticValue(key, keyStr, value);
+      this.mixedArrays.delete(keyStr);
+    }
+    this.builders.delete(keyStr);
+  }
+  /**
+   * Sets a static value with proper type handling
+   */
+  setStaticValue(key, keyStr, value) {
+    this.values[key] = value;
+    this.builders.delete(keyStr);
+    this.mixedArrays.delete(keyStr);
+  }
+  /**
+   * Checks if an object contains any builders recursively
+   * Handles circular references gracefully
+   */
+  containsBuilder(obj, visited = /* @__PURE__ */ new WeakSet()) {
+    if (isFluentBuilder(obj)) return true;
+    if (!obj || typeof obj !== "object") return false;
+    if (visited.has(obj)) return false;
+    visited.add(obj);
+    if (Array.isArray(obj)) {
+      return obj.some((item) => this.containsBuilder(item, visited));
+    }
+    const proto = Object.getPrototypeOf(obj);
+    if (proto === Object.prototype || proto === null) {
+      return Object.values(obj).some(
+        (val) => this.containsBuilder(val, visited)
+      );
+    }
+    return false;
+  }
+  /**
+   * Checks if a property has been set
+   */
+  has(key) {
+    const keyStr = String(key);
+    return key in this.values || this.builders.has(keyStr) || this.mixedArrays.has(keyStr);
+  }
+  /**
+   * Peeks at a property value without resolving builders
+   * Returns the raw value if it's static, the array if it's mixed, or undefined if it's a builder
+   */
+  peek(key) {
+    const keyStr = String(key);
+    const mixedArray = this.mixedArrays.get(keyStr);
+    if (mixedArray) {
+      return mixedArray.array;
+    }
+    if (this.builders.has(keyStr)) {
+      return void 0;
+    }
+    return this.values[key];
+  }
+  /**
+   * Gets builder for a property if one is set
+   */
+  peekBuilder(key) {
+    const keyStr = String(key);
+    const entry = this.builders.get(keyStr);
+    if (!entry) return void 0;
+    if (isFluentBuilder(entry)) {
+      return entry;
+    }
+    return void 0;
+  }
+  /**
+   * Gets the type of value stored for a property
+   */
+  getValueType(key) {
+    const keyStr = String(key);
+    if (this.mixedArrays.has(keyStr)) {
+      return "mixed-array";
+    }
+    if (this.builders.has(keyStr)) {
+      return "builder";
+    }
+    if (key in this.values) {
+      return "static";
+    }
+    return "unset";
+  }
+  /**
+   * Gets all static values for the build pipeline
+   */
+  getValues() {
+    return this.values;
+  }
+  /**
+   * Gets all builder entries for the build pipeline
+   */
+  getBuilders() {
+    return this.builders;
+  }
+  /**
+   * Gets all mixed array entries for the build pipeline
+   */
+  getMixedArrays() {
+    return this.mixedArrays;
+  }
+  /**
+   * Unsets a property, removing it from storage
+   */
+  unset(key) {
+    const keyStr = String(key);
+    delete this.values[key];
+    this.builders.delete(keyStr);
+    this.mixedArrays.delete(keyStr);
+  }
+  /**
+   * Clears all properties from storage
+   */
+  clear() {
+    this.values = {};
+    this.builders.clear();
+    this.mixedArrays.clear();
+  }
+  /**
+   * Clones the storage, creating an independent copy
+   */
+  clone() {
+    const cloned = new _ValueStorage();
+    cloned.values = { ...this.values };
+    cloned.builders = new Map(this.builders);
+    cloned.mixedArrays = new Map(
+      Array.from(this.mixedArrays.entries()).map(([key, metadata]) => [
+        key,
+        {
+          array: metadata.array,
+          builderIndices: new Set(metadata.builderIndices),
+          objectIndices: new Set(metadata.objectIndices)
+        }
+      ])
+    );
+    return cloned;
+  }
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/storage/auxiliary-storage.ts
+var AuxiliaryStorage = class _AuxiliaryStorage {
+  data = /* @__PURE__ */ new Map();
+  /**
+   * Sets auxiliary data with a given key
+   */
+  set(key, value) {
+    this.data.set(key, value);
+  }
+  /**
+   * Gets auxiliary data with type assertion
+   * The caller is responsible for knowing the correct type
+   */
+  get(key) {
+    const value = this.data.get(key);
+    return value;
+  }
+  /**
+   * Pushes an item to an auxiliary data array
+   * Creates the array if it doesn't exist
+   */
+  push(key, item) {
+    const existing = this.data.get(key);
+    if (Array.isArray(existing)) {
+      existing.push(item);
+    } else {
+      this.data.set(key, [item]);
+    }
+  }
+  /**
+   * Gets an auxiliary data array
+   * Returns empty array if doesn't exist or isn't an array
+   */
+  getArray(key) {
+    const existing = this.data.get(key);
+    return Array.isArray(existing) ? existing : [];
+  }
+  /**
+   * Checks if auxiliary data exists for a key
+   */
+  has(key) {
+    return this.data.has(key);
+  }
+  /**
+   * Deletes auxiliary data for a key
+   */
+  delete(key) {
+    return this.data.delete(key);
+  }
+  /**
+   * Clears all auxiliary data
+   */
+  clear() {
+    this.data.clear();
+  }
+  /**
+   * Clones the auxiliary storage, creating an independent copy
+   */
+  clone() {
+    const cloned = new _AuxiliaryStorage();
+    cloned.data = new Map(this.data);
+    return cloned;
+  }
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/static-values.ts
+function resolveStaticValues(storage, result, context) {
+  const values = storage.getValues();
+  for (const [key, value] of Object.entries(values)) {
+    if (!isAssetWrapperValue(value)) {
+      const extracted = extractValue(value, { propertyKey: key });
+      result[key] = resolveValue(extracted, { context, propertyName: key });
+    } else {
+      result[key] = value;
+    }
+  }
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/asset-id.ts
+function generateAssetIdForBuilder(storage, result, context) {
+  const hasIdSet = storage.has("id");
+  const hasType = storage.has("type") || "type" in result;
+  const hasIdField = "id" in result;
+  if (!hasIdSet && hasType) {
+    const typeValue = result.type;
+    const assetValue = result.value;
+    const assetBinding = result.binding;
+    if (!isStringOrUndefined(typeValue)) {
+      return;
+    }
+    if (!isStringOrUndefined(assetValue)) {
+      return;
+    }
+    if (!isStringOrUndefined(assetBinding)) {
+      return;
+    }
+    const assetMetadata = {
+      type: typeValue,
+      ...assetValue ? { value: assetValue } : {},
+      ...assetBinding ? { binding: assetBinding } : {}
+    };
+    const generatedId = generateAssetId({
+      context,
+      parameterName: typeValue,
+      assetMetadata,
+      explicitId: void 0
+    });
+    if (generatedId) {
+      result.id = generatedId;
+    }
+  } else if (!hasIdSet && hasIdField && !hasType && context && context.branch) {
+    const generatedId = generateAssetId({
+      context,
+      parameterName: "item",
+      assetMetadata: void 0,
+      explicitId: void 0
+    });
+    if (generatedId) {
+      result.id = generatedId;
+    }
+  }
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/asset-wrappers.ts
+function resolveAssetWrappers(storage, result, nestedParentContext) {
+  if (!nestedParentContext) {
+    return;
+  }
+  const values = storage.getValues();
+  for (const key of Object.keys(values)) {
+    const value = values[key];
+    if (isAssetWrapperValue(value)) {
+      const unwrapped = value.asset;
+      if (Array.isArray(unwrapped)) {
+        result[key] = resolveAssetWrapperArray(
+          unwrapped,
+          nestedParentContext,
+          key
+        );
+      } else {
+        result[key] = resolveAndWrapAsset(unwrapped, {
+          context: nestedParentContext,
+          slotName: key
+        });
+      }
+    }
+  }
+}
+function resolveAssetWrapperArray(array, context, key) {
+  return array.filter((item) => item !== null && item !== void 0).map((item, index) => {
+    const slotName = `${key}-${index}`;
+    return resolveAndWrapAsset(item, { context, slotName });
+  });
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/mixed-arrays.ts
+function resolveMixedArrays(storage, result, nestedParentContext) {
+  const mixedArrays = storage.getMixedArrays();
+  mixedArrays.forEach((metadata, key) => {
+    const { array, builderIndices, objectIndices } = metadata;
+    const currentValue = result[key];
+    if (isAssetWrapperValue(currentValue)) {
+      resolveMixedArrayAsAssetWrapper(
+        result,
+        key,
+        currentValue,
+        nestedParentContext
+      );
+    } else {
+      resolveMixedArrayNormal(
+        result,
+        key,
+        array,
+        builderIndices,
+        objectIndices,
+        nestedParentContext
+      );
+    }
+  });
+}
+function resolveMixedArrayAsAssetWrapper(result, key, wrapperValue, nestedParentContext) {
+  const unwrappedArray = wrapperValue.asset;
+  if (Array.isArray(unwrappedArray)) {
+    result[key] = unwrappedArray.filter((item) => item !== null && item !== void 0).map((item, index) => {
+      const slotName = `${key}-${index}`;
+      return resolveAndWrapAsset(item, {
+        context: nestedParentContext,
+        slotName
+      });
+    });
+  }
+}
+function resolveMixedArrayNormal(result, key, array, builderIndices, objectIndices, nestedParentContext) {
+  result[key] = array.filter((item) => item !== null && item !== void 0).map((item, index) => {
+    const slotName = `${key}-${index}`;
+    return resolveAndWrapAsset(item, {
+      context: nestedParentContext,
+      slotName
+    });
+  });
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/builders.ts
+function resolveBuilders(storage, result, nestedParentContext) {
+  const builders = storage.getBuilders();
+  builders.forEach((value, key) => {
+    if (isAssetWrapperValue(value)) {
+      resolveBuilderAsAssetWrapper(result, key, value, nestedParentContext);
+    } else {
+      resolveBuilderNormal(result, key, value, nestedParentContext);
+    }
+  });
+}
+function resolveBuilderAsAssetWrapper(result, key, wrapperValue, nestedParentContext) {
+  const unwrapped = wrapperValue.asset;
+  if (nestedParentContext) {
+    if (Array.isArray(unwrapped)) {
+      result[key] = unwrapped.filter((item) => item !== null && item !== void 0).map((item, index) => {
+        const slotName = `${key}-${index}`;
+        return resolveAndWrapAsset(item, {
+          context: nestedParentContext,
+          slotName
+        });
+      });
+    } else {
+      result[key] = resolveAndWrapAsset(unwrapped, {
+        context: nestedParentContext,
+        slotName: key
+      });
+    }
+  } else {
+    result[key] = resolveValue(wrapperValue, {});
+  }
+}
+function resolveBuilderNormal(result, key, value, nestedParentContext) {
+  result[key] = resolveAndWrapAsset(value, {
+    context: nestedParentContext,
+    slotName: key
+  });
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/path-resolver.ts
+function asRecordOrEmpty(value) {
+  return isPlainObject(value) ? value : {};
+}
+function setValueAtPath(obj, path, value) {
+  if (path.length === 0) return;
+  if (path.length === 1) {
+    obj[path[0]] = value;
+    return;
+  }
+  const [currentKey, ...restPath] = path;
+  const nextKey = restPath[0];
+  const currentValue = obj[currentKey];
+  const isAssetWrapperWithArray = isAssetWrapperValue(currentValue) && Array.isArray(currentValue.asset);
+  if (isAssetWrapperWithArray && typeof nextKey === "number") {
+    setValueInAssetWrapperArray(
+      obj,
+      currentKey,
+      currentValue,
+      nextKey,
+      restPath,
+      value
+    );
+  } else if (Array.isArray(currentValue) && typeof nextKey === "number") {
+    setValueInArray(obj, currentKey, currentValue, nextKey, restPath, value);
+  } else {
+    setValueInObject(obj, currentKey, restPath, value);
+  }
+}
+function setValueInAssetWrapperArray(obj, currentKey, wrappedArray, nextKey, restPath, value) {
+  const arrayResult = [...wrappedArray.asset];
+  if (restPath.length === 1) {
+    arrayResult[nextKey] = value;
+  } else {
+    const nestedObj = asRecordOrEmpty(arrayResult[nextKey]);
+    setValueAtPath(nestedObj, restPath.slice(1), value);
+    arrayResult[nextKey] = nestedObj;
+  }
+  obj[currentKey] = { asset: arrayResult };
+}
+function setValueInArray(obj, currentKey, array, nextKey, restPath, value) {
+  const arrayResult = [...array];
+  if (restPath.length === 1) {
+    arrayResult[nextKey] = value;
+  } else {
+    const nestedObj = asRecordOrEmpty(arrayResult[nextKey]);
+    setValueAtPath(nestedObj, restPath.slice(1), value);
+    arrayResult[nextKey] = nestedObj;
+  }
+  obj[currentKey] = arrayResult;
+}
+function setValueInObject(obj, currentKey, restPath, value) {
+  const nestedObj = asRecordOrEmpty(obj[currentKey]);
+  setValueAtPath(nestedObj, restPath, value);
+  obj[currentKey] = nestedObj;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/switches.ts
+function resolveSwitches(auxiliaryStorage, result, nestedParentContext, arrayProperties) {
+  const switches = auxiliaryStorage.getArray(
+    StorageKeys.SWITCHES
+  );
+  if (switches.length === 0 || !nestedParentContext) {
+    return;
+  }
+  let globalCaseIndex = 0;
+  switches.forEach(({ path, switchFn }) => {
+    const propertyName = String(path[0]);
+    const switchParentId = nestedParentContext.parentId ? `${nestedParentContext.parentId}-${propertyName}` : propertyName;
+    const switchContext = {
+      ...nestedParentContext,
+      parentId: switchParentId,
+      branch: void 0
+    };
+    let switchResult = switchFn(switchContext, globalCaseIndex);
+    if (isSwitchResult(switchResult)) {
+      const switchCases = switchResult.staticSwitch ?? switchResult.dynamicSwitch;
+      if (Array.isArray(switchCases)) {
+        globalCaseIndex += switchCases.length;
+      }
+    }
+    if (arrayProperties.has(propertyName) && path.length === 1) {
+      switchResult = [switchResult];
+    }
+    setValueAtPath(result, path, switchResult);
+  });
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/templates.ts
+function resolveTemplates(auxiliaryStorage, result, context) {
+  const templateFns = auxiliaryStorage.getArray(StorageKeys.TEMPLATES);
+  if (templateFns.length === 0) {
+    return;
+  }
+  if (!context) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `resolveTemplates: ${templateFns.length} template(s) exist but no context provided. Templates will be ignored. Pass a build context to .build() to enable template resolution.`
+      );
+    }
+    return;
+  }
+  const templates = templateFns.map((fn) => fn(context));
+  result.template = templates;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/steps/nested-asset-wrappers.ts
+function resolveNestedAssetWrappers(result, context, assetWrapperPaths) {
+  if (assetWrapperPaths.length === 0) {
+    return;
+  }
+  for (const path of assetWrapperPaths) {
+    if (path.length === 0) {
+      continue;
+    }
+    if (path.length < 2) {
+      continue;
+    }
+    resolvePathInResult(result, path, context);
+  }
+}
+function resolvePathInResult(result, path, context) {
+  let current = result;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (!isPlainObject(current)) {
+      return;
+    }
+    let next = current[key];
+    if (next === void 0 || next === null) {
+      return;
+    }
+    if (isFluentBuilder(next)) {
+      next = resolveValue(next, { context, propertyName: key });
+      current[key] = next;
+    }
+    current = next;
+  }
+  const finalKey = path[path.length - 1];
+  if (!isPlainObject(current)) {
+    return;
+  }
+  const parent = current;
+  const value = parent[finalKey];
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (isAssetWrapper(value)) {
+    return;
+  }
+  const slotName = path.join("-");
+  if (Array.isArray(value)) {
+    parent[finalKey] = value.filter((item) => item !== null && item !== void 0).map((item, index) => {
+      if (isAssetWrapper(item)) {
+        return item;
+      }
+      return resolveAndWrapAsset(item, {
+        context,
+        slotName: `${slotName}-${index}`
+      });
+    });
+    return;
+  }
+  if (isFluentBuilder(value) || isAsset(value)) {
+    parent[finalKey] = resolveAndWrapAsset(value, {
+      context,
+      slotName
+    });
+  }
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/resolution/pipeline.ts
+function createNestedParentContext(result, context) {
+  if (!context) {
+    return void 0;
+  }
+  const parentId = "id" in result && typeof result.id === "string" ? result.id : void 0;
+  return {
+    ...context,
+    parentId,
+    branch: void 0
+  };
+}
+function executeBuildPipeline(valueStorage, auxiliaryStorage, defaults, context, arrayProperties, assetWrapperPaths = []) {
+  const result = defaults ? { ...defaults } : {};
+  resolveStaticValues(valueStorage, result, context);
+  generateAssetIdForBuilder(valueStorage, result, context);
+  const nestedParentContext = createNestedParentContext(result, context);
+  resolveAssetWrappers(valueStorage, result, nestedParentContext);
+  resolveMixedArrays(valueStorage, result, nestedParentContext);
+  resolveBuilders(valueStorage, result, nestedParentContext);
+  resolveNestedAssetWrappers(result, nestedParentContext, assetWrapperPaths);
+  resolveSwitches(
+    auxiliaryStorage,
+    result,
+    nestedParentContext,
+    arrayProperties
+  );
+  resolveTemplates(auxiliaryStorage, result, context);
+  return result;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/conditional/index.ts
+function resolveValueOrFunction(value) {
+  if (typeof value === "function" && !isFluentBuilder(value)) {
+    return value();
+  }
+  return value;
+}
+function shouldWrapInAssetWrapper(value) {
+  if (isAssetWrapperValue(value)) {
+    return false;
+  }
+  if (isFluentBuilder(value)) {
+    return true;
+  }
+  if (isAsset(value)) {
+    return true;
+  }
+  if (Array.isArray(value) && value.length > 0) {
+    const firstItem = value[0];
+    return isFluentBuilder(firstItem) || isAsset(firstItem);
+  }
+  return false;
+}
+function maybeWrapAsset(value) {
+  if (shouldWrapInAssetWrapper(value)) {
+    return { asset: value };
+  }
+  return value;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/switch/index.ts
+function processCaseExpression(exp) {
+  if (typeof exp === "boolean") {
+    return exp;
+  }
+  if (isTaggedTemplateValue(exp)) {
+    return exp.toString();
+  }
+  return String(exp);
+}
+var switch_ = ({
+  cases,
+  isDynamic = false
+}) => (ctx, caseOffset = 0) => {
+  const switchType = isDynamic ? "dynamic" : "static";
+  return {
+    [`${switchType}Switch`]: cases.map((c, index) => {
+      const caseParentCtx = {
+        ...ctx,
+        parentId: ctx.parentId,
+        branch: {
+          type: BranchTypes.SWITCH,
+          kind: switchType,
+          index: caseOffset + index
+        }
+      };
+      const asset = isFluentBuilder(c.asset) && "build" in c.asset ? c.asset.build(caseParentCtx) : c.asset;
+      return {
+        case: processCaseExpression(c.case),
+        asset: {
+          ...asset,
+          id: asset.id ?? genId(caseParentCtx)
+        }
+      };
+    })
+  };
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/fluent-builder-base.ts
+var FluentBuilderBase = class {
+  [FLUENT_BUILDER_SYMBOL] = true;
+  valueStorage;
+  auxiliaryStorage;
+  context;
+  /**
+   * Creates a new builder instance
+   * @param initial - Optional initial values (accepts FluentPartial for TaggedTemplateValue support)
+   */
+  constructor(initial) {
+    this.valueStorage = new ValueStorage(initial);
+    this.auxiliaryStorage = new AuxiliaryStorage();
+  }
+  /**
+   * Accessor for generated builders to access values
+   * This maintains backward compatibility with generated code
+   */
+  get values() {
+    return this.valueStorage.getValues();
+  }
+  /**
+   * Setter for generated builders to set values in bulk
+   * Used by withAdditionalProperties() in generated builders
+   */
+  set values(newValues) {
+    Object.entries(newValues).forEach(([key, value]) => {
+      this.valueStorage.set(key, value);
+    });
+  }
+  /**
+   * Sets additional properties in bulk that may not be defined in the type schema
+   * Useful for extensibility and forward compatibility
+   */
+  withAdditionalProperties(values) {
+    this.values = values;
+    return this;
+  }
+  /**
+   * Sets a property value, intelligently routing it to the appropriate storage
+   * @param key - The property key to set
+   * @param value - The value to set
+   * @returns This builder instance for chaining
+   */
+  set(key, value) {
+    this.valueStorage.set(key, value);
+    return this;
+  }
+  /**
+   * Builds the final object with defaults and nested builder resolution
+   * Executes the complete 8-step build pipeline
+   *
+   * @param defaults - Optional default values
+   * @param context - Optional build context
+   */
+  buildWithDefaults(defaults, context) {
+    const arrayProperties = this.getArrayPropertiesMetadata();
+    const assetWrapperPaths = this.getAssetWrapperPathsMetadata();
+    return executeBuildPipeline(
+      this.valueStorage,
+      this.auxiliaryStorage,
+      defaults,
+      context,
+      arrayProperties,
+      assetWrapperPaths
+    );
+  }
+  /**
+   * Gets array property metadata from the builder class
+   * Generated builders include a static __arrayProperties__ set
+   */
+  getArrayPropertiesMetadata() {
+    const constructor = this.constructor;
+    return constructor.__arrayProperties__ ?? /* @__PURE__ */ new Set();
+  }
+  /**
+   * Gets asset wrapper paths metadata from the builder class.
+   * Generated builders include a static __assetWrapperPaths__ array of paths.
+   * Each path is an array of property names leading to an AssetWrapper.
+   */
+  getAssetWrapperPathsMetadata() {
+    const constructor = this.constructor;
+    return constructor.__assetWrapperPaths__ ?? [];
+  }
+  /**
+   * Conditionally sets a property based on a predicate
+   *
+   * Accepts unwrapped Asset builders and automatically wraps them in AssetWrapper format.
+   *
+   * @param predicate - Function to determine if the property should be set
+   * @param property - The property key
+   * @param value - The value, builder, or function returning either
+   *
+   * @example
+   * action()
+   *   .if(() => showLabel, "label", text().withValue("Submit"))
+   */
+  if(predicate, property, value) {
+    if (predicate(this)) {
+      const resolved = resolveValueOrFunction(value);
+      const wrapped = maybeWrapAsset(resolved);
+      this.set(property, wrapped);
+    }
+    return this;
+  }
+  /**
+   * Conditionally sets a property choosing between two values
+   *
+   * Accepts unwrapped Asset builders and automatically wraps them in AssetWrapper format.
+   *
+   * @param predicate - Function to determine which value to use
+   * @param property - The property key
+   * @param trueValue - Value to use if predicate is true
+   * @param falseValue - Value to use if predicate is false
+   *
+   * @example
+   * action()
+   *   .ifElse(
+   *     () => isActive,
+   *     "label",
+   *     text().withValue("Deactivate"),
+   *     text().withValue("Activate")
+   *   )
+   */
+  ifElse(predicate, property, trueValue, falseValue) {
+    const valueToUse = predicate(this) ? trueValue : falseValue;
+    const resolved = resolveValueOrFunction(valueToUse);
+    const wrapped = maybeWrapAsset(resolved);
+    this.set(property, wrapped);
+    return this;
+  }
+  /**
+   * Checks if a property has been set
+   */
+  has(key) {
+    return this.valueStorage.has(key);
+  }
+  /**
+   * Peeks at a property value without resolving builders
+   */
+  peek(key) {
+    return this.valueStorage.peek(key);
+  }
+  /**
+   * Gets builder for a property if one is set
+   */
+  peekBuilder(key) {
+    return this.valueStorage.peekBuilder(key);
+  }
+  /**
+   * Gets the type of value stored for a property
+   */
+  getValueType(key) {
+    return this.valueStorage.getValueType(key);
+  }
+  /**
+   * Clones the builder, creating an independent copy with the same state.
+   *
+   * Note: This method requires that the builder class has a constructor that
+   * accepts an optional `initial` parameter (like all generated builders do).
+   * If your custom builder has required constructor parameters, you must
+   * override this method.
+   */
+  clone() {
+    const BuilderClass = this.constructor;
+    let cloned;
+    try {
+      cloned = new BuilderClass();
+    } catch (error) {
+      throw new Error(
+        `clone() failed: Builder class "${this.constructor.name}" requires constructor arguments. Override clone() in your subclass to handle this case.`
+      );
+    }
+    cloned.valueStorage = this.valueStorage.clone();
+    cloned.auxiliaryStorage = this.auxiliaryStorage.clone();
+    if (this.context) {
+      cloned.context = this.context;
+    }
+    return cloned;
+  }
+  /**
+   * Unsets a property, removing it from the builder
+   */
+  unset(key) {
+    this.valueStorage.unset(key);
+    return this;
+  }
+  /**
+   * Clears all properties from the builder, resetting it to initial state
+   */
+  clear() {
+    this.valueStorage.clear();
+    return this;
+  }
+  /**
+   * Adds a template to this builder
+   */
+  template(templateFn) {
+    this.auxiliaryStorage.push(StorageKeys.TEMPLATES, templateFn);
+    return this;
+  }
+  /**
+   * Adds a switch to this builder at a specific path
+   */
+  switch(path, switchFnArgs) {
+    this.auxiliaryStorage.push(StorageKeys.SWITCHES, {
+      path,
+      switchFn: switch_(switchFnArgs)
+    });
+    return this;
+  }
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/utils.ts
+function createInspectMethod(builderName, properties) {
+  return `${builderName} { properties: ${JSON.stringify(
+    properties,
+    null,
+    2
+  )} }`;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/base-builder/errors.ts
+var ErrorCodes = {
+  /** Context is missing when required */
+  MISSING_CONTEXT: "FLUENT_MISSING_CONTEXT",
+  /** Invalid branch type in ID generation */
+  INVALID_BRANCH: "FLUENT_INVALID_BRANCH",
+  /** Template produced no output */
+  TEMPLATE_NO_OUTPUT: "FLUENT_TEMPLATE_NO_OUTPUT",
+  /** Invalid path in value resolution */
+  INVALID_PATH: "FLUENT_INVALID_PATH"
+};
+var FluentError = class _FluentError extends Error {
+  code;
+  context;
+  constructor(code, message, context) {
+    const contextStr = context ? ` Context: ${JSON.stringify(context)}` : "";
+    super(`[${code}] ${message}${contextStr}`);
+    this.name = "FluentError";
+    this.code = code;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FluentError);
+    }
+  }
+};
+function createFluentError(code, message, context) {
+  return new FluentError(code, message, context);
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/template/index.ts
+var TEMPLATE_MARKER = Symbol.for("fluent-builder-template");
+function isTemplate(fn) {
+  return typeof fn === "function" && TEMPLATE_MARKER in fn;
+}
+var template = ({
+  data,
+  output,
+  value,
+  dynamic = false
+}) => {
+  const templateFn = (parentCtx) => {
+    const resolvedOutput = output || inferOutputFromContext(parentCtx);
+    if (!resolvedOutput) {
+      throw new Error(
+        "Template output must be provided or inferrable from context. When using template in asset arrays, ensure the array property can be inferred (e.g., collection().withValues([template(...)]) infers 'values' as output)."
+      );
+    }
+    const templateValueCtx = {
+      parentId: genId(parentCtx),
+      branch: {
+        type: BranchTypes.TEMPLATE,
+        depth: 0
+      }
+    };
+    let resolvedAsset;
+    if (isFluentBuilder(value)) {
+      resolvedAsset = value.build(templateValueCtx);
+    } else if (typeof value === "function") {
+      const builderResult = value(templateValueCtx);
+      if (typeof builderResult === "function") {
+        resolvedAsset = builderResult(
+          templateValueCtx
+        );
+      } else {
+        resolvedAsset = builderResult;
+      }
+    } else {
+      if (typeof value === "object" && value !== null) {
+        resolvedAsset = { ...value };
+      } else {
+        resolvedAsset = value;
+      }
+    }
+    return {
+      data: isTaggedTemplateValue(data) ? data.toString() : data,
+      output: resolvedOutput,
+      value: {
+        asset: resolvedAsset
+      },
+      ...dynamic && { dynamic }
+    };
+  };
+  templateFn[TEMPLATE_MARKER] = true;
+  return templateFn;
+};
+function inferOutputFromContext(parentCtx) {
+  if (parentCtx.branch?.type === "slot") {
+    const slotName = parentCtx.branch.name;
+    const match = slotName.match(/^([a-zA-Z_][a-zA-Z0-9_]*)-\d+$/);
+    if (match) {
+      return match[1];
+    }
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(slotName)) {
+      return slotName;
+    }
+  }
+  return void 0;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/flow/index.ts
+function isBuilder(value) {
+  return typeof value === "object" && value !== null && "build" in value && typeof value.build === "function";
+}
+function isBuilderFunction(value) {
+  return typeof value === "function";
+}
+function flow(options) {
+  const flowId = options.id || "root";
+  const viewsNamespace = `${flowId}-views`;
+  const processedViews = (() => {
+    const processViews = () => {
+      const results = [];
+      for (let index = 0; index < options.views.length; index++) {
+        const viewOrFn = options.views[index];
+        const ctx = {
+          parentId: viewsNamespace,
+          branch: {
+            type: BranchTypes.ARRAY_ITEM,
+            index
+          },
+          ...options.context ?? {}
+        };
+        if (isBuilder(viewOrFn)) {
+          results.push(viewOrFn.build(ctx));
+        } else if (isBuilderFunction(viewOrFn)) {
+          results.push(viewOrFn(ctx));
+        } else {
+          results.push(viewOrFn);
+        }
+      }
+      return results;
+    };
+    return processViews();
+  })();
+  const { views: _views, context: _context, ...restOptions } = options;
+  return {
+    ...restOptions,
+    id: flowId,
+    views: processedViews,
+    ...options.data && { data: options.data },
+    ...options.schema && { schema: options.schema },
+    navigation: options.navigation
+  };
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/schema/index.ts
+var import_tapable_ts = require("tapable-ts");
+var import_dequal = require("dequal");
+var SchemaTypeName = Symbol.for("Schema Rename");
+var isTypeDef = (property) => {
+  return property.type !== void 0;
+};
+var SchemaGenerator = class {
+  children = [];
+  generatedDataTypes = /* @__PURE__ */ new Map();
+  typeNameCache = /* @__PURE__ */ new Map();
+  logger;
+  hooks = {
+    createSchemaNode: new import_tapable_ts.SyncWaterfallHook()
+  };
+  constructor(logger) {
+    this.logger = logger ?? console;
+  }
+  /**
+   * Converts an object to a `Schema.Schema` representation
+   * Optimized to minimize object operations and memory allocations
+   */
+  toSchema = (schema) => {
+    this.children.length = 0;
+    this.generatedDataTypes.clear();
+    this.typeNameCache.clear();
+    const newSchema = {
+      ROOT: {}
+    };
+    const rootKeys = Object.keys(schema);
+    for (let i = 0; i < rootKeys.length; i++) {
+      const property = rootKeys[i];
+      const subType = schema[property];
+      newSchema.ROOT[property] = this.hooks.createSchemaNode.call(
+        this.processChild(property, subType),
+        subType
+      );
+    }
+    while (this.children.length > 0) {
+      const { name, child } = this.children.pop();
+      const typeDef = {};
+      const childKeys = Object.keys(child);
+      for (let i = 0; i < childKeys.length; i++) {
+        const property = childKeys[i];
+        const subType = child[property];
+        typeDef[property] = this.hooks.createSchemaNode.call(
+          this.processChild(property, subType),
+          subType
+        );
+      }
+      newSchema[name] = typeDef;
+    }
+    return newSchema;
+  };
+  processChild(property, subType) {
+    if (isTypeDef(subType)) {
+      return subType;
+    }
+    let intermediateType;
+    let child;
+    if (Array.isArray(subType)) {
+      if (subType.length > 1) {
+        this.logger.warn(
+          `Type ${property} has multiple types in array, should only contain one top level object type. Only taking first defined type`
+        );
+      }
+      const subTypeName = subType[0][SchemaTypeName] ?? property;
+      intermediateType = this.makePlaceholderArrayType(subTypeName);
+      child = subType[0];
+    } else {
+      const subTypeName = subType[SchemaTypeName] ?? property;
+      intermediateType = this.makePlaceholderType(subTypeName);
+      child = subType;
+    }
+    const typeName = intermediateType.type;
+    if (this.generatedDataTypes.has(typeName)) {
+      const generatedType = this.generatedDataTypes.get(typeName);
+      if (!(0, import_dequal.dequal)(child, this.generatedDataTypes.get(typeName)?.node)) {
+        generatedType.count += 1;
+        const newTypeName = `${typeName}${generatedType.count}`;
+        intermediateType = {
+          ...intermediateType,
+          type: newTypeName
+        };
+        this.logger.warn(
+          `WARNING: Generated two intermediate types with the name: ${typeName} that are of different shapes, using artificial type ${newTypeName}`
+        );
+        this.generatedDataTypes.set(newTypeName, {
+          node: subType,
+          count: 1
+        });
+        this.children.push({ name: newTypeName, child });
+        return intermediateType;
+      }
+    } else {
+      this.generatedDataTypes.set(typeName, {
+        node: subType,
+        count: 1
+      });
+    }
+    this.children.push({ name: intermediateType.type, child });
+    return intermediateType;
+  }
+  /**
+   * Cached type name generation
+   */
+  makePlaceholderType = (typeName) => {
+    let cachedName = this.typeNameCache.get(typeName);
+    if (!cachedName) {
+      cachedName = `${typeName}Type`;
+      this.typeNameCache.set(typeName, cachedName);
+    }
+    return { type: cachedName };
+  };
+  /**
+   * Cached array type name generation
+   */
+  makePlaceholderArrayType(typeName) {
+    let cachedName = this.typeNameCache.get(typeName);
+    if (!cachedName) {
+      cachedName = `${typeName}Type`;
+      this.typeNameCache.set(typeName, cachedName);
+    }
+    return {
+      type: cachedName,
+      isArray: true
+    };
+  }
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/fluent/src/core/utils/index.ts
+function safeToString(value) {
+  if (isTaggedTemplateValue(value)) {
+    return value.toString();
+  }
+  return String(value);
+}
+function safeToBoolean(value) {
+  if (isTaggedTemplateValue(value)) {
+    return value.toString() === "true";
+  }
+  return Boolean(value);
+}
+function safeToNumber(value) {
+  if (isTaggedTemplateValue(value)) {
+    return Number(value.toString());
+  }
+  return Number(value);
+}
+function safeToArray(value) {
+  if (isTaggedTemplateValue(value)) {
+    return [value.toString()];
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (isTaggedTemplateValue(item)) {
+        return item.toString();
+      } else if (Array.isArray(item)) {
+        return safeToArray(item);
+      } else if (item && typeof item === "object" && !isTaggedTemplateValue(item)) {
+        return safeToObject(item);
+      }
+      return item;
+    });
+  }
+  return [value];
+}
+function safeToObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, val]) => {
+      if (isTaggedTemplateValue(val)) {
+        return [key, val.toString()];
+      } else if (Array.isArray(val)) {
+        return [key, safeToArray(val)];
+      } else if (val && typeof val === "object" && !isTaggedTemplateValue(val)) {
+        return [key, safeToObject(val)];
+      }
+      return [key, val];
+    })
+  );
+}
+function safeFromMixedType(value) {
+  if (isTaggedTemplateValue(value)) {
+    return value.toString();
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return safeToObject(
+      value
+    );
+  }
+  if (Array.isArray(value)) {
+    return safeToArray(value);
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AND,
+  BranchTypes,
+  ErrorCodes,
+  FLUENT_BUILDER_SYMBOL,
+  FluentBuilderBase,
+  FluentError,
+  IDRegistry,
+  NAND,
+  NOR,
+  NOT,
+  OR,
+  PropertyKeys,
+  SchemaGenerator,
+  SchemaTypeName,
+  StorageKeys,
+  TEMPLATE_MARKER,
+  TaggedTemplateValueSymbol,
+  XOR,
+  add,
+  and,
+  binding,
+  call,
+  conditional,
+  createFluentError,
+  createIdRegistry,
+  createInspectMethod,
+  createNestedContext,
+  createSwitchContext,
+  createTemplateContext,
+  determineSlotName,
+  div,
+  divide,
+  eq,
+  equal,
+  expression,
+  extractBindingsFromSchema,
+  extractValue,
+  flow,
+  genId,
+  generateAssetId,
+  globalIdRegistry,
+  greaterThan,
+  greaterThanOrEqual,
+  gt,
+  gte,
+  ifElse,
+  isAsset,
+  isAssetWrapper,
+  isAssetWrapperValue,
+  isAssetWrapperWithAsset,
+  isBuilderArray,
+  isFluentBuilder,
+  isPlainObject,
+  isStringOrUndefined,
+  isSwitchResult,
+  isTaggedTemplateValue,
+  isTemplate,
+  lessThan,
+  lessThanOrEqual,
+  literal,
+  lt,
+  lte,
+  minus,
+  mod,
+  modulo,
+  multiply,
+  nand,
+  needsAssetWrapper,
+  neq,
+  nor,
+  not,
+  notEqual,
+  or,
+  peekId,
+  plus,
+  resetGlobalIdSet,
+  resolveAndWrapAsset,
+  resolveValue,
+  safeFromMixedType,
+  safeToArray,
+  safeToBoolean,
+  safeToNumber,
+  safeToObject,
+  safeToString,
+  strictEq,
+  strictEqual,
+  strictNeq,
+  strictNotEqual,
+  subtract,
+  switch_,
+  template,
+  ternary,
+  times,
+  xor
+});
+//# sourceMappingURL=index.cjs.map