@scarn/sdk 0.0.0-stage → 0.8.0

package/dist/chunk-zm72ksz0.js

@@ -0,0 +1,256 @@
+// @bun
+import {
+  PipelineDefinitions,
+  createClient
+} from "./chunk-vfeytkqx.js";
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/definitions/pipelines/pipeline-definitions-client.ts
+var pipelineDocumentIssueSchema = exports_external.object({
+  code: exports_external.string(),
+  path: exports_external.string(),
+  message: exports_external.string(),
+  hint: exports_external.string().optional()
+});
+
+class PipelineDefinitionsApiError extends Error {
+  code;
+  issues;
+  constructor(error) {
+    super(error.detail ?? error.title ?? JSON.stringify(error));
+    this.name = "PipelineDefinitionsApiError";
+    this.code = error.code;
+    this.issues = documentIssuesOf(error.meta);
+  }
+}
+function documentIssuesOf(meta) {
+  const errors = meta?.["errors"];
+  if (!Array.isArray(errors))
+    return [];
+  return errors.flatMap((error) => {
+    const parsed = pipelineDocumentIssueSchema.safeParse(error);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function unwrap(result) {
+  if (result.error !== undefined) {
+    throw new PipelineDefinitionsApiError(result.error);
+  }
+  return result.data;
+}
+function createPipelineDefinitionsClient(baseUrl) {
+  const client = createClient({ baseUrl });
+  return buildPipelineDefinitionsClient(new PipelineDefinitions({ client }));
+}
+var buildPipelineDefinitionsClient = (pipelineDefinitions) => ({
+  listByProjectId: async (projectId, options) => unwrap(await pipelineDefinitions.listPipelineDefinitions({
+    path: { projectId },
+    headers: options?.headers
+  })),
+  get: async (pipelineDefinitionId, options) => unwrap(await pipelineDefinitions.getPipelineDefinition({
+    path: { pipelineDefinitionId },
+    headers: options?.headers
+  })),
+  create: async (input, options) => unwrap(await pipelineDefinitions.createPipelineDefinition({
+    body: input,
+    headers: options?.headers
+  })),
+  publishVersion: async (pipelineDefinitionId, document, options) => unwrap(await pipelineDefinitions.publishPipelineDefinitionVersion({
+    path: { pipelineDefinitionId },
+    body: { document },
+    headers: options?.headers
+  })),
+  activateVersion: async (pipelineDefinitionId, version, options) => unwrap(await pipelineDefinitions.activatePipelineDefinitionVersion({
+    path: { pipelineDefinitionId, version },
+    headers: options?.headers
+  })),
+  listVersions: async (pipelineDefinitionId, options) => unwrap(await pipelineDefinitions.listPipelineDefinitionVersions({
+    path: { pipelineDefinitionId },
+    headers: options?.headers
+  })),
+  getVersion: async (pipelineDefinitionId, version, options) => unwrap(await pipelineDefinitions.getPipelineDefinitionVersion({
+    path: { pipelineDefinitionId, version },
+    headers: options?.headers
+  }))
+});
+// src/definitions/pipelines/work-item-fields.ts
+var WORK_ITEM_TOP_LEVEL_FIELDS = [
+  "id",
+  "projectId",
+  "platform",
+  "platformId",
+  "platformKey",
+  "url",
+  "title",
+  "description",
+  "sourceCreatedAt",
+  "sourceUpdatedAt",
+  "createdByUserId",
+  "parentWorkItemId",
+  "createdAt",
+  "updatedAt"
+];
+var WORK_ITEM_FIELDS_PATH_PREFIX = "fields.";
+function resolveWorkItemFieldPath(record, path) {
+  if (typeof record !== "object" || record === null)
+    return;
+  const asRecord = record;
+  if (path.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX)) {
+    const fieldName = path.slice(WORK_ITEM_FIELDS_PATH_PREFIX.length);
+    const fields = asRecord["fields"];
+    if (typeof fields !== "object" || fields === null)
+      return;
+    return fields[fieldName];
+  }
+  return asRecord[path];
+}
+
+// src/definitions/pipelines/define-default-pipeline-assignment.ts
+var DEFAULT_PIPELINE_ASSIGNMENT_FILENAME = "default-pipeline-assignment.ts";
+function makeLeaf(fact, path, operator, value) {
+  const condition = {
+    _tag: "leaf",
+    fact,
+    ...path ? { path } : {},
+    operator,
+    value
+  };
+  return {
+    _condition: condition,
+    then(outcome) {
+      return {
+        _tag: "assignment_rule",
+        conditions: [condition],
+        mode: "all",
+        outcome
+      };
+    }
+  };
+}
+function makeFieldRef(fact, path) {
+  const untyped = {
+    eq: (v) => makeLeaf(fact, path, "equal", v),
+    ne: (v) => makeLeaf(fact, path, "notEqual", v),
+    gt: (v) => makeLeaf(fact, path, "greaterThan", v),
+    gte: (v) => makeLeaf(fact, path, "greaterThanInclusive", v),
+    lt: (v) => makeLeaf(fact, path, "lessThan", v),
+    lte: (v) => makeLeaf(fact, path, "lessThanInclusive", v),
+    in: (vs) => makeLeaf(fact, path, "in", vs),
+    notIn: (vs) => makeLeaf(fact, path, "notIn", vs),
+    contains: (v) => makeLeaf(fact, path, "contains", v),
+    doesNotContain: (v) => makeLeaf(fact, path, "doesNotContain", v)
+  };
+  return untyped;
+}
+function buildWorkItemAccessor() {
+  const accessor = {
+    field: (name) => makeFieldRef("workItem", `$.${WORK_ITEM_FIELDS_PATH_PREFIX}${name}`)
+  };
+  for (const key of WORK_ITEM_TOP_LEVEL_FIELDS) {
+    accessor[key] = makeFieldRef("workItem", `$.${key}`);
+  }
+  return accessor;
+}
+function makeAssign(pipeline) {
+  const key = typeof pipeline === "string" ? pipeline : pipeline.key;
+  if (typeof key !== "string" || key.length === 0) {
+    throw new Error("assign() requires a pipeline key or the value definePipeline() returns.");
+  }
+  return { _tag: "assign", pipelineKey: key };
+}
+function extractCondition(ref) {
+  return ref._condition;
+}
+function makeGroup(mode, refs) {
+  const conditions = refs.map(extractCondition);
+  const condition = { _tag: "group", mode, conditions };
+  return {
+    _condition: condition,
+    then(outcome) {
+      return { _tag: "assignment_rule", conditions, mode, outcome };
+    }
+  };
+}
+function buildCtx() {
+  return {
+    workItem: buildWorkItemAccessor(),
+    context: {
+      isNew: makeFieldRef("context", "$.isNew")
+    },
+    assign: makeAssign,
+    skip: () => ({ _tag: "skip" }),
+    all: (...refs) => makeGroup("all", refs),
+    any: (...refs) => makeGroup("any", refs)
+  };
+}
+function defaultPipelineAssignment(callback) {
+  const input = callback(buildCtx());
+  return {
+    _tag: "default_pipeline_assignment",
+    default: input.default,
+    rules: input.rules
+  };
+}
+function serializeConditionNode(condition) {
+  if (condition._tag === "leaf") {
+    return {
+      fact: condition.fact,
+      ...condition.path ? { path: condition.path } : {},
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition.mode === "all") {
+    return { all: condition.conditions.map(serializeConditionNode) };
+  }
+  return { any: condition.conditions.map(serializeConditionNode) };
+}
+function serializeOutcome(outcome) {
+  if (outcome._tag === "skip")
+    return { type: "skip", params: null };
+  return { type: "assign", params: { pipelineKey: outcome.pipelineKey } };
+}
+function serializeAssignmentRule(rule) {
+  const { type, params } = serializeOutcome(rule.outcome);
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeConditionNode) },
+    event: { type, ...params ? { params } : {} }
+  };
+}
+function serializeDefaultPipelineAssignment(spec) {
+  let primaryKey = null;
+  if (spec.default._tag === "assign") {
+    primaryKey = spec.default.pipelineKey;
+  } else {
+    for (const rule of spec.rules) {
+      if (rule.outcome._tag === "assign") {
+        primaryKey = rule.outcome.pipelineKey;
+        break;
+      }
+    }
+  }
+  if (primaryKey === null) {
+    throw new Error("defaultPipelineAssignment must contain at least one assign() outcome " + "(in `default` or in `rules`). A policy that only skips is not useful.");
+  }
+  const { type: defaultType, params: defaultParams } = serializeOutcome(spec.default);
+  const outcomeSet = new Set([defaultType]);
+  const serializedRules = spec.rules.map((rule) => {
+    outcomeSet.add(serializeOutcome(rule.outcome).type);
+    return serializeAssignmentRule(rule);
+  });
+  return {
+    pipelineDefinitionKey: primaryKey,
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultType,
+    defaultEventParamsJson: defaultParams,
+    allowedEventTypes: [...outcomeSet]
+  };
+}
+function isDefaultPipelineAssignmentSpec(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  return value["_tag"] === "default_pipeline_assignment";
+}
+export { PipelineDefinitionsApiError, createPipelineDefinitionsClient, WORK_ITEM_TOP_LEVEL_FIELDS, WORK_ITEM_FIELDS_PATH_PREFIX, resolveWorkItemFieldPath, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME, defaultPipelineAssignment, serializeDefaultPipelineAssignment, isDefaultPipelineAssignmentSpec };

