@google/adk 1.6.0 → 2.0.0

package/dist/web/utils/schema.js

@@ -0,0 +1,167 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zodToJsonSchema as toJSONSchemaV3 } from "zod-to-json-schema";
+import { toJSONSchema as toJSONSchemaV4, z as z4 } from "zod/v4";
+import { genaiSchemaToJsonSchema } from "./genai_schema_to_json.js";
+import {
+  isZodSchema,
+  isZodV3Schema,
+  isZodV4Schema
+} from "./simple_zod_to_json.js";
+const genaiValidators = /* @__PURE__ */ new WeakMap();
+function genaiSchemaValidator(schema) {
+  const cached = genaiValidators.get(schema);
+  if (cached !== void 0) {
+    return cached != null ? cached : void 0;
+  }
+  let validator = null;
+  try {
+    validator = z4.fromJSONSchema(
+      genaiSchemaToJsonSchema(schema)
+    );
+  } catch (e) {
+    validator = null;
+  }
+  genaiValidators.set(schema, validator);
+  return validator != null ? validator : void 0;
+}
+__name(genaiSchemaValidator, "genaiSchemaValidator");
+function parseWithSchema(schema, value) {
+  if (schema === void 0) {
+    return value;
+  }
+  if (isZodSchema(schema)) {
+    return schema.parse(value);
+  }
+  const validator = genaiSchemaValidator(schema);
+  return validator ? validator.parse(value) : value;
+}
+__name(parseWithSchema, "parseWithSchema");
+function toJsonSchema(schema) {
+  if (isZodV4Schema(schema)) {
+    return toJSONSchemaV4(schema);
+  }
+  if (isZodV3Schema(schema)) {
+    return toJSONSchemaV3(schema);
+  }
+  return genaiSchemaToJsonSchema(schema);
+}
+__name(toJsonSchema, "toJsonSchema");
+function compileJsonSchema(jsonSchema) {
+  if (jsonSchema === null || typeof jsonSchema !== "object") {
+    return void 0;
+  }
+  try {
+    return z4.fromJSONSchema(jsonSchema);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(compileJsonSchema, "compileJsonSchema");
+const objectFieldValidators = /* @__PURE__ */ new WeakMap();
+function objectSchemaFields(schema) {
+  const cached = objectFieldValidators.get(schema);
+  if (cached !== void 0) {
+    return cached != null ? cached : void 0;
+  }
+  let fields = null;
+  try {
+    const document = toJsonSchema(schema);
+    const properties = document["properties"];
+    if (properties && typeof properties === "object") {
+      fields = new Map(
+        Object.entries(properties).map(
+          ([name, fieldSchema]) => [name, compileField(fieldSchema, document)]
+        )
+      );
+    }
+  } catch (e) {
+    fields = null;
+  }
+  objectFieldValidators.set(schema, fields);
+  return fields != null ? fields : void 0;
+}
+__name(objectSchemaFields, "objectSchemaFields");
+const UNRESOLVABLE_REF = Symbol("unresolvable-ref");
+function compileField(fieldSchema, document) {
+  try {
+    return compileJsonSchema(inlineRefs(fieldSchema, document));
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(compileField, "compileField");
+function resolvePointer(document, ref) {
+  if (!ref.startsWith("#")) {
+    throw UNRESOLVABLE_REF;
+  }
+  let node = document;
+  for (const rawSegment of ref.slice(1).split("/").filter(Boolean)) {
+    const segment = decodeURIComponent(rawSegment).replaceAll("~1", "/").replaceAll("~0", "~");
+    if (node === null || typeof node !== "object") {
+      throw UNRESOLVABLE_REF;
+    }
+    node = node[segment];
+  }
+  if (node === void 0) {
+    throw UNRESOLVABLE_REF;
+  }
+  return node;
+}
+__name(resolvePointer, "resolvePointer");
+function inlineRefs(node, document, seen = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    return node.map((item) => inlineRefs(item, document, seen));
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const entries = Object.entries(node);
+  const ref = node["$ref"];
+  if (typeof ref === "string") {
+    if (seen.has(ref)) {
+      throw UNRESOLVABLE_REF;
+    }
+    const target = inlineRefs(
+      resolvePointer(document, ref),
+      document,
+      /* @__PURE__ */ new Set([...seen, ref])
+    );
+    const siblings = Object.fromEntries(
+      entries.filter(([key]) => key !== "$ref")
+    );
+    return __spreadValues(__spreadValues({}, target), siblings);
+  }
+  return Object.fromEntries(
+    entries.map(([key, value]) => [key, inlineRefs(value, document, seen)])
+  );
+}
+__name(inlineRefs, "inlineRefs");
+export {
+  compileJsonSchema,
+  objectSchemaFields,
+  parseWithSchema,
+  toJsonSchema
+};

package/dist/web/utils/simple_zod_to_json.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -13,12 +15,15 @@ import { toJSONSchema as toJSONSchemaV4 } from "zod/v4";
 function isZodSchema(obj) {
   return obj !== null && typeof obj === "object" && "parse" in obj && typeof obj.parse === "function" && "safeParse" in obj && typeof obj.safeParse === "function";
 }
+__name(isZodSchema, "isZodSchema");
 function isZodV3Schema(obj) {
   return isZodSchema(obj) && !("_zod" in obj);
 }
+__name(isZodV3Schema, "isZodV3Schema");
 function isZodV4Schema(obj) {
   return isZodSchema(obj) && "_zod" in obj;
 }
+__name(isZodV4Schema, "isZodV4Schema");
 function getZodTypeName(schema) {
   var _a, _b;
   const schemaAny = schema;
@@ -31,9 +36,11 @@ function getZodTypeName(schema) {
   }
   return void 0;
 }
+__name(getZodTypeName, "getZodTypeName");
 function isZodObject(obj) {
   return isZodSchema(obj) && getZodTypeName(obj) === "ZodObject";
 }
+__name(isZodObject, "isZodObject");
 function zodObjectToSchema(schema) {
   if (!isZodObject(schema)) {
     throw new Error("Expected a Zod Object");
@@ -42,7 +49,7 @@ function zodObjectToSchema(schema) {
     return toJSONSchemaV4(schema, {
       target: "openapi-3.0",
       io: "input",
-      override: (ctx) => {
+      override: /* @__PURE__ */ __name((ctx) => {
         var _a;
         const { jsonSchema } = ctx;
         if (jsonSchema.additionalProperties !== void 0) {
@@ -73,14 +80,14 @@ function zodObjectToSchema(schema) {
         if (jsonSchema.type !== void 0) {
           jsonSchema.type = jsonSchema.type.toUpperCase();
         }
-      }
+      }, "override")
     });
   }
   if (isZodV3Schema(schema)) {
     return toJSONSchemaV3(schema, {
       target: "openApi3",
       emailStrategy: "format:email",
-      postProcess: (jsonSchema) => {
+      postProcess: /* @__PURE__ */ __name((jsonSchema) => {
         var _a, _b, _c, _d, _e, _f, _g;
         if (!jsonSchema) {
           return;
@@ -112,12 +119,16 @@ function zodObjectToSchema(schema) {
           jsonSchema.type = jsonSchema.type.toUpperCase();
         }
         return jsonSchema;
-      }
+      }, "postProcess")
     });
   }
   throw new Error("Unsupported Zod schema version.");
 }
+__name(zodObjectToSchema, "zodObjectToSchema");
 export {
   isZodObject,
+  isZodSchema,
+  isZodV3Schema,
+  isZodV4Schema,
   zodObjectToSchema
 };

package/dist/web/utils/streaming_utils.js

@@ -23,6 +23,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -79,7 +80,7 @@ import { generateClientFunctionCallId } from "../events/event.js";
 import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
 import { createLlmResponse } from "../models/llm_response.js";
 const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-class ProgressiveStrategy {
+const _ProgressiveStrategy = class _ProgressiveStrategy {
   constructor() {
     this.partsSequence = [];
     this.currentTextBuffer = "";
@@ -263,8 +264,10 @@ class ProgressiveStrategy {
     }
     return finalParts;
   }
-}
-class NonProgressiveStrategy {
+};
+__name(_ProgressiveStrategy, "ProgressiveStrategy");
+let ProgressiveStrategy = _ProgressiveStrategy;
+const _NonProgressiveStrategy = class _NonProgressiveStrategy {
   constructor() {
     this.text = "";
     this.thoughtText = "";
@@ -339,8 +342,10 @@ class NonProgressiveStrategy {
     }
     return void 0;
   }
-}
-class StreamingResponseAggregator {
+};
+__name(_NonProgressiveStrategy, "NonProgressiveStrategy");
+let NonProgressiveStrategy = _NonProgressiveStrategy;
+const _StreamingResponseAggregator = class _StreamingResponseAggregator {
   constructor(isProgressiveMode = isFeatureEnabled(
     FeatureName.PROGRESSIVE_SSE_STREAMING
   )) {
@@ -420,10 +425,13 @@ class StreamingResponseAggregator {
       partial: false
     };
   }
-}
+};
+__name(_StreamingResponseAggregator, "StreamingResponseAggregator");
+let StreamingResponseAggregator = _StreamingResponseAggregator;
 function isEmptyContentPart(part) {
   return !part.functionCall && !part.functionResponse && !part.fileData && !part.inlineData && !part.executableCode && !part.codeExecutionResult && (!part.text || part.text === "");
 }
+__name(isEmptyContentPart, "isEmptyContentPart");
 export {
   StreamingResponseAggregator,
   isEmptyContentPart

package/dist/web/utils/task.js

@@ -1,18 +1,20 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class Task {
+const _Task = class _Task {
   constructor(executable) {
     this.executable = executable;
     this.isDone = false;
     this.abortController = new AbortController();
-    const markDone = () => {
+    const markDone = /* @__PURE__ */ __name(() => {
       this.isDone = true;
-    };
+    }, "markDone");
     this.promise = executable(this.abortController.signal);
     this.promise.then(markDone).catch(markDone);
   }
@@ -28,7 +30,9 @@ class Task {
   done() {
     return this.isDone;
   }
-}
+};
+__name(_Task, "Task");
+let Task = _Task;
 export {
   Task
 };

package/dist/web/utils/variant_utils.js

@@ -1,19 +1,22 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getBooleanEnvVar } from "./env_aware_utils.js";
+import { isEnterpriseModeEnabled } from "./env_aware_utils.js";
 var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
   GoogleLLMVariant2["VERTEX_AI"] = "VERTEX_AI";
   GoogleLLMVariant2["GEMINI_API"] = "GEMINI_API";
   return GoogleLLMVariant2;
 })(GoogleLLMVariant || {});
 function getGoogleLlmVariant() {
-  return getBooleanEnvVar("GOOGLE_GENAI_USE_VERTEXAI") ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
+  return isEnterpriseModeEnabled() ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
 }
+__name(getGoogleLlmVariant, "getGoogleLlmVariant");
 export {
   GoogleLLMVariant,
   getGoogleLlmVariant

package/dist/web/utils/vertex_ai_utils.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getBooleanEnvVar } from "./env_aware_utils.js";
+import { isEnterpriseModeEnabled } from "./env_aware_utils.js";
 const EXPRESS_MODE_UNSUPPORTED_MESSAGE = "Vertex AI Express Mode (expressModeApiKey / GOOGLE_API_KEY) is not supported: the @google-cloud/vertexai Agent Engine client cannot send an API key. Provide projectId and location (with Application Default Credentials), or inject a preconfigured client.";
 function getExpressModeApiKey(project, location, expressModeApiKey) {
   if ((project || location) && expressModeApiKey) {
@@ -13,11 +15,12 @@ function getExpressModeApiKey(project, location, expressModeApiKey) {
       "Cannot specify project or location and expressModeApiKey. Either use project and location, or just the expressModeApiKey."
     );
   }
-  if (getBooleanEnvVar("GOOGLE_GENAI_USE_VERTEXAI")) {
+  if (isEnterpriseModeEnabled()) {
     return expressModeApiKey || process.env.GOOGLE_API_KEY;
   }
   return void 0;
 }
+__name(getExpressModeApiKey, "getExpressModeApiKey");
 export {
   EXPRESS_MODE_UNSUPPORTED_MESSAGE,
   getExpressModeApiKey

package/dist/web/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "1.6.0";
+const version = "2.0.0";
 export {
   version
 };

package/dist/web/workflow/base_node.js

@@ -0,0 +1,215 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+import { createModelContent } from "@google/genai";
+import { createEvent, isEvent } from "../events/event.js";
+import { parseWithSchema } from "../utils/schema.js";
+import { NodeSchemaValidationError } from "./errors.js";
+import { isRequestInput } from "./request_input.js";
+import {
+  prepareRetryConfig
+} from "./retry_config.js";
+import { createRequestInputEvent } from "./utils/hitl_utils.js";
+const BASE_NODE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.baseNode");
+_a = BASE_NODE_SIGNATURE_SYMBOL;
+const _BaseNode = class _BaseNode {
+  constructor(config) {
+    /** Brand identifying this object as a {@link BaseNode} (see `isBaseNode`). */
+    this[_a] = true;
+    var _a2, _b, _c;
+    if (!config.name || typeof config.name !== "string" || config.name.trim().length === 0) {
+      throw new Error("Node name must be a non-empty string.");
+    }
+    this.name = config.name.trim();
+    this.description = (_a2 = config.description) != null ? _a2 : "";
+    this.rerunOnResume = (_b = config.rerunOnResume) != null ? _b : false;
+    this.waitForOutput = (_c = config.waitForOutput) != null ? _c : false;
+    this.retryConfig = config.retryConfig;
+    this.preparedRetryConfig = config.retryConfig ? prepareRetryConfig(config.retryConfig) : void 0;
+    this.timeout = config.timeout;
+    this.inputSchema = config.inputSchema;
+    this.outputSchema = config.outputSchema;
+    this.stateSchema = config.stateSchema;
+    this.isolationScope = config.isolationScope;
+  }
+  /**
+   * Whether this node must wait for ALL of its predecessors to trigger before
+   * it runs (fan-in barrier). Overridden by `JoinNode`.
+   */
+  get requiresAllPredecessors() {
+    return false;
+  }
+  /**
+   * Runs the node, normalizing every yielded item into an {@link Event}. This
+   * is what the engine (and `ctx.runNode()`) consumes. Validates the input
+   * against `inputSchema` once, up front (skipping genai `Content`, which nodes
+   * coerce themselves).
+   */
+  run(ctx, input) {
+    return __asyncGenerator(this, null, function* () {
+      const validatedInput = this.validateInput(input);
+      try {
+        for (var iter = __forAwait(this.runImpl(ctx, validatedInput)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const item = temp.value;
+          if (isRequestInput(item)) {
+            yield createRequestInputEvent(item);
+            continue;
+          }
+          const event = this.toEvent(ctx, item);
+          if (event) {
+            yield event;
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  /**
+   * Validates node input against `inputSchema` (Content passes through). Only
+   * enforced for Zod schemas; a genai `Schema` is left unvalidated (see
+   * `parseWithSchema`).
+   */
+  validateInput(input) {
+    if (isContent(input)) {
+      return input;
+    }
+    try {
+      return parseWithSchema(this.inputSchema, input);
+    } catch (e) {
+      throw new NodeSchemaValidationError({
+        nodeName: this.name,
+        direction: "input",
+        cause: e
+      });
+    }
+  }
+  /**
+   * Validates node output against `outputSchema` (Content passes through). Only
+   * enforced for Zod schemas; a genai `Schema` is left unvalidated (see
+   * `parseWithSchema`).
+   */
+  validateOutput(output) {
+    if (isContent(output)) {
+      return output;
+    }
+    try {
+      return parseWithSchema(this.outputSchema, output);
+    } catch (e) {
+      throw new NodeSchemaValidationError({
+        nodeName: this.name,
+        direction: "output",
+        cause: e
+      });
+    }
+  }
+  /**
+   * Normalizes a single yielded item into an {@link Event} (or `null` to skip).
+   * Subclasses may override for richer coercion (e.g. `FunctionNode`).
+   */
+  toEvent(ctx, data) {
+    if (data === null || data === void 0) {
+      return null;
+    }
+    if (isEvent(data)) {
+      const event = data;
+      if (event.output !== void 0) {
+        event.output = this.validateOutput(event.output);
+      }
+      return event;
+    }
+    const output = this.validateOutput(data);
+    return createEvent({
+      author: this.name,
+      invocationId: ctx.invocationContext.invocationId,
+      branch: ctx.branch,
+      content: toContent(output),
+      output
+    });
+  }
+};
+__name(_BaseNode, "BaseNode");
+let BaseNode = _BaseNode;
+function isBaseNode(value) {
+  return typeof value === "object" && value !== null && BASE_NODE_SIGNATURE_SYMBOL in value && value[BASE_NODE_SIGNATURE_SYMBOL] === true;
+}
+__name(isBaseNode, "isBaseNode");
+function isContent(value) {
+  return typeof value === "object" && value !== null && "parts" in value && Array.isArray(value.parts);
+}
+__name(isContent, "isContent");
+const _StartNode = class _StartNode extends BaseNode {
+  // eslint-disable-next-line require-yield
+  runImpl() {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("START node is never executed.");
+    });
+  }
+};
+__name(_StartNode, "StartNode");
+let StartNode = _StartNode;
+const START = new StartNode({ name: "__START__" });
+function toContent(val) {
+  if (val === null || val === void 0) {
+    return void 0;
+  }
+  if (isContent(val)) {
+    return val;
+  }
+  try {
+    return createModelContent(val);
+  } catch (e) {
+    return createModelContent(valueToText(val));
+  }
+}
+__name(toContent, "toContent");
+function valueToText(val) {
+  var _a2;
+  if (typeof val === "string") {
+    return val;
+  }
+  try {
+    return (_a2 = JSON.stringify(val)) != null ? _a2 : String(val);
+  } catch (e) {
+    return String(val);
+  }
+}
+__name(valueToText, "valueToText");
+export {
+  BaseNode,
+  START,
+  isBaseNode,
+  isContent,
+  toContent
+};

package/dist/web/workflow/branch_path.js

@@ -0,0 +1,77 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _BranchPath = class _BranchPath {
+  constructor(segments) {
+    this.segments = [...segments];
+  }
+  toString() {
+    return this.segments.join(".");
+  }
+  /** Returns a copy of the path segments. */
+  getSegments() {
+    return [...this.segments];
+  }
+  /** Whether this path is a strict descendant of `ancestor`. */
+  isDescendantOf(ancestor) {
+    if (this.segments.length <= ancestor.segments.length) {
+      return false;
+    }
+    return ancestor.segments.every((seg, i) => this.segments[i] === seg);
+  }
+  /** Returns a new path with a `name@runId` (or `name`) segment appended. */
+  append(name, runId) {
+    const segment = runId !== void 0 ? "".concat(name, "@").concat(runId) : name;
+    return new _BranchPath([...this.segments, segment]);
+  }
+};
+__name(_BranchPath, "BranchPath");
+let BranchPath = _BranchPath;
+function branchPathFromString(path) {
+  if (!path) {
+    return new BranchPath([]);
+  }
+  return new BranchPath(path.split("."));
+}
+__name(branchPathFromString, "branchPathFromString");
+function commonPrefixOfPaths(paths) {
+  if (paths.length === 0) {
+    return new BranchPath([]);
+  }
+  const allSegments = paths.map((p) => p.getSegments());
+  const common = [];
+  const minLen = Math.min(...allSegments.map((s) => s.length));
+  for (let i = 0; i < minLen; i++) {
+    const seg = allSegments[0][i];
+    if (allSegments.every((s) => s[i] === seg)) {
+      common.push(seg);
+    } else {
+      break;
+    }
+  }
+  return new BranchPath(common);
+}
+__name(commonPrefixOfPaths, "commonPrefixOfPaths");
+function createSubBranch(baseBranch, options) {
+  return branchPathFromString(baseBranch).append(options.name, options.runId).toString();
+}
+__name(createSubBranch, "createSubBranch");
+function commonPrefixOf(branches) {
+  return commonPrefixOfPaths(
+    branches.map((b) => branchPathFromString(b))
+  ).toString();
+}
+__name(commonPrefixOf, "commonPrefixOf");
+export {
+  BranchPath,
+  branchPathFromString,
+  commonPrefixOf,
+  commonPrefixOfPaths,
+  createSubBranch
+};