@boboddy/sdk 0.5.1 → 0.5.3

package/dist/definitions/pipelines/chain-graph.d.ts

@@ -18,3 +18,32 @@ export declare function tryComputeTopoRanks(nodeDefinitions: readonly Pick<NodeD
  * `tryComputeTopoRanks` does.
  */
 export declare function tryOrderNodeDefinitionsByTopoRank(nodeDefinitions: readonly NodeDefinitionSpec[], dependencyEdges: readonly DependencyEdgeSpec[]): NodeDefinitionSpec[] | null;
+/**
+ * For every node reachable from `entryNodeKey`, the set of nodes that
+ * *dominate* it — every node that appears on *every* path from the entry to
+ * it, including the node itself (`dom(n)` always contains `n`). Standard
+ * iterative dataflow (Cooper/Harvey/Kennedy-style):
+ * `dom(entry) = {entry}`; `dom(n) = {n} ∪ ⋂ dom(p)` for each predecessor `p`
+ * of `n`, iterated to a fixed point.
+ *
+ * Unlike `tryComputeTopoRanks` above — which deliberately treats *every*
+ * in-degree-zero node as its own rank-0 root, so a graph with several
+ * disconnected entry points still ranks (see lines 51-56) — a dominator
+ * relation is only meaningful relative to a single root: "runs on every
+ * path from the entry" has no answer if there could be more than one
+ * entry. Callers must supply that root explicitly as `entryNodeKey`
+ * (`PipelineDefinitionSpec.entryNodeKey`, the node `config.startAt` names)
+ * rather than have it inferred from in-degree.
+ *
+ * Returns `null` (does not throw), same as `tryComputeTopoRanks`, when
+ * `entryNodeKey` does not name a node in `nodeDefinitions`, when
+ * `dependencyEdges` references a node key outside `nodeDefinitions`, or
+ * when the graph contains a cycle — every caller here is a diagnostic
+ * tool, not a build-time assertion (see `tryComputeTopoRanks`'s own doc
+ * comment), so it degrades gracefully rather than crashing validation.
+ *
+ * Nodes unreachable from `entryNodeKey` are simply absent from the
+ * returned map — an unreachable node can never appear on a path from the
+ * entry, so it neither dominates nor is dominated by anything reachable.
+ */
+export declare function tryComputeDominators(nodeDefinitions: readonly Pick<NodeDefinitionSpec, "nodeKey">[], dependencyEdges: readonly DependencyEdgeSpec[], entryNodeKey: string): Map<string, ReadonlySet<string>> | null;

package/dist/definitions/pipelines/compile-node-definitions.d.ts

@@ -17,11 +17,3 @@ export declare function compileFanOutState(stateKey: string, state: FanOutState,
 export declare function compileParallelState(stateKey: string, state: ParallelState, ctx: CompileContext): CompiledState;
 export declare function compileLoopState(stateKey: string, state: LoopState, ctx: CompileContext): CompiledState;
 export declare function compileTerminalState(stateKey: string, kind: "succeed" | "fail"): CompiledState;
-/**
- * The SDK-side mirror of §6's domain invariant: a node may have more than
- * one incoming edge only when every source is a `choice`/`loop` state
- * (never an unconditional `step`/`fanOut`/`parallel`/`cohortGate`
- * successor) — gives authors a fast local error instead of a round-trip to
- * the server.
- */
-export declare function assertNoIllegalConvergentEdges(pipelineKey: string, nodeKindByKey: ReadonlyMap<string, NodeDefinitionSpec["kind"]>, edges: readonly DependencyEdgeSpec[]): void;

package/dist/definitions/pipelines/define-pipeline.d.ts

@@ -117,6 +117,8 @@ export type PipelineDefinitionSpec = {
     version: number;
     status: "draft" | "active" | "archived";
     inputSchemaJson?: Record<string, unknown> | null;
+    /** The node the pipeline begins execution at — mirrors `config.startAt`. */
+    entryNodeKey: string;
     nodeDefinitions: NodeDefinitionSpec[];
     dependencyEdges: DependencyEdgeSpec[];
     /** Step specs referenced by this pipeline. Used by the push command to auto-push steps that aren't explicitly exported. */

package/dist/definitions/pipelines/index.js

@@ -14984,25 +14984,6 @@ function compileLoopState(stateKey, state, ctx) {
 function compileTerminalState(stateKey, kind) {
   return { nodeDefinitions: [{ nodeKey: stateKey, kind }], edges: [] };
 }
-function assertNoIllegalConvergentEdges(pipelineKey, nodeKindByKey, edges) {
-  const incoming = new Map;
-  for (const edge of edges) {
-    const list = incoming.get(edge.toNodeKey) ?? [];
-    list.push(edge);
-    incoming.set(edge.toNodeKey, list);
-  }
-  for (const [targetKey, incomingEdges] of incoming) {
-    if (incomingEdges.length <= 1)
-      continue;
-    const hasInvalidSource = incomingEdges.some((edge) => {
-      const kind = nodeKindByKey.get(edge.fromNodeKey);
-      return kind !== "choice" && kind !== "loop";
-    });
-    if (hasInvalidSource) {
-      throw new Error(`Pipeline "${pipelineKey}": state "${targetKey}" has more than one incoming edge, but not every source is a 'choice'/'loop' state (unconditional convergent edges are not allowed \u2014 see docs/research/flat-pipeline-sdk-and-visual-designer.md \xA76).`);
-    }
-  }
-}
 
 // src/definitions/pipelines/define-pipeline.ts
 function isWorkingNodeDefinition(node) {
@@ -15039,8 +15020,6 @@ function definePipeline(config2) {
     nodeDefinitions.push(...compiled.nodeDefinitions);
     dependencyEdges.push(...compiled.edges);
   }
-  const nodeKindByKey = new Map(nodeDefinitions.map((node) => [node.nodeKey, node.kind]));
-  assertNoIllegalConvergentEdges(config2.key, nodeKindByKey, dependencyEdges);
   let inputSchemaJson = null;
   if (config2.input) {
     try {
@@ -15056,6 +15035,7 @@ function definePipeline(config2) {
     version: config2.version ?? 1,
     status: config2.status ?? "active",
     inputSchemaJson,
+    entryNodeKey: config2.startAt,
     _stepDefinitions: [...stepDefMap.values()],
     nodeDefinitions,
     dependencyEdges
@@ -16748,6 +16728,7 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
         description: spec.description,
         status: spec.status,
         inputSchemaJson: spec.inputSchemaJson,
+        entryNodeKey: spec.entryNodeKey,
         nodeDefinitions,
         dependencyEdges
       };

package/dist/definitions/steps/define-code-step.d.ts

@@ -1,5 +1,6 @@
 import type { ZodType } from "zod";
-import type { SignalKeysOf, SignalTypeMapOf, TypedStepDefinitionSpec } from "./define-step";
+import type { EffectiveResult, SignalKeysOf, SignalTypeMapOf, TypedStepDefinitionSpec } from "./define-step";
+import type { AnyStepFeature, FeatureSignalKeys } from "./step-features";
 /**
  * `codeStep()`'s own signal spec shape — unlike `defineStep()`'s
  * `SignalSpecInput`, `type` is required rather than inferred from the
@@ -17,7 +18,7 @@ export type CodeStepSignalSpec = {
     availableWhenResultStatusIn?: string[] | null;
 };
 export type CodeStepFn<TInput, TResult> = (input: TInput) => TResult | Promise<TResult>;
-export type DefineCodeStepInput<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType> = {
+export type DefineCodeStepInput<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType, TFeatures extends ReadonlyArray<AnyStepFeature> = never[]> = {
     key: string;
     name: string;
     description?: string | null;
@@ -30,11 +31,22 @@ export type DefineCodeStepInput<TInput extends ZodType = ZodType, TResult extend
      * Must be a plain named export of the same module `codeStep()` is
      * called from (see docs/research/flat-pipeline-sdk-and-visual-designer.md
      * §7.7/§8's "code-step entrypoints resolve against the target repo").
+     *
+     * Typed against `EffectiveResult`, not the bare `resultSchema` output, so
+     * a step with `features: [Features.notifications()]` can return the
+     * `$boboddy_notifications_v1` field (e.g. via `Notify.inApp(...)`)
+     * without a type error.
      */
-    fn: CodeStepFn<TInput["_output"], TResult["_output"]>;
+    fn: CodeStepFn<TInput["_output"], EffectiveResult<TResult["_output"], TFeatures>>;
     inputSchema?: TInput;
     resultSchema?: TResult;
     signals?: readonly CodeStepSignalSpec[];
+    /**
+     * Step features to attach — unlike `defineStep()`, only each feature's
+     * `_resultExtension`/`_signals` apply here (there is no prompt to append
+     * to on a `kind: "code"` step).
+     */
+    features?: TFeatures;
     status?: "draft" | "active";
 };
 /**
@@ -45,6 +57,6 @@ export type DefineCodeStepInput<TInput extends ZodType = ZodType, TResult extend
  * `entrypoint.fn` reference attached instead — see `StepDefinitionSpec`'s
  * own doc comment for what happens to it during collection.
  */
-export declare function codeStep<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType, const TSignals extends ReadonlyArray<CodeStepSignalSpec> = never[]>(config: DefineCodeStepInput<TInput, TResult> & {
+export declare function codeStep<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType, const TSignals extends ReadonlyArray<CodeStepSignalSpec> = never[], const TFeatures extends ReadonlyArray<AnyStepFeature> = never[]>(config: DefineCodeStepInput<TInput, TResult, TFeatures> & {
     signals?: TSignals;
-}): TypedStepDefinitionSpec<TInput["_output"], TResult["_output"], SignalKeysOf<TSignals>, SignalTypeMapOf<TSignals, TResult["_output"]>>;
+}): TypedStepDefinitionSpec<TInput["_output"], EffectiveResult<TResult["_output"], TFeatures>, SignalKeysOf<TSignals> | FeatureSignalKeys<TFeatures>, SignalTypeMapOf<TSignals, TResult["_output"]>>;

package/dist/definitions/steps/define-step.d.ts

@@ -159,7 +159,7 @@ export type SignalTypeMapOf<TSignals extends readonly unknown[], TResult> = Pret
         sourcePath: infer P extends string;
     } ? TypeAtPath<TResult, P> : unknown;
 }>;
-type EffectiveResult<TResult, TFeatures extends ReadonlyArray<AnyStepFeature>> = Prettify<TResult & FeatureResultExtensions<TFeatures>>;
+export type EffectiveResult<TResult, TFeatures extends ReadonlyArray<AnyStepFeature>> = Prettify<TResult & FeatureResultExtensions<TFeatures>>;
 type HasAdditionalInput<T> = 0 extends 1 & T ? boolean : [unknown] extends [T] ? false : true;
 export type TypedStepDefinitionSpec<TInput = unknown, TResult = unknown, TSignalKeys extends string = string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>> = StepDefinitionSpec & {
     readonly __inputType: TInput;

package/dist/definitions/steps/index.js

@@ -12082,6 +12082,12 @@ ${feature._promptAddition}` : feature._promptAddition;
 }
 // src/definitions/steps/define-code-step.ts
 function codeStep(config2) {
+  const features = config2.features ?? [];
+  let effectiveResult = config2.resultSchema;
+  for (const feature of features) {
+    effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
+  }
+  const featureSignals = features.flatMap((f) => f._signals);
   const spec = {
     key: config2.key,
     name: config2.name,
@@ -12091,14 +12097,23 @@ function codeStep(config2) {
     status: config2.status ?? "active",
     prompt: null,
     inputSchemaJson: config2.inputSchema ? toJSONSchema(config2.inputSchema) : null,
-    resultSchemaJson: config2.resultSchema ? toJSONSchema(config2.resultSchema) : null,
-    signalExtractorDefinitions: (config2.signals ?? []).map((signal) => ({
-      key: signal.key ?? signal.sourcePath,
-      sourcePath: signal.sourcePath,
-      type: signal.type,
-      required: signal.required ?? true,
-      availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
-    })),
+    resultSchemaJson: effectiveResult ? toJSONSchema(effectiveResult) : null,
+    signalExtractorDefinitions: [
+      ...(config2.signals ?? []).map((signal) => ({
+        key: signal.key ?? signal.sourcePath,
+        sourcePath: signal.sourcePath,
+        type: signal.type,
+        required: signal.required ?? true,
+        availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
+      })),
+      ...featureSignals.map((signal) => ({
+        key: signal.key,
+        sourcePath: signal.sourcePath,
+        type: signal.type,
+        required: signal.required ?? true,
+        availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
+      }))
+    ],
     opencodeMcpJson: null,
     opencodePluginJson: null,
     healthChecksJson: null,
@@ -13716,7 +13731,7 @@ var buildStepDefinitionsClient = (stepDefinitions) => {
         key: spec.key,
         name: spec.name,
         description: spec.description,
-        prompt: spec.prompt ?? "",
+        prompt: spec.prompt ?? null,
         version: spec.version,
         kind: spec.kind,
         entrypointJson: spec.entrypointJson ?? null,
@@ -16084,20 +16099,29 @@ function date4(params) {
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/definitions/steps/step-features.ts
+var notificationKindSchema = exports_external.enum([
+  "feedback_request",
+  "status_update",
+  "blocked",
+  "result_ready",
+  "warning"
+]);
+var notificationPrioritySchema = exports_external.enum(["low", "normal", "high", "urgent"]);
+var notificationChannelSchema = exports_external.enum([
+  "in_app",
+  "work_item_platform_comment",
+  "email",
+  "slack"
+]);
 var NOTIFICATION_SIGNAL_KEY = "$boboddy_notifications_v1";
 var NOTIFICATION_RESULT_KEY = "$boboddy_notifications_v1";
+var DEFAULT_NOTIFICATION_KIND = "status_update";
 var notificationItemSchema = exports_external.object({
-  kind: exports_external.enum([
-    "feedback_request",
-    "status_update",
-    "blocked",
-    "result_ready",
-    "warning"
-  ]).describe("The kind of user notification."),
+  kind: notificationKindSchema.describe("The kind of user notification."),
   title: exports_external.string().describe("Short, human-readable notification title."),
   body: exports_external.string().describe("The notification body / details."),
-  priority: exports_external.enum(["low", "normal", "high", "urgent"]).describe("How important this notification is for the user."),
-  suggestedChannels: exports_external.array(exports_external.enum(["in_app", "work_item_platform_comment", "email", "slack"])).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
+  priority: notificationPrioritySchema.describe("How important this notification is for the user."),
+  suggestedChannels: exports_external.array(notificationChannelSchema).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
   payload: exports_external.record(exports_external.string(), exports_external.unknown()).optional().describe('Kind-specific structured data. For "feedback_request": { category, urgency, suggestedKey? }.')
 }).describe("A single user notification emitted by the agent.");
 var notificationsFeature = {
@@ -16127,27 +16151,68 @@ var notificationsFeature = {
     }
   ]
 };
+var feedbackRequestsFeature = {
+  _resultExtension: exports_external.object({
+    [NOTIFICATION_RESULT_KEY]: exports_external.array(notificationItemSchema.extend({ kind: exports_external.literal("feedback_request") })).optional()
+  }),
+  _promptAddition: [
+    "## Feedback Requests",
+    "",
+    `If you need to ask a human a clarifying question, populate the \`${NOTIFICATION_RESULT_KEY}\` array with items of kind \`"feedback_request"\`.`,
+    "Each item must include:",
+    "- **title**: A short, human-readable summary of the question.",
+    "- **body**: The full question.",
+    "- **priority**: One of `low`, `normal`, `high`, `urgent`.",
+    '- **payload**: `{ "category": string, "urgency": "blocking"|"clarification"|"assumption"|"informational", "suggestedKey"?: string }`.'
+  ].join(`
+`),
+  _signals: notificationsFeature._signals
+};
 var Features = {
-  notifications: Object.assign(() => notificationsFeature, {
-    signal: {
-      key: NOTIFICATION_SIGNAL_KEY,
-      find(signals) {
-        const match = signals.find((s) => s.key === NOTIFICATION_SIGNAL_KEY);
-        if (!match)
-          return;
-        const parsed = exports_external.array(notificationItemSchema).safeParse(match.valueJson);
-        return parsed.success ? parsed.data : undefined;
-      }
-    }
+  notifications: () => notificationsFeature,
+  feedbackRequests: () => feedbackRequestsFeature
+};
+var NotificationSignal = {
+  key: NOTIFICATION_SIGNAL_KEY,
+  find(signals) {
+    const match = signals.find((s) => s.key === NOTIFICATION_SIGNAL_KEY);
+    if (!match)
+      return;
+    const parsed = exports_external.array(notificationItemSchema).safeParse(match.valueJson);
+    return parsed.success ? parsed.data : undefined;
+  }
+};
+var Notify = {
+  create: (item) => ({
+    [NOTIFICATION_RESULT_KEY]: [item]
+  }),
+  inApp: (title, body, priority, options) => Notify.create({
+    kind: options?.kind ?? DEFAULT_NOTIFICATION_KIND,
+    title,
+    body,
+    priority,
+    suggestedChannels: ["in_app"],
+    ...options?.payload ? { payload: options.payload } : {}
   }),
-  feedbackRequests: Object.assign(() => notificationsFeature, {
-    signal: {
-      key: NOTIFICATION_SIGNAL_KEY
+  feedbackRequest: (question, category, urgency, suggestedKey) => Notify.create({
+    kind: "feedback_request",
+    title: question,
+    body: question,
+    priority: "normal",
+    payload: {
+      category,
+      urgency,
+      ...suggestedKey ? { suggestedKey } : {}
     }
+  }),
+  merge: (...fragments) => ({
+    [NOTIFICATION_RESULT_KEY]: fragments.flatMap((fragment) => fragment[NOTIFICATION_RESULT_KEY])
   })
 };
 export {
   Features,
+  NotificationSignal,
+  Notify,
   codeStep,
   createPromptInputProxy,
   createPromptTemplateContext,

package/dist/definitions/steps/step-features.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { ZodObject, ZodRawShape } from "zod";
 type FeatureSignalSpec = {
     key: string;
@@ -17,24 +18,69 @@ export type AnyStepFeature = StepFeature;
 type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 export type FeatureResultExtensions<TFeatures extends readonly AnyStepFeature[]> = [TFeatures[number]] extends [never] ? Record<never, never> : UnionToIntersection<TFeatures[number] extends StepFeature<infer R> ? R : never>;
 export type FeatureSignalKeys<TFeatures extends readonly AnyStepFeature[]> = NonNullable<TFeatures[number]["__signalKeys"]>;
-export type NotificationKind = "feedback_request" | "status_update" | "blocked" | "result_ready" | "warning";
-export type NotificationPriority = "low" | "normal" | "high" | "urgent";
-export type NotificationChannel = "in_app" | "work_item_platform_comment" | "email" | "slack";
+declare const notificationKindSchema: z.ZodEnum<{
+    blocked: "blocked";
+    feedback_request: "feedback_request";
+    status_update: "status_update";
+    result_ready: "result_ready";
+    warning: "warning";
+}>;
+export type NotificationKind = z.infer<typeof notificationKindSchema>;
+declare const notificationPrioritySchema: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    normal: "normal";
+    urgent: "urgent";
+}>;
+export type NotificationPriority = z.infer<typeof notificationPrioritySchema>;
+declare const notificationChannelSchema: z.ZodEnum<{
+    in_app: "in_app";
+    work_item_platform_comment: "work_item_platform_comment";
+    email: "email";
+    slack: "slack";
+}>;
+export type NotificationChannel = z.infer<typeof notificationChannelSchema>;
 export type FeedbackRequestUrgency = "blocking" | "clarification" | "assumption" | "informational";
-export type NotificationItem = {
-    kind: NotificationKind;
-    title: string;
-    body: string;
-    priority: NotificationPriority;
-    suggestedChannels?: NotificationChannel[];
-    /**
-     * Kind-specific structured payload. For `feedback_request`:
-     * `{ category, urgency, suggestedKey? }`.
-     */
-    payload?: Record<string, unknown>;
-};
 declare const NOTIFICATION_SIGNAL_KEY: "$boboddy_notifications_v1";
 declare const NOTIFICATION_RESULT_KEY: "$boboddy_notifications_v1";
+declare const notificationItemSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        blocked: "blocked";
+        feedback_request: "feedback_request";
+        status_update: "status_update";
+        result_ready: "result_ready";
+        warning: "warning";
+    }>;
+    title: z.ZodString;
+    body: z.ZodString;
+    priority: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        normal: "normal";
+        urgent: "urgent";
+    }>;
+    suggestedChannels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        in_app: "in_app";
+        work_item_platform_comment: "work_item_platform_comment";
+        email: "email";
+        slack: "slack";
+    }>>>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** A single notification. Inferred from `notificationItemSchema` — the
+ * schema is the source of truth; this type can never drift from what's
+ * actually validated and pushed as JSON Schema. */
+export type NotificationItem = z.infer<typeof notificationItemSchema>;
+/**
+ * The shape `Notify.*` returns: a step result fragment carrying one or more
+ * notifications. Spread it into a larger result object, or return it
+ * directly if the notification *is* the step's whole result — either way it
+ * slots into the same `$boboddy_notifications_v1` field `Features.notifications()`
+ * wires a signal extractor for.
+ */
+export type NotificationResultFragment = {
+    readonly [NOTIFICATION_RESULT_KEY]: NotificationItem[];
+};
 type NotificationsFeature = StepFeature<{
     [NOTIFICATION_RESULT_KEY]?: NotificationItem[];
 }, typeof NOTIFICATION_SIGNAL_KEY>;
@@ -45,23 +91,38 @@ export type FeedbackRequestItem = {
     suggestedKey?: string;
 };
 export declare const Features: {
-    readonly notifications: (() => NotificationsFeature) & {
-        signal: {
-            key: "$boboddy_notifications_v1";
-            find(signals: Array<{
-                key: string;
-                valueJson: unknown;
-            }>): NotificationItem[] | undefined;
-        };
-    };
+    readonly notifications: () => NotificationsFeature;
     /**
-     * Convenience wrapper that emits `feedback_request` notifications.
-     * Backed by the same `$boboddy_notifications_v1` signal.
+     * A real specialization of `notifications()`, not an alias: narrows every
+     * emitted item to `kind: "feedback_request"` and swaps in a
+     * feedback-request-specific prompt section. Backed by the same
+     * `$boboddy_notifications_v1` signal.
      */
-    readonly feedbackRequests: (() => NotificationsFeature) & {
-        signal: {
-            key: "$boboddy_notifications_v1";
-        };
-    };
+    readonly feedbackRequests: () => NotificationsFeature;
+};
+export declare const NotificationSignal: {
+    readonly key: "$boboddy_notifications_v1";
+    readonly find: (signals: Array<{
+        key: string;
+        valueJson: unknown;
+    }>) => NotificationItem[] | undefined;
+};
+export declare const Notify: {
+    /** The one generic constructor. Field names match `NotificationItem`
+     * exactly, so a new optional field never forces a call-site rewrite. */
+    readonly create: (item: NotificationItem) => NotificationResultFragment;
+    /** Build a notification for the in-app inbox — the one channel the
+     * platform always delivers, so it's the safest default when the caller
+     * doesn't need a specific channel. */
+    readonly inApp: (title: string, body: string, priority: NotificationPriority, options?: {
+        kind?: NotificationKind;
+        payload?: Record<string, unknown>;
+    }) => NotificationResultFragment;
+    /** Build a `kind: "feedback_request"` notification — the value-builder
+     * counterpart to `Features.feedbackRequests()`. */
+    readonly feedbackRequest: (question: string, category: string, urgency: FeedbackRequestUrgency, suggestedKey?: string) => NotificationResultFragment;
+    /** Combine several notification result fragments (e.g. more than one
+     * `Notify.*` call) into a single result value. */
+    readonly merge: (...fragments: NotificationResultFragment[]) => NotificationResultFragment;
 };
 export {};

package/dist/definitions/validation/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./json-schema-paths";
 export * from "./validate-definition-specs";
+export * from "./validate-input-bindings";
+export * from "./validation-issue";