package/dist/client.d.ts

@@ -0,0 +1,4 @@
+import { ScarnClient } from "./generated";
+export * from "./task-plane-client";
+export * from "./generated/";
+export declare function createScarnClient(baseUrl: string): ScarnClient;

package/dist/client.js

@@ -0,0 +1,58 @@
+// @bun
+import {
+  createScarnClient,
+  createTaskPlaneClient
+} from "./chunk-700xe701.js";
+import {
+  Api,
+  Billing,
+  Conversations,
+  GitHubIntegrations,
+  NotificationRules,
+  PipelineDefinitions,
+  PipelineExecutions,
+  ProjectArtifacts,
+  ProjectIntegrations,
+  ProjectInvites,
+  Projects,
+  ScarnClient,
+  Secrets,
+  StepDefinitionTemplates,
+  StepDefinitions,
+  TaskRuns,
+  Tasks,
+  UserNotifications,
+  Username,
+  WorkItemBlocks,
+  WorkItemCommentDrafts,
+  WorkItemComments,
+  WorkItems
+} from "./chunk-vfeytkqx.js";
+import"./chunk-y64skrwp.js";
+export {
+  Api,
+  Billing,
+  Conversations,
+  GitHubIntegrations,
+  NotificationRules,
+  PipelineDefinitions,
+  PipelineExecutions,
+  ProjectArtifacts,
+  ProjectIntegrations,
+  ProjectInvites,
+  Projects,
+  ScarnClient,
+  Secrets,
+  StepDefinitionTemplates,
+  StepDefinitions,
+  TaskRuns,
+  Tasks,
+  UserNotifications,
+  Username,
+  WorkItemBlocks,
+  WorkItemCommentDrafts,
+  WorkItemComments,
+  WorkItems,
+  createScarnClient,
+  createTaskPlaneClient
+};

package/dist/contracts/artifact-markers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The artifact marker wire format, shared by the SDK (`Artifact.embed` /
+ * `Artifact.link` and definition validation) and core (draft resolution and
+ * rendering):
+ *
+ * - `![caption](artifact:signal/<stepKey>/<signalKey>)` / `[label](...)`
+ *   point at a declared artifact signal and are required.
+ * - `![caption](artifact:<name-or-glob>)` / `[label](...)` point at any file
+ *   under `artifactsDir` and are optional.
+ *
+ * Text inside `[...]` escapes `\`, `[` and `]` with a backslash. A ref with
+ * whitespace or `<`/`>` is wrapped in `<...>`; otherwise `\`, `(` and `)` are
+ * backslash-escaped.
+ */
+export declare const ARTIFACT_MARKER_SCHEME = "artifact:";
+export type ArtifactMarkerKind = "embed" | "link";
+export type ArtifactMarkerRef = {
+    readonly type: "signal";
+    readonly stepKey: string;
+    readonly signalKey: string;
+} | {
+    readonly type: "path";
+    readonly pattern: string;
+};
+/** A marker found in a piece of text. `start`/`end` are string offsets. */
+export type ArtifactMarkerMatch = {
+    readonly kind: ArtifactMarkerKind;
+    /** The caption (embed) or label (link), unescaped. */
+    readonly text: string;
+    /** Everything after `artifact:`, unescaped. */
+    readonly rawRef: string;
+    readonly ref: ArtifactMarkerRef;
+    readonly start: number;
+    readonly end: number;
+};
+/** Splits the part after `artifact:` into a signal or path ref. */
+export declare function parseArtifactMarkerRef(rawRef: string): ArtifactMarkerRef;
+export declare function formatArtifactMarkerRef(ref: ArtifactMarkerRef): string;
+/** Builds a marker string. `text` is the caption (embed) or label (link). */
+export declare function buildArtifactMarker(kind: ArtifactMarkerKind, ref: ArtifactMarkerRef, text: string): string;
+/** Every artifact marker in `text`, in order. Other links are ignored. */
+export declare function findArtifactMarkers(text: string): ArtifactMarkerMatch[];

package/dist/contracts/artifact-markers.js

@@ -0,0 +1,16 @@
+// @bun
+import {
+  ARTIFACT_MARKER_SCHEME,
+  buildArtifactMarker,
+  findArtifactMarkers,
+  formatArtifactMarkerRef,
+  parseArtifactMarkerRef
+} from "../chunk-ngy1fdcx.js";
+import"../chunk-y64skrwp.js";
+export {
+  ARTIFACT_MARKER_SCHEME,
+  buildArtifactMarker,
+  findArtifactMarkers,
+  formatArtifactMarkerRef,
+  parseArtifactMarkerRef
+};

package/dist/contracts/artifacts.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Artifact contract shared by the SDK, the opencode plugin, the worker and
+ * core. Everything here works on JSON Schema only (the `x-scarn-artifact`
+ * keyword), never on Zod schemas, so the server can use it without knowing
+ * how a step was authored.
+ */
+import { z } from "zod";
+export declare const artifactKindSchema: z.ZodEnum<{
+    generic: "generic";
+    "playwright-trace": "playwright-trace";
+    video: "video";
+    image: "image";
+}>;
+export type ArtifactKind = z.infer<typeof artifactKindSchema>;
+export declare const ARTIFACT_SCHEMA_KEYWORD = "x-scarn-artifact";
+export type ArtifactSchemaKeyword = {
+    readonly accept: readonly string[];
+};
+/** A JSON Schema node. `true` / `false` are the boolean schema forms. */
+export type ArtifactJsonSchemaNode = boolean | {
+    readonly [key: string]: unknown;
+};
+/** A declared artifact field in a step's result schema. */
+export type ArtifactField = {
+    /**
+     * Dot path of the field. Array items appear as `[]`, e.g. `shots[]` or
+     * `runs[].video`.
+     */
+    readonly path: string;
+    /** Lower-case extensions with a leading dot. Empty accepts any file. */
+    readonly accept: readonly string[];
+    readonly nullable: boolean;
+    readonly description: string | null;
+    /** True when the field sits inside an array, which v1 does not support. */
+    readonly inArray: boolean;
+};
+export declare const artifactPlatforms: readonly ["github", "jira", "bitbucket"];
+export type ArtifactPlatform = (typeof artifactPlatforms)[number];
+/**
+ * Extensions each platform can show inline in a comment. Anything else is
+ * linked to its Scarn artifact page. GitHub and Bitbucket link everything
+ * in v1.
+ */
+export declare const EMBEDDABLE_ARTIFACT_EXTENSIONS: Readonly<Record<ArtifactPlatform, readonly string[]>>;
+export declare function isEmbeddableArtifactExtension(platform: ArtifactPlatform, extension: string): boolean;
+/** The lower-cased extension of a file name, with its dot; `""` when none. */
+export declare function artifactFileExtension(fileName: string): string;
+/** Whether a file name matches an `accept` list. An empty list accepts any file. */
+export declare function artifactAcceptsFile(accept: readonly string[], fileName: string): boolean;
+/** Reads the `x-scarn-artifact` keyword on this exact node. */
+export declare function readArtifactKeyword(node: ArtifactJsonSchemaNode): ArtifactSchemaKeyword | null;
+export type ArtifactNodeMatch = ArtifactSchemaKeyword & {
+    readonly nullable: boolean;
+    readonly description: string | null;
+};
+/**
+ * Matches a node that is an artifact field, either directly or as
+ * `anyOf: [<artifact>, { type: "null" }]` (Zod's `.nullable()`).
+ */
+export declare function matchArtifactNode(node: ArtifactJsonSchemaNode): ArtifactNodeMatch | null;
+/**
+ * Every artifact field declared in a result schema: walks object
+ * properties, `anyOf` / `oneOf` / `allOf` branches, local `$ref`s and array
+ * items. Fields inside arrays are returned with `inArray: true`; v1 rejects
+ * them at definition time.
+ */
+export declare function findArtifactFields(schema: ArtifactJsonSchemaNode | null | undefined): ArtifactField[];

package/dist/contracts/artifacts.js

@@ -0,0 +1,27 @@
+// @bun
+import {
+  ARTIFACT_SCHEMA_KEYWORD,
+  EMBEDDABLE_ARTIFACT_EXTENSIONS,
+  artifactAcceptsFile,
+  artifactFileExtension,
+  artifactKindSchema,
+  artifactPlatforms,
+  findArtifactFields,
+  isEmbeddableArtifactExtension,
+  matchArtifactNode,
+  readArtifactKeyword
+} from "../chunk-y2pv8d6a.js";
+import"../chunk-skzxcba3.js";
+import"../chunk-y64skrwp.js";
+export {
+  ARTIFACT_SCHEMA_KEYWORD,
+  EMBEDDABLE_ARTIFACT_EXTENSIONS,
+  artifactAcceptsFile,
+  artifactFileExtension,
+  artifactKindSchema,
+  artifactPlatforms,
+  findArtifactFields,
+  isEmbeddableArtifactExtension,
+  matchArtifactNode,
+  readArtifactKeyword
+};

package/dist/contracts/pipeline-document/built-ins.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Built-in error names and the schemas of built-in values: wait results,
+ * the input a `reply` wait takes, and caught errors.
+ */
+import type { JsonSchema } from "./json";
+export declare const BUILT_IN_ERRORS: readonly ["Scarn.All", "Scarn.StepFailed", "Scarn.HealthCheckFailed", "Scarn.Timeout", "Scarn.HeartbeatTimeout", "Scarn.MaxRunsExceeded", "Scarn.MaxTurnsExceeded", "Scarn.ConditionError", "Scarn.ArgsError"];
+/** The errors a wait node can raise, so the only names its `catch` may use. */
+export declare const WAIT_ERRORS: readonly ["Scarn.All", "Scarn.MaxRunsExceeded", "Scarn.ArgsError"];
+/**
+ * The result of a `wait` node with `for: decision`: the chosen action's key
+ * and the person's text. With no actions (an invalid node) `action` is any
+ * string, so only the missing actions are reported.
+ */
+export declare function decisionResultSchema(actions: readonly {
+    key: string;
+}[]): JsonSchema;
+/** The result of a `wait` node with `for: reply`; `replied: false` is "continue without reply". */
+export declare const REPLY_RESULT_SCHEMA: JsonSchema;
+/** The result of a conversation step (a step with no result schema): the conversation and the agent's last message. */
+export declare const CONVERSATION_RESULT_SCHEMA: JsonSchema;
+/** What every transition into a `reply` wait must pass. */
+export declare const REPLY_INPUT_SCHEMA: JsonSchema;
+export declare const ERROR_SCHEMA: JsonSchema;

package/dist/contracts/pipeline-document/conditions/operators.d.ts

@@ -0,0 +1,8 @@
+/** Condition operator and computed-function names, shared by schema, evaluator and validator. */
+export declare const COMPARISON_OPERATORS: readonly ["equal", "notEqual", "lessThan", "lessThanInclusive", "greaterThan", "greaterThanInclusive"];
+export declare const CONDITION_OPERATORS: readonly ["equal", "notEqual", "lessThan", "lessThanInclusive", "greaterThan", "greaterThanInclusive", "exists", "isEmpty", "contains", "startsWith", "endsWith", "matches", "before", "after", "some", "every", "none"];
+export declare const COMPUTED_FUNCTIONS: readonly ["sum", "avg", "min", "max", "count"];
+export declare const ORDERING_OPERATORS: Set<string>;
+export declare const STRING_OPERATORS: Set<string>;
+export declare const DATE_OPERATORS: Set<string>;
+export declare const LIST_OPERATORS: Set<string>;

package/dist/contracts/pipeline-document/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The pipeline document contract: what a pipeline JSON document is. Logic
+ * that works on documents (validation, evaluation) lives in
+ * `@scarn/shared-core/pipelines`.
+ */
+export * from "./json";
+export * from "./schema";
+export * from "./routes";
+export * from "./conditions/operators";
+export * from "./step-contract";
+export * from "./built-ins";

package/dist/contracts/pipeline-document/index.js

@@ -0,0 +1,99 @@
+// @bun
+import {
+  ALIAS_PATTERN,
+  COMPARISON_OPERATORS,
+  COMPUTED_FUNCTIONS,
+  CONDITION_OPERATORS,
+  DATE_OPERATORS,
+  DECISION_BODY_MODES,
+  DEFAULT_MAX_TURNS,
+  LIST_OPERATORS,
+  MATCH_MODES,
+  NODE_ID_PATTERN,
+  ORDERING_OPERATORS,
+  STRING_OPERATORS,
+  argValueSchema,
+  catchSchema,
+  computedSourceSchema,
+  conditionSchema,
+  decisionActionSchema,
+  deepEqual,
+  eachSchema,
+  failNodeSchema,
+  isJsonObject,
+  jsonPointer,
+  listSchema,
+  literalSchema,
+  nextSchema,
+  nodeSchema,
+  otherwiseSchema,
+  pipelineDocumentJsonSchema,
+  pipelineDocumentSchema,
+  retrySchema,
+  routeAt,
+  routeEntries,
+  routeSchema,
+  startSchema,
+  stepNodeSchema,
+  succeedNodeSchema,
+  toleratedFailuresSchema,
+  waitNodeSchema
+} from "../../chunk-p7yrcmqm.js";
+import {
+  BUILT_IN_ERRORS,
+  CONVERSATION_RESULT_SCHEMA,
+  ERROR_SCHEMA,
+  REPLY_INPUT_SCHEMA,
+  REPLY_RESULT_SCHEMA,
+  WAIT_ERRORS,
+  decisionResultSchema
+} from "../../chunk-dp86pa6m.js";
+import"../../chunk-skzxcba3.js";
+import"../../chunk-y64skrwp.js";
+export {
+  ALIAS_PATTERN,
+  BUILT_IN_ERRORS,
+  COMPARISON_OPERATORS,
+  COMPUTED_FUNCTIONS,
+  CONDITION_OPERATORS,
+  CONVERSATION_RESULT_SCHEMA,
+  DATE_OPERATORS,
+  DECISION_BODY_MODES,
+  DEFAULT_MAX_TURNS,
+  ERROR_SCHEMA,
+  LIST_OPERATORS,
+  MATCH_MODES,
+  NODE_ID_PATTERN,
+  ORDERING_OPERATORS,
+  REPLY_INPUT_SCHEMA,
+  REPLY_RESULT_SCHEMA,
+  STRING_OPERATORS,
+  WAIT_ERRORS,
+  argValueSchema,
+  catchSchema,
+  computedSourceSchema,
+  conditionSchema,
+  decisionActionSchema,
+  decisionResultSchema,
+  deepEqual,
+  eachSchema,
+  failNodeSchema,
+  isJsonObject,
+  jsonPointer,
+  listSchema,
+  literalSchema,
+  nextSchema,
+  nodeSchema,
+  otherwiseSchema,
+  pipelineDocumentJsonSchema,
+  pipelineDocumentSchema,
+  retrySchema,
+  routeAt,
+  routeEntries,
+  routeSchema,
+  startSchema,
+  stepNodeSchema,
+  succeedNodeSchema,
+  toleratedFailuresSchema,
+  waitNodeSchema
+};

package/dist/contracts/pipeline-document/json.d.ts

@@ -0,0 +1,35 @@
+/**
+ * JSON value and JSON Schema types shared across the package, plus small
+ * helpers for JSON pointers and structural equality.
+ */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export interface JsonSchemaObject {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: JsonSchema;
+    items?: JsonSchema;
+    prefixItems?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    enum?: JsonValue[];
+    const?: JsonValue;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    definitions?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    format?: string;
+    [key: string]: unknown;
+}
+export type JsonSchema = boolean | JsonSchemaObject;
+export declare function isJsonObject(value: JsonValue | undefined): value is JsonObject;
+/** Builds an RFC 6901 JSON pointer such as `/nodes/fix/next/routes/1/args/plan`. */
+export declare function jsonPointer(segments: readonly (string | number)[]): string;
+export declare function deepEqual(left: JsonValue | undefined, right: JsonValue | undefined): boolean;

package/dist/contracts/pipeline-document/routes.d.ts

@@ -0,0 +1,16 @@
+/** Reading the routes of a node's `next` object. */
+import type { Next, Otherwise, Route } from "./schema";
+export type RouteKind = "route" | "otherwise";
+/** One entry of a `next` object: a route, or the `otherwise` route. */
+export interface RouteEntry {
+    kind: RouteKind;
+    /** The route's index in `routes`, or 0 for `otherwise`. */
+    index: number;
+    route: Route | Otherwise;
+    /** Where the entry sits inside the `next` object. */
+    pointer: ["routes", number] | ["otherwise"];
+}
+/** Every route of `next` in order, with `otherwise` last. */
+export declare function routeEntries(next: Next | undefined): RouteEntry[];
+/** The route a `kind` and `index` name, if `next` has it. */
+export declare function routeAt(next: Next | undefined, kind: RouteKind, index: number): Route | Otherwise | undefined